ath6kl: Bringing in the upstream version

chromeos/drivers/ath6kl/os/linux/wireless_ext.c

-/*
- *
- * Copyright (c) 2004-2010 Atheros Communications Inc.
- * 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;
+//------------------------------------------------------------------------------
+// Copyright (c) 2004-2010 Atheros Communications Inc.
+// All rights reserved.
 //
-// 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.
 //
 //
- *
- */
+//
+// Author(s): ="Atheros"
+//------------------------------------------------------------------------------
 
 #include "ar6000_drv.h"
 
+#define IWE_STREAM_ADD_EVENT(p1, p2, p3, p4, p5) \
+    iwe_stream_add_event((p1), (p2), (p3), (p4), (p5))
+
+#define IWE_STREAM_ADD_POINT(p1, p2, p3, p4, p5) \
+    iwe_stream_add_point((p1), (p2), (p3), (p4), (p5))
+
+#define IWE_STREAM_ADD_VALUE(p1, p2, p3, p4, p5, p6) \
+    iwe_stream_add_value((p1), (p2), (p3), (p4), (p5), (p6))
+
 static void ar6000_set_quality(struct iw_quality *iq, A_INT8 rssi);
 extern unsigned int wmitimeout;
 extern A_WAITQUEUE_HEAD arEvent;
 
 #if WIRELESS_EXT > 14
 /*
  * Encode a WPA or RSN information element as a custom
  * element using the hostap format.
  */
 static u_int
@@ skipping 62 matching lines @@
     end_buf = param->end_buf;
 
     cie = &ni->ni_cie;
 
     if ((end_buf - current_ev) > IW_EV_ADDR_LEN)
     {
         A_MEMZERO(&iwe, sizeof(iwe));
         iwe.cmd = SIOCGIWAP;
         iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
         A_MEMCPY(iwe.u.ap_addr.sa_data, ni->ni_macaddr, 6);
-        current_ev = iwe_stream_add_event(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe,
-                          IW_EV_ADDR_LEN);
+        current_ev = IWE_STREAM_ADD_EVENT(param->info, current_ev, end_buf,
+                                          &iwe, IW_EV_ADDR_LEN);
     }
     param->bytes_needed += IW_EV_ADDR_LEN;
 
     data_len = cie->ie_ssid[1] + IW_EV_POINT_LEN;
     if ((end_buf - current_ev) > data_len)
     {
         A_MEMZERO(&iwe, sizeof(iwe));
         iwe.cmd = SIOCGIWESSID;
         iwe.u.data.flags = 1;
         iwe.u.data.length = cie->ie_ssid[1];
-        current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe,
-                          (char*)&cie->ie_ssid[2]);
+        current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
+                                          &iwe, (char*)&cie->ie_ssid[2]);
     }
     param->bytes_needed += data_len;
 
     if (cie->ie_capInfo & (IEEE80211_CAPINFO_ESS|IEEE80211_CAPINFO_IBSS)) {
         if ((end_buf - current_ev) > IW_EV_UINT_LEN)
         {
             A_MEMZERO(&iwe, sizeof(iwe));
             iwe.cmd = SIOCGIWMODE;
             iwe.u.mode = cie->ie_capInfo & IEEE80211_CAPINFO_ESS ?
                          IW_MODE_MASTER : IW_MODE_ADHOC;
-            current_ev = iwe_stream_add_event(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe,
-                          IW_EV_UINT_LEN);
+            current_ev = IWE_STREAM_ADD_EVENT(param->info, current_ev, end_buf,
+                                              &iwe, IW_EV_UINT_LEN);
         }
         param->bytes_needed += IW_EV_UINT_LEN;
     }
 
     if ((end_buf - current_ev) > IW_EV_FREQ_LEN)
     {
         A_MEMZERO(&iwe, sizeof(iwe));
         iwe.cmd = SIOCGIWFREQ;
         iwe.u.freq.m = cie->ie_chan * 100000;
         iwe.u.freq.e = 1;
-        current_ev = iwe_stream_add_event(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe,
-                          IW_EV_FREQ_LEN);
+        current_ev = IWE_STREAM_ADD_EVENT(param->info, current_ev, end_buf,
+                                          &iwe, IW_EV_FREQ_LEN);
     }
     param->bytes_needed += IW_EV_FREQ_LEN;
 
     if ((end_buf - current_ev) > IW_EV_QUAL_LEN)
     {
         A_MEMZERO(&iwe, sizeof(iwe));
         iwe.cmd = IWEVQUAL;
         ar6000_set_quality(&iwe.u.qual, ni->ni_snr);
-        current_ev = iwe_stream_add_event(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe,
-                          IW_EV_QUAL_LEN);
+        current_ev = IWE_STREAM_ADD_EVENT(param->info, current_ev, end_buf,
+                                          &iwe, IW_EV_QUAL_LEN);
     }
     param->bytes_needed += IW_EV_QUAL_LEN;
 
     if ((end_buf - current_ev) > IW_EV_POINT_LEN)
     {
         A_MEMZERO(&iwe, sizeof(iwe));
         iwe.cmd = SIOCGIWENCODE;
         if (cie->ie_capInfo & IEEE80211_CAPINFO_PRIVACY) {
             iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
         } else {
             iwe.u.data.flags = IW_ENCODE_DISABLED;
         }
         iwe.u.data.length = 0;
-        current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe, "");
+        current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
+                                          &iwe, "");
     }
     param->bytes_needed += IW_EV_POINT_LEN;
 
     /* supported bit rate */
     A_MEMZERO(&iwe, sizeof(iwe));
     iwe.cmd = SIOCGIWRATE;
     iwe.u.bitrate.fixed = 0;
     iwe.u.bitrate.disabled = 0;
     iwe.u.bitrate.value = 0;
     current_val = current_ev + IW_EV_LCP_LEN;
     param->bytes_needed += IW_EV_LCP_LEN;
 
     if (cie->ie_rates != NULL) {
         rate_len = cie->ie_rates[1];
         data_len = (rate_len * (IW_EV_PARAM_LEN - IW_EV_LCP_LEN));
         if ((end_buf - current_ev) > data_len)
         {
             for (j = 0; j < rate_len; j++) {
                     unsigned char val;
                     val = cie->ie_rates[2 + j];
                     iwe.u.bitrate.value =
                         (val >= 0x80)? ((val - 0x80) * 500000): (val * 500000);
-                    current_val = iwe_stream_add_value(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                                      param->info,
-#endif
-                                      current_ev,
-                                      current_val,
-                                      end_buf,
-                                      &iwe,
-                                      IW_EV_PARAM_LEN);
+                    current_val = IWE_STREAM_ADD_VALUE(param->info, current_ev,
+                                                       current_val, end_buf,
+                                                       &iwe, IW_EV_PARAM_LEN);
             }
         }
         param->bytes_needed += data_len;
     }
 
     if (cie->ie_xrates != NULL) {
         rate_len = cie->ie_xrates[1];
         data_len = (rate_len * (IW_EV_PARAM_LEN - IW_EV_LCP_LEN));
         if ((end_buf - current_ev) > data_len)
         {
             for (j = 0; j < rate_len; j++) {
                     unsigned char val;
                     val = cie->ie_xrates[2 + j];
                     iwe.u.bitrate.value =
                         (val >= 0x80)? ((val - 0x80) * 500000): (val * 500000);
-                    current_val = iwe_stream_add_value(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                                      param->info,
-#endif
-                                      current_ev,
-                                      current_val,
-                                      end_buf,
-                                      &iwe,
-                                      IW_EV_PARAM_LEN);
+                    current_val = IWE_STREAM_ADD_VALUE(param->info, current_ev,
+                                                       current_val, end_buf,
+                                                       &iwe, IW_EV_PARAM_LEN);
             }
         }
         param->bytes_needed += data_len;
     }
     /* remove fixed header if no rates were added */
     if ((current_val - current_ev) > IW_EV_LCP_LEN)
         current_ev = current_val;
 
 #if WIRELESS_EXT >= 18
     /* IE */
     if (cie->ie_wpa != NULL) {
         data_len = cie->ie_wpa[1] + 2 + IW_EV_POINT_LEN;
         if ((end_buf - current_ev) > data_len)
         {
             A_MEMZERO(&iwe, sizeof(iwe));
             iwe.cmd = IWEVGENIE;
             iwe.u.data.length = cie->ie_wpa[1] + 2;
-            current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe, (char*)cie->ie_wpa);
+            current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
+                                              &iwe, (char*)cie->ie_wpa);
         }
         param->bytes_needed += data_len;
     }
 
     if (cie->ie_rsn != NULL && cie->ie_rsn[0] == IEEE80211_ELEMID_RSN) {
         data_len = cie->ie_rsn[1] + 2 + IW_EV_POINT_LEN;
         if ((end_buf - current_ev) > data_len)
         {
             A_MEMZERO(&iwe, sizeof(iwe));
             iwe.cmd = IWEVGENIE;
             iwe.u.data.length = cie->ie_rsn[1] + 2;
-            current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe, (char*)cie->ie_rsn);
+            current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
+                                              &iwe, (char*)cie->ie_rsn);
         }
         param->bytes_needed += data_len;
     }
 
 #endif /* WIRELESS_EXT >= 18 */
 
     if ((end_buf - current_ev) > IW_EV_CHAR_LEN)
     {
         /* protocol */
         A_MEMZERO(&iwe, sizeof(iwe));
         iwe.cmd = SIOCGIWNAME;
         switch (get_bss_phy_capability(ni)) {
         case WMI_11A_CAPABILITY:
             snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11a");
             break;
         case WMI_11G_CAPABILITY:
             snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11g");
             break;
         case WMI_11NA_CAPABILITY:
             snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11na");
             break;
         case WMI_11NG_CAPABILITY:
             snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11ng");
             break;
         default:
             snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b");
             break;
         }
-        current_ev = iwe_stream_add_event(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe, IW_EV_CHAR_LEN);
+        current_ev = IWE_STREAM_ADD_EVENT(param->info, current_ev, end_buf,
+                                          &iwe, IW_EV_CHAR_LEN);
     }
     param->bytes_needed += IW_EV_CHAR_LEN;
 
 #if WIRELESS_EXT > 14
     A_MEMZERO(&iwe, sizeof(iwe));
     iwe.cmd = IWEVCUSTOM;
     iwe.u.data.length = snprintf(buf, sizeof(buf), "bcn_int=%d", cie->ie_beaconInt);
     data_len = iwe.u.data.length + IW_EV_POINT_LEN;
     if ((end_buf - current_ev) > data_len)
     {
-        current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe, buf);
+        current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
+                                          &iwe, buf);
     }
     param->bytes_needed += data_len;
 
 #if WIRELESS_EXT < 18
     if (cie->ie_wpa != NULL) {
         static const char wpa_leader[] = "wpa_ie=";
         data_len = (sizeof(wpa_leader) - 1) + ((cie->ie_wpa[1]+2) * 2) + IW_EV_POINT_LEN;
         if ((end_buf - current_ev) > data_len)
         {
             A_MEMZERO(&iwe, sizeof(iwe));
             iwe.cmd = IWEVCUSTOM;
             iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_wpa,
                                           cie->ie_wpa[1]+2,
                                           wpa_leader, sizeof(wpa_leader)-1);
 
             if (iwe.u.data.length != 0) {
-                current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                              param->info,
-#endif
-                              current_ev, end_buf, &iwe, buf);
+                current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, 
+                                                  end_buf, &iwe, buf);
             }
         }
         param->bytes_needed += data_len;
     }
 
     if (cie->ie_rsn != NULL && cie->ie_rsn[0] == IEEE80211_ELEMID_RSN) {
         static const char rsn_leader[] = "rsn_ie=";
         data_len = (sizeof(rsn_leader) - 1) + ((cie->ie_rsn[1]+2) * 2) + IW_EV_POINT_LEN;
         if ((end_buf - current_ev) > data_len)
         {
             A_MEMZERO(&iwe, sizeof(iwe));
             iwe.cmd = IWEVCUSTOM;
             iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_rsn,
                                           cie->ie_rsn[1]+2,
                                           rsn_leader, sizeof(rsn_leader)-1);
 
             if (iwe.u.data.length != 0) {
-                current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                              param->info,
-#endif
-                              current_ev, end_buf, &iwe, buf);
+                current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, 
+                                                  end_buf, &iwe, buf);
             }
         }
         param->bytes_needed += data_len;
     }
 #endif /* WIRELESS_EXT < 18 */
 
     if (cie->ie_wmm != NULL) {
         static const char wmm_leader[] = "wmm_ie=";
         data_len = (sizeof(wmm_leader) - 1) + ((cie->ie_wmm[1]+2) * 2) + IW_EV_POINT_LEN;
         if ((end_buf - current_ev) > data_len)
         {
             A_MEMZERO(&iwe, sizeof(iwe));
             iwe.cmd = IWEVCUSTOM;
             iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_wmm,
                                           cie->ie_wmm[1]+2,
                                           wmm_leader, sizeof(wmm_leader)-1);
             if (iwe.u.data.length != 0) {
-                current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                              param->info,
-#endif
-                              current_ev, end_buf, &iwe, buf);
+                current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev,
+                                                  end_buf, &iwe, buf);
             }
         }
         param->bytes_needed += data_len;
     }
 
     if (cie->ie_ath != NULL) {
         static const char ath_leader[] = "ath_ie=";
         data_len = (sizeof(ath_leader) - 1) + ((cie->ie_ath[1]+2) * 2) + IW_EV_POINT_LEN;
         if ((end_buf - current_ev) > data_len)
         {
             A_MEMZERO(&iwe, sizeof(iwe));
             iwe.cmd = IWEVCUSTOM;
             iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_ath,
                                           cie->ie_ath[1]+2,
                                           ath_leader, sizeof(ath_leader)-1);
             if (iwe.u.data.length != 0) {
-                current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                              param->info,
-#endif
-                              current_ev, end_buf, &iwe, buf);
+                current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev,
+                                                  end_buf, &iwe, buf);
             }
         }
         param->bytes_needed += data_len;
     }
 
 #ifdef WAPI_ENABLE
     if (cie->ie_wapi != NULL) {
         static const char wapi_leader[] = "wapi_ie=";
         data_len = (sizeof(wapi_leader) - 1) + ((cie->ie_wapi[1] + 2) * 2) + IW_EV_POINT_LEN;
         if ((end_buf - current_ev) > data_len) {
             A_MEMZERO(&iwe, sizeof(iwe));
             iwe.cmd = IWEVCUSTOM;
             iwe.u.data.length = encode_ie(buf, sizeof(buf), cie->ie_wapi,
                                       cie->ie_wapi[1] + 2,
                                       wapi_leader, sizeof(wapi_leader) - 1);
             if (iwe.u.data.length != 0) {
-                current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                                              param->info,
-#endif
-                                              current_ev, end_buf, &iwe, buf);
+                current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev,
+                                                  end_buf, &iwe, buf);
             }
         }
         param->bytes_needed += data_len;
     }
 #endif /* WAPI_ENABLE */
 
 #endif /* WIRELESS_EXT > 14 */
 
 #if WIRELESS_EXT >= 18
     if (cie->ie_wsc != NULL) {
         data_len = (cie->ie_wsc[1] + 2) + IW_EV_POINT_LEN;
         if ((end_buf - current_ev) > data_len)
         {
             A_MEMZERO(&iwe, sizeof(iwe));
             iwe.cmd = IWEVGENIE;
             iwe.u.data.length = cie->ie_wsc[1] + 2;
-            current_ev = iwe_stream_add_point(
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
-                          param->info,
-#endif
-                          current_ev, end_buf, &iwe, (char*)cie->ie_wsc);
+            current_ev = IWE_STREAM_ADD_POINT(param->info, current_ev, end_buf,
+                                              &iwe, (char*)cie->ie_wsc);
         }
         param->bytes_needed += data_len;
     }
 #endif /* WIRELESS_EXT >= 18 */
 
     param->current_ev = current_ev;
 }
 
 int
 ar6000_ioctl_giwscan(struct net_device *dev,
@@ skipping 12 matching lines @@
         return -EIO;
     }
 
     if (ar->arWmiReady == FALSE) {
         return -EIO;
     }
 
     param.current_ev = extra;
     param.end_buf = extra + data->length;
     param.bytes_needed = 0;
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
     param.info = info;
-#endif
 
     /* Translate data to WE format */
     wmi_iterate_nodes(ar->arWmi, ar6000_scan_node, &param);
 
     /* check if bytes needed is greater than bytes consumed */
     if (param.bytes_needed > (param.current_ev - extra))
     {
         /* Request one byte more than needed, because when "data->length" equals bytes_needed,
         it is not possible to add the last event data as all iwe_stream_add_xxxxx() functions
         checks whether (cur_ptr + ev_len) < end_ptr, due to this one more retry would happen*/
@@ skipping 257 matching lines @@
 /*
  * SIOCSIWRATE
  */
 int
 ar6000_ioctl_siwrate(struct net_device *dev,
             struct iw_request_info *info,
             struct iw_param *rrq, char *extra)
 {
     AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
     A_UINT32  kbps;
+    A_INT8  rate_idx;
 
     if (is_iwioctl_allowed(ar->arNextMode, info->cmd) != A_OK) {
         A_PRINTF("wext_ioctl: cmd=0x%x not allowed in this mode\n", info->cmd);
         return -EOPNOTSUPP;
     }
 
     if (rrq->fixed) {
         kbps = rrq->value / 1000;           /* rrq->value is in bps */
     } else {
         kbps = -1;                          /* -1 indicates auto rate */
     }
-    if(kbps != -1 && wmi_validate_bitrate(ar->arWmi, kbps) == A_EINVAL)
+    if(kbps != -1 && wmi_validate_bitrate(ar->arWmi, kbps, &rate_idx) != A_OK)
     {
         AR_DEBUG_PRINTF(ATH_DEBUG_ERR,("BitRate is not Valid %d\n", kbps));
         return -EINVAL;
     }
     ar->arBitRate = kbps;
     if(ar->arWmiReady == TRUE)
     {
         if (wmi_set_bitrate_cmd(ar->arWmi, kbps, -1, -1) != A_OK) {
             return -EINVAL;
         }
@@ skipping 1612 matching lines @@
     if (ar->arConnected != TRUE) {
         return -EINVAL;
     }
 
     A_MEMCPY(&ap_addr->sa_data, ar->arBssid, sizeof(ar->arBssid));
     ap_addr->sa_family = ARPHRD_ETHER;
 
     return 0;
 }
 
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
+#if (WIRELESS_EXT >= 18)
 /*
  * SIOCSIWMLME
  */
 int
 ar6000_ioctl_siwmlme(struct net_device *dev,
             struct iw_request_info *info,
             struct iw_point *data, char *extra)
 {
     AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev);
 
@@ skipping 56 matching lines @@
                 /* fall through */
             default:
                 up(&ar->arSem);
                 return -EOPNOTSUPP;
         }
     }
 
     up(&ar->arSem);
     return 0;
 }
-#endif /* LINUX_VERSION_CODE */
+#endif /* WIRELESS_EXT >= 18 */
 
 /*
  * SIOCGIWAPLIST
  */
 int
 ar6000_ioctl_iwaplist(struct net_device *dev,
             struct iw_request_info *info,
             struct iw_point *data, char *extra)
 {
     return -EIO;            /* for now */
@@ skipping 53 matching lines @@
 #if WIRELESS_EXT >= 18
     if (data->pointer && (data->length == sizeof(struct iw_scan_req)))
     {
         if ((data->flags & IW_SCAN_THIS_ESSID) == IW_SCAN_THIS_ESSID)
         {
             struct iw_scan_req req;
             if (copy_from_user(&req, data->pointer, sizeof(struct iw_scan_req)))
                 return -EIO;
             if (wmi_probedSsid_cmd(ar->arWmi, 1, SPECIFIC_SSID_FLAG, req.essid_len, req.essid) != A_OK)
                 return -EIO;
+            ar->scanSpecificSsid = 1;
         }
         else
         {
-            if (wmi_probedSsid_cmd(ar->arWmi, 1, DISABLE_SSID_FLAG, 0, NULL) != A_OK)
-                return -EIO;
+            if (ar->scanSpecificSsid) {
+                if (wmi_probedSsid_cmd(ar->arWmi, 1, DISABLE_SSID_FLAG, 0, NULL) != A_OK)
+                    return -EIO;
+                 ar->scanSpecificSsid = 0;
+            }
         }
     }
     else
     {
-        if (wmi_probedSsid_cmd(ar->arWmi, 1, DISABLE_SSID_FLAG, 0, NULL) != A_OK)
-            return -EIO;
+        if (ar->scanSpecificSsid) {
+            if (wmi_probedSsid_cmd(ar->arWmi, 1, DISABLE_SSID_FLAG, 0, NULL) != A_OK)
+                return -EIO;
+             ar->scanSpecificSsid = 0;
+        }
     }
 #endif
 #endif /* ANDROID_ENV */
 
     if (wmi_startscan_cmd(ar->arWmi, WMI_LONG_SCAN, FALSE, FALSE, \
                           0, 0, 0, NULL) != A_OK) {
         ret = -EIO;
     }
 
     if (ret == 0) {
@@ skipping 126 matching lines @@
     (iw_handler) NULL /* not used */,           /* SIOCSIWPRIV */
     (iw_handler) NULL /* kernel code */,        /* SIOCGIWPRIV */
     (iw_handler) NULL /* not used */,           /* SIOCSIWSTATS */
     (iw_handler) NULL /* kernel code */,        /* SIOCGIWSTATS */
     (iw_handler) NULL,                          /* SIOCSIWSPY */
     (iw_handler) NULL,                          /* SIOCGIWSPY */
     (iw_handler) NULL,                          /* SIOCSIWTHRSPY */
     (iw_handler) NULL,                          /* SIOCGIWTHRSPY */
     (iw_handler) ar6000_ioctl_siwap,            /* SIOCSIWAP */
     (iw_handler) ar6000_ioctl_giwap,            /* SIOCGIWAP */
-#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,13)
+#if (WIRELESS_EXT >= 18)
     (iw_handler) ar6000_ioctl_siwmlme,          /* SIOCSIWMLME */
 #else
     (iw_handler) NULL,                          /* -- hole -- */
-#endif  /* LINUX_VERSION_CODE */
+#endif  /* WIRELESS_EXT >= 18 */
     (iw_handler) ar6000_ioctl_iwaplist,         /* SIOCGIWAPLIST */
     (iw_handler) ar6000_ioctl_siwscan,          /* SIOCSIWSCAN */
     (iw_handler) ar6000_ioctl_giwscan,          /* SIOCGIWSCAN */
     (iw_handler) W_PROTO(ar6000_ioctl_siwessid),/* SIOCSIWESSID */
     (iw_handler) ar6000_ioctl_giwessid,         /* SIOCGIWESSID */
     (iw_handler) NULL,                          /* SIOCSIWNICKN */
     (iw_handler) NULL,                          /* SIOCGIWNICKN */
     (iw_handler) NULL,                          /* -- hole -- */
     (iw_handler) NULL,                          /* -- hole -- */
     (iw_handler) ar6000_ioctl_siwrate,          /* SIOCSIWRATE */
@@ skipping 24 matching lines @@
     (iw_handler) ar6000_ioctl_siwpmksa,         /* SIOCSIWPMKSA */
 #endif // WIRELESS_EXT >= 18
 };
 
 struct iw_handler_def ath_iw_handler_def = {
     .standard         = (iw_handler *)ath_handlers,
     .num_standard     = ARRAY_SIZE(ath_handlers),
     .private          = NULL,
     .num_private      = 0,
 };