//------------------------------------------------------------------------------ // Copyright (c) 2004-2010 Atheros Communications Inc. // All rights reserved. // // // // 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 encode_ie(void *buf, size_t bufsize, const u_int8_t *ie, size_t ielen, const char *leader, size_t leader_len) { u_int8_t *p; int i; if (bufsize < leader_len) return 0; p = buf; memcpy(p, leader, leader_len); bufsize -= leader_len; p += leader_len; for (i = 0; i < ielen && bufsize > 2; i++) { p += sprintf((char*)p, "%02x", ie[i]); bufsize -= 2; } return (i == ielen ? p - (u_int8_t *)buf : 0); } #endif /* WIRELESS_EXT > 14 */ static A_UINT8 get_bss_phy_capability(bss_t *bss) { A_UINT8 capability = 0; struct ieee80211_common_ie *cie = &bss->ni_cie; #define CHAN_IS_11A(x) (!((x >= 2412) && (x <= 2484))) if (CHAN_IS_11A(cie->ie_chan)) { if (cie->ie_htcap) { capability = WMI_11NA_CAPABILITY; } else { capability = WMI_11A_CAPABILITY; } } else if ((cie->ie_erp) || (cie->ie_xrates)) { if (cie->ie_htcap) { capability = WMI_11NG_CAPABILITY; } else { capability = WMI_11G_CAPABILITY; } } return capability; } void ar6000_scan_node(void *arg, bss_t *ni) { struct iw_event iwe; #if WIRELESS_EXT > 14 char buf[256]; #endif struct ar_giwscan_param *param; A_CHAR *current_ev; A_CHAR *end_buf; struct ieee80211_common_ie *cie; A_CHAR *current_val; A_INT32 j; A_UINT32 rate_len, data_len = 0; param = (struct ar_giwscan_param *)arg; current_ev = param->current_ev; 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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, struct iw_request_info *info, struct iw_point *data, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); struct ar_giwscan_param param; 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (ar->arWmiReady == FALSE) { return -EIO; } param.current_ev = extra; param.end_buf = extra + data->length; param.bytes_needed = 0; param.info = info; /* Translate data to WE format */ wmi_iterate_nodes(ar->arWmi, ar6000_scan_node, ¶m); /* 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*/ data->length = param.bytes_needed + 1; return -E2BIG; } return 0; } extern int reconnect_flag; /* SIOCSIWESSID */ static int ar6000_ioctl_siwessid(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *ssid) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); A_STATUS status; A_UINT8 arNetworkType; A_UINT8 prevMode = ar->arNetworkType; 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 (ar->bIsDestroyProgress) { return -EBUSY; } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (ar->arWmiReady == FALSE) { return -EIO; } #if defined(WIRELESS_EXT) if (WIRELESS_EXT >= 20) { data->length += 1; } #endif /* * iwconfig passes a null terminated string with length including this * so we need to account for this */ if (data->flags && (!data->length || (data->length == 1) || ((data->length - 1) > sizeof(ar->arSsid)))) { /* * ssid is invalid */ return -EINVAL; } if (ar->arNextMode == AP_NETWORK) { /* SSID change for AP network - Will take effect on commit */ if(A_MEMCMP(ar->arSsid,ssid,32) != 0) { ar->arSsidLen = data->length - 1; A_MEMCPY(ar->arSsid, ssid, ar->arSsidLen); ar->ap_profile_flag = 1; /* There is a change in profile */ } return 0; } else if(ar->arNetworkType == AP_NETWORK) { A_UINT8 ctr; struct sk_buff *skb; /* We are switching from AP to STA | IBSS mode, cleanup the AP state */ for (ctr=0; ctr < AP_MAX_NUM_STA; ctr++) { remove_sta(ar, ar->sta_list[ctr].mac, 0); } A_MUTEX_LOCK(&ar->mcastpsqLock); while (!A_NETBUF_QUEUE_EMPTY(&ar->mcastpsq)) { skb = A_NETBUF_DEQUEUE(&ar->mcastpsq); A_NETBUF_FREE(skb); } A_MUTEX_UNLOCK(&ar->mcastpsqLock); } /* Added for bug 25178, return an IOCTL error instead of target returning Illegal parameter error when either the BSSID or channel is missing and we cannot scan during connect. */ if (data->flags) { if (ar->arSkipScan == TRUE && (ar->arChannelHint == 0 || (!ar->arReqBssid[0] && !ar->arReqBssid[1] && !ar->arReqBssid[2] && !ar->arReqBssid[3] && !ar->arReqBssid[4] && !ar->arReqBssid[5]))) { return -EINVAL; } } if (down_interruptible(&ar->arSem)) { return -ERESTARTSYS; } if (ar->bIsDestroyProgress || ar->arWlanState == WLAN_DISABLED) { up(&ar->arSem); return -EBUSY; } if (ar->arTxPending[wmi_get_control_ep(ar->arWmi)]) { /* * sleep until the command queue drains */ wait_event_interruptible_timeout(arEvent, ar->arTxPending[wmi_get_control_ep(ar->arWmi)] == 0, wmitimeout * HZ); if (signal_pending(current)) { return -EINTR; } } if (!data->flags) { arNetworkType = ar->arNetworkType; #ifdef ATH6K_CONFIG_CFG80211 if (ar->arConnected) { #endif /* ATH6K_CONFIG_CFG80211 */ ar6000_init_profile_info(ar); #ifdef ATH6K_CONFIG_CFG80211 } #endif /* ATH6K_CONFIG_CFG80211 */ ar->arNetworkType = arNetworkType; } /* Update the arNetworkType */ ar->arNetworkType = ar->arNextMode; if ((prevMode != AP_NETWORK) && ((ar->arSsidLen) || ((ar->arSsidLen == 0) && ar->arConnected) || (!data->flags))) { if ((!data->flags) || (A_MEMCMP(ar->arSsid, ssid, ar->arSsidLen) != 0) || (ar->arSsidLen != (data->length - 1))) { /* * SSID set previously or essid off has been issued. * * Disconnect Command is issued in two cases after wmi is ready * (1) ssid is different from the previous setting * (2) essid off has been issued * */ if (ar->arWmiReady == TRUE) { reconnect_flag = 0; status = wmi_setPmkid_cmd(ar->arWmi, ar->arBssid, NULL, 0); status = wmi_disconnect_cmd(ar->arWmi); A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); ar->arSsidLen = 0; if (ar->arSkipScan == FALSE) { A_MEMZERO(ar->arReqBssid, sizeof(ar->arReqBssid)); } if (!data->flags) { up(&ar->arSem); return 0; } } else { up(&ar->arSem); } } else { /* * SSID is same, so we assume profile hasn't changed. * If the interface is up and wmi is ready, we issue * a reconnect cmd. Issue a reconnect only we are already * connected. */ if((ar->arConnected == TRUE) && (ar->arWmiReady == TRUE)) { reconnect_flag = TRUE; status = wmi_reconnect_cmd(ar->arWmi,ar->arReqBssid, ar->arChannelHint); up(&ar->arSem); if (status != A_OK) { return -EIO; } return 0; } else{ /* * Dont return if connect is pending. */ if(!(ar->arConnectPending)) { up(&ar->arSem); return 0; } } } } ar->arSsidLen = data->length - 1; A_MEMCPY(ar->arSsid, ssid, ar->arSsidLen); if (ar6000_connect_to_ap(ar)!= A_OK) { up(&ar->arSem); return -EIO; }else{ up(&ar->arSem); } return 0; } /* SIOCGIWESSID */ static int ar6000_ioctl_giwessid(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *essid) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (!ar->arSsidLen) { return -EINVAL; } data->flags = 1; data->length = ar->arSsidLen; A_MEMCPY(essid, ar->arSsid, ar->arSsidLen); return 0; } void ar6000_install_static_wep_keys(AR_SOFTC_T *ar) { A_UINT8 index; A_UINT8 keyUsage; for (index = WMI_MIN_KEY_INDEX; index <= WMI_MAX_KEY_INDEX; index++) { if (ar->arWepKeyList[index].arKeyLen) { keyUsage = GROUP_USAGE; if (index == ar->arDefTxKeyIndex) { keyUsage |= TX_USAGE; } wmi_addKey_cmd(ar->arWmi, index, WEP_CRYPT, keyUsage, ar->arWepKeyList[index].arKeyLen, NULL, ar->arWepKeyList[index].arKey, KEY_OP_INIT_VAL, NULL, NO_SYNC_WMIFLAG); } } } /* * 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, &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; } } return 0; } /* * SIOCGIWRATE */ int ar6000_ioctl_giwrate(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); int ret = 0; 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 (ar->bIsDestroyProgress) { return -EBUSY; } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if ((ar->arNextMode != AP_NETWORK && !ar->arConnected) || ar->arWmiReady == FALSE) { rrq->value = 1000 * 1000; return 0; } if (down_interruptible(&ar->arSem)) { return -ERESTARTSYS; } if (ar->bIsDestroyProgress || ar->arWlanState == WLAN_DISABLED) { up(&ar->arSem); return -EBUSY; } ar->arBitRate = 0xFFFF; if (wmi_get_bitrate_cmd(ar->arWmi) != A_OK) { up(&ar->arSem); return -EIO; } wait_event_interruptible_timeout(arEvent, ar->arBitRate != 0xFFFF, wmitimeout * HZ); if (signal_pending(current)) { ret = -EINTR; } /* If the interface is down or wmi is not ready or the target is not connected - return the value stored in the device structure */ if (!ret) { if (ar->arBitRate == -1) { rrq->fixed = TRUE; rrq->value = 0; } else { rrq->value = ar->arBitRate * 1000; } } up(&ar->arSem); return ret; } /* * SIOCSIWTXPOW */ static int ar6000_ioctl_siwtxpow(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_UINT8 dbM; 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (rrq->disabled) { return -EOPNOTSUPP; } if (rrq->fixed) { if (rrq->flags != IW_TXPOW_DBM) { return -EOPNOTSUPP; } ar->arTxPwr= dbM = rrq->value; ar->arTxPwrSet = TRUE; } else { ar->arTxPwr = dbM = 0; ar->arTxPwrSet = FALSE; } if(ar->arWmiReady == TRUE) { AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_TX,("Set tx pwr cmd %d dbM\n", dbM)); wmi_set_txPwr_cmd(ar->arWmi, dbM); } return 0; } /* * SIOCGIWTXPOW */ int ar6000_ioctl_giwtxpow(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); int ret = 0; 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 (ar->bIsDestroyProgress) { return -EBUSY; } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (down_interruptible(&ar->arSem)) { return -ERESTARTSYS; } if (ar->bIsDestroyProgress) { up(&ar->arSem); return -EBUSY; } if((ar->arWmiReady == TRUE) && (ar->arConnected == TRUE)) { ar->arTxPwr = 0; if (wmi_get_txPwr_cmd(ar->arWmi) != A_OK) { up(&ar->arSem); return -EIO; } wait_event_interruptible_timeout(arEvent, ar->arTxPwr != 0, wmitimeout * HZ); if (signal_pending(current)) { ret = -EINTR; } } /* If the interace is down or wmi is not ready or target is not connected then return value stored in the device structure */ if (!ret) { if (ar->arTxPwrSet == TRUE) { rrq->fixed = TRUE; } rrq->value = ar->arTxPwr; rrq->flags = IW_TXPOW_DBM; // // IWLIST need this flag to get TxPower // rrq->disabled = 0; } up(&ar->arSem); return ret; } /* * SIOCSIWRETRY * since iwconfig only provides us with one max retry value, we use it * to apply to data frames of the BE traffic class. */ static int ar6000_ioctl_siwretry(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); 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (rrq->disabled) { return -EOPNOTSUPP; } if ((rrq->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT) { return -EOPNOTSUPP; } if ( !(rrq->value >= WMI_MIN_RETRIES) || !(rrq->value <= WMI_MAX_RETRIES)) { return - EINVAL; } if(ar->arWmiReady == TRUE) { if (wmi_set_retry_limits_cmd(ar->arWmi, DATA_FRAMETYPE, WMM_AC_BE, rrq->value, 0) != A_OK){ return -EINVAL; } } ar->arMaxRetries = rrq->value; return 0; } /* * SIOCGIWRETRY */ static int ar6000_ioctl_giwretry(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); 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } rrq->disabled = 0; switch (rrq->flags & IW_RETRY_TYPE) { case IW_RETRY_LIFETIME: return -EOPNOTSUPP; break; case IW_RETRY_LIMIT: rrq->flags = IW_RETRY_LIMIT; switch (rrq->flags & IW_RETRY_MODIFIER) { case IW_RETRY_MIN: rrq->flags |= IW_RETRY_MIN; rrq->value = WMI_MIN_RETRIES; break; case IW_RETRY_MAX: rrq->flags |= IW_RETRY_MAX; rrq->value = ar->arMaxRetries; break; } break; } return 0; } /* * SIOCSIWENCODE */ static int ar6000_ioctl_siwencode(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *keybuf) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); int index; A_INT32 auth = 0; 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(ar->arNextMode != AP_NETWORK) { /* * Static WEP Keys should be configured before setting the SSID */ if (ar->arSsid[0] && erq->length) { return -EIO; } } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } index = erq->flags & IW_ENCODE_INDEX; if (index && (((index - 1) < WMI_MIN_KEY_INDEX) || ((index - 1) > WMI_MAX_KEY_INDEX))) { return -EIO; } if (erq->flags & IW_ENCODE_DISABLED) { /* * Encryption disabled */ if (index) { /* * If key index was specified then clear the specified key */ index--; A_MEMZERO(ar->arWepKeyList[index].arKey, sizeof(ar->arWepKeyList[index].arKey)); ar->arWepKeyList[index].arKeyLen = 0; } ar->arDot11AuthMode = OPEN_AUTH; ar->arPairwiseCrypto = NONE_CRYPT; ar->arGroupCrypto = NONE_CRYPT; ar->arAuthMode = NONE_AUTH; } else { /* * Enabling WEP encryption */ if (index) { index--; /* keyindex is off base 1 in iwconfig */ } if (erq->flags & IW_ENCODE_OPEN) { auth |= OPEN_AUTH; ar->arDefTxKeyIndex = index; } if (erq->flags & IW_ENCODE_RESTRICTED) { auth |= SHARED_AUTH; } if (!auth) { auth = OPEN_AUTH; } if (erq->length) { if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(erq->length)) { return -EIO; } A_MEMZERO(ar->arWepKeyList[index].arKey, sizeof(ar->arWepKeyList[index].arKey)); A_MEMCPY(ar->arWepKeyList[index].arKey, keybuf, erq->length); ar->arWepKeyList[index].arKeyLen = erq->length; ar->arDot11AuthMode = auth; } else { if (ar->arWepKeyList[index].arKeyLen == 0) { return -EIO; } ar->arDefTxKeyIndex = index; if(ar->arSsidLen && ar->arWepKeyList[index].arKeyLen) { wmi_addKey_cmd(ar->arWmi, index, WEP_CRYPT, GROUP_USAGE | TX_USAGE, ar->arWepKeyList[index].arKeyLen, NULL, ar->arWepKeyList[index].arKey, KEY_OP_INIT_VAL, NULL, NO_SYNC_WMIFLAG); } } ar->arPairwiseCrypto = WEP_CRYPT; ar->arGroupCrypto = WEP_CRYPT; ar->arAuthMode = NONE_AUTH; } if(ar->arNextMode != AP_NETWORK) { /* * profile has changed. Erase ssid to signal change */ A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); ar->arSsidLen = 0; } ar->ap_profile_flag = 1; /* There is a change in profile */ return 0; } static int ar6000_ioctl_giwencode(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *key) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); A_UINT8 keyIndex; struct ar_wep_key *wk; 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (ar->arPairwiseCrypto == NONE_CRYPT) { erq->length = 0; erq->flags = IW_ENCODE_DISABLED; } else { if (ar->arPairwiseCrypto == WEP_CRYPT) { /* get the keyIndex */ keyIndex = erq->flags & IW_ENCODE_INDEX; if (0 == keyIndex) { keyIndex = ar->arDefTxKeyIndex; } else if ((keyIndex - 1 < WMI_MIN_KEY_INDEX) || (keyIndex - 1 > WMI_MAX_KEY_INDEX)) { keyIndex = WMI_MIN_KEY_INDEX; } else { keyIndex--; } erq->flags = keyIndex + 1; erq->flags &= ~IW_ENCODE_DISABLED; wk = &ar->arWepKeyList[keyIndex]; if (erq->length > wk->arKeyLen) { erq->length = wk->arKeyLen; } if (wk->arKeyLen) { A_MEMCPY(key, wk->arKey, erq->length); } } else { erq->flags &= ~IW_ENCODE_DISABLED; if (ar->user_saved_keys.keyOk) { erq->length = ar->user_saved_keys.ucast_ik.ik_keylen; if (erq->length) { A_MEMCPY(key, ar->user_saved_keys.ucast_ik.ik_keydata, erq->length); } } else { erq->length = 1; // not really printing any key but let iwconfig know enc is on } } if (ar->arDot11AuthMode & OPEN_AUTH) { erq->flags |= IW_ENCODE_OPEN; } if (ar->arDot11AuthMode & SHARED_AUTH) { erq->flags |= IW_ENCODE_RESTRICTED; } } return 0; } #if WIRELESS_EXT >= 18 /* * SIOCSIWGENIE */ static int ar6000_ioctl_siwgenie(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); #ifdef WAPI_ENABLE A_UINT8 *ie = erq->pointer; A_UINT8 ie_type = ie[0]; A_UINT16 ie_length = erq->length; A_UINT8 wapi_ie[128]; #endif if (ar->arWmiReady == FALSE) { return -EIO; } #ifdef WAPI_ENABLE if (ie_type == IEEE80211_ELEMID_WAPI) { if (ie_length > 0) { if (copy_from_user(wapi_ie, ie, ie_length)) { return -EIO; } } wmi_set_appie_cmd(ar->arWmi, WMI_FRAME_ASSOC_REQ, ie_length, wapi_ie); } else if (ie_length == 0) { wmi_set_appie_cmd(ar->arWmi, WMI_FRAME_ASSOC_REQ, ie_length, wapi_ie); } #endif return 0; } /* * SIOCGIWGENIE */ static int ar6000_ioctl_giwgenie(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); if (ar->arWmiReady == FALSE) { return -EIO; } erq->length = 0; erq->flags = 0; return 0; } /* * SIOCSIWAUTH */ static int ar6000_ioctl_siwauth(struct net_device *dev, struct iw_request_info *info, struct iw_param *data, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); A_BOOL profChanged; A_UINT16 param; A_INT32 ret; A_INT32 value; if (ar->arWmiReady == FALSE) { return -EIO; } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } param = data->flags & IW_AUTH_INDEX; value = data->value; profChanged = TRUE; ret = 0; switch (param) { case IW_AUTH_WPA_VERSION: if (value & IW_AUTH_WPA_VERSION_DISABLED) { ar->arAuthMode = NONE_AUTH; } else if (value & IW_AUTH_WPA_VERSION_WPA) { ar->arAuthMode = WPA_AUTH; } else if (value & IW_AUTH_WPA_VERSION_WPA2) { ar->arAuthMode = WPA2_AUTH; } else { ret = -1; profChanged = FALSE; } break; case IW_AUTH_CIPHER_PAIRWISE: if (value & IW_AUTH_CIPHER_NONE) { ar->arPairwiseCrypto = NONE_CRYPT; ar->arPairwiseCryptoLen = 0; } else if (value & IW_AUTH_CIPHER_WEP40) { ar->arPairwiseCrypto = WEP_CRYPT; ar->arPairwiseCryptoLen = 5; } else if (value & IW_AUTH_CIPHER_TKIP) { ar->arPairwiseCrypto = TKIP_CRYPT; ar->arPairwiseCryptoLen = 0; } else if (value & IW_AUTH_CIPHER_CCMP) { ar->arPairwiseCrypto = AES_CRYPT; ar->arPairwiseCryptoLen = 0; } else if (value & IW_AUTH_CIPHER_WEP104) { ar->arPairwiseCrypto = WEP_CRYPT; ar->arPairwiseCryptoLen = 13; } else { ret = -1; profChanged = FALSE; } break; case IW_AUTH_CIPHER_GROUP: if (value & IW_AUTH_CIPHER_NONE) { ar->arGroupCrypto = NONE_CRYPT; ar->arGroupCryptoLen = 0; } else if (value & IW_AUTH_CIPHER_WEP40) { ar->arGroupCrypto = WEP_CRYPT; ar->arGroupCryptoLen = 5; } else if (value & IW_AUTH_CIPHER_TKIP) { ar->arGroupCrypto = TKIP_CRYPT; ar->arGroupCryptoLen = 0; } else if (value & IW_AUTH_CIPHER_CCMP) { ar->arGroupCrypto = AES_CRYPT; ar->arGroupCryptoLen = 0; } else if (value & IW_AUTH_CIPHER_WEP104) { ar->arGroupCrypto = WEP_CRYPT; ar->arGroupCryptoLen = 13; } else { ret = -1; profChanged = FALSE; } break; case IW_AUTH_KEY_MGMT: if (value & IW_AUTH_KEY_MGMT_PSK) { if (WPA_AUTH == ar->arAuthMode) { ar->arAuthMode = WPA_PSK_AUTH; } else if (WPA2_AUTH == ar->arAuthMode) { ar->arAuthMode = WPA2_PSK_AUTH; } else { ret = -1; } } else if (!(value & IW_AUTH_KEY_MGMT_802_1X)) { ar->arAuthMode = NONE_AUTH; } break; case IW_AUTH_TKIP_COUNTERMEASURES: wmi_set_tkip_countermeasures_cmd(ar->arWmi, value); profChanged = FALSE; break; case IW_AUTH_DROP_UNENCRYPTED: profChanged = FALSE; break; case IW_AUTH_80211_AUTH_ALG: ar->arDot11AuthMode = 0; if (value & IW_AUTH_ALG_OPEN_SYSTEM) { ar->arDot11AuthMode |= OPEN_AUTH; } if (value & IW_AUTH_ALG_SHARED_KEY) { ar->arDot11AuthMode |= SHARED_AUTH; } if (value & IW_AUTH_ALG_LEAP) { ar->arDot11AuthMode = LEAP_AUTH; } if(ar->arDot11AuthMode == 0) { ret = -1; profChanged = FALSE; } break; case IW_AUTH_WPA_ENABLED: if (!value) { ar->arAuthMode = NONE_AUTH; /* when the supplicant is stopped, it calls this * handler with value=0. The followings need to be * reset if the STA were to connect again * without security */ ar->arDot11AuthMode = OPEN_AUTH; ar->arPairwiseCrypto = NONE_CRYPT; ar->arPairwiseCryptoLen = 0; ar->arGroupCrypto = NONE_CRYPT; ar->arGroupCryptoLen = 0; } break; case IW_AUTH_RX_UNENCRYPTED_EAPOL: profChanged = FALSE; break; case IW_AUTH_ROAMING_CONTROL: profChanged = FALSE; break; case IW_AUTH_PRIVACY_INVOKED: if (!value) { ar->arPairwiseCrypto = NONE_CRYPT; ar->arPairwiseCryptoLen = 0; ar->arGroupCrypto = NONE_CRYPT; ar->arGroupCryptoLen = 0; } break; #ifdef WAPI_ENABLE case IW_AUTH_WAPI_ENABLED: ar->arWapiEnable = value; break; #endif default: ret = -1; profChanged = FALSE; break; } if (profChanged == TRUE) { /* * profile has changed. Erase ssid to signal change */ A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); ar->arSsidLen = 0; } return ret; } /* * SIOCGIWAUTH */ static int ar6000_ioctl_giwauth(struct net_device *dev, struct iw_request_info *info, struct iw_param *data, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); A_UINT16 param; A_INT32 ret; if (ar->arWmiReady == FALSE) { return -EIO; } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } param = data->flags & IW_AUTH_INDEX; ret = 0; data->value = 0; switch (param) { case IW_AUTH_WPA_VERSION: if (ar->arAuthMode == NONE_AUTH) { data->value |= IW_AUTH_WPA_VERSION_DISABLED; } else if (ar->arAuthMode == WPA_AUTH) { data->value |= IW_AUTH_WPA_VERSION_WPA; } else if (ar->arAuthMode == WPA2_AUTH) { data->value |= IW_AUTH_WPA_VERSION_WPA2; } else { ret = -1; } break; case IW_AUTH_CIPHER_PAIRWISE: if (ar->arPairwiseCrypto == NONE_CRYPT) { data->value |= IW_AUTH_CIPHER_NONE; } else if (ar->arPairwiseCrypto == WEP_CRYPT) { if (ar->arPairwiseCryptoLen == 13) { data->value |= IW_AUTH_CIPHER_WEP104; } else { data->value |= IW_AUTH_CIPHER_WEP40; } } else if (ar->arPairwiseCrypto == TKIP_CRYPT) { data->value |= IW_AUTH_CIPHER_TKIP; } else if (ar->arPairwiseCrypto == AES_CRYPT) { data->value |= IW_AUTH_CIPHER_CCMP; } else { ret = -1; } break; case IW_AUTH_CIPHER_GROUP: if (ar->arGroupCrypto == NONE_CRYPT) { data->value |= IW_AUTH_CIPHER_NONE; } else if (ar->arGroupCrypto == WEP_CRYPT) { if (ar->arGroupCryptoLen == 13) { data->value |= IW_AUTH_CIPHER_WEP104; } else { data->value |= IW_AUTH_CIPHER_WEP40; } } else if (ar->arGroupCrypto == TKIP_CRYPT) { data->value |= IW_AUTH_CIPHER_TKIP; } else if (ar->arGroupCrypto == AES_CRYPT) { data->value |= IW_AUTH_CIPHER_CCMP; } else { ret = -1; } break; case IW_AUTH_KEY_MGMT: if ((ar->arAuthMode == WPA_PSK_AUTH) || (ar->arAuthMode == WPA2_PSK_AUTH)) { data->value |= IW_AUTH_KEY_MGMT_PSK; } else if ((ar->arAuthMode == WPA_AUTH) || (ar->arAuthMode == WPA2_AUTH)) { data->value |= IW_AUTH_KEY_MGMT_802_1X; } break; case IW_AUTH_TKIP_COUNTERMEASURES: // TODO. Save countermeassure enable/disable data->value = 0; break; case IW_AUTH_DROP_UNENCRYPTED: break; case IW_AUTH_80211_AUTH_ALG: if (ar->arDot11AuthMode == OPEN_AUTH) { data->value |= IW_AUTH_ALG_OPEN_SYSTEM; } else if (ar->arDot11AuthMode == SHARED_AUTH) { data->value |= IW_AUTH_ALG_SHARED_KEY; } else if (ar->arDot11AuthMode == LEAP_AUTH) { data->value |= IW_AUTH_ALG_LEAP; } else { ret = -1; } break; case IW_AUTH_WPA_ENABLED: if (ar->arAuthMode == NONE_AUTH) { data->value = 0; } else { data->value = 1; } break; case IW_AUTH_RX_UNENCRYPTED_EAPOL: break; case IW_AUTH_ROAMING_CONTROL: break; case IW_AUTH_PRIVACY_INVOKED: if (ar->arPairwiseCrypto == NONE_CRYPT) { data->value = 0; } else { data->value = 1; } break; #ifdef WAPI_ENABLE case IW_AUTH_WAPI_ENABLED: data->value = ar->arWapiEnable; break; #endif default: ret = -1; break; } return 0; } /* * SIOCSIWPMKSA */ static int ar6000_ioctl_siwpmksa(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); A_INT32 ret; A_STATUS status; struct iw_pmksa *pmksa; pmksa = (struct iw_pmksa *)extra; if (ar->arWmiReady == FALSE) { return -EIO; } ret = 0; status = A_OK; switch (pmksa->cmd) { case IW_PMKSA_ADD: status = wmi_setPmkid_cmd(ar->arWmi, (A_UINT8*)pmksa->bssid.sa_data, pmksa->pmkid, TRUE); break; case IW_PMKSA_REMOVE: status = wmi_setPmkid_cmd(ar->arWmi, (A_UINT8*)pmksa->bssid.sa_data, pmksa->pmkid, FALSE); break; case IW_PMKSA_FLUSH: if (ar->arConnected == TRUE) { status = wmi_setPmkid_cmd(ar->arWmi, ar->arBssid, NULL, 0); } break; default: ret=-1; break; } if (status != A_OK) { ret = -1; } return ret; } #ifdef WAPI_ENABLE #define PN_INIT 0x5c365c36 static int ar6000_set_wapi_key(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); struct iw_encode_ext *ext = (struct iw_encode_ext *)extra; KEY_USAGE keyUsage = 0; A_INT32 keyLen; A_UINT8 *keyData; A_INT32 index; A_UINT32 *PN; A_INT32 i; A_STATUS status; A_UINT8 wapiKeyRsc[16]; CRYPTO_TYPE keyType = WAPI_CRYPT; const A_UINT8 broadcastMac[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; index = erq->flags & IW_ENCODE_INDEX; if (index && (((index - 1) < WMI_MIN_KEY_INDEX) || ((index - 1) > WMI_MAX_KEY_INDEX))) { return -EIO; } index--; if (index < 0 || index > 4) { return -EIO; } keyData = (A_UINT8 *)(ext + 1); keyLen = erq->length - sizeof(struct iw_encode_ext); A_MEMCPY(wapiKeyRsc, ext->tx_seq, sizeof(wapiKeyRsc)); if (A_MEMCMP(ext->addr.sa_data, broadcastMac, sizeof(broadcastMac)) == 0) { keyUsage |= GROUP_USAGE; PN = (A_UINT32 *)wapiKeyRsc; for (i = 0; i < 4; i++) { PN[i] = PN_INIT; } } else { keyUsage |= PAIRWISE_USAGE; } status = wmi_addKey_cmd(ar->arWmi, index, keyType, keyUsage, keyLen, wapiKeyRsc, keyData, KEY_OP_INIT_WAPIPN, NULL, SYNC_BEFORE_WMIFLAG); if (A_OK != status) { return -EIO; } return 0; } #endif /* * SIOCSIWENCODEEXT */ static int ar6000_ioctl_siwencodeext(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); A_INT32 index; struct iw_encode_ext *ext; KEY_USAGE keyUsage; A_INT32 keyLen; A_UINT8 *keyData; A_UINT8 keyRsc[8]; A_STATUS status; CRYPTO_TYPE keyType; #ifdef USER_KEYS struct ieee80211req_key ik; #endif /* USER_KEYS */ if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } #ifdef USER_KEYS ar->user_saved_keys.keyOk = FALSE; #endif /* USER_KEYS */ index = erq->flags & IW_ENCODE_INDEX; if (index && (((index - 1) < WMI_MIN_KEY_INDEX) || ((index - 1) > WMI_MAX_KEY_INDEX))) { return -EIO; } ext = (struct iw_encode_ext *)extra; if (erq->flags & IW_ENCODE_DISABLED) { /* * Encryption disabled */ if (index) { /* * If key index was specified then clear the specified key */ index--; A_MEMZERO(ar->arWepKeyList[index].arKey, sizeof(ar->arWepKeyList[index].arKey)); ar->arWepKeyList[index].arKeyLen = 0; } } else { /* * Enabling WEP encryption */ if (index) { index--; /* keyindex is off base 1 in iwconfig */ } keyUsage = 0; keyLen = erq->length - sizeof(struct iw_encode_ext); if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) { keyUsage = TX_USAGE; ar->arDefTxKeyIndex = index; // Just setting the key index if (keyLen == 0) { return 0; } } if (keyLen <= 0) { return -EIO; } /* key follows iw_encode_ext */ keyData = (A_UINT8 *)(ext + 1); switch (ext->alg) { case IW_ENCODE_ALG_WEP: keyType = WEP_CRYPT; #ifdef USER_KEYS ik.ik_type = IEEE80211_CIPHER_WEP; #endif /* USER_KEYS */ if (!IEEE80211_IS_VALID_WEP_CIPHER_LEN(keyLen)) { return -EIO; } /* Check whether it is static wep. */ if (!ar->arConnected) { A_MEMZERO(ar->arWepKeyList[index].arKey, sizeof(ar->arWepKeyList[index].arKey)); A_MEMCPY(ar->arWepKeyList[index].arKey, keyData, keyLen); ar->arWepKeyList[index].arKeyLen = keyLen; return 0; } break; case IW_ENCODE_ALG_TKIP: keyType = TKIP_CRYPT; #ifdef USER_KEYS ik.ik_type = IEEE80211_CIPHER_TKIP; #endif /* USER_KEYS */ break; case IW_ENCODE_ALG_CCMP: keyType = AES_CRYPT; #ifdef USER_KEYS ik.ik_type = IEEE80211_CIPHER_AES_CCM; #endif /* USER_KEYS */ break; #ifdef WAPI_ENABLE case IW_ENCODE_ALG_SM4: if (ar->arWapiEnable) { return ar6000_set_wapi_key(dev, info, erq, extra); } else { return -EIO; } #endif case IW_ENCODE_ALG_PMK: ar->arConnectCtrlFlags |= CONNECT_DO_WPA_OFFLOAD; return wmi_set_pmk_cmd(ar->arWmi, keyData); default: return -EIO; } if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) { keyUsage |= GROUP_USAGE; } else { keyUsage |= PAIRWISE_USAGE; } if (ext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) { A_MEMCPY(keyRsc, ext->rx_seq, sizeof(keyRsc)); } else { A_MEMZERO(keyRsc, sizeof(keyRsc)); } if (((WPA_PSK_AUTH == ar->arAuthMode) || (WPA2_PSK_AUTH == ar->arAuthMode)) && (GROUP_USAGE & keyUsage)) { A_UNTIMEOUT(&ar->disconnect_timer); } status = wmi_addKey_cmd(ar->arWmi, index, keyType, keyUsage, keyLen, keyRsc, keyData, KEY_OP_INIT_VAL, (A_UINT8*)ext->addr.sa_data, SYNC_BOTH_WMIFLAG); if (status != A_OK) { return -EIO; } #ifdef USER_KEYS ik.ik_keyix = index; ik.ik_keylen = keyLen; memcpy(ik.ik_keydata, keyData, keyLen); memcpy(&ik.ik_keyrsc, keyRsc, sizeof(keyRsc)); memcpy(ik.ik_macaddr, ext->addr.sa_data, ETH_ALEN); if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) { memcpy(&ar->user_saved_keys.bcast_ik, &ik, sizeof(struct ieee80211req_key)); } else { memcpy(&ar->user_saved_keys.ucast_ik, &ik, sizeof(struct ieee80211req_key)); } ar->user_saved_keys.keyOk = TRUE; #endif /* USER_KEYS */ } return 0; } /* * SIOCGIWENCODEEXT */ static int ar6000_ioctl_giwencodeext(struct net_device *dev, struct iw_request_info *info, struct iw_point *erq, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (ar->arPairwiseCrypto == NONE_CRYPT) { erq->length = 0; erq->flags = IW_ENCODE_DISABLED; } else { erq->length = 0; } return 0; } #endif // WIRELESS_EXT >= 18 #if WIRELESS_EXT > 20 static int ar6000_ioctl_siwpower(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { #ifndef ATH6K_CONFIG_OTA_MODE AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); WMI_POWER_MODE power_mode; if (ar->arWmiReady == FALSE) { return -EIO; } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (wrqu->power.disabled) power_mode = MAX_PERF_POWER; else power_mode = REC_POWER; if (wmi_powermode_cmd(ar->arWmi, power_mode) < 0) return -EIO; #endif return 0; } static int ar6000_ioctl_giwpower(struct net_device *dev, struct iw_request_info *info, union iwreq_data *wrqu, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); WMI_POWER_MODE power_mode; if (ar->arWmiReady == FALSE) { return -EIO; } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } power_mode = wmi_get_power_mode_cmd(ar->arWmi); if (power_mode == MAX_PERF_POWER) wrqu->power.disabled = 1; else wrqu->power.disabled = 0; return 0; } #endif // WIRELESS_EXT > 20 /* * SIOCGIWNAME */ int ar6000_ioctl_giwname(struct net_device *dev, struct iw_request_info *info, char *name, char *extra) { A_UINT8 capability; AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } capability = ar->arPhyCapability; if(ar->arNetworkType == INFRA_NETWORK && ar->arConnected) { bss_t *bss = wmi_find_node(ar->arWmi, ar->arBssid); if (bss) { capability = get_bss_phy_capability(bss); wmi_node_return(ar->arWmi, bss); } } switch (capability) { case (WMI_11A_CAPABILITY): strncpy(name, "AR6000 802.11a", IFNAMSIZ); break; case (WMI_11G_CAPABILITY): strncpy(name, "AR6000 802.11g", IFNAMSIZ); break; case (WMI_11AG_CAPABILITY): strncpy(name, "AR6000 802.11ag", IFNAMSIZ); break; case (WMI_11NA_CAPABILITY): strncpy(name, "AR6000 802.11na", IFNAMSIZ); break; case (WMI_11NG_CAPABILITY): strncpy(name, "AR6000 802.11ng", IFNAMSIZ); break; case (WMI_11NAG_CAPABILITY): strncpy(name, "AR6000 802.11nag", IFNAMSIZ); break; default: strncpy(name, "AR6000 802.11b", IFNAMSIZ); break; } return 0; } /* * SIOCSIWFREQ */ int ar6000_ioctl_siwfreq(struct net_device *dev, struct iw_request_info *info, struct iw_freq *freq, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } /* * We support limiting the channels via wmiconfig. * * We use this command to configure the channel hint for the connect cmd * so it is possible the target will end up connecting to a different * channel. */ if (freq->e > 1) { return -EINVAL; } else if (freq->e == 1) { ar->arChannelHint = freq->m / 100000; } else { if(freq->m) { ar->arChannelHint = wlan_ieee2freq(freq->m); } else { /* Auto Channel Selection */ ar->arChannelHint = 0; } } ar->ap_profile_flag = 1; /* There is a change in profile */ A_PRINTF("channel hint set to %d\n", ar->arChannelHint); return 0; } /* * SIOCGIWFREQ */ int ar6000_ioctl_giwfreq(struct net_device *dev, struct iw_request_info *info, struct iw_freq *freq, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (ar->arNetworkType == AP_NETWORK) { if(ar->arChannelHint) { freq->m = ar->arChannelHint * 100000; } else if(ar->arACS) { freq->m = ar->arACS * 100000; } else { return -EINVAL; } } else { if (ar->arConnected != TRUE) { return -EINVAL; } else { freq->m = ar->arBssChannel * 100000; } } freq->e = 1; return 0; } /* * SIOCSIWMODE */ int ar6000_ioctl_siwmode(struct net_device *dev, struct iw_request_info *info, __u32 *mode, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } /* * clear SSID during mode switch in connected state */ if(!(ar->arNetworkType == (((*mode) == IW_MODE_INFRA) ? INFRA_NETWORK : ADHOC_NETWORK)) && (ar->arConnected == TRUE) ){ A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); ar->arSsidLen = 0; } switch (*mode) { case IW_MODE_INFRA: ar->arNextMode = INFRA_NETWORK; break; case IW_MODE_ADHOC: ar->arNextMode = ADHOC_NETWORK; break; case IW_MODE_MASTER: ar->arNextMode = AP_NETWORK; break; default: return -EINVAL; } /* clear all shared parameters between AP and STA|IBSS modes when we * switch between them. Switch between STA & IBSS modes does'nt clear * the shared profile. This is as per the original design for switching * between STA & IBSS. */ if (ar->arNetworkType == AP_NETWORK || ar->arNextMode == AP_NETWORK) { ar->arDot11AuthMode = OPEN_AUTH; ar->arAuthMode = NONE_AUTH; ar->arPairwiseCrypto = NONE_CRYPT; ar->arPairwiseCryptoLen = 0; ar->arGroupCrypto = NONE_CRYPT; ar->arGroupCryptoLen = 0; ar->arChannelHint = 0; ar->arBssChannel = 0; A_MEMZERO(ar->arBssid, sizeof(ar->arBssid)); A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); ar->arSsidLen = 0; } /* SSID has to be cleared to trigger a profile change while switching * between STA & IBSS modes having the same SSID */ if (ar->arNetworkType != ar->arNextMode) { A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); ar->arSsidLen = 0; } return 0; } /* * SIOCGIWMODE */ int ar6000_ioctl_giwmode(struct net_device *dev, struct iw_request_info *info, __u32 *mode, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } switch (ar->arNetworkType) { case INFRA_NETWORK: *mode = IW_MODE_INFRA; break; case ADHOC_NETWORK: *mode = IW_MODE_ADHOC; break; case AP_NETWORK: *mode = IW_MODE_MASTER; break; default: return -EIO; } return 0; } /* * SIOCSIWSENS */ int ar6000_ioctl_siwsens(struct net_device *dev, struct iw_request_info *info, struct iw_param *sens, char *extra) { return 0; } /* * SIOCGIWSENS */ int ar6000_ioctl_giwsens(struct net_device *dev, struct iw_request_info *info, struct iw_param *sens, char *extra) { sens->value = 0; sens->fixed = 1; return 0; } /* * SIOCGIWRANGE */ int ar6000_ioctl_giwrange(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); struct iw_range *range = (struct iw_range *) extra; int i, ret = 0; 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 (ar->bIsDestroyProgress) { return -EBUSY; } if (ar->arWmiReady == FALSE) { return -EIO; } if (down_interruptible(&ar->arSem)) { return -ERESTARTSYS; } if (ar->bIsDestroyProgress) { up(&ar->arSem); return -EBUSY; } ar->arNumChannels = -1; A_MEMZERO(ar->arChannelList, sizeof (ar->arChannelList)); if (wmi_get_channelList_cmd(ar->arWmi) != A_OK) { up(&ar->arSem); return -EIO; } wait_event_interruptible_timeout(arEvent, ar->arNumChannels != -1, wmitimeout * HZ); if (signal_pending(current)) { up(&ar->arSem); return -EINTR; } data->length = sizeof(struct iw_range); A_MEMZERO(range, sizeof(struct iw_range)); range->txpower_capa = 0; range->min_pmp = 1 * 1024; range->max_pmp = 65535 * 1024; range->min_pmt = 1 * 1024; range->max_pmt = 1000 * 1024; range->pmp_flags = IW_POWER_PERIOD; range->pmt_flags = IW_POWER_TIMEOUT; range->pm_capa = 0; range->we_version_compiled = WIRELESS_EXT; range->we_version_source = 13; range->retry_capa = IW_RETRY_LIMIT; range->retry_flags = IW_RETRY_LIMIT; range->min_retry = 0; range->max_retry = 255; range->num_frequency = range->num_channels = ar->arNumChannels; for (i = 0; i < ar->arNumChannels; i++) { range->freq[i].i = wlan_freq2ieee(ar->arChannelList[i]); range->freq[i].m = ar->arChannelList[i] * 100000; range->freq[i].e = 1; /* * Linux supports max of 32 channels, bail out once you * reach the max. */ if (i == IW_MAX_FREQUENCIES) { break; } } /* Max quality is max field value minus noise floor */ range->max_qual.qual = 0xff - 161; /* * In order to use dBm measurements, 'level' must be lower * than any possible measurement (see iw_print_stats() in * wireless tools). It's unclear how this is meant to be * done, but setting zero in these values forces dBm and * the actual numbers are not used. */ range->max_qual.level = 0; range->max_qual.noise = 0; range->sensitivity = 3; range->max_encoding_tokens = 4; /* XXX query driver to find out supported key sizes */ range->num_encoding_sizes = 3; range->encoding_size[0] = 5; /* 40-bit */ range->encoding_size[1] = 13; /* 104-bit */ range->encoding_size[2] = 16; /* 128-bit */ range->num_bitrates = 0; /* estimated maximum TCP throughput values (bps) */ range->throughput = 22000000; range->min_rts = 0; range->max_rts = 2347; range->min_frag = 256; range->max_frag = 2346; up(&ar->arSem); return ret; } /* * SIOCSIWAP * This ioctl is used to set the desired bssid for the connect command. */ int ar6000_ioctl_siwap(struct net_device *dev, struct iw_request_info *info, struct sockaddr *ap_addr, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (ap_addr->sa_family != ARPHRD_ETHER) { return -EIO; } if (A_MEMCMP(&ap_addr->sa_data, bcast_mac, AR6000_ETH_ADDR_LEN) == 0) { A_MEMZERO(ar->arReqBssid, sizeof(ar->arReqBssid)); } else { A_MEMCPY(ar->arReqBssid, &ap_addr->sa_data, sizeof(ar->arReqBssid)); } return 0; } /* * SIOCGIWAP */ int ar6000_ioctl_giwap(struct net_device *dev, struct iw_request_info *info, struct sockaddr *ap_addr, char *extra) { AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); 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 (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (ar->arNetworkType == AP_NETWORK) { A_MEMCPY(&ap_addr->sa_data, dev->dev_addr, ATH_MAC_LEN); ap_addr->sa_family = ARPHRD_ETHER; return 0; } 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 (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); 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 (ar->bIsDestroyProgress) { return -EBUSY; } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } if (ar->arWmiReady == FALSE) { return -EIO; } if (down_interruptible(&ar->arSem)) { return -ERESTARTSYS; } if (data->pointer && data->length == sizeof(struct iw_mlme)) { A_UINT8 arNetworkType; struct iw_mlme mlme; if (copy_from_user(&mlme, data->pointer, sizeof(struct iw_mlme))) return -EIO; switch (mlme.cmd) { case IW_MLME_DEAUTH: /* fall through */ case IW_MLME_DISASSOC: if ((ar->arConnected != TRUE) || (memcmp(ar->arBssid, mlme.addr.sa_data, 6) != 0)) { up(&ar->arSem); return -EINVAL; } wmi_setPmkid_cmd(ar->arWmi, ar->arBssid, NULL, 0); arNetworkType = ar->arNetworkType; ar6000_init_profile_info(ar); ar->arNetworkType = arNetworkType; reconnect_flag = 0; wmi_disconnect_cmd(ar->arWmi); A_MEMZERO(ar->arSsid, sizeof(ar->arSsid)); ar->arSsidLen = 0; if (ar->arSkipScan == FALSE) { A_MEMZERO(ar->arReqBssid, sizeof(ar->arReqBssid)); } break; case IW_MLME_AUTH: /* fall through */ case IW_MLME_ASSOC: /* fall through */ default: up(&ar->arSem); return -EOPNOTSUPP; } } up(&ar->arSem); return 0; } #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 */ } /* * SIOCSIWSCAN */ int ar6000_ioctl_siwscan(struct net_device *dev, struct iw_request_info *info, struct iw_point *data, char *extra) { #define ACT_DWELLTIME_DEFAULT 105 #define HOME_TXDRAIN_TIME 100 #define SCAN_INT HOME_TXDRAIN_TIME + ACT_DWELLTIME_DEFAULT AR_SOFTC_T *ar = (AR_SOFTC_T *)ar6k_priv(dev); int ret = 0; 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 (ar->arWmiReady == FALSE) { return -EIO; } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } /* If scan is issued in the middle of ongoing scan or connect, dont issue another one */ if ( ar->scan_triggered > 0 ) { ++ar->scan_triggered; if (ar->scan_triggered < 5) { return 0; } else { AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_SCAN,("Scan request is triggered over 5 times. Not scan complete event\n")); } } if (!ar->arUserBssFilter) { if (wmi_bssfilter_cmd(ar->arWmi, ALL_BSS_FILTER, 0) != A_OK) { return -EIO; } } if (ar->arConnected) { if (wmi_get_stats_cmd(ar->arWmi) != A_OK) { return -EIO; } } #ifdef ANDROID_ENV #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 (ar->scanSpecificSsid) { if (wmi_probedSsid_cmd(ar->arWmi, 1, DISABLE_SSID_FLAG, 0, NULL) != A_OK) return -EIO; ar->scanSpecificSsid = 0; } } } else { 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) { ar->scan_triggered = 1; } return ret; #undef ACT_DWELLTIME_DEFAULT #undef HOME_TXDRAIN_TIME #undef SCAN_INT } /* * Units are in db above the noise floor. That means the * rssi values reported in the tx/rx descriptors in the * driver are the SNR expressed in db. * * If you assume that the noise floor is -95, which is an * excellent assumption 99.5 % of the time, then you can * derive the absolute signal level (i.e. -95 + rssi). * There are some other slight factors to take into account * depending on whether the rssi measurement is from 11b, * 11g, or 11a. These differences are at most 2db and * can be documented. * * NB: various calculations are based on the orinoco/wavelan * drivers for compatibility */ static void ar6000_set_quality(struct iw_quality *iq, A_INT8 rssi) { if (rssi < 0) { iq->qual = 0; } else { iq->qual = rssi; } /* NB: max is 94 because noise is hardcoded to 161 */ if (iq->qual > 94) iq->qual = 94; iq->noise = 161; /* -95dBm */ iq->level = iq->noise + iq->qual; iq->updated = 7; } int ar6000_ioctl_siwcommit(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); 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 (ar->arWmiReady == FALSE) { return -EIO; } if (ar->arWlanState == WLAN_DISABLED) { return -EIO; } AR_DEBUG_PRINTF(ATH_DEBUG_WLAN_CONNECT,("AP: SSID %s freq %d authmode %d dot11 auth %d"\ " PW crypto %d GRP crypto %d\n", ar->arSsid, ar->arChannelHint, ar->arAuthMode, ar->arDot11AuthMode, ar->arPairwiseCrypto, ar->arGroupCrypto)); ar6000_ap_mode_profile_commit(ar); /* if there is a profile switch from STA|IBSS mode to AP mode, * update the host driver association state for the STA|IBSS mode. */ if (ar->arNetworkType != AP_NETWORK && ar->arNextMode == AP_NETWORK) { ar->arConnectPending = FALSE; ar->arConnected = FALSE; /* Stop getting pkts from upper stack */ netif_stop_queue(ar->arNetDev); A_MEMZERO(ar->arBssid, sizeof(ar->arBssid)); ar->arBssChannel = 0; ar->arBeaconInterval = 0; /* Flush the Tx queues */ ar6000_TxDataCleanup(ar); /* Start getting pkts from upper stack */ netif_wake_queue(ar->arNetDev); } return 0; } #define W_PROTO(_x) wait_ ## _x #define WAIT_HANDLER_IMPL(_x, type) \ int wait_ ## _x (struct net_device *dev, struct iw_request_info *info, type wrqu, char *extra) {\ int ret; \ dev_hold(dev); \ rtnl_unlock(); \ ret = _x(dev, info, wrqu, extra); \ rtnl_lock(); \ dev_put(dev); \ return ret;\ } WAIT_HANDLER_IMPL(ar6000_ioctl_siwessid, struct iw_point *) WAIT_HANDLER_IMPL(ar6000_ioctl_giwrate, struct iw_param *) WAIT_HANDLER_IMPL(ar6000_ioctl_giwtxpow, struct iw_param *) WAIT_HANDLER_IMPL(ar6000_ioctl_giwrange, struct iw_point*) /* Structures to export the Wireless Handlers */ static const iw_handler ath_handlers[] = { (iw_handler) ar6000_ioctl_siwcommit, /* SIOCSIWCOMMIT */ (iw_handler) ar6000_ioctl_giwname, /* SIOCGIWNAME */ (iw_handler) NULL, /* SIOCSIWNWID */ (iw_handler) NULL, /* SIOCGIWNWID */ (iw_handler) ar6000_ioctl_siwfreq, /* SIOCSIWFREQ */ (iw_handler) ar6000_ioctl_giwfreq, /* SIOCGIWFREQ */ (iw_handler) ar6000_ioctl_siwmode, /* SIOCSIWMODE */ (iw_handler) ar6000_ioctl_giwmode, /* SIOCGIWMODE */ (iw_handler) ar6000_ioctl_siwsens, /* SIOCSIWSENS */ (iw_handler) ar6000_ioctl_giwsens, /* SIOCGIWSENS */ (iw_handler) NULL /* not _used */, /* SIOCSIWRANGE */ (iw_handler) W_PROTO(ar6000_ioctl_giwrange),/* SIOCGIWRANGE */ (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 (WIRELESS_EXT >= 18) (iw_handler) ar6000_ioctl_siwmlme, /* SIOCSIWMLME */ #else (iw_handler) NULL, /* -- hole -- */ #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 */ (iw_handler) W_PROTO(ar6000_ioctl_giwrate), /* SIOCGIWRATE */ (iw_handler) NULL, /* SIOCSIWRTS */ (iw_handler) NULL, /* SIOCGIWRTS */ (iw_handler) NULL, /* SIOCSIWFRAG */ (iw_handler) NULL, /* SIOCGIWFRAG */ (iw_handler) ar6000_ioctl_siwtxpow, /* SIOCSIWTXPOW */ (iw_handler) W_PROTO(ar6000_ioctl_giwtxpow),/* SIOCGIWTXPOW */ (iw_handler) ar6000_ioctl_siwretry, /* SIOCSIWRETRY */ (iw_handler) ar6000_ioctl_giwretry, /* SIOCGIWRETRY */ (iw_handler) ar6000_ioctl_siwencode, /* SIOCSIWENCODE */ (iw_handler) ar6000_ioctl_giwencode, /* SIOCGIWENCODE */ #if WIRELESS_EXT > 20 (iw_handler) ar6000_ioctl_siwpower, /* SIOCSIWPOWER */ (iw_handler) ar6000_ioctl_giwpower, /* SIOCGIWPOWER */ #endif // WIRELESS_EXT > 20 #if WIRELESS_EXT >= 18 (iw_handler) NULL, /* -- hole -- */ (iw_handler) NULL, /* -- hole -- */ (iw_handler) ar6000_ioctl_siwgenie, /* SIOCSIWGENIE */ (iw_handler) ar6000_ioctl_giwgenie, /* SIOCGIWGENIE */ (iw_handler) ar6000_ioctl_siwauth, /* SIOCSIWAUTH */ (iw_handler) ar6000_ioctl_giwauth, /* SIOCGIWAUTH */ (iw_handler) ar6000_ioctl_siwencodeext, /* SIOCSIWENCODEEXT */ (iw_handler) ar6000_ioctl_giwencodeext, /* SIOCGIWENCODEEXT */ (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, };