ath6kl: Bringing in the upstream version

chromeos/drivers/ath6kl/wmi/wmi.c

 //------------------------------------------------------------------------------
-// <copyright file="wmi.c" company="Atheros">
-//    Copyright (c) 2004-2010 Atheros Corporation.  All rights reserved.
+// Copyright (c) 2004-2010 Atheros Corporation.  All rights reserved.
 // 
-// This program is free software; you can redistribute it and/or modify
-// it under the terms of the GNU General Public License version 2 as
-// published by the Free Software Foundation;
 //
-// Software distributed under the License is distributed on an "AS
-// IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
-// implied. See the License for the specific language governing
-// rights and limitations under the License.
+// Permission to use, copy, modify, and/or distribute this software for any
+// purpose with or without fee is hereby granted, provided that the above
+// copyright notice and this permission notice appear in all copies.
+//
+// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 //
 //
 //------------------------------------------------------------------------------
 //==============================================================================
 // This module implements the hardware independent layer of the
 // Wireless Module Interface (WMI) protocol.
 //
 // Author(s): ="Atheros"
 //==============================================================================
 
@@ skipping 13 matching lines @@
 #include "wmi_host.h"
 #include "a_drv.h"
 #include "a_drv_api.h"
 #define ATH_MODULE_NAME wmi
 #include "a_debug.h"
 #include "dbglog_api.h"
 #include "roaming.h"
 
 #define ATH_DEBUG_WMI ATH_DEBUG_MAKE_MODULE_MASK(0)
 
-#ifdef DEBUG
+#ifdef ATH_DEBUG_MODULE
 
 static ATH_DEBUG_MASK_DESCRIPTION wmi_debug_desc[] = {
     { ATH_DEBUG_WMI , "General WMI Tracing"},
 };
 
 ATH_DEBUG_INSTANTIATE_MODULE_VAR(wmi,
                                  "wmi",
                                  "Wireless Module Interface",
                                  ATH_DEBUG_MASK_DEFAULTS,
                                  ATH_DEBUG_DESCRIPTION_COUNT(wmi_debug_desc),
@@ skipping 62 matching lines @@
 static A_STATUS wmi_roam_data_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
                                       int len);
 static A_STATUS wmi_get_wow_list_event_rx(struct wmi_t *wmip, A_UINT8 *datap,
                                       int len);
 static A_STATUS
 wmi_get_pmkid_list_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len);
 
 static A_STATUS
 wmi_set_params_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len);
 
+static A_STATUS
+wmi_acm_reject_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len);
+
 #ifdef CONFIG_HOST_GPIO_SUPPORT
 static A_STATUS wmi_gpio_intr_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
 static A_STATUS wmi_gpio_data_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
 static A_STATUS wmi_gpio_ack_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
 #endif /* CONFIG_HOST_GPIO_SUPPORT */
 
 #ifdef CONFIG_HOST_TCMD_SUPPORT
 static A_STATUS
 wmi_tcmd_test_report_rx(struct wmi_t *wmip, A_UINT8 *datap, int len);
 #endif
@@ skipping 142 matching lines @@
 #define IP_OFFMASK 0x1fff               /* mask for fragmenting bits */
     A_UINT8     ip_ttl;                 /* time to live */
     A_UINT8     ip_p;                   /* protocol */
     A_UINT16    ip_sum;                 /* checksum */
     A_UINT8     ip_src[4];              /* source and dest address */
     A_UINT8     ip_dst[4];
 } POSTPACK iphdr;
 
 #include "athendpack.h"
 
-A_INT16 rssi_event_value = 0;
-A_INT16 snr_event_value = 0;
+static A_INT16 rssi_event_value = 0;
+static A_INT16 snr_event_value = 0;
 
 A_BOOL is_probe_ssid = FALSE;
 
 void *
 wmi_init(void *devt)
 {
     struct wmi_t *wmip;
 
     A_REGISTER_MODULE_DEBUG_INFO(wmi);
 
-    wmip = A_MALLOC(sizeof(struct wmi_t));
+    wmip = A_MALLOC (sizeof(struct wmi_t));
     if (wmip == NULL) {
         return (NULL);
     }
-    A_MEMZERO(wmip, sizeof(*wmip));
-    A_MUTEX_INIT(&wmip->wmi_lock);
+    A_MEMZERO(wmip, sizeof(struct wmi_t ));
+#ifdef THREAD_X
+    INIT_WMI_LOCK(wmip);
+#else
+        A_MUTEX_INIT(&wmip->wmi_lock);
+#endif
     wmip->wmi_devt = devt;
     wlan_node_table_init(wmip, &wmip->wmi_scan_table);
     wmi_qos_state_init(wmip);
 
     wmip->wmi_powerMode = REC_POWER;
     wmip->wmi_phyMode = WMI_11G_MODE;
 
     wmip->wmi_pair_crypto_type  = NONE_CRYPT;
     wmip->wmi_grp_crypto_type   = NONE_CRYPT;
 
@@ skipping 39 matching lines @@
 {
     return(wmip->wmi_endpoint_id);
 }
 
 void
 wmi_shutdown(struct wmi_t *wmip)
 {
     if (wmip != NULL) {
         wlan_node_table_cleanup(&wmip->wmi_scan_table);
         if (A_IS_MUTEX_VALID(&wmip->wmi_lock)) {
+#ifdef THREAD_X
+            DELETE_WMI_LOCK(&wmip);
+#else
             A_MUTEX_DELETE(&wmip->wmi_lock);
+#endif
         }
         A_FREE(wmip);
     }
 }
 
 /*
  *  performs DIX to 802.3 encapsulation for transmit packets.
  *  uses passed in buffer.  Returns buffer or NULL if failed.
  *  Assumes the entire DIX header is contigous and that there is
  *  enough room in the buffer for a 802.3 mac header and LLC+SNAP headers.
@@ skipping 188 matching lines @@
             /* Extract the endpoint info from the TOS field in the IP header */
 
             userPriority = wmi_determine_userPriority (((A_UINT8 *)llcHdr) + sizeof(ATH_LLC_SNAP_HDR),layer2Priority);
         }
         else
         {
             userPriority = layer2Priority & 0x7;
         }
     }
 
+
+    /* workaround for WMM S5 */
+    if ((WMM_AC_VI == wmip->wmi_traffic_class) && ((5 == userPriority) || (4 == userPriority)))
+    {
+        userPriority = 1;
+    }
+
     trafficClass = convert_userPriority_to_trafficClass(userPriority);
 
     WMI_DATA_HDR_SET_UP(dtHdr, userPriority);
-    //dtHdr->info |= (userPriority & WMI_DATA_HDR_UP_MASK) << WMI_DATA_HDR_UP_SHIFT;  /* lower 3-bits are 802.1d priority */
+    /* lower 3-bits are 802.1d priority */
+    //dtHdr->info |= (userPriority & WMI_DATA_HDR_UP_MASK) << WMI_DATA_HDR_UP_SHIFT;
 
     LOCK_WMI(wmip);
     streamExists = wmip->wmi_fatPipeExists;
     UNLOCK_WMI(wmip);
 
     if (!(streamExists & (1 << trafficClass)))
     {
 
         A_MEMZERO(&cmd, sizeof(cmd));
         cmd.trafficClass = trafficClass;
@@ skipping 124 matching lines @@
         hdrsize = A_ROUND_UP(sizeof(struct ieee80211_qosframe),sizeof(A_UINT32));
         A_NETBUF_PULL(osbuf, hdrsize);
     } else if (subtype == IEEE80211_FC0_SUBTYPE_DATA) {
         A_NETBUF_PULL(osbuf, sizeof(struct ieee80211_frame));
     }
 
     datap = A_NETBUF_DATA(osbuf);
     llcHdr = (ATH_LLC_SNAP_HDR *)(datap);
 
     macHdr.typeOrLen = llcHdr->etherType;
+    A_MEMZERO(macHdr.dstMac, sizeof(macHdr.dstMac));
+    A_MEMZERO(macHdr.srcMac, sizeof(macHdr.srcMac));
 
     switch (wh.i_fc[1] & IEEE80211_FC1_DIR_MASK) {
     case IEEE80211_FC1_DIR_NODS:
         IEEE80211_ADDR_COPY(macHdr.dstMac, wh.i_addr1);
         IEEE80211_ADDR_COPY(macHdr.srcMac, wh.i_addr2);
         break;
     case IEEE80211_FC1_DIR_TODS:
         IEEE80211_ADDR_COPY(macHdr.dstMac, wh.i_addr3);
         IEEE80211_ADDR_COPY(macHdr.srcMac, wh.i_addr2);
         break;
@@ skipping 367 matching lines @@
         status = wmi_pspoll_event_rx(wmip, datap, len);
         break;
     case (WMI_DTIMEXPIRY_EVENTID):
         A_DPRINTF(DBG_WMI, (DBGFMT "WMI_DTIMEXPIRY_EVENT\n", DBGARG));
         status = wmi_dtimexpiry_event_rx(wmip, datap, len);
         break;
     case (WMI_SET_PARAMS_REPLY_EVENTID):
         A_DPRINTF(DBG_WMI, (DBGFMT "WMI_SET_PARAMS_REPLY Event\n", DBGARG));
         status = wmi_set_params_event_rx(wmip, datap, len);
         break;
+    case (WMI_ACM_REJECT_EVENTID):
+        A_DPRINTF(DBG_WMI, (DBGFMT "WMI_SET_PARAMS_REPLY Event\n", DBGARG));
+        status = wmi_acm_reject_event_rx(wmip, datap, len);
+        break;          
 #ifdef ATH_AR6K_11N_SUPPORT
     case (WMI_ADDBA_REQ_EVENTID):
         status = wmi_addba_req_event_rx(wmip, datap, len);
         break;
     case (WMI_ADDBA_RESP_EVENTID):
         status = wmi_addba_resp_event_rx(wmip, datap, len);
         break;
     case (WMI_DELBA_REQ_EVENTID):
         status = wmi_delba_req_event_rx(wmip, datap, len);
         break;
@@ skipping 200 matching lines @@
 
     A_WMI_NEIGHBORREPORT_EVENT(wmip->wmi_devt, numAps, ev->neighbor);
 
     return A_OK;
 }
 
 static A_STATUS
 wmi_disconnect_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 {
     WMI_DISCONNECT_EVENT *ev;
+    wmip->wmi_traffic_class = 100;
 
     if (len < sizeof(WMI_DISCONNECT_EVENT)) {
         return A_EINVAL;
     }
     A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
 
     ev = (WMI_DISCONNECT_EVENT *)datap;
 
     A_MEMZERO(wmip->wmi_bssid, sizeof(wmip->wmi_bssid));
 
@@ skipping 78 matching lines @@
     }
 
     if(!nodeCachingAllowed) {
         wmi_node_return(wmip, bss);
         return A_OK;
     }
 
     buf = datap + sizeof(WMI_BSS_INFO_HDR);
     len -= sizeof(WMI_BSS_INFO_HDR);
 
-    A_DPRINTF(DBG_WMI2, (DBGFMT "bssInfo event - ch %u, rssi %02x, "
-              "bssid \"%02x:%02x:%02x:%02x:%02x:%02x\"\n", DBGARG,
-              bih->channel, (unsigned char) bih->rssi, bih->bssid[0],
-              bih->bssid[1], bih->bssid[2], bih->bssid[3], bih->bssid[4],
-              bih->bssid[5]));
+        A_DPRINTF(DBG_WMI2, (DBGFMT "bssInfo event - ch %u, rssi %02x, "
+                "bssid \"%pM\"\n", DBGARG, bih->channel,
+                (unsigned char) bih->rssi, bih->bssid));
 
     if(wps_enable && (bih->frameType == PROBERESP_FTYPE) ) {
         wmi_node_return(wmip, bss);
         return A_OK;
     }
 
     if (bss != NULL) {
         /*
          * Free up the node.  Not the most efficient process given
          * we are about to allocate a new node but it is simple and should be
          * adequate.
          */
 
         /* In case of hidden AP, beacon will not have ssid,
          * but a directed probe response will have it,
          * so cache the probe-resp-ssid if already present. */
         if ((TRUE == is_probe_ssid) && (BEACON_FTYPE == bih->frameType))
         {
             A_UCHAR *ie_ssid;
 
             ie_ssid = bss->ni_cie.ie_ssid;
             if(ie_ssid && (ie_ssid[1] <= IEEE80211_NWID_LEN) && (ie_ssid[2] != 0))
             {
                 cached_ssid_len = ie_ssid[1];
                 memcpy(cached_ssid_buf, ie_ssid + 2, cached_ssid_len);
             }
         }
 
-        /* 
-         * Use the current average rssi of associated AP base on assumpiton 
+        /*
+         * Use the current average rssi of associated AP base on assumpiton
          * 1. Most os with GUI will update RSSI by wmi_get_stats_cmd() periodically
          * 2. wmi_get_stats_cmd(..) will be called when calling wmi_startscan_cmd(...)
          * The average value of RSSI give end-user better feeling for instance value of scan result
          * It also sync up RSSI info in GUI between scan result and RSSI signal icon
          */
-        if (bss && IEEE80211_ADDR_EQ(wmip->wmi_bssid, bih->bssid)) {
+        if (IEEE80211_ADDR_EQ(wmip->wmi_bssid, bih->bssid)) {
             bih->rssi = bss->ni_rssi;
             bih->snr  = bss->ni_snr;
-        } 
+        }
 
         wlan_node_reclaim(&wmip->wmi_scan_table, bss);
     }
 
     /*  beacon/probe response frame format
      *  [8] time stamp
      *  [2] beacon interval
      *  [2] capability information
      *  [tlv] ssid */
     beacon_ssid_len = buf[SSID_IE_LEN_INDEX];
@@ skipping 298 matching lines @@
     return A_OK;
 }
 #endif /* CONFIG_HOST_DSET_SUPPORT */
 
 static A_STATUS
 wmi_scanComplete_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 {
     WMI_SCAN_COMPLETE_EVENT *ev;
 
     ev = (WMI_SCAN_COMPLETE_EVENT *)datap;
+    if ((A_STATUS)ev->status == A_OK) {
+        wlan_refresh_inactive_nodes(&wmip->wmi_scan_table);
+    }
     A_WMI_SCANCOMPLETE_EVENT(wmip->wmi_devt, (A_STATUS) ev->status);
     is_probe_ssid = FALSE;
 
     return A_OK;
 }
 
 /*
  * Target is reporting a programming error.  This is for
  * developer aid only.  Target only checks a few common violations
  * and it is responsibility of host to do all error checking.
@@ skipping 152 matching lines @@
     A_WMI_REPORT_ERROR_EVENT(wmip->wmi_devt, (WMI_TARGET_ERROR_VAL) reply->errorVal);
 
     return A_OK;
 }
 
 static A_STATUS
 wmi_cac_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
 {
     WMI_CAC_EVENT *reply;
     WMM_TSPEC_IE *tspec_ie;
+    A_UINT16 activeTsids;
 
     if (len < sizeof(*reply)) {
         return A_EINVAL;
     }
     reply = (WMI_CAC_EVENT *)datap;
 
     A_DPRINTF(DBG_WMI, (DBGFMT "Enter\n", DBGARG));
 
     if ((reply->cac_indication == CAC_INDICATION_ADMISSION_RESP) &&
         (reply->statusCode != TSPEC_STATUS_CODE_ADMISSION_ACCEPTED)) {
         tspec_ie = (WMM_TSPEC_IE *) &(reply->tspecSuggestion);
 
         wmi_delete_pstream_cmd(wmip, reply->ac,
                 (tspec_ie->tsInfo_info >> TSPEC_TSID_S) & TSPEC_TSID_MASK);
     }
     else if (reply->cac_indication == CAC_INDICATION_NO_RESP) {
-        A_UINT16 activeTsids;
         A_UINT8 i;
 
         /* following assumes that there is only one outstanding ADDTS request
            when this event is received */
         LOCK_WMI(wmip);
         activeTsids = wmip->wmi_streamExistsForAC[reply->ac];
         UNLOCK_WMI(wmip);
 
         for (i = 0; i < sizeof(activeTsids) * 8; i++) {
             if ((activeTsids >> i) & 1) {
                 break;
             }
         }
         if (i < (sizeof(activeTsids) * 8)) {
             wmi_delete_pstream_cmd(wmip, reply->ac, i);
         }
     }
+        /*
+         * Ev#72990: Clear active tsids and Add missing handling
+         * for delete qos stream from AP
+         */
+    else if (reply->cac_indication == CAC_INDICATION_DELETE) {
+        A_UINT8 tsid = 0;
+
+        tspec_ie = (WMM_TSPEC_IE *) &(reply->tspecSuggestion);
+        tsid= ((tspec_ie->tsInfo_info >> TSPEC_TSID_S) & TSPEC_TSID_MASK);
+        LOCK_WMI(wmip);
+        wmip->wmi_streamExistsForAC[reply->ac] &= ~(1<<tsid);
+        activeTsids = wmip->wmi_streamExistsForAC[reply->ac];
+        UNLOCK_WMI(wmip);
+
+
+        /* Indicate stream inactivity to driver layer only if all tsids
+         * within this AC are deleted.
+         */
+       if (!activeTsids) {
+           A_WMI_STREAM_TX_INACTIVE(wmip->wmi_devt, reply->ac);
+           wmip->wmi_fatPipeExists &= ~(1 << reply->ac);
+        }
+    }
 
     A_WMI_CAC_EVENT(wmip->wmi_devt, reply->ac,
                 reply->cac_indication, reply->statusCode,
                 reply->tspecSuggestion);
 
     return A_OK;
 }
 
 static A_STATUS
 wmi_channel_change_event_rx(struct wmi_t *wmip, A_UINT8 *datap, int len)
@@ skipping 357 matching lines @@
 A_STATUS
 wmi_connect_cmd(struct wmi_t *wmip, NETWORK_TYPE netType,
                 DOT11_AUTH_MODE dot11AuthMode, AUTH_MODE authMode,
                 CRYPTO_TYPE pairwiseCrypto, A_UINT8 pairwiseCryptoLen,
                 CRYPTO_TYPE groupCrypto, A_UINT8 groupCryptoLen,
                 int ssidLength, A_UCHAR *ssid,
                 A_UINT8 *bssid, A_UINT16 channel, A_UINT32 ctrl_flags)
 {
     void *osbuf;
     WMI_CONNECT_CMD *cc;
+    wmip->wmi_traffic_class = 100;
 
     if ((pairwiseCrypto == NONE_CRYPT) && (groupCrypto != NONE_CRYPT)) {
         return A_EINVAL;
     }
     if ((pairwiseCrypto != NONE_CRYPT) && (groupCrypto == NONE_CRYPT)) {
         return A_EINVAL;
     }
 
     osbuf = A_NETBUF_ALLOC(sizeof(WMI_CONNECT_CMD));
     if (osbuf == NULL) {
@@ skipping 17 matching lines @@
     cc->pairwiseCryptoType  = pairwiseCrypto;
     cc->pairwiseCryptoLen   = pairwiseCryptoLen;
     cc->groupCryptoType     = groupCrypto;
     cc->groupCryptoLen      = groupCryptoLen;
     cc->channel             = channel;
     cc->ctrl_flags          = ctrl_flags;
 
     if (bssid != NULL) {
         A_MEMCPY(cc->bssid, bssid, ATH_MAC_LEN);
     }
-   
+
     wmip->wmi_pair_crypto_type  = pairwiseCrypto;
     wmip->wmi_grp_crypto_type   = groupCrypto;
 
     return (wmi_cmd_send(wmip, osbuf, WMI_CONNECT_CMDID, NO_SYNC_WMIFLAG));
 }
 
 A_STATUS
 wmi_reconnect_cmd(struct wmi_t *wmip, A_UINT8 *bssid, A_UINT16 channel)
 {
     void *osbuf;
     WMI_RECONNECT_CMD *cc;
+    wmip->wmi_traffic_class = 100;
 
     osbuf = A_NETBUF_ALLOC(sizeof(WMI_RECONNECT_CMD));
     if (osbuf == NULL) {
         return A_NO_MEMORY;
     }
 
     A_NETBUF_PUT(osbuf, sizeof(WMI_RECONNECT_CMD));
 
     cc = (WMI_RECONNECT_CMD *)(A_NETBUF_DATA(osbuf));
     A_MEMZERO(cc, sizeof(*cc));
 
     cc->channel = channel;
 
     if (bssid != NULL) {
         A_MEMCPY(cc->bssid, bssid, ATH_MAC_LEN);
     }
 
     return (wmi_cmd_send(wmip, osbuf, WMI_RECONNECT_CMDID, NO_SYNC_WMIFLAG));
 }
 
 A_STATUS
 wmi_disconnect_cmd(struct wmi_t *wmip)
 {
     A_STATUS status;
+    wmip->wmi_traffic_class = 100;
 
     /* Bug fix for 24817(elevator bug) - the disconnect command does not
        need to do a SYNC before.*/
     status = wmi_simple_cmd(wmip, WMI_DISCONNECT_CMDID);
 
     return status;
 }
 
 A_STATUS
 wmi_startscan_cmd(struct wmi_t *wmip, WMI_SCAN_TYPE scanType,
@@ skipping 878 matching lines @@
 
 /*
  * used to set the bit rate.  rate is in Kbps.  If rate == -1
  * then auto selection is used.
  */
 A_STATUS
 wmi_set_bitrate_cmd(struct wmi_t *wmip, A_INT32 dataRate, A_INT32 mgmtRate, A_INT32 ctlRate)
 {
     void *osbuf;
     WMI_BIT_RATE_CMD *cmd;
-    A_INT8 drix, mrix, crix;
+    A_INT8 drix, mrix, crix, ret_val;
 
     if (dataRate != -1) {
-        drix = wmi_validate_bitrate(wmip, dataRate);
-        if(drix == A_EINVAL){
+        ret_val = wmi_validate_bitrate(wmip, dataRate, &drix);
+        if(ret_val == A_EINVAL){
             return A_EINVAL;
         }
     } else {
         drix = -1;
     }
 
     if (mgmtRate != -1) {
-        mrix = wmi_validate_bitrate(wmip, mgmtRate);
-        if(mrix == A_EINVAL){
+        ret_val = wmi_validate_bitrate(wmip, mgmtRate, &mrix);
+        if(ret_val == A_EINVAL){
             return A_EINVAL;
         }
     } else {
         mrix = -1;
     }
     if (ctlRate != -1) {
-        crix = wmi_validate_bitrate(wmip, ctlRate);
-        if(crix == A_EINVAL){
+        ret_val = wmi_validate_bitrate(wmip, ctlRate, &crix);
+        if(ret_val == A_EINVAL){
             return A_EINVAL;
         }
     } else {
         crix = -1;
     }
     osbuf = A_NETBUF_ALLOC(sizeof(*cmd));
     if (osbuf == NULL) {
         return A_NO_MEMORY;
     }
 
@@ skipping 49 matching lines @@
                     isValid = FALSE;
                 }
             } else {
                 if ((rateIndex < MODE_GONLY_SUPPORT_RATE_START) || (rateIndex > MODE_GONLY_SUPPORT_RATE_STOP)) {
                     isValid = FALSE;
                 }
             }
             break;
 
         case WMI_11G_MODE:
-        case WMI_11AG_MODE:        
+        case WMI_11AG_MODE:
             if (wmip->wmi_ht_allowed[A_BAND_24GHZ]){
                 if ((rateIndex < MODE_G_SUPPORT_RATE_START) || (rateIndex > MODE_GHT20_SUPPORT_RATE_STOP)) {
                     isValid = FALSE;
                 }
             } else {
                 if ((rateIndex < MODE_G_SUPPORT_RATE_START) || (rateIndex > MODE_G_SUPPORT_RATE_STOP)) {
                     isValid = FALSE;
                 }
             }
-            break;        
+            break;
         default:
             A_ASSERT(FALSE);
             break;
     }
 
     return isValid;
 }
 
 A_INT8
-wmi_validate_bitrate(struct wmi_t *wmip, A_INT32 rate)
+wmi_validate_bitrate(struct wmi_t *wmip, A_INT32 rate, A_INT8 *rate_idx)
 {
     A_INT8 i;
-    if (rate != -1)
+
+    for (i=0;;i++)
     {
-        for (i=0;;i++)
-        {
-            if (wmi_rateTable[(A_UINT32) i][0] == 0) {
-                return A_EINVAL;
-            }
-            if (wmi_rateTable[(A_UINT32) i][0] == rate) {
-                break;
-            }
+        if (wmi_rateTable[(A_UINT32) i][0] == 0) {
+            return A_EINVAL;
         }
-    }
-    else{
-     i = -1;
+        if (wmi_rateTable[(A_UINT32) i][0] == rate) {
+            break;
+        }
     }
 
     if(wmi_is_bitrate_index_valid(wmip, (A_INT32) i) != TRUE) {
         return A_EINVAL;
     }
 
-    return i;
+    *rate_idx = i;
+    return A_OK;
 }
 
 A_STATUS
 wmi_set_fixrates_cmd(struct wmi_t *wmip, A_UINT32 fixRatesMask)
 {
     void *osbuf;
     WMI_FIX_RATES_CMD *cmd;
 #if 0
     A_INT32 rateIndex;
 /* This check does not work for AR6003 as the HT modes are enabled only when
@@ skipping 1841 matching lines @@
 wmi_find_Ssidnode (struct wmi_t *wmip, A_UCHAR *pSsid,
                    A_UINT32 ssidLength, A_BOOL bIsWPA2, A_BOOL bMatchSSID)
 {
     bss_t *node = NULL;
     node = wlan_find_Ssidnode (&wmip->wmi_scan_table, pSsid,
                                ssidLength, bIsWPA2, bMatchSSID);
     return node;
 }
 
 
+#ifdef THREAD_X
+void
+wmi_refresh_scan_table (struct wmi_t *wmip)
+{
+        wlan_refresh_inactive_nodes (&wmip->wmi_scan_table);
+}
+#endif
+
 void
 wmi_free_allnodes(struct wmi_t *wmip)
 {
     wlan_free_allnodes(&wmip->wmi_scan_table);
 }
 
 bss_t *
 wmi_find_node(struct wmi_t *wmip, const A_UINT8 *macaddr)
 {
     bss_t *ni=NULL;
@@ skipping 20 matching lines @@
                     A_UINT32 access_cookie,
                     A_UINT32 dset_size,
                     A_UINT32 dset_version,
                     A_UINT32 targ_handle,
                     A_UINT32 targ_reply_fn,
                     A_UINT32 targ_reply_arg)
 {
     void *osbuf;
     WMIX_DSETOPEN_REPLY_CMD *open_reply;
 
-    A_DPRINTF(DBG_WMI, (DBGFMT "Enter - wmip=0x%x\n", DBGARG, (int)wmip));
+    A_DPRINTF(DBG_WMI, (DBGFMT "Enter - wmip=0x%lx\n", DBGARG, (unsigned long)wmip));
 
     osbuf = A_NETBUF_ALLOC(sizeof(*open_reply));
     if (osbuf == NULL) {
         return A_NO_MEMORY;
     }
 
     A_NETBUF_PUT(osbuf, sizeof(*open_reply));
     open_reply = (WMIX_DSETOPEN_REPLY_CMD *)(A_NETBUF_DATA(osbuf));
 
     open_reply->status                   = status;
@@ skipping 48 matching lines @@
     else
     {
 
     }
 
     return A_OK;
 }
 
 
 
+static A_STATUS
+wmi_acm_reject_event_rx(struct wmi_t *wmip, A_UINT8 *datap, A_UINT32 len)
+{
+    WMI_ACM_REJECT_EVENT *ev;
+
+    ev = (WMI_ACM_REJECT_EVENT *)datap;
+    wmip->wmi_traffic_class = ev->trafficClass;
+    printk("ACM REJECT %d\n",wmip->wmi_traffic_class);
+    return A_OK;
+}
+
+
 #ifdef CONFIG_HOST_DSET_SUPPORT
 A_STATUS
 wmi_dset_data_reply(struct wmi_t *wmip,
                     A_UINT32 status,
                     A_UINT8 *user_buf,
                     A_UINT32 length,
                     A_UINT32 targ_buf,
                     A_UINT32 targ_reply_fn,
                     A_UINT32 targ_reply_arg)
 {
@@ skipping 862 matching lines @@
     }
 
     A_NETBUF_PUT(osbuf, sizeof(*htCap));
 
     band = (cmd->band)? A_BAND_5GHZ : A_BAND_24GHZ;
     wmip->wmi_ht_allowed[band] = (cmd->enable)? 1:0;
 
     htCap = (WMI_SET_HT_CAP_CMD *)(A_NETBUF_DATA(osbuf));
     A_MEMZERO(htCap, sizeof(*htCap));
     A_MEMCPY(htCap, cmd, sizeof(*htCap));
-    
+
     return (wmi_cmd_send(wmip, osbuf, WMI_SET_HT_CAP_CMDID,
                          NO_SYNC_WMIFLAG));
 }
 
 A_STATUS
 wmi_set_ht_op_cmd(struct wmi_t *wmip, A_UINT8 sta_chan_width)
 {
     void *osbuf;
     WMI_SET_HT_OP_CMD *htInfo;
 
@@ skipping 195 matching lines @@
     A_NETBUF_PUT(osbuf, sizeof(WMI_SET_PMK_CMD));
 
     p = (WMI_SET_PMK_CMD *)(A_NETBUF_DATA(osbuf));
     A_MEMZERO(p, sizeof(*p));
 
     A_MEMCPY(p->pmk, pmk, WMI_PMK_LEN);
 
     return (wmi_cmd_send(wmip, osbuf, WMI_SET_PMK_CMDID, NO_SYNC_WMIFLAG));
 }
 
+A_STATUS
+wmi_SGI_cmd(struct wmi_t *wmip, A_UINT32 sgiMask, A_UINT8 sgiPERThreshold)
+{
+    void *osbuf;
+    WMI_SET_TX_SGI_PARAM_CMD *cmd;
+
+    osbuf = A_NETBUF_ALLOC(sizeof(*cmd));
+    if (osbuf == NULL) {
+        return A_NO_MEMORY ;
+    }
+
+    A_NETBUF_PUT(osbuf, sizeof(*cmd));
+
+    cmd = (WMI_SET_TX_SGI_PARAM_CMD *)(A_NETBUF_DATA(osbuf));
+    A_MEMZERO(cmd, sizeof(*cmd));
+    cmd->sgiMask = sgiMask;
+    cmd->sgiPERThreshold = sgiPERThreshold;
+    return (wmi_cmd_send(wmip, osbuf, WMI_SET_TX_SGI_PARAM_CMDID,
+                         NO_SYNC_WMIFLAG));
+}
+
 bss_t *
 wmi_find_matching_Ssidnode (struct wmi_t *wmip, A_UCHAR *pSsid,
                    A_UINT32 ssidLength,
                    A_UINT32 dot11AuthMode, A_UINT32 authMode,
                    A_UINT32 pairwiseCryptoType, A_UINT32 grpwiseCryptoTyp)
 {
     bss_t *node = NULL;
     node = wlan_find_matching_Ssidnode (&wmip->wmi_scan_table, pSsid,
                                ssidLength, dot11AuthMode, authMode, pairwiseCryptoType, grpwiseCryptoTyp);
 
     return node;
 }
 
 A_UINT16
 wmi_ieee2freq (int chan)
 {
     A_UINT16 freq = 0;
     freq = wlan_ieee2freq (chan);
     return freq;
 
 }
 
 A_UINT32
 wmi_freq2ieee (A_UINT16 freq)
 {
     A_UINT16 chan = 0;
     chan = wlan_freq2ieee (freq);
     return chan;
 }