]> pilppa.org Git - linux-2.6-omap-h63xx.git/blobdiff - drivers/net/wireless/libertas/cmdresp.c
[PATCH] libertas: simplify and clean up data rate handling
[linux-2.6-omap-h63xx.git] / drivers / net / wireless / libertas / cmdresp.c
index cdb012c7e9cfcf1c2190b52d2a76742f1814b9c4..577c434089b06b8ac82948aca1439b53fc8fdea9 100644 (file)
@@ -9,7 +9,6 @@
 #include <net/iw_handler.h>
 
 #include "host.h"
-#include "sbi.h"
 #include "decl.h"
 #include "defs.h"
 #include "dev.h"
@@ -29,10 +28,10 @@ void libertas_mac_event_disconnected(wlan_private * priv)
        wlan_adapter *adapter = priv->adapter;
        union iwreq_data wrqu;
 
-       if (adapter->connect_status != libertas_connected)
+       if (adapter->connect_status != LIBERTAS_CONNECTED)
                return;
 
-       lbs_pr_debug(1, "Handles disconnect event.\n");
+       lbs_deb_cmd("Handles disconnect event.\n");
 
        memset(wrqu.ap_addr.sa_data, 0x00, ETH_ALEN);
        wrqu.ap_addr.sa_family = ARPHRD_ETHER;
@@ -43,15 +42,15 @@ void libertas_mac_event_disconnected(wlan_private * priv)
         */
 
        msleep_interruptible(1000);
-       wireless_send_event(priv->wlan_dev.netdev, SIOCGIWAP, &wrqu, NULL);
+       wireless_send_event(priv->dev, SIOCGIWAP, &wrqu, NULL);
 
        /* Free Tx and Rx packets */
        kfree_skb(priv->adapter->currenttxskb);
        priv->adapter->currenttxskb = NULL;
 
        /* report disconnect to upper layer */
-       netif_stop_queue(priv->wlan_dev.netdev);
-       netif_carrier_off(priv->wlan_dev.netdev);
+       netif_stop_queue(priv->dev);
+       netif_carrier_off(priv->dev);
 
        /* reset SNR/NF/RSSI values */
        memset(adapter->SNR, 0x00, sizeof(adapter->SNR));
@@ -62,37 +61,32 @@ void libertas_mac_event_disconnected(wlan_private * priv)
        adapter->nextSNRNF = 0;
        adapter->numSNRNF = 0;
        adapter->rxpd_rate = 0;
-       lbs_pr_debug(1, "Current SSID=%s, ssid length=%u\n",
-              adapter->curbssparams.ssid.ssid,
-              adapter->curbssparams.ssid.ssidlength);
-       lbs_pr_debug(1, "Previous SSID=%s, ssid length=%u\n",
-              adapter->previousssid.ssid, adapter->previousssid.ssidlength);
-
-       /* reset internal flags */
-       adapter->secinfo.WPAenabled = 0;
-       adapter->secinfo.WPA2enabled = 0;
-       adapter->wpa_ie_len = 0;
-       adapter->secinfo.auth1xalg = WLAN_1X_AUTH_ALG_NONE;
-       adapter->secinfo.Encryptionmode = CIPHER_NONE;
-
-       adapter->connect_status = libertas_disconnected;
-
-       /*
-        * memorize the previous SSID and BSSID
-        * it could be used for re-assoc
+       lbs_deb_cmd("Current SSID='%s', ssid length=%u\n",
+                   escape_essid(adapter->curbssparams.ssid,
+                                adapter->curbssparams.ssid_len),
+                   adapter->curbssparams.ssid_len);
+       lbs_deb_cmd("Previous SSID='%s', ssid length=%u\n",
+                   escape_essid(adapter->prev_ssid, adapter->prev_ssid_len),
+                   adapter->prev_ssid_len);
+
+       adapter->connect_status = LIBERTAS_DISCONNECTED;
+
+       /* Save previous SSID and BSSID for possible reassociation */
+       memcpy(&adapter->prev_ssid, &adapter->curbssparams.ssid,
+              IW_ESSID_MAX_SIZE);
+       adapter->prev_ssid_len = adapter->curbssparams.ssid_len;
+       memcpy(adapter->prev_bssid, adapter->curbssparams.bssid, ETH_ALEN);
+
+       /* Clear out associated SSID and BSSID since connection is
+        * no longer valid.
         */
-       memcpy(&adapter->previousssid,
-              &adapter->curbssparams.ssid, sizeof(struct WLAN_802_11_SSID));
-       memcpy(adapter->previousbssid,
-              adapter->curbssparams.bssid, ETH_ALEN);
-
-       /* need to erase the current SSID and BSSID info */
-       adapter->pattemptedbssdesc = NULL;
-       memset(&adapter->curbssparams, 0, sizeof(adapter->curbssparams));
+       memset(&adapter->curbssparams.bssid, 0, ETH_ALEN);
+       memset(&adapter->curbssparams.ssid, 0, IW_ESSID_MAX_SIZE);
+       adapter->curbssparams.ssid_len = 0;
 
        if (adapter->psstate != PS_STATE_FULL_POWER) {
                /* make firmware to exit PS mode */
-               lbs_pr_debug(1, "Disconnected, so exit PS mode.\n");
+               lbs_deb_cmd("Disconnected, so exit PS mode.\n");
                libertas_ps_wakeup(priv, 0);
        }
 }
@@ -124,55 +118,45 @@ static void handle_mic_failureevent(wlan_private * priv, u32 event)
 static int wlan_ret_reg_access(wlan_private * priv,
                               u16 type, struct cmd_ds_command *resp)
 {
+       int ret = 0;
        wlan_adapter *adapter = priv->adapter;
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
        switch (type) {
-       case cmd_ret_mac_reg_access:
+       case CMD_RET_MAC_REG_ACCESS:
                {
-                       struct cmd_ds_mac_reg_access *reg;
+                       struct cmd_ds_mac_reg_access *reg = &resp->params.macreg;
 
-                       reg =
-                           (struct cmd_ds_mac_reg_access *)&resp->params.
-                           macreg;
-
-                       adapter->offsetvalue.offset = reg->offset;
-                       adapter->offsetvalue.value = reg->value;
+                       adapter->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
+                       adapter->offsetvalue.value = le32_to_cpu(reg->value);
                        break;
                }
 
-       case cmd_ret_bbp_reg_access:
+       case CMD_RET_BBP_REG_ACCESS:
                {
-                       struct cmd_ds_bbp_reg_access *reg;
-                       reg =
-                           (struct cmd_ds_bbp_reg_access *)&resp->params.
-                           bbpreg;
+                       struct cmd_ds_bbp_reg_access *reg = &resp->params.bbpreg;
 
-                       adapter->offsetvalue.offset = reg->offset;
+                       adapter->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
                        adapter->offsetvalue.value = reg->value;
                        break;
                }
 
-       case cmd_ret_rf_reg_access:
+       case CMD_RET_RF_REG_ACCESS:
                {
-                       struct cmd_ds_rf_reg_access *reg;
-                       reg =
-                           (struct cmd_ds_rf_reg_access *)&resp->params.
-                           rfreg;
+                       struct cmd_ds_rf_reg_access *reg = &resp->params.rfreg;
 
-                       adapter->offsetvalue.offset = reg->offset;
+                       adapter->offsetvalue.offset = (u32)le16_to_cpu(reg->offset);
                        adapter->offsetvalue.value = reg->value;
                        break;
                }
 
        default:
-               LEAVE();
-               return -1;
+               ret = -1;
        }
 
-       LEAVE();
-       return 0;
+       lbs_deb_enter_args(LBS_DEB_CMD, "ret %d", ret);
+       return ret;
 }
 
 static int wlan_ret_get_hw_spec(wlan_private * priv,
@@ -183,19 +167,20 @@ static int wlan_ret_get_hw_spec(wlan_private * priv,
        wlan_adapter *adapter = priv->adapter;
        int ret = 0;
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
        adapter->fwcapinfo = le32_to_cpu(hwspec->fwcapinfo);
 
-       adapter->fwreleasenumber = hwspec->fwreleasenumber;
+       memcpy(adapter->fwreleasenumber, hwspec->fwreleasenumber, 4);
 
-       lbs_pr_debug(1, "GET_HW_SPEC: FWReleaseVersion- 0x%X\n",
-              adapter->fwreleasenumber);
-       lbs_pr_debug(1, "GET_HW_SPEC: Permanent addr- %2x:%2x:%2x:%2x:%2x:%2x\n",
+       lbs_deb_cmd("GET_HW_SPEC: FWReleaseVersion- %u.%u.%u.p%u\n",
+                   adapter->fwreleasenumber[2], adapter->fwreleasenumber[1],
+                   adapter->fwreleasenumber[0], adapter->fwreleasenumber[3]);
+       lbs_deb_cmd("GET_HW_SPEC: Permanent addr- %2x:%2x:%2x:%2x:%2x:%2x\n",
               hwspec->permanentaddr[0], hwspec->permanentaddr[1],
               hwspec->permanentaddr[2], hwspec->permanentaddr[3],
               hwspec->permanentaddr[4], hwspec->permanentaddr[5]);
-       lbs_pr_debug(1, "GET_HW_SPEC: hwifversion=0x%X  version=0x%X\n",
+       lbs_deb_cmd("GET_HW_SPEC: hwifversion=0x%X  version=0x%X\n",
               hwspec->hwifversion, hwspec->version);
 
        adapter->regioncode = le16_to_cpu(hwspec->regioncode);
@@ -212,17 +197,15 @@ static int wlan_ret_get_hw_spec(wlan_private * priv,
        if (i >= MRVDRV_MAX_REGION_CODE) {
                adapter->regioncode = 0x10;
                adapter->regiontableindex = 0;
-               lbs_pr_info(
-                      "unidentified region code, use the default (USA)\n");
+               lbs_pr_info("unidentified region code; using the default (USA)\n");
        }
 
-       if (adapter->current_addr[0] == 0xff) {
-               memmove(adapter->current_addr, hwspec->permanentaddr,
-                       ETH_ALEN);
-       }
+       if (adapter->current_addr[0] == 0xff)
+               memmove(adapter->current_addr, hwspec->permanentaddr, ETH_ALEN);
 
-       memcpy(priv->wlan_dev.netdev->dev_addr, adapter->current_addr, ETH_ALEN);
-       memcpy(priv->mesh_dev->dev_addr, adapter->current_addr, ETH_ALEN);
+       memcpy(priv->dev->dev_addr, adapter->current_addr, ETH_ALEN);
+       if (priv->mesh_dev)
+               memcpy(priv->mesh_dev->dev_addr, adapter->current_addr, ETH_ALEN);
 
        if (libertas_set_regiontable(priv, adapter->regioncode, 0)) {
                ret = -1;
@@ -234,8 +217,8 @@ static int wlan_ret_get_hw_spec(wlan_private * priv,
                goto done;
        }
 
-      done:
-       LEAVE();
+done:
+       lbs_deb_enter_args(LBS_DEB_CMD, "ret %d", ret);
        return ret;
 }
 
@@ -245,19 +228,21 @@ static int wlan_ret_802_11_sleep_params(wlan_private * priv,
        struct cmd_ds_802_11_sleep_params *sp = &resp->params.sleep_params;
        wlan_adapter *adapter = priv->adapter;
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
+
+       lbs_deb_cmd("error=%x offset=%x stabletime=%x calcontrol=%x\n"
+                   " extsleepclk=%x\n", le16_to_cpu(sp->error),
+                   le16_to_cpu(sp->offset), le16_to_cpu(sp->stabletime),
+                   sp->calcontrol, sp->externalsleepclk);
 
-       lbs_pr_debug(1, "error=%x offset=%x stabletime=%x calcontrol=%x\n"
-              " extsleepclk=%x\n", sp->error, sp->offset,
-              sp->stabletime, sp->calcontrol, sp->externalsleepclk);
        adapter->sp.sp_error = le16_to_cpu(sp->error);
        adapter->sp.sp_offset = le16_to_cpu(sp->offset);
        adapter->sp.sp_stabletime = le16_to_cpu(sp->stabletime);
-       adapter->sp.sp_calcontrol = le16_to_cpu(sp->calcontrol);
-       adapter->sp.sp_extsleepclk = le16_to_cpu(sp->externalsleepclk);
+       adapter->sp.sp_calcontrol = sp->calcontrol;
+       adapter->sp.sp_extsleepclk = sp->externalsleepclk;
        adapter->sp.sp_reserved = le16_to_cpu(sp->reserved);
 
-       LEAVE();
+       lbs_deb_enter(LBS_DEB_CMD);
        return 0;
 }
 
@@ -283,42 +268,38 @@ static int wlan_ret_802_11_snmp_mib(wlan_private * priv,
        u16 oid = le16_to_cpu(smib->oid);
        u16 querytype = le16_to_cpu(smib->querytype);
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
-       lbs_pr_debug(1, "SNMP_RESP: value of the oid = %x, querytype=%x\n", oid,
+       lbs_deb_cmd("SNMP_RESP: value of the oid = %x, querytype=%x\n", oid,
               querytype);
-       lbs_pr_debug(1, "SNMP_RESP: Buf size  = %x\n",
-              le16_to_cpu(smib->bufsize));
+       lbs_deb_cmd("SNMP_RESP: Buf size  = %x\n", le16_to_cpu(smib->bufsize));
 
-       if (querytype == cmd_act_get) {
+       if (querytype == CMD_ACT_GET) {
                switch (oid) {
-               case fragthresh_i:
+               case FRAGTHRESH_I:
                        priv->adapter->fragthsd =
-                           le16_to_cpu(*
-                                            ((unsigned short *)(smib->value)));
-                       lbs_pr_debug(1, "SNMP_RESP: fragthsd =%u\n",
-                              priv->adapter->fragthsd);
+                               le16_to_cpu(*((__le16 *)(smib->value)));
+                       lbs_deb_cmd("SNMP_RESP: fragthsd =%u\n",
+                                   priv->adapter->fragthsd);
                        break;
-               case rtsthresh_i:
+               case RTSTHRESH_I:
                        priv->adapter->rtsthsd =
-                           le16_to_cpu(*
-                                            ((unsigned short *)(smib->value)));
-                       lbs_pr_debug(1, "SNMP_RESP: rtsthsd =%u\n",
-                              priv->adapter->rtsthsd);
+                               le16_to_cpu(*((__le16 *)(smib->value)));
+                       lbs_deb_cmd("SNMP_RESP: rtsthsd =%u\n",
+                                   priv->adapter->rtsthsd);
                        break;
-               case short_retrylim_i:
+               case SHORT_RETRYLIM_I:
                        priv->adapter->txretrycount =
-                           le16_to_cpu(*
-                                            ((unsigned short *)(smib->value)));
-                       lbs_pr_debug(1, "SNMP_RESP: txretrycount =%u\n",
-                              priv->adapter->rtsthsd);
+                               le16_to_cpu(*((__le16 *)(smib->value)));
+                       lbs_deb_cmd("SNMP_RESP: txretrycount =%u\n",
+                                   priv->adapter->rtsthsd);
                        break;
                default:
                        break;
                }
        }
 
-       LEAVE();
+       lbs_deb_enter(LBS_DEB_CMD);
        return 0;
 }
 
@@ -330,21 +311,22 @@ static int wlan_ret_802_11_key_material(wlan_private * priv,
        wlan_adapter *adapter = priv->adapter;
        u16 action = le16_to_cpu(pkeymaterial->action);
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
        /* Copy the returned key to driver private data */
-       if (action == cmd_act_get) {
+       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 WLAN_802_11_KEY * pkey;
-                       u16 key_info = le16_to_cpu(pkeyparamset->keyinfo);
+                       struct enc_key * pkey;
                        u16 param_set_len = le16_to_cpu(pkeyparamset->length);
-                       u8 * end;
                        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)
@@ -353,27 +335,27 @@ static int wlan_ret_802_11_key_material(wlan_private * priv,
                        if (end > resp_end)
                                break;
 
-                       if (key_info & KEY_INFO_WPA_UNICAST)
+                       if (key_flags & KEY_INFO_WPA_UNICAST)
                                pkey = &adapter->wpa_unicast_key;
-                       else if (key_info & KEY_INFO_WPA_MCAST)
+                       else if (key_flags & KEY_INFO_WPA_MCAST)
                                pkey = &adapter->wpa_mcast_key;
                        else
                                break;
 
                        /* Copy returned key into driver */
-                       memset(pkey, 0, sizeof(struct WLAN_802_11_KEY));
+                       memset(pkey, 0, sizeof(struct enc_key));
                        if (key_len > sizeof(pkey->key))
                                break;
-                       pkey->type = le16_to_cpu(pkeyparamset->keytypeid);
-                       pkey->flags = le16_to_cpu(pkeyparamset->keyinfo);
-                       pkey->len = le16_to_cpu(pkeyparamset->keylen);
+                       pkey->type = key_type;
+                       pkey->flags = key_flags;
+                       pkey->len = key_len;
                        memcpy(pkey->key, pkeyparamset->key, pkey->len);
 
                        buf_ptr = end + 1;
                }
        }
 
-       LEAVE();
+       lbs_deb_enter(LBS_DEB_CMD);
        return 0;
 }
 
@@ -383,11 +365,11 @@ static int wlan_ret_802_11_mac_address(wlan_private * priv,
        struct cmd_ds_802_11_mac_address *macadd = &resp->params.macadd;
        wlan_adapter *adapter = priv->adapter;
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
        memcpy(adapter->current_addr, macadd->macadd, ETH_ALEN);
 
-       LEAVE();
+       lbs_deb_enter(LBS_DEB_CMD);
        return 0;
 }
 
@@ -397,13 +379,13 @@ static int wlan_ret_802_11_rf_tx_power(wlan_private * priv,
        struct cmd_ds_802_11_rf_tx_power *rtp = &resp->params.txp;
        wlan_adapter *adapter = priv->adapter;
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
        adapter->txpowerlevel = le16_to_cpu(rtp->currentlevel);
 
-       lbs_pr_debug(1, "Current TxPower Level = %d\n", adapter->txpowerlevel);
+       lbs_deb_cmd("Current TxPower Level = %d\n", adapter->txpowerlevel);
 
-       LEAVE();
+       lbs_deb_enter(LBS_DEB_CMD);
        return 0;
 }
 
@@ -414,15 +396,13 @@ static int wlan_ret_802_11_rf_antenna(wlan_private * priv,
        wlan_adapter *adapter = priv->adapter;
        u16 action = le16_to_cpu(pAntenna->action);
 
-       if (action == cmd_act_get_rx)
-               adapter->rxantennamode =
-                   le16_to_cpu(pAntenna->antennamode);
+       if (action == CMD_ACT_GET_RX)
+               adapter->rxantennamode = le16_to_cpu(pAntenna->antennamode);
 
-       if (action == cmd_act_get_tx)
-               adapter->txantennamode =
-                   le16_to_cpu(pAntenna->antennamode);
+       if (action == CMD_ACT_GET_TX)
+               adapter->txantennamode = le16_to_cpu(pAntenna->antennamode);
 
-       lbs_pr_debug(1, "RF_ANT_RESP: action = 0x%x, mode = 0x%04x\n",
+       lbs_deb_cmd("RF_ANT_RESP: action = 0x%x, mode = 0x%04x\n",
               action, le16_to_cpu(pAntenna->antennamode));
 
        return 0;
@@ -431,19 +411,17 @@ static int wlan_ret_802_11_rf_antenna(wlan_private * priv,
 static int wlan_ret_802_11_rate_adapt_rateset(wlan_private * priv,
                                              struct cmd_ds_command *resp)
 {
-       struct cmd_ds_802_11_rate_adapt_rateset *rates =
-           &resp->params.rateset;
+       struct cmd_ds_802_11_rate_adapt_rateset *rates = &resp->params.rateset;
        wlan_adapter *adapter = priv->adapter;
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
-       if (rates->action == cmd_act_get) {
-               adapter->enablehwauto = rates->enablehwauto;
-               adapter->ratebitmap = rates->bitmap;
+       if (rates->action == CMD_ACT_GET) {
+               adapter->enablehwauto = le16_to_cpu(rates->enablehwauto);
+               adapter->ratebitmap = le16_to_cpu(rates->bitmap);
        }
 
-       LEAVE();
-
+       lbs_deb_enter(LBS_DEB_CMD);
        return 0;
 }
 
@@ -452,45 +430,41 @@ static int wlan_ret_802_11_data_rate(wlan_private * priv,
 {
        struct cmd_ds_802_11_data_rate *pdatarate = &resp->params.drate;
        wlan_adapter *adapter = priv->adapter;
-       u8 dot11datarate;
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
-       lbs_dbg_hex("DATA_RATE_RESP: data_rate- ",
-               (u8 *) pdatarate, sizeof(struct cmd_ds_802_11_data_rate));
+       lbs_dbg_hex("DATA_RATE_RESP: data_rate- ", (u8 *) pdatarate,
+               sizeof(struct cmd_ds_802_11_data_rate));
 
-       dot11datarate = pdatarate->datarate[0];
-       if (pdatarate->action == cmd_act_get_tx_rate) {
-               memcpy(adapter->libertas_supported_rates, pdatarate->datarate,
-                      sizeof(adapter->libertas_supported_rates));
-       }
-       adapter->datarate = libertas_index_to_data_rate(dot11datarate);
+       /* FIXME: get actual rates FW can do if this command actually returns
+        * all data rates supported.
+        */
+       adapter->cur_rate = libertas_fw_index_to_data_rate(pdatarate->rates[0]);
 
-       LEAVE();
+       lbs_deb_leave(LBS_DEB_CMD);
        return 0;
 }
 
 static int wlan_ret_802_11_rf_channel(wlan_private * priv,
                                      struct cmd_ds_command *resp)
 {
-       struct cmd_ds_802_11_rf_channel *rfchannel =
-           &resp->params.rfchannel;
+       struct cmd_ds_802_11_rf_channel *rfchannel = &resp->params.rfchannel;
        wlan_adapter *adapter = priv->adapter;
        u16 action = le16_to_cpu(rfchannel->action);
        u16 newchannel = le16_to_cpu(rfchannel->currentchannel);
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
-       if (action == cmd_opt_802_11_rf_channel_get
+       if (action == CMD_OPT_802_11_RF_CHANNEL_GET
            && adapter->curbssparams.channel != newchannel) {
-               lbs_pr_debug(1, "channel Switch: %d to %d\n",
+               lbs_deb_cmd("channel Switch: %d to %d\n",
                       adapter->curbssparams.channel, newchannel);
 
                /* Update the channel again */
                adapter->curbssparams.channel = newchannel;
        }
 
-       LEAVE();
+       lbs_deb_enter(LBS_DEB_CMD);
        return 0;
 }
 
@@ -502,12 +476,10 @@ static int wlan_ret_802_11_rssi(wlan_private * priv,
 
        /* store the non average value */
        adapter->SNR[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->SNR);
-       adapter->NF[TYPE_BEACON][TYPE_NOAVG] =
-           le16_to_cpu(rssirsp->noisefloor);
+       adapter->NF[TYPE_BEACON][TYPE_NOAVG] = le16_to_cpu(rssirsp->noisefloor);
 
        adapter->SNR[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgSNR);
-       adapter->NF[TYPE_BEACON][TYPE_AVG] =
-           le16_to_cpu(rssirsp->avgnoisefloor);
+       adapter->NF[TYPE_BEACON][TYPE_AVG] = le16_to_cpu(rssirsp->avgnoisefloor);
 
        adapter->RSSI[TYPE_BEACON][TYPE_NOAVG] =
            CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_NOAVG],
@@ -517,7 +489,7 @@ static int wlan_ret_802_11_rssi(wlan_private * priv,
            CAL_RSSI(adapter->SNR[TYPE_BEACON][TYPE_AVG] / AVG_SCALE,
                     adapter->NF[TYPE_BEACON][TYPE_AVG] / AVG_SCALE);
 
-       lbs_pr_debug(1, "Beacon RSSI value = 0x%x\n",
+       lbs_deb_cmd("Beacon RSSI value = 0x%x\n",
               adapter->RSSI[TYPE_BEACON][TYPE_AVG]);
 
        return 0;
@@ -530,11 +502,11 @@ static int wlan_ret_802_11_eeprom_access(wlan_private * priv,
        struct wlan_ioctl_regrdwr *pbuf;
        pbuf = (struct wlan_ioctl_regrdwr *) adapter->prdeeprom;
 
-       lbs_pr_debug(1, "eeprom read len=%x\n",
+       lbs_deb_cmd("eeprom read len=%x\n",
               le16_to_cpu(resp->params.rdeeprom.bytecount));
        if (pbuf->NOB < le16_to_cpu(resp->params.rdeeprom.bytecount)) {
                pbuf->NOB = 0;
-               lbs_pr_debug(1, "eeprom read return length is too big\n");
+               lbs_deb_cmd("eeprom read return length is too big\n");
                return -1;
        }
        pbuf->NOB = le16_to_cpu(resp->params.rdeeprom.bytecount);
@@ -551,17 +523,33 @@ static int wlan_ret_802_11_eeprom_access(wlan_private * priv,
 static int wlan_ret_get_log(wlan_private * priv,
                            struct cmd_ds_command *resp)
 {
-       struct cmd_ds_802_11_get_log *logmessage =
-           (struct cmd_ds_802_11_get_log *)&resp->params.glog;
+       struct cmd_ds_802_11_get_log *logmessage = &resp->params.glog;
+       wlan_adapter *adapter = priv->adapter;
+
+       lbs_deb_enter(LBS_DEB_CMD);
+
+       /* Stored little-endian */
+       memcpy(&adapter->logmsg, logmessage, sizeof(struct cmd_ds_802_11_get_log));
+
+       lbs_deb_enter(LBS_DEB_CMD);
+       return 0;
+}
+
+static int libertas_ret_802_11_enable_rsn(wlan_private * priv,
+                                          struct cmd_ds_command *resp)
+{
+       struct cmd_ds_802_11_enable_rsn *enable_rsn = &resp->params.enbrsn;
        wlan_adapter *adapter = priv->adapter;
+       u32 * pdata_buf = adapter->cur_cmd->pdata_buf;
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
-       /* TODO Convert it to Big Endian before copy */
-       memcpy(&adapter->logmsg, logmessage,
-              sizeof(struct cmd_ds_802_11_get_log));
+       if (enable_rsn->action == cpu_to_le16(CMD_ACT_GET)) {
+               if (pdata_buf)
+                       *pdata_buf = (u32) le16_to_cpu(enable_rsn->enable);
+       }
 
-       LEAVE();
+       lbs_deb_enter(LBS_DEB_CMD);
        return 0;
 }
 
@@ -574,175 +562,172 @@ static inline int handle_cmd_response(u16 respcmd,
        wlan_adapter *adapter = priv->adapter;
 
        switch (respcmd) {
-       case cmd_ret_mac_reg_access:
-       case cmd_ret_bbp_reg_access:
-       case cmd_ret_rf_reg_access:
+       case CMD_RET_MAC_REG_ACCESS:
+       case CMD_RET_BBP_REG_ACCESS:
+       case CMD_RET_RF_REG_ACCESS:
                ret = wlan_ret_reg_access(priv, respcmd, resp);
                break;
 
-       case cmd_ret_hw_spec_info:
+       case CMD_RET_HW_SPEC_INFO:
                ret = wlan_ret_get_hw_spec(priv, resp);
                break;
 
-       case cmd_ret_802_11_scan:
+       case CMD_RET_802_11_SCAN:
                ret = libertas_ret_80211_scan(priv, resp);
                break;
 
-       case cmd_ret_802_11_get_log:
+       case CMD_RET_802_11_GET_LOG:
                ret = wlan_ret_get_log(priv, resp);
                break;
 
-       case cmd_ret_802_11_associate:
-       case cmd_ret_802_11_reassociate:
+       case CMD_RET_802_11_ASSOCIATE:
+       case CMD_RET_802_11_REASSOCIATE:
                ret = libertas_ret_80211_associate(priv, resp);
                break;
 
-       case cmd_ret_802_11_disassociate:
-       case cmd_ret_802_11_deauthenticate:
+       case CMD_RET_802_11_DISASSOCIATE:
+       case CMD_RET_802_11_DEAUTHENTICATE:
                ret = libertas_ret_80211_disassociate(priv, resp);
                break;
 
-       case cmd_ret_802_11_ad_hoc_start:
-       case cmd_ret_802_11_ad_hoc_join:
+       case CMD_RET_802_11_AD_HOC_START:
+       case CMD_RET_802_11_AD_HOC_JOIN:
                ret = libertas_ret_80211_ad_hoc_start(priv, resp);
                break;
 
-       case cmd_ret_802_11_stat:
+       case CMD_RET_802_11_STAT:
                ret = wlan_ret_802_11_stat(priv, resp);
                break;
 
-       case cmd_ret_802_11_snmp_mib:
+       case CMD_RET_802_11_SNMP_MIB:
                ret = wlan_ret_802_11_snmp_mib(priv, resp);
                break;
 
-       case cmd_ret_802_11_rf_tx_power:
+       case CMD_RET_802_11_RF_TX_POWER:
                ret = wlan_ret_802_11_rf_tx_power(priv, resp);
                break;
 
-       case cmd_ret_802_11_set_afc:
-       case cmd_ret_802_11_get_afc:
+       case CMD_RET_802_11_SET_AFC:
+       case CMD_RET_802_11_GET_AFC:
                spin_lock_irqsave(&adapter->driver_lock, flags);
-               memmove(adapter->cur_cmd->pdata_buf,
-                       &resp->params.afc,
+               memmove(adapter->cur_cmd->pdata_buf, &resp->params.afc,
                        sizeof(struct cmd_ds_802_11_afc));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
 
                break;
-       case cmd_ret_802_11_rf_antenna:
+       case CMD_RET_802_11_RF_ANTENNA:
                ret = wlan_ret_802_11_rf_antenna(priv, resp);
                break;
 
-       case cmd_ret_mac_multicast_adr:
-       case cmd_ret_mac_control:
-       case cmd_ret_802_11_set_wep:
-       case cmd_ret_802_11_reset:
-       case cmd_ret_802_11_authenticate:
-       case cmd_ret_802_11_radio_control:
-       case cmd_ret_802_11_beacon_stop:
-       case cmd_ret_802_11_enable_rsn:
+       case CMD_RET_MAC_MULTICAST_ADR:
+       case CMD_RET_MAC_CONTROL:
+       case CMD_RET_802_11_SET_WEP:
+       case CMD_RET_802_11_RESET:
+       case CMD_RET_802_11_AUTHENTICATE:
+       case CMD_RET_802_11_RADIO_CONTROL:
+       case CMD_RET_802_11_BEACON_STOP:
+               break;
+
+       case CMD_RET_802_11_ENABLE_RSN:
+               ret = libertas_ret_802_11_enable_rsn(priv, resp);
                break;
 
-       case cmd_ret_802_11_data_rate:
+       case CMD_RET_802_11_DATA_RATE:
                ret = wlan_ret_802_11_data_rate(priv, resp);
                break;
-       case cmd_ret_802_11_rate_adapt_rateset:
+       case CMD_RET_802_11_RATE_ADAPT_RATESET:
                ret = wlan_ret_802_11_rate_adapt_rateset(priv, resp);
                break;
-       case cmd_ret_802_11_rf_channel:
+       case CMD_RET_802_11_RF_CHANNEL:
                ret = wlan_ret_802_11_rf_channel(priv, resp);
                break;
 
-       case cmd_ret_802_11_rssi:
+       case CMD_RET_802_11_RSSI:
                ret = wlan_ret_802_11_rssi(priv, resp);
                break;
 
-       case cmd_ret_802_11_mac_address:
+       case CMD_RET_802_11_MAC_ADDRESS:
                ret = wlan_ret_802_11_mac_address(priv, resp);
                break;
 
-       case cmd_ret_802_11_ad_hoc_stop:
+       case CMD_RET_802_11_AD_HOC_STOP:
                ret = libertas_ret_80211_ad_hoc_stop(priv, resp);
                break;
 
-       case cmd_ret_802_11_key_material:
-               lbs_pr_debug(1, "CMD_RESP: KEY_MATERIAL command response\n");
+       case CMD_RET_802_11_KEY_MATERIAL:
+               lbs_deb_cmd("CMD_RESP: KEY_MATERIAL command response\n");
                ret = wlan_ret_802_11_key_material(priv, resp);
                break;
 
-       case cmd_ret_802_11_eeprom_access:
+       case CMD_RET_802_11_EEPROM_ACCESS:
                ret = wlan_ret_802_11_eeprom_access(priv, resp);
                break;
 
-       case cmd_ret_802_11d_domain_info:
+       case CMD_RET_802_11D_DOMAIN_INFO:
                ret = libertas_ret_802_11d_domain_info(priv, resp);
                break;
 
-       case cmd_ret_802_11_sleep_params:
+       case CMD_RET_802_11_SLEEP_PARAMS:
                ret = wlan_ret_802_11_sleep_params(priv, resp);
                break;
-       case cmd_ret_802_11_inactivity_timeout:
+       case CMD_RET_802_11_INACTIVITY_TIMEOUT:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                *((u16 *) adapter->cur_cmd->pdata_buf) =
                    le16_to_cpu(resp->params.inactivity_timeout.timeout);
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
 
-       case cmd_ret_802_11_tpc_cfg:
+       case CMD_RET_802_11_TPC_CFG:
                spin_lock_irqsave(&adapter->driver_lock, flags);
-               memmove(adapter->cur_cmd->pdata_buf,
-                       &resp->params.tpccfg,
+               memmove(adapter->cur_cmd->pdata_buf, &resp->params.tpccfg,
                        sizeof(struct cmd_ds_802_11_tpc_cfg));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
-       case cmd_ret_802_11_led_gpio_ctrl:
+       case CMD_RET_802_11_LED_GPIO_CTRL:
                spin_lock_irqsave(&adapter->driver_lock, flags);
-               memmove(adapter->cur_cmd->pdata_buf,
-                       &resp->params.ledgpio,
+               memmove(adapter->cur_cmd->pdata_buf, &resp->params.ledgpio,
                        sizeof(struct cmd_ds_802_11_led_ctrl));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
-       case cmd_ret_802_11_pwr_cfg:
+       case CMD_RET_802_11_PWR_CFG:
                spin_lock_irqsave(&adapter->driver_lock, flags);
-               memmove(adapter->cur_cmd->pdata_buf,
-                       &resp->params.pwrcfg,
+               memmove(adapter->cur_cmd->pdata_buf, &resp->params.pwrcfg,
                        sizeof(struct cmd_ds_802_11_pwr_cfg));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
 
                break;
 
-       case cmd_ret_get_tsf:
+       case CMD_RET_GET_TSF:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                memcpy(priv->adapter->cur_cmd->pdata_buf,
                       &resp->params.gettsf.tsfvalue, sizeof(u64));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
-       case cmd_ret_bt_access:
+       case CMD_RET_BT_ACCESS:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                if (adapter->cur_cmd->pdata_buf)
                        memcpy(adapter->cur_cmd->pdata_buf,
                               &resp->params.bt.addr1, 2 * ETH_ALEN);
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
-       case cmd_ret_fwt_access:
+       case CMD_RET_FWT_ACCESS:
                spin_lock_irqsave(&adapter->driver_lock, flags);
                if (adapter->cur_cmd->pdata_buf)
-                       memcpy(adapter->cur_cmd->pdata_buf,
-                              &resp->params.fwt,
-                               sizeof(resp->params.fwt));
+                       memcpy(adapter->cur_cmd->pdata_buf, &resp->params.fwt,
+                              sizeof(resp->params.fwt));
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                break;
-       case cmd_ret_mesh_access:
+       case CMD_RET_MESH_ACCESS:
                if (adapter->cur_cmd->pdata_buf)
-                       memcpy(adapter->cur_cmd->pdata_buf,
-                              &resp->params.mesh,
+                       memcpy(adapter->cur_cmd->pdata_buf, &resp->params.mesh,
                               sizeof(resp->params.mesh));
                break;
-       case cmd_rte_802_11_tx_rate_query:
+       case CMD_RTE_802_11_TX_RATE_QUERY:
                priv->adapter->txrate = resp->params.txrate.txrate;
                break;
        default:
-               lbs_pr_debug(1, "CMD_RESP: Unknown command response %#x\n",
-                      resp->command);
+               lbs_deb_cmd("CMD_RESP: Unknown command response %#x\n",
+                           resp->command);
                break;
        }
        return ret;
@@ -757,9 +742,9 @@ int libertas_process_rx_command(wlan_private * priv)
        ulong flags;
        u16 result;
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
-       lbs_pr_debug(1, "CMD_RESP: @ %lu\n", jiffies);
+       lbs_deb_cmd("CMD_RESP: @ %lu\n", jiffies);
 
        /* Now we got response from FW, cancel the command timer */
        del_timer(&adapter->command_timer);
@@ -768,7 +753,7 @@ int libertas_process_rx_command(wlan_private * priv)
        spin_lock_irqsave(&adapter->driver_lock, flags);
 
        if (!adapter->cur_cmd) {
-               lbs_pr_debug(1, "CMD_RESP: NULL cur_cmd=%p\n", adapter->cur_cmd);
+               lbs_deb_cmd("CMD_RESP: NULL cur_cmd=%p\n", adapter->cur_cmd);
                ret = -1;
                spin_unlock_irqrestore(&adapter->driver_lock, flags);
                goto done;
@@ -776,17 +761,17 @@ int libertas_process_rx_command(wlan_private * priv)
        resp = (struct cmd_ds_command *)(adapter->cur_cmd->bufvirtualaddr);
 
        lbs_dbg_hex("CMD_RESP:", adapter->cur_cmd->bufvirtualaddr,
-               priv->wlan_dev.upld_len);
+                   priv->upld_len);
 
        respcmd = le16_to_cpu(resp->command);
 
        result = le16_to_cpu(resp->result);
 
-       lbs_pr_debug(1, "CMD_RESP: %x result: %d length: %d\n", respcmd,
-              result, priv->wlan_dev.upld_len);
+       lbs_deb_cmd("CMD_RESP: %x result: %d length: %d\n", respcmd,
+                   result, priv->upld_len);
 
        if (!(respcmd & 0x8000)) {
-               lbs_pr_debug(1, "Invalid response to command!");
+               lbs_deb_cmd("Invalid response to command!");
                adapter->cur_cmd_retcode = -1;
                __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
                adapter->nr_cmd_pending--;
@@ -797,56 +782,52 @@ int libertas_process_rx_command(wlan_private * priv)
        }
 
        /* Store the response code to cur_cmd_retcode. */
-       adapter->cur_cmd_retcode = le16_to_cpu(resp->result);
+       adapter->cur_cmd_retcode = result;;
 
-       if (respcmd == cmd_ret_802_11_ps_mode) {
-               struct cmd_ds_802_11_ps_mode *psmode;
+       if (respcmd == CMD_RET_802_11_PS_MODE) {
+               struct cmd_ds_802_11_ps_mode *psmode = &resp->params.psmode;
+               u16 action = le16_to_cpu(psmode->action);
 
-               psmode = &resp->params.psmode;
-               lbs_pr_debug(1,
+               lbs_deb_cmd(
                       "CMD_RESP: PS_MODE cmd reply result=%#x action=0x%X\n",
-                      resp->result, psmode->action);
-               psmode->action = cpu_to_le16(psmode->action);
+                      result, action);
 
                if (result) {
-                       lbs_pr_debug(1, "CMD_RESP: PS command failed- %#x \n",
-                              resp->result);
-                       if (adapter->inframode == wlan802_11ibss) {
-                               /*
-                                * We should not re-try enter-ps command in
-                                * ad-hoc mode. It takes place in
-                                * libertas_execute_next_command().
-                                */
-                               if (psmode->action == cmd_subcmd_enter_ps)
-                                       adapter->psmode =
-                                           wlan802_11powermodecam;
-                       }
-               } else if (psmode->action == cmd_subcmd_enter_ps) {
+                       lbs_deb_cmd("CMD_RESP: PS command failed- %#x \n",
+                                   result);
+                       /*
+                        * We should not re-try enter-ps command in
+                        * ad-hoc mode. It takes place in
+                        * libertas_execute_next_command().
+                        */
+                       if (adapter->mode == IW_MODE_ADHOC &&
+                           action == CMD_SUBCMD_ENTER_PS)
+                               adapter->psmode = WLAN802_11POWERMODECAM;
+               } else if (action == CMD_SUBCMD_ENTER_PS) {
                        adapter->needtowakeup = 0;
                        adapter->psstate = PS_STATE_AWAKE;
 
-                       lbs_pr_debug(1, "CMD_RESP: Enter_PS command response\n");
-                       if (adapter->connect_status != libertas_connected) {
+                       lbs_deb_cmd("CMD_RESP: Enter_PS command response\n");
+                       if (adapter->connect_status != LIBERTAS_CONNECTED) {
                                /*
                                 * When Deauth Event received before Enter_PS command
                                 * response, We need to wake up the firmware.
                                 */
-                               lbs_pr_debug(1,
+                               lbs_deb_cmd(
                                       "Disconnected, Going to invoke libertas_ps_wakeup\n");
 
-                               mutex_unlock(&adapter->lock);
                                spin_unlock_irqrestore(&adapter->driver_lock, flags);
+                               mutex_unlock(&adapter->lock);
                                libertas_ps_wakeup(priv, 0);
                                mutex_lock(&adapter->lock);
                                spin_lock_irqsave(&adapter->driver_lock, flags);
                        }
-               } else if (psmode->action == cmd_subcmd_exit_ps) {
+               } else if (action == CMD_SUBCMD_EXIT_PS) {
                        adapter->needtowakeup = 0;
                        adapter->psstate = PS_STATE_FULL_POWER;
-                       lbs_pr_debug(1, "CMD_RESP: Exit_PS command response\n");
+                       lbs_deb_cmd("CMD_RESP: Exit_PS command response\n");
                } else {
-                       lbs_pr_debug(1, "CMD_RESP: PS- action=0x%X\n",
-                              psmode->action);
+                       lbs_deb_cmd("CMD_RESP: PS- action=0x%X\n", action);
                }
 
                __libertas_cleanup_and_insert_cmd(priv, adapter->cur_cmd);
@@ -867,15 +848,15 @@ int libertas_process_rx_command(wlan_private * priv)
 
        /* If the command is not successful, cleanup and return failure */
        if ((result != 0 || !(respcmd & 0x8000))) {
-               lbs_pr_debug(1, "CMD_RESP: command reply %#x result=%#x\n",
-                      resp->command, resp->result);
+               lbs_deb_cmd("CMD_RESP: command reply %#x result=%#x\n",
+                      respcmd, result);
                /*
                 * Handling errors here
                 */
                switch (respcmd) {
-               case cmd_ret_hw_spec_info:
-               case cmd_ret_802_11_reset:
-                       lbs_pr_debug(1, "CMD_RESP: Reset command failed\n");
+               case CMD_RET_HW_SPEC_INFO:
+               case CMD_RET_802_11_RESET:
+                       lbs_deb_cmd("CMD_RESP: Reset command failed\n");
                        break;
 
                }
@@ -905,7 +886,7 @@ int libertas_process_rx_command(wlan_private * priv)
 
 done:
        mutex_unlock(&adapter->lock);
-       LEAVE();
+       lbs_deb_enter_args(LBS_DEB_CMD, "ret %d", ret);
        return ret;
 }
 
@@ -919,37 +900,37 @@ int libertas_process_event(wlan_private * priv)
        eventcause = adapter->eventcause;
        spin_unlock_irq(&adapter->driver_lock);
 
-       ENTER();
+       lbs_deb_enter(LBS_DEB_CMD);
 
-       lbs_pr_debug(1, "EVENT Cause %x\n", eventcause);
+       lbs_deb_cmd("EVENT Cause %x\n", eventcause);
 
        switch (eventcause >> SBI_EVENT_CAUSE_SHIFT) {
        case MACREG_INT_CODE_LINK_SENSED:
-               lbs_pr_debug(1, "EVENT: MACREG_INT_CODE_LINK_SENSED\n");
+               lbs_deb_cmd("EVENT: MACREG_INT_CODE_LINK_SENSED\n");
                break;
 
        case MACREG_INT_CODE_DEAUTHENTICATED:
-               lbs_pr_debug(1, "EVENT: Deauthenticated\n");
+               lbs_deb_cmd("EVENT: Deauthenticated\n");
                libertas_mac_event_disconnected(priv);
                break;
 
        case MACREG_INT_CODE_DISASSOCIATED:
-               lbs_pr_debug(1, "EVENT: Disassociated\n");
+               lbs_deb_cmd("EVENT: Disassociated\n");
                libertas_mac_event_disconnected(priv);
                break;
 
        case MACREG_INT_CODE_LINK_LOSE_NO_SCAN:
-               lbs_pr_debug(1, "EVENT: Link lost\n");
+               lbs_deb_cmd("EVENT: Link lost\n");
                libertas_mac_event_disconnected(priv);
                break;
 
        case MACREG_INT_CODE_PS_SLEEP:
-               lbs_pr_debug(1, "EVENT: SLEEP\n");
-               lbs_pr_debug(1, "_");
+               lbs_deb_cmd("EVENT: SLEEP\n");
+               lbs_deb_cmd("_");
 
                /* handle unexpected PS SLEEP event */
                if (adapter->psstate == PS_STATE_FULL_POWER) {
-                       lbs_pr_debug(1,
+                       lbs_deb_cmd(
                               "EVENT: In FULL POWER mode - ignore PS SLEEP\n");
                        break;
                }
@@ -960,12 +941,12 @@ int libertas_process_event(wlan_private * priv)
                break;
 
        case MACREG_INT_CODE_PS_AWAKE:
-               lbs_pr_debug(1, "EVENT: AWAKE \n");
-               lbs_pr_debug(1, "|");
+               lbs_deb_cmd("EVENT: AWAKE \n");
+               lbs_deb_cmd("|");
 
                /* handle unexpected PS AWAKE event */
                if (adapter->psstate == PS_STATE_FULL_POWER) {
-                       lbs_pr_debug(1,
+                       lbs_deb_cmd(
                               "EVENT: In FULL POWER mode - ignore PS AWAKE\n");
                        break;
                }
@@ -979,18 +960,18 @@ int libertas_process_event(wlan_private * priv)
                         * adapter->needtowakeup will be set to FALSE
                         * in libertas_ps_wakeup()
                         */
-                       lbs_pr_debug(1, "Waking up...\n");
+                       lbs_deb_cmd("Waking up...\n");
                        libertas_ps_wakeup(priv, 0);
                }
                break;
 
        case MACREG_INT_CODE_MIC_ERR_UNICAST:
-               lbs_pr_debug(1, "EVENT: UNICAST MIC ERROR\n");
+               lbs_deb_cmd("EVENT: UNICAST MIC ERROR\n");
                handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_UNICAST);
                break;
 
        case MACREG_INT_CODE_MIC_ERR_MULTICAST:
-               lbs_pr_debug(1, "EVENT: MULTICAST MIC ERROR\n");
+               lbs_deb_cmd("EVENT: MULTICAST MIC ERROR\n");
                handle_mic_failureevent(priv, MACREG_INT_CODE_MIC_ERR_MULTICAST);
                break;
        case MACREG_INT_CODE_MIB_CHANGED:
@@ -998,7 +979,7 @@ int libertas_process_event(wlan_private * priv)
                break;
 
        case MACREG_INT_CODE_ADHOC_BCN_LOST:
-               lbs_pr_debug(1, "EVENT: HWAC - ADHOC BCN LOST\n");
+               lbs_deb_cmd("EVENT: HWAC - ADHOC BCN LOST\n");
                break;
 
        case MACREG_INT_CODE_RSSI_LOW:
@@ -1017,6 +998,17 @@ int libertas_process_event(wlan_private * priv)
                lbs_pr_alert( "EVENT: SNR_HIGH\n");
                break;
 
+       case MACREG_INT_CODE_MESH_AUTO_STARTED:
+               lbs_pr_alert( "EVENT: MESH_AUTO_STARTED\n");
+               adapter->connect_status = LIBERTAS_CONNECTED ;
+               if (priv->mesh_open == 1) {
+                       netif_wake_queue(priv->mesh_dev) ;
+                       netif_carrier_on(priv->mesh_dev) ;
+               }
+               adapter->mode = IW_MODE_ADHOC ;
+               schedule_work(&priv->sync_channel);
+               break;
+
        default:
                lbs_pr_alert( "EVENT: unknown event id: %#x\n",
                       eventcause >> SBI_EVENT_CAUSE_SHIFT);
@@ -1026,6 +1018,7 @@ int libertas_process_event(wlan_private * priv)
        spin_lock_irq(&adapter->driver_lock);
        adapter->eventcause = 0;
        spin_unlock_irq(&adapter->driver_lock);
-       LEAVE();
+
+       lbs_deb_enter_args(LBS_DEB_CMD, "ret %d", ret);
        return ret;
 }