1 // SPDX-License-Identifier: GPL-2.0 2 /****************************************************************************** 3 * rtl871x_ioctl_linux.c 4 * 5 * Copyright(c) 2007 - 2010 Realtek Corporation. All rights reserved. 6 * Linux device driver for RTL8192SU 7 * 8 * Modifications for inclusion into the Linux staging tree are 9 * Copyright(c) 2010 Larry Finger. All rights reserved. 10 * 11 * Contact information: 12 * WLAN FAE <wlanfae@realtek.com> 13 * Larry Finger <Larry.Finger@lwfinger.net> 14 * 15 ******************************************************************************/ 16 17 #define _RTL871X_IOCTL_LINUX_C_ 18 #define _RTL871X_MP_IOCTL_C_ 19 20 #include "osdep_service.h" 21 #include "drv_types.h" 22 #include "wlan_bssdef.h" 23 #include "rtl871x_debug.h" 24 #include "wifi.h" 25 #include "rtl871x_mlme.h" 26 #include "rtl871x_ioctl.h" 27 #include "rtl871x_ioctl_set.h" 28 #include "rtl871x_mp_ioctl.h" 29 #include "mlme_osdep.h" 30 #include <linux/wireless.h> 31 #include <linux/module.h> 32 #include <linux/kernel.h> 33 #include <linux/io.h> 34 #include <linux/semaphore.h> 35 #include <net/iw_handler.h> 36 #include <linux/if_arp.h> 37 #include <linux/etherdevice.h> 38 39 40 #define RTL_IOCTL_WPA_SUPPLICANT (SIOCIWFIRSTPRIV + 0x1E) 41 42 #define SCAN_ITEM_SIZE 768 43 #define MAX_CUSTOM_LEN 64 44 #define RATE_COUNT 4 45 46 47 static const u32 rtl8180_rates[] = {1000000, 2000000, 5500000, 11000000, 48 6000000, 9000000, 12000000, 18000000, 49 24000000, 36000000, 48000000, 54000000}; 50 51 static const long ieee80211_wlan_frequencies[] = { 52 2412, 2417, 2422, 2427, 53 2432, 2437, 2442, 2447, 54 2452, 2457, 2462, 2467, 55 2472, 2484 56 }; 57 58 void r8712_indicate_wx_assoc_event(struct _adapter *padapter) 59 { 60 union iwreq_data wrqu; 61 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 62 63 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 64 memcpy(wrqu.ap_addr.sa_data, pmlmepriv->cur_network.network.MacAddress, 65 ETH_ALEN); 66 wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL); 67 } 68 69 void r8712_indicate_wx_disassoc_event(struct _adapter *padapter) 70 { 71 union iwreq_data wrqu; 72 73 wrqu.ap_addr.sa_family = ARPHRD_ETHER; 74 eth_zero_addr(wrqu.ap_addr.sa_data); 75 wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL); 76 } 77 78 static inline void handle_pairwise_key(struct sta_info *psta, 79 struct ieee_param *param, 80 struct _adapter *padapter) 81 { 82 /* pairwise key */ 83 memcpy(psta->x_UncstKey.skey, param->u.crypt.key, 84 (param->u.crypt. key_len > 16 ? 16 : param->u.crypt.key_len)); 85 if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */ 86 memcpy(psta->tkiptxmickey. skey, 87 &(param->u.crypt.key[16]), 8); 88 memcpy(psta->tkiprxmickey. skey, 89 &(param->u.crypt.key[24]), 8); 90 padapter->securitypriv. busetkipkey = false; 91 mod_timer(&padapter->securitypriv.tkip_timer, 92 jiffies + msecs_to_jiffies(50)); 93 } 94 r8712_setstakey_cmd(padapter, (unsigned char *)psta, true); 95 } 96 97 static inline void handle_group_key(struct ieee_param *param, 98 struct _adapter *padapter) 99 { 100 union Keytype *gk = padapter->securitypriv.XGrpKey; 101 union Keytype *gtk = padapter->securitypriv.XGrptxmickey; 102 union Keytype *grk = padapter->securitypriv.XGrprxmickey; 103 104 if (param->u.crypt.idx > 0 && 105 param->u.crypt.idx < 3) { 106 /* group key idx is 1 or 2 */ 107 memcpy(gk[param->u.crypt.idx - 1].skey, 108 param->u.crypt.key, 109 (param->u.crypt.key_len > 16 ? 16 : 110 param->u.crypt.key_len)); 111 memcpy(gtk[param->u.crypt.idx - 1].skey, 112 ¶m->u.crypt.key[16], 8); 113 memcpy(grk[param->u.crypt.idx - 1].skey, 114 ¶m->u.crypt.key[24], 8); 115 padapter->securitypriv.binstallGrpkey = true; 116 r8712_set_key(padapter, &padapter->securitypriv, 117 param->u.crypt.idx); 118 if (padapter->registrypriv.power_mgnt > PS_MODE_ACTIVE) { 119 if (padapter->registrypriv.power_mgnt != 120 padapter->pwrctrlpriv.pwr_mode) 121 mod_timer(&padapter->mlmepriv.dhcp_timer, 122 jiffies + msecs_to_jiffies(60000)); 123 } 124 } 125 } 126 127 static noinline_for_stack char *translate_scan_wpa(struct iw_request_info *info, 128 struct wlan_network *pnetwork, 129 struct iw_event *iwe, 130 char *start, char *stop) 131 { 132 /* parsing WPA/WPA2 IE */ 133 u8 buf[MAX_WPA_IE_LEN]; 134 u8 wpa_ie[255], rsn_ie[255]; 135 u16 wpa_len = 0, rsn_len = 0; 136 int n, i; 137 138 r8712_get_sec_ie(pnetwork->network.IEs, 139 pnetwork->network.IELength, rsn_ie, &rsn_len, 140 wpa_ie, &wpa_len); 141 if (wpa_len > 0) { 142 memset(buf, 0, MAX_WPA_IE_LEN); 143 n = sprintf(buf, "wpa_ie="); 144 for (i = 0; i < wpa_len; i++) { 145 n += snprintf(buf + n, MAX_WPA_IE_LEN - n, 146 "%02x", wpa_ie[i]); 147 if (n >= MAX_WPA_IE_LEN) 148 break; 149 } 150 memset(iwe, 0, sizeof(*iwe)); 151 iwe->cmd = IWEVCUSTOM; 152 iwe->u.data.length = (u16)strlen(buf); 153 start = iwe_stream_add_point(info, start, stop, 154 iwe, buf); 155 memset(iwe, 0, sizeof(*iwe)); 156 iwe->cmd = IWEVGENIE; 157 iwe->u.data.length = (u16)wpa_len; 158 start = iwe_stream_add_point(info, start, stop, 159 iwe, wpa_ie); 160 } 161 if (rsn_len > 0) { 162 memset(buf, 0, MAX_WPA_IE_LEN); 163 n = sprintf(buf, "rsn_ie="); 164 for (i = 0; i < rsn_len; i++) { 165 n += snprintf(buf + n, MAX_WPA_IE_LEN - n, 166 "%02x", rsn_ie[i]); 167 if (n >= MAX_WPA_IE_LEN) 168 break; 169 } 170 memset(iwe, 0, sizeof(*iwe)); 171 iwe->cmd = IWEVCUSTOM; 172 iwe->u.data.length = strlen(buf); 173 start = iwe_stream_add_point(info, start, stop, 174 iwe, buf); 175 memset(iwe, 0, sizeof(*iwe)); 176 iwe->cmd = IWEVGENIE; 177 iwe->u.data.length = rsn_len; 178 start = iwe_stream_add_point(info, start, stop, iwe, 179 rsn_ie); 180 } 181 182 return start; 183 } 184 185 static noinline_for_stack char *translate_scan_wps(struct iw_request_info *info, 186 struct wlan_network *pnetwork, 187 struct iw_event *iwe, 188 char *start, char *stop) 189 { 190 /* parsing WPS IE */ 191 u8 wps_ie[512]; 192 uint wps_ielen; 193 194 if (r8712_get_wps_ie(pnetwork->network.IEs, 195 pnetwork->network.IELength, 196 wps_ie, &wps_ielen)) { 197 if (wps_ielen > 2) { 198 iwe->cmd = IWEVGENIE; 199 iwe->u.data.length = (u16)wps_ielen; 200 start = iwe_stream_add_point(info, start, stop, 201 iwe, wps_ie); 202 } 203 } 204 205 return start; 206 } 207 208 static char *translate_scan(struct _adapter *padapter, 209 struct iw_request_info *info, 210 struct wlan_network *pnetwork, 211 char *start, char *stop) 212 { 213 struct iw_event iwe; 214 struct ieee80211_ht_cap *pht_capie; 215 char *current_val; 216 s8 *p; 217 u32 i = 0, ht_ielen = 0; 218 u16 cap, ht_cap = false, mcs_rate; 219 u8 rssi; 220 221 if ((pnetwork->network.Configuration.DSConfig < 1) || 222 (pnetwork->network.Configuration.DSConfig > 14)) { 223 if (pnetwork->network.Configuration.DSConfig < 1) 224 pnetwork->network.Configuration.DSConfig = 1; 225 else 226 pnetwork->network.Configuration.DSConfig = 14; 227 } 228 /* AP MAC address */ 229 iwe.cmd = SIOCGIWAP; 230 iwe.u.ap_addr.sa_family = ARPHRD_ETHER; 231 ether_addr_copy(iwe.u.ap_addr.sa_data, pnetwork->network.MacAddress); 232 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_ADDR_LEN); 233 /* Add the ESSID */ 234 iwe.cmd = SIOCGIWESSID; 235 iwe.u.data.flags = 1; 236 iwe.u.data.length = min_t(u32, pnetwork->network.Ssid.SsidLength, 32); 237 start = iwe_stream_add_point(info, start, stop, &iwe, 238 pnetwork->network.Ssid.Ssid); 239 /* parsing HT_CAP_IE */ 240 p = r8712_get_ie(&pnetwork->network.IEs[12], _HT_CAPABILITY_IE_, 241 &ht_ielen, pnetwork->network.IELength - 12); 242 if (p && ht_ielen > 0) { 243 ht_cap = true; 244 pht_capie = (struct ieee80211_ht_cap *)(p + 2); 245 memcpy(&mcs_rate, pht_capie->supp_mcs_set, 2); 246 } 247 /* Add the protocol name */ 248 iwe.cmd = SIOCGIWNAME; 249 if (r8712_is_cckratesonly_included(pnetwork->network.rates)) { 250 if (ht_cap) 251 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bn"); 252 else 253 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b"); 254 } else if (r8712_is_cckrates_included(pnetwork->network.rates)) { 255 if (ht_cap) 256 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bgn"); 257 else 258 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bg"); 259 } else { 260 if (ht_cap) 261 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11gn"); 262 else 263 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11g"); 264 } 265 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_CHAR_LEN); 266 /* Add mode */ 267 iwe.cmd = SIOCGIWMODE; 268 memcpy((u8 *)&cap, r8712_get_capability_from_ie(pnetwork->network.IEs), 269 2); 270 le16_to_cpus(&cap); 271 if (cap & (WLAN_CAPABILITY_IBSS | WLAN_CAPABILITY_BSS)) { 272 if (cap & WLAN_CAPABILITY_BSS) 273 iwe.u.mode = (u32)IW_MODE_MASTER; 274 else 275 iwe.u.mode = (u32)IW_MODE_ADHOC; 276 start = iwe_stream_add_event(info, start, stop, &iwe, 277 IW_EV_UINT_LEN); 278 } 279 /* Add frequency/channel */ 280 iwe.cmd = SIOCGIWFREQ; 281 { 282 /* check legal index */ 283 u8 dsconfig = pnetwork->network.Configuration.DSConfig; 284 285 if (dsconfig >= 1 && dsconfig <= sizeof( 286 ieee80211_wlan_frequencies) / sizeof(long)) 287 iwe.u.freq.m = 288 (s32)(ieee80211_wlan_frequencies 289 [dsconfig - 1] * 100000); 290 else 291 iwe.u.freq.m = 0; 292 } 293 iwe.u.freq.e = (s16)1; 294 iwe.u.freq.i = (u8)pnetwork->network.Configuration.DSConfig; 295 start = iwe_stream_add_event(info, start, stop, &iwe, 296 IW_EV_FREQ_LEN); 297 /* Add encryption capability */ 298 iwe.cmd = SIOCGIWENCODE; 299 if (cap & WLAN_CAPABILITY_PRIVACY) 300 iwe.u.data.flags = (u16)(IW_ENCODE_ENABLED | 301 IW_ENCODE_NOKEY); 302 else 303 iwe.u.data.flags = (u16)(IW_ENCODE_DISABLED); 304 iwe.u.data.length = (u16)0; 305 start = iwe_stream_add_point(info, start, stop, &iwe, 306 pnetwork->network.Ssid.Ssid); 307 /*Add basic and extended rates */ 308 current_val = start + iwe_stream_lcp_len(info); 309 iwe.cmd = SIOCGIWRATE; 310 iwe.u.bitrate.fixed = 0; 311 iwe.u.bitrate.disabled = 0; 312 iwe.u.bitrate.value = 0; 313 i = 0; 314 while (pnetwork->network.rates[i] != 0) { 315 /* Bit rate given in 500 kb/s units */ 316 iwe.u.bitrate.value = (pnetwork->network.rates[i++] & 317 0x7F) * 500000; 318 current_val = iwe_stream_add_value(info, start, current_val, 319 stop, &iwe, IW_EV_PARAM_LEN); 320 } 321 /* Check if we added any event */ 322 if ((current_val - start) > iwe_stream_lcp_len(info)) 323 start = current_val; 324 325 start = translate_scan_wpa(info, pnetwork, &iwe, start, stop); 326 327 start = translate_scan_wps(info, pnetwork, &iwe, start, stop); 328 329 /* Add quality statistics */ 330 iwe.cmd = IWEVQUAL; 331 rssi = r8712_signal_scale_mapping(pnetwork->network.Rssi); 332 /* we only update signal_level (signal strength) that is rssi. */ 333 iwe.u.qual.updated = (u8)(IW_QUAL_QUAL_INVALID | IW_QUAL_LEVEL_UPDATED | 334 IW_QUAL_NOISE_INVALID); 335 iwe.u.qual.level = rssi; /* signal strength */ 336 iwe.u.qual.qual = 0; /* signal quality */ 337 iwe.u.qual.noise = 0; /* noise level */ 338 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_QUAL_LEN); 339 /* how to translate rssi to ?% */ 340 return start; 341 } 342 343 static int wpa_set_auth_algs(struct net_device *dev, u32 value) 344 { 345 struct _adapter *padapter = netdev_priv(dev); 346 int ret = 0; 347 348 if ((value & AUTH_ALG_SHARED_KEY) && (value & AUTH_ALG_OPEN_SYSTEM)) { 349 padapter->securitypriv.ndisencryptstatus = 350 Ndis802_11Encryption1Enabled; 351 padapter->securitypriv.ndisauthtype = 352 Ndis802_11AuthModeAutoSwitch; 353 padapter->securitypriv.AuthAlgrthm = 3; 354 } else if (value & AUTH_ALG_SHARED_KEY) { 355 padapter->securitypriv.ndisencryptstatus = 356 Ndis802_11Encryption1Enabled; 357 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeShared; 358 padapter->securitypriv.AuthAlgrthm = 1; 359 } else if (value & AUTH_ALG_OPEN_SYSTEM) { 360 if (padapter->securitypriv.ndisauthtype < 361 Ndis802_11AuthModeWPAPSK) { 362 padapter->securitypriv.ndisauthtype = 363 Ndis802_11AuthModeOpen; 364 padapter->securitypriv.AuthAlgrthm = 0; 365 } 366 } else { 367 ret = -EINVAL; 368 } 369 return ret; 370 } 371 372 static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param, 373 u32 param_len) 374 { 375 int ret = 0; 376 u32 wep_key_idx, wep_key_len = 0; 377 struct NDIS_802_11_WEP *pwep = NULL; 378 struct _adapter *padapter = netdev_priv(dev); 379 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 380 struct security_priv *psecuritypriv = &padapter->securitypriv; 381 382 param->u.crypt.err = 0; 383 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0'; 384 if (param_len != (u32)((u8 *) param->u.crypt.key - (u8 *)param) + 385 param->u.crypt.key_len) 386 return -EINVAL; 387 if (!is_broadcast_ether_addr(param->sta_addr)) 388 return -EINVAL; 389 390 if (param->u.crypt.idx >= WEP_KEYS) { 391 /* for large key indices, set the default (0) */ 392 param->u.crypt.idx = 0; 393 } 394 if (strcmp(param->u.crypt.alg, "WEP") == 0) { 395 netdev_info(dev, "r8712u: %s: crypt.alg = WEP\n", __func__); 396 padapter->securitypriv.ndisencryptstatus = 397 Ndis802_11Encryption1Enabled; 398 padapter->securitypriv.PrivacyAlgrthm = _WEP40_; 399 padapter->securitypriv.XGrpPrivacy = _WEP40_; 400 wep_key_idx = param->u.crypt.idx; 401 wep_key_len = param->u.crypt.key_len; 402 if (wep_key_idx >= WEP_KEYS) 403 wep_key_idx = 0; 404 if (wep_key_len <= 0) 405 return -EINVAL; 406 407 wep_key_len = wep_key_len <= 5 ? 5 : 13; 408 pwep = kzalloc(sizeof(*pwep), GFP_ATOMIC); 409 if (!pwep) 410 return -ENOMEM; 411 pwep->KeyLength = wep_key_len; 412 pwep->Length = wep_key_len + 413 FIELD_OFFSET(struct NDIS_802_11_WEP, KeyMaterial); 414 if (wep_key_len == 13) { 415 padapter->securitypriv.PrivacyAlgrthm = _WEP104_; 416 padapter->securitypriv.XGrpPrivacy = _WEP104_; 417 } 418 pwep->KeyIndex = wep_key_idx; 419 pwep->KeyIndex |= 0x80000000; 420 memcpy(pwep->KeyMaterial, param->u.crypt.key, pwep->KeyLength); 421 if (param->u.crypt.set_tx) { 422 if (r8712_set_802_11_add_wep(padapter, pwep)) 423 ret = -EOPNOTSUPP; 424 } else { 425 /* don't update "psecuritypriv->PrivacyAlgrthm" and 426 * "psecuritypriv->PrivacyKeyIndex=keyid", but can 427 * r8712_set_key to fw/cam 428 */ 429 if (wep_key_idx >= WEP_KEYS) { 430 ret = -EOPNOTSUPP; 431 goto exit; 432 } 433 memcpy(&psecuritypriv->DefKey[wep_key_idx].skey[0], 434 pwep->KeyMaterial, 435 pwep->KeyLength); 436 psecuritypriv->DefKeylen[wep_key_idx] = 437 pwep->KeyLength; 438 r8712_set_key(padapter, psecuritypriv, wep_key_idx); 439 } 440 goto exit; 441 } 442 if (padapter->securitypriv.AuthAlgrthm == 2) { /* 802_1x */ 443 struct sta_info *psta, *pbcmc_sta; 444 struct sta_priv *pstapriv = &padapter->stapriv; 445 struct security_priv *spriv = &padapter->securitypriv; 446 447 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE | 448 WIFI_MP_STATE)) { /* sta mode */ 449 psta = r8712_get_stainfo(pstapriv, 450 get_bssid(pmlmepriv)); 451 if (psta) { 452 psta->ieee8021x_blocked = false; 453 if (spriv->ndisencryptstatus == 454 Ndis802_11Encryption2Enabled || 455 spriv->ndisencryptstatus == 456 Ndis802_11Encryption3Enabled) 457 psta->XPrivacy = spriv->PrivacyAlgrthm; 458 if (param->u.crypt.set_tx == 1) 459 handle_pairwise_key(psta, param, 460 padapter); 461 else /* group key */ 462 handle_group_key(param, padapter); 463 } 464 pbcmc_sta = r8712_get_bcmc_stainfo(padapter); 465 if (pbcmc_sta) { 466 pbcmc_sta->ieee8021x_blocked = false; 467 if (spriv->ndisencryptstatus == 468 Ndis802_11Encryption2Enabled || 469 spriv->ndisencryptstatus == 470 Ndis802_11Encryption3Enabled) 471 pbcmc_sta->XPrivacy = 472 spriv->PrivacyAlgrthm; 473 } 474 } 475 } 476 exit: 477 kfree(pwep); 478 return ret; 479 } 480 481 static int r871x_set_wpa_ie(struct _adapter *padapter, char *pie, 482 unsigned short ielen) 483 { 484 u8 *buf = NULL; 485 int group_cipher = 0, pairwise_cipher = 0; 486 int ret = 0; 487 488 if ((ielen > MAX_WPA_IE_LEN) || (pie == NULL)) 489 return -EINVAL; 490 if (ielen) { 491 buf = kmemdup(pie, ielen, GFP_ATOMIC); 492 if (buf == NULL) 493 return -ENOMEM; 494 if (ielen < RSN_HEADER_LEN) { 495 ret = -EINVAL; 496 goto exit; 497 } 498 if (r8712_parse_wpa_ie(buf, ielen, &group_cipher, 499 &pairwise_cipher) == 0) { 500 padapter->securitypriv.AuthAlgrthm = 2; 501 padapter->securitypriv.ndisauthtype = 502 Ndis802_11AuthModeWPAPSK; 503 } 504 if (r8712_parse_wpa2_ie(buf, ielen, &group_cipher, 505 &pairwise_cipher) == 0) { 506 padapter->securitypriv.AuthAlgrthm = 2; 507 padapter->securitypriv.ndisauthtype = 508 Ndis802_11AuthModeWPA2PSK; 509 } 510 switch (group_cipher) { 511 case WPA_CIPHER_NONE: 512 padapter->securitypriv.XGrpPrivacy = 513 _NO_PRIVACY_; 514 padapter->securitypriv.ndisencryptstatus = 515 Ndis802_11EncryptionDisabled; 516 break; 517 case WPA_CIPHER_WEP40: 518 padapter->securitypriv.XGrpPrivacy = _WEP40_; 519 padapter->securitypriv.ndisencryptstatus = 520 Ndis802_11Encryption1Enabled; 521 break; 522 case WPA_CIPHER_TKIP: 523 padapter->securitypriv.XGrpPrivacy = _TKIP_; 524 padapter->securitypriv.ndisencryptstatus = 525 Ndis802_11Encryption2Enabled; 526 break; 527 case WPA_CIPHER_CCMP: 528 padapter->securitypriv.XGrpPrivacy = _AES_; 529 padapter->securitypriv.ndisencryptstatus = 530 Ndis802_11Encryption3Enabled; 531 break; 532 case WPA_CIPHER_WEP104: 533 padapter->securitypriv.XGrpPrivacy = _WEP104_; 534 padapter->securitypriv.ndisencryptstatus = 535 Ndis802_11Encryption1Enabled; 536 break; 537 } 538 switch (pairwise_cipher) { 539 case WPA_CIPHER_NONE: 540 padapter->securitypriv.PrivacyAlgrthm = 541 _NO_PRIVACY_; 542 padapter->securitypriv.ndisencryptstatus = 543 Ndis802_11EncryptionDisabled; 544 break; 545 case WPA_CIPHER_WEP40: 546 padapter->securitypriv.PrivacyAlgrthm = _WEP40_; 547 padapter->securitypriv.ndisencryptstatus = 548 Ndis802_11Encryption1Enabled; 549 break; 550 case WPA_CIPHER_TKIP: 551 padapter->securitypriv.PrivacyAlgrthm = _TKIP_; 552 padapter->securitypriv.ndisencryptstatus = 553 Ndis802_11Encryption2Enabled; 554 break; 555 case WPA_CIPHER_CCMP: 556 padapter->securitypriv.PrivacyAlgrthm = _AES_; 557 padapter->securitypriv.ndisencryptstatus = 558 Ndis802_11Encryption3Enabled; 559 break; 560 case WPA_CIPHER_WEP104: 561 padapter->securitypriv.PrivacyAlgrthm = _WEP104_; 562 padapter->securitypriv.ndisencryptstatus = 563 Ndis802_11Encryption1Enabled; 564 break; 565 } 566 padapter->securitypriv.wps_phase = false; 567 {/* set wps_ie */ 568 u16 cnt = 0; 569 u8 eid, wps_oui[4] = {0x0, 0x50, 0xf2, 0x04}; 570 571 while (cnt < ielen) { 572 eid = buf[cnt]; 573 574 if ((eid == _VENDOR_SPECIFIC_IE_) && 575 (!memcmp(&buf[cnt + 2], wps_oui, 4))) { 576 netdev_info(padapter->pnetdev, "r8712u: SET WPS_IE\n"); 577 padapter->securitypriv.wps_ie_len = 578 ((buf[cnt + 1] + 2) < 579 (MAX_WPA_IE_LEN << 2)) ? 580 (buf[cnt + 1] + 2) : 581 (MAX_WPA_IE_LEN << 2); 582 memcpy(padapter->securitypriv.wps_ie, 583 &buf[cnt], 584 padapter->securitypriv.wps_ie_len); 585 padapter->securitypriv.wps_phase = 586 true; 587 netdev_info(padapter->pnetdev, "r8712u: SET WPS_IE, wps_phase==true\n"); 588 cnt += buf[cnt + 1] + 2; 589 break; 590 } 591 592 cnt += buf[cnt + 1] + 2; 593 } 594 } 595 } 596 exit: 597 kfree(buf); 598 return ret; 599 } 600 601 static int r8711_wx_get_name(struct net_device *dev, 602 struct iw_request_info *info, 603 union iwreq_data *wrqu, char *extra) 604 { 605 struct _adapter *padapter = netdev_priv(dev); 606 u32 ht_ielen = 0; 607 char *p; 608 u8 ht_cap = false; 609 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 610 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network; 611 u8 *prates; 612 613 if (check_fwstate(pmlmepriv, _FW_LINKED | WIFI_ADHOC_MASTER_STATE) == 614 true) { 615 /* parsing HT_CAP_IE */ 616 p = r8712_get_ie(&pcur_bss->IEs[12], _HT_CAPABILITY_IE_, 617 &ht_ielen, pcur_bss->IELength - 12); 618 if (p && ht_ielen > 0) 619 ht_cap = true; 620 prates = pcur_bss->rates; 621 if (r8712_is_cckratesonly_included(prates)) { 622 if (ht_cap) 623 snprintf(wrqu->name, IFNAMSIZ, 624 "IEEE 802.11bn"); 625 else 626 snprintf(wrqu->name, IFNAMSIZ, 627 "IEEE 802.11b"); 628 } else if (r8712_is_cckrates_included(prates)) { 629 if (ht_cap) 630 snprintf(wrqu->name, IFNAMSIZ, 631 "IEEE 802.11bgn"); 632 else 633 snprintf(wrqu->name, IFNAMSIZ, 634 "IEEE 802.11bg"); 635 } else { 636 if (ht_cap) 637 snprintf(wrqu->name, IFNAMSIZ, 638 "IEEE 802.11gn"); 639 else 640 snprintf(wrqu->name, IFNAMSIZ, 641 "IEEE 802.11g"); 642 } 643 } else { 644 snprintf(wrqu->name, IFNAMSIZ, "unassociated"); 645 } 646 return 0; 647 } 648 649 static const long frequency_list[] = { 650 2412, 2417, 2422, 2427, 2432, 2437, 2442, 2447, 2452, 2457, 2462, 651 2467, 2472, 2484, 4915, 4920, 4925, 4935, 4940, 4945, 4960, 4980, 652 5035, 5040, 5045, 5055, 5060, 5080, 5170, 5180, 5190, 5200, 5210, 653 5220, 5230, 5240, 5260, 5280, 5300, 5320, 5500, 5520, 5540, 5560, 654 5580, 5600, 5620, 5640, 5660, 5680, 5700, 5745, 5765, 5785, 5805, 655 5825 656 }; 657 658 static int r8711_wx_set_freq(struct net_device *dev, 659 struct iw_request_info *info, 660 union iwreq_data *wrqu, char *extra) 661 { 662 struct _adapter *padapter = netdev_priv(dev); 663 struct iw_freq *fwrq = &wrqu->freq; 664 int rc = 0; 665 666 /* If setting by frequency, convert to a channel */ 667 if ((fwrq->e == 1) && 668 (fwrq->m >= (int) 2.412e8) && 669 (fwrq->m <= (int) 2.487e8)) { 670 int f = fwrq->m / 100000; 671 int c = 0; 672 673 while ((c < 14) && (f != frequency_list[c])) 674 c++; 675 fwrq->e = 0; 676 fwrq->m = c + 1; 677 } 678 /* Setting by channel number */ 679 if ((fwrq->m > 14) || (fwrq->e > 0)) { 680 rc = -EOPNOTSUPP; 681 } else { 682 int channel = fwrq->m; 683 684 if ((channel < 1) || (channel > 14)) { 685 rc = -EINVAL; 686 } else { 687 /* Yes ! We can set it !!! */ 688 padapter->registrypriv.channel = channel; 689 } 690 } 691 return rc; 692 } 693 694 static int r8711_wx_get_freq(struct net_device *dev, 695 struct iw_request_info *info, 696 union iwreq_data *wrqu, char *extra) 697 { 698 struct _adapter *padapter = netdev_priv(dev); 699 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 700 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network; 701 702 if (!check_fwstate(pmlmepriv, _FW_LINKED)) 703 return -ENOLINK; 704 705 wrqu->freq.m = ieee80211_wlan_frequencies[ 706 pcur_bss->Configuration.DSConfig - 1] * 100000; 707 wrqu->freq.e = 1; 708 wrqu->freq.i = pcur_bss->Configuration.DSConfig; 709 710 return 0; 711 } 712 713 static int r8711_wx_set_mode(struct net_device *dev, 714 struct iw_request_info *a, 715 union iwreq_data *wrqu, char *b) 716 { 717 struct _adapter *padapter = netdev_priv(dev); 718 enum NDIS_802_11_NETWORK_INFRASTRUCTURE networkType; 719 720 switch (wrqu->mode) { 721 case IW_MODE_AUTO: 722 networkType = Ndis802_11AutoUnknown; 723 break; 724 case IW_MODE_ADHOC: 725 networkType = Ndis802_11IBSS; 726 break; 727 case IW_MODE_MASTER: 728 networkType = Ndis802_11APMode; 729 break; 730 case IW_MODE_INFRA: 731 networkType = Ndis802_11Infrastructure; 732 break; 733 default: 734 return -EINVAL; 735 } 736 if (Ndis802_11APMode == networkType) 737 r8712_setopmode_cmd(padapter, networkType); 738 else 739 r8712_setopmode_cmd(padapter, Ndis802_11AutoUnknown); 740 741 r8712_set_802_11_infrastructure_mode(padapter, networkType); 742 return 0; 743 } 744 745 static int r8711_wx_get_mode(struct net_device *dev, struct iw_request_info *a, 746 union iwreq_data *wrqu, char *b) 747 { 748 struct _adapter *padapter = netdev_priv(dev); 749 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 750 751 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) 752 wrqu->mode = IW_MODE_INFRA; 753 else if (check_fwstate(pmlmepriv, 754 WIFI_ADHOC_MASTER_STATE | WIFI_ADHOC_STATE)) 755 wrqu->mode = IW_MODE_ADHOC; 756 else if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) 757 wrqu->mode = IW_MODE_MASTER; 758 else 759 wrqu->mode = IW_MODE_AUTO; 760 return 0; 761 } 762 763 static int r871x_wx_set_pmkid(struct net_device *dev, 764 struct iw_request_info *a, 765 union iwreq_data *wrqu, char *extra) 766 { 767 struct _adapter *padapter = netdev_priv(dev); 768 struct security_priv *psecuritypriv = &padapter->securitypriv; 769 struct iw_pmksa *pPMK = (struct iw_pmksa *) extra; 770 struct RT_PMKID_LIST *pl = psecuritypriv->PMKIDList; 771 u8 strZeroMacAddress[ETH_ALEN] = {0x00}; 772 u8 strIssueBssid[ETH_ALEN] = {0x00}; 773 u8 j, blInserted = false; 774 int intReturn = false; 775 776 /* 777 * There are the BSSID information in the bssid.sa_data array. 778 * If cmd is IW_PMKSA_FLUSH, it means the wpa_supplicant wants to clear 779 * all the PMKID information. If cmd is IW_PMKSA_ADD, it means the 780 * wpa_supplicant wants to add a PMKID/BSSID to driver. 781 * If cmd is IW_PMKSA_REMOVE, it means the wpa_supplicant wants to 782 * remove a PMKID/BSSID from driver. 783 */ 784 if (pPMK == NULL) 785 return -EINVAL; 786 memcpy(strIssueBssid, pPMK->bssid.sa_data, ETH_ALEN); 787 switch (pPMK->cmd) { 788 case IW_PMKSA_ADD: 789 if (!memcmp(strIssueBssid, strZeroMacAddress, ETH_ALEN)) 790 return intReturn; 791 intReturn = true; 792 blInserted = false; 793 /* overwrite PMKID */ 794 for (j = 0; j < NUM_PMKID_CACHE; j++) { 795 if (!memcmp(pl[j].Bssid, strIssueBssid, ETH_ALEN)) { 796 /* BSSID is matched, the same AP => rewrite 797 * with new PMKID. 798 */ 799 netdev_info(dev, "r8712u: %s: BSSID exists in the PMKList.\n", 800 __func__); 801 memcpy(pl[j].PMKID, pPMK->pmkid, IW_PMKID_LEN); 802 pl[j].bUsed = true; 803 psecuritypriv->PMKIDIndex = j + 1; 804 blInserted = true; 805 break; 806 } 807 } 808 if (!blInserted) { 809 /* Find a new entry */ 810 netdev_info(dev, "r8712u: %s: Use the new entry index = %d for this PMKID.\n", 811 __func__, psecuritypriv->PMKIDIndex); 812 memcpy(pl[psecuritypriv->PMKIDIndex].Bssid, 813 strIssueBssid, ETH_ALEN); 814 memcpy(pl[psecuritypriv->PMKIDIndex].PMKID, 815 pPMK->pmkid, IW_PMKID_LEN); 816 pl[psecuritypriv->PMKIDIndex].bUsed = true; 817 psecuritypriv->PMKIDIndex++; 818 if (psecuritypriv->PMKIDIndex == NUM_PMKID_CACHE) 819 psecuritypriv->PMKIDIndex = 0; 820 } 821 break; 822 case IW_PMKSA_REMOVE: 823 intReturn = true; 824 for (j = 0; j < NUM_PMKID_CACHE; j++) { 825 if (!memcmp(pl[j].Bssid, strIssueBssid, ETH_ALEN)) { 826 /* BSSID is matched, the same AP => Remove 827 * this PMKID information and reset it. 828 */ 829 eth_zero_addr(pl[j].Bssid); 830 pl[j].bUsed = false; 831 break; 832 } 833 } 834 break; 835 case IW_PMKSA_FLUSH: 836 memset(psecuritypriv->PMKIDList, 0, 837 sizeof(struct RT_PMKID_LIST) * NUM_PMKID_CACHE); 838 psecuritypriv->PMKIDIndex = 0; 839 intReturn = true; 840 break; 841 default: 842 netdev_info(dev, "r8712u: %s: unknown Command\n", __func__); 843 intReturn = false; 844 break; 845 } 846 return intReturn; 847 } 848 849 static int r8711_wx_get_sens(struct net_device *dev, 850 struct iw_request_info *info, 851 union iwreq_data *wrqu, char *extra) 852 { 853 wrqu->sens.value = 0; 854 wrqu->sens.fixed = 0; /* no auto select */ 855 wrqu->sens.disabled = 1; 856 return 0; 857 } 858 859 static int r8711_wx_get_range(struct net_device *dev, 860 struct iw_request_info *info, 861 union iwreq_data *wrqu, char *extra) 862 { 863 struct iw_range *range = (struct iw_range *)extra; 864 u16 val; 865 int i; 866 867 wrqu->data.length = sizeof(*range); 868 memset(range, 0, sizeof(*range)); 869 /* Let's try to keep this struct in the same order as in 870 * linux/include/wireless.h 871 */ 872 873 /* TODO: See what values we can set, and remove the ones we can't 874 * set, or fill them with some default data. 875 */ 876 /* ~5 Mb/s real (802.11b) */ 877 range->throughput = 5 * 1000 * 1000; 878 /* TODO: 8711 sensitivity ? */ 879 /* signal level threshold range */ 880 /* percent values between 0 and 100. */ 881 range->max_qual.qual = 100; 882 range->max_qual.level = 100; 883 range->max_qual.noise = 100; 884 range->max_qual.updated = 7; /* Updated all three */ 885 range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */ 886 /* TODO: Find real 'good' to 'bad' threshold value for RSSI */ 887 range->avg_qual.level = 0x100 - 78; 888 range->avg_qual.noise = 0; 889 range->avg_qual.updated = 7; /* Updated all three */ 890 range->num_bitrates = RATE_COUNT; 891 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++) 892 range->bitrate[i] = rtl8180_rates[i]; 893 range->min_frag = MIN_FRAG_THRESHOLD; 894 range->max_frag = MAX_FRAG_THRESHOLD; 895 range->pm_capa = 0; 896 range->we_version_compiled = WIRELESS_EXT; 897 range->we_version_source = 16; 898 range->num_channels = 14; 899 for (i = 0, val = 0; i < 14; i++) { 900 /* Include only legal frequencies for some countries */ 901 range->freq[val].i = i + 1; 902 range->freq[val].m = ieee80211_wlan_frequencies[i] * 100000; 903 range->freq[val].e = 1; 904 val++; 905 if (val == IW_MAX_FREQUENCIES) 906 break; 907 } 908 range->num_frequency = val; 909 range->enc_capa = IW_ENC_CAPA_WPA | 910 IW_ENC_CAPA_WPA2 | 911 IW_ENC_CAPA_CIPHER_TKIP | 912 IW_ENC_CAPA_CIPHER_CCMP; 913 return 0; 914 } 915 916 static int r8711_wx_get_rate(struct net_device *dev, 917 struct iw_request_info *info, 918 union iwreq_data *wrqu, char *extra); 919 920 static int r871x_wx_set_priv(struct net_device *dev, 921 struct iw_request_info *info, 922 union iwreq_data *awrq, 923 char *extra) 924 { 925 int ret = 0, len = 0; 926 char *ext; 927 struct _adapter *padapter = netdev_priv(dev); 928 struct iw_point *dwrq = (struct iw_point *)awrq; 929 930 len = dwrq->length; 931 ext = memdup_user(dwrq->pointer, len); 932 if (IS_ERR(ext)) 933 return PTR_ERR(ext); 934 935 if (!strcasecmp(ext, "RSSI")) { 936 /*Return received signal strength indicator in -db for */ 937 /* current AP */ 938 /*<ssid> Rssi xx */ 939 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 940 struct wlan_network *pcur_network = &pmlmepriv->cur_network; 941 /*static u8 xxxx; */ 942 if (check_fwstate(pmlmepriv, _FW_LINKED)) { 943 sprintf(ext, "%s rssi %d", 944 pcur_network->network.Ssid.Ssid, 945 /*(xxxx=xxxx+10) */ 946 ((padapter->recvpriv.fw_rssi) >> 1) - 95 947 /*pcur_network->network.Rssi */ 948 ); 949 } else { 950 sprintf(ext, "OK"); 951 } 952 } else if (!strcasecmp(ext, "LINKSPEED")) { 953 /*Return link speed in MBPS */ 954 /*LinkSpeed xx */ 955 union iwreq_data wrqd; 956 int ret_inner; 957 int mbps; 958 959 ret_inner = r8711_wx_get_rate(dev, info, &wrqd, extra); 960 if (ret_inner != 0) 961 mbps = 0; 962 else 963 mbps = wrqd.bitrate.value / 1000000; 964 sprintf(ext, "LINKSPEED %d", mbps); 965 } else if (!strcasecmp(ext, "MACADDR")) { 966 /*Return mac address of the station */ 967 /* Macaddr = xx:xx:xx:xx:xx:xx */ 968 sprintf(ext, "MACADDR = %pM", dev->dev_addr); 969 } else if (!strcasecmp(ext, "SCAN-ACTIVE")) { 970 /*Set scan type to active */ 971 /*OK if successful */ 972 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 973 974 pmlmepriv->passive_mode = 1; 975 sprintf(ext, "OK"); 976 } else if (!strcasecmp(ext, "SCAN-PASSIVE")) { 977 /*Set scan type to passive */ 978 /*OK if successful */ 979 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 980 981 pmlmepriv->passive_mode = 0; 982 sprintf(ext, "OK"); 983 } else if (!strncmp(ext, "DCE-E", 5)) { 984 /*Set scan type to passive */ 985 /*OK if successful */ 986 r8712_disconnectCtrlEx_cmd(padapter 987 , 1 /*u32 enableDrvCtrl */ 988 , 5 /*u32 tryPktCnt */ 989 , 100 /*u32 tryPktInterval */ 990 , 5000 /*u32 firstStageTO */ 991 ); 992 sprintf(ext, "OK"); 993 } else if (!strncmp(ext, "DCE-D", 5)) { 994 /*Set scan type to passive */ 995 /*OK if successfu */ 996 r8712_disconnectCtrlEx_cmd(padapter 997 , 0 /*u32 enableDrvCtrl */ 998 , 5 /*u32 tryPktCnt */ 999 , 100 /*u32 tryPktInterval */ 1000 , 5000 /*u32 firstStageTO */ 1001 ); 1002 sprintf(ext, "OK"); 1003 } else { 1004 netdev_info(dev, "r8712u: %s: unknown Command %s.\n", 1005 __func__, ext); 1006 goto FREE_EXT; 1007 } 1008 if (copy_to_user(dwrq->pointer, ext, 1009 min(dwrq->length, (__u16)(strlen(ext) + 1)))) 1010 ret = -EFAULT; 1011 1012 FREE_EXT: 1013 kfree(ext); 1014 return ret; 1015 } 1016 1017 /* set bssid flow 1018 * s1. set_802_11_infrastructure_mode() 1019 * s2. set_802_11_authentication_mode() 1020 * s3. set_802_11_encryption_mode() 1021 * s4. set_802_11_bssid() 1022 * 1023 * This function intends to handle the Set AP command, which specifies the 1024 * MAC# of a preferred Access Point. 1025 * Currently, the request comes via Wireless Extensions' SIOCSIWAP ioctl. 1026 * 1027 * For this operation to succeed, there is no need for the interface to be up. 1028 * 1029 */ 1030 static int r8711_wx_set_wap(struct net_device *dev, 1031 struct iw_request_info *info, 1032 union iwreq_data *awrq, 1033 char *extra) 1034 { 1035 int ret = -EINPROGRESS; 1036 struct _adapter *padapter = netdev_priv(dev); 1037 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1038 struct __queue *queue = &pmlmepriv->scanned_queue; 1039 struct sockaddr *temp = (struct sockaddr *)awrq; 1040 unsigned long irqL; 1041 struct list_head *phead; 1042 u8 *dst_bssid; 1043 struct wlan_network *pnetwork = NULL; 1044 enum NDIS_802_11_AUTHENTICATION_MODE authmode; 1045 1046 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) 1047 return -EBUSY; 1048 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) 1049 return ret; 1050 if (temp->sa_family != ARPHRD_ETHER) 1051 return -EINVAL; 1052 authmode = padapter->securitypriv.ndisauthtype; 1053 spin_lock_irqsave(&queue->lock, irqL); 1054 phead = &queue->queue; 1055 pmlmepriv->pscanned = phead->next; 1056 while (1) { 1057 if (end_of_queue_search(phead, pmlmepriv->pscanned)) 1058 break; 1059 pnetwork = container_of(pmlmepriv->pscanned, 1060 struct wlan_network, list); 1061 pmlmepriv->pscanned = pmlmepriv->pscanned->next; 1062 dst_bssid = pnetwork->network.MacAddress; 1063 if (!memcmp(dst_bssid, temp->sa_data, ETH_ALEN)) { 1064 r8712_set_802_11_infrastructure_mode(padapter, 1065 pnetwork->network.InfrastructureMode); 1066 break; 1067 } 1068 } 1069 spin_unlock_irqrestore(&queue->lock, irqL); 1070 if (!ret) { 1071 if (!r8712_set_802_11_authentication_mode(padapter, authmode)) { 1072 ret = -ENOMEM; 1073 } else { 1074 if (!r8712_set_802_11_bssid(padapter, temp->sa_data)) 1075 ret = -1; 1076 } 1077 } 1078 return ret; 1079 } 1080 1081 static int r8711_wx_get_wap(struct net_device *dev, 1082 struct iw_request_info *info, 1083 union iwreq_data *wrqu, char *extra) 1084 { 1085 struct _adapter *padapter = netdev_priv(dev); 1086 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1087 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network; 1088 1089 wrqu->ap_addr.sa_family = ARPHRD_ETHER; 1090 if (check_fwstate(pmlmepriv, _FW_LINKED | WIFI_ADHOC_MASTER_STATE | 1091 WIFI_AP_STATE)) 1092 ether_addr_copy(wrqu->ap_addr.sa_data, pcur_bss->MacAddress); 1093 else 1094 eth_zero_addr(wrqu->ap_addr.sa_data); 1095 return 0; 1096 } 1097 1098 static int r871x_wx_set_mlme(struct net_device *dev, 1099 struct iw_request_info *info, 1100 union iwreq_data *wrqu, char *extra) 1101 { 1102 int ret = 0; 1103 struct _adapter *padapter = netdev_priv(dev); 1104 struct iw_mlme *mlme = (struct iw_mlme *) extra; 1105 1106 if (mlme == NULL) 1107 return -1; 1108 switch (mlme->cmd) { 1109 case IW_MLME_DEAUTH: 1110 if (!r8712_set_802_11_disassociate(padapter)) 1111 ret = -1; 1112 break; 1113 case IW_MLME_DISASSOC: 1114 if (!r8712_set_802_11_disassociate(padapter)) 1115 ret = -1; 1116 break; 1117 default: 1118 return -EOPNOTSUPP; 1119 } 1120 return ret; 1121 } 1122 1123 /* 1124 * 1125 * This function intends to handle the Set Scan command. 1126 * Currently, the request comes via Wireless Extensions' SIOCSIWSCAN ioctl. 1127 * 1128 * For this operation to succeed, the interface is brought Up beforehand. 1129 * 1130 */ 1131 static int r8711_wx_set_scan(struct net_device *dev, 1132 struct iw_request_info *a, 1133 union iwreq_data *wrqu, char *extra) 1134 { 1135 struct _adapter *padapter = netdev_priv(dev); 1136 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1137 u8 status = true; 1138 1139 if (padapter->driver_stopped) { 1140 netdev_info(dev, "In %s: driver_stopped=%d\n", 1141 __func__, padapter->driver_stopped); 1142 return -1; 1143 } 1144 if (!padapter->bup) 1145 return -ENETDOWN; 1146 if (!padapter->hw_init_completed) 1147 return -1; 1148 if ((check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | _FW_UNDER_LINKING)) || 1149 (pmlmepriv->sitesurveyctrl.traffic_busy)) 1150 return 0; 1151 if (wrqu->data.length == sizeof(struct iw_scan_req)) { 1152 struct iw_scan_req *req = (struct iw_scan_req *)extra; 1153 1154 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) { 1155 struct ndis_802_11_ssid ssid; 1156 unsigned long irqL; 1157 u32 len = min_t(u8, req->essid_len, IW_ESSID_MAX_SIZE); 1158 1159 memset((unsigned char *)&ssid, 0, 1160 sizeof(struct ndis_802_11_ssid)); 1161 memcpy(ssid.Ssid, req->essid, len); 1162 ssid.SsidLength = len; 1163 spin_lock_irqsave(&pmlmepriv->lock, irqL); 1164 if ((check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | 1165 _FW_UNDER_LINKING)) || 1166 (pmlmepriv->sitesurveyctrl.traffic_busy)) { 1167 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) 1168 status = false; 1169 } else { 1170 status = r8712_sitesurvey_cmd(padapter, &ssid); 1171 } 1172 spin_unlock_irqrestore(&pmlmepriv->lock, irqL); 1173 } 1174 } else { 1175 status = r8712_set_802_11_bssid_list_scan(padapter); 1176 } 1177 if (!status) 1178 return -1; 1179 return 0; 1180 } 1181 1182 static int r8711_wx_get_scan(struct net_device *dev, 1183 struct iw_request_info *a, 1184 union iwreq_data *wrqu, char *extra) 1185 { 1186 struct _adapter *padapter = netdev_priv(dev); 1187 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1188 struct __queue *queue = &pmlmepriv->scanned_queue; 1189 struct wlan_network *pnetwork = NULL; 1190 unsigned long irqL; 1191 struct list_head *plist, *phead; 1192 char *ev = extra; 1193 char *stop = ev + wrqu->data.length; 1194 u32 ret = 0, cnt = 0; 1195 1196 if (padapter->driver_stopped) 1197 return -EINVAL; 1198 while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | 1199 _FW_UNDER_LINKING)) { 1200 msleep(30); 1201 cnt++; 1202 if (cnt > 100) 1203 break; 1204 } 1205 spin_lock_irqsave(&queue->lock, irqL); 1206 phead = &queue->queue; 1207 plist = phead->next; 1208 while (1) { 1209 if (end_of_queue_search(phead, plist)) 1210 break; 1211 if ((stop - ev) < SCAN_ITEM_SIZE) { 1212 ret = -E2BIG; 1213 break; 1214 } 1215 pnetwork = container_of(plist, struct wlan_network, list); 1216 ev = translate_scan(padapter, a, pnetwork, ev, stop); 1217 plist = plist->next; 1218 } 1219 spin_unlock_irqrestore(&queue->lock, irqL); 1220 wrqu->data.length = ev - extra; 1221 wrqu->data.flags = 0; 1222 return ret; 1223 } 1224 1225 /* set ssid flow 1226 * s1. set_802_11_infrastructure_mode() 1227 * s2. set_802_11_authenticaion_mode() 1228 * s3. set_802_11_encryption_mode() 1229 * s4. set_802_11_ssid() 1230 * 1231 * This function intends to handle the Set ESSID command. 1232 * Currently, the request comes via the Wireless Extensions' SIOCSIWESSID ioctl. 1233 * 1234 * For this operation to succeed, there is no need for the interface to be Up. 1235 * 1236 */ 1237 static int r8711_wx_set_essid(struct net_device *dev, 1238 struct iw_request_info *a, 1239 union iwreq_data *wrqu, char *extra) 1240 { 1241 struct _adapter *padapter = netdev_priv(dev); 1242 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1243 struct __queue *queue = &pmlmepriv->scanned_queue; 1244 struct wlan_network *pnetwork = NULL; 1245 enum NDIS_802_11_AUTHENTICATION_MODE authmode; 1246 struct ndis_802_11_ssid ndis_ssid; 1247 u8 *dst_ssid, *src_ssid; 1248 struct list_head *phead; 1249 u32 len; 1250 1251 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY)) 1252 return -EBUSY; 1253 if (check_fwstate(pmlmepriv, _FW_UNDER_LINKING)) 1254 return 0; 1255 if (wrqu->essid.length > IW_ESSID_MAX_SIZE) 1256 return -E2BIG; 1257 authmode = padapter->securitypriv.ndisauthtype; 1258 if (wrqu->essid.flags && wrqu->essid.length) { 1259 len = (wrqu->essid.length < IW_ESSID_MAX_SIZE) ? 1260 wrqu->essid.length : IW_ESSID_MAX_SIZE; 1261 memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid)); 1262 ndis_ssid.SsidLength = len; 1263 memcpy(ndis_ssid.Ssid, extra, len); 1264 src_ssid = ndis_ssid.Ssid; 1265 phead = &queue->queue; 1266 pmlmepriv->pscanned = phead->next; 1267 while (1) { 1268 if (end_of_queue_search(phead, pmlmepriv->pscanned)) 1269 break; 1270 pnetwork = container_of(pmlmepriv->pscanned, 1271 struct wlan_network, list); 1272 pmlmepriv->pscanned = pmlmepriv->pscanned->next; 1273 dst_ssid = pnetwork->network.Ssid.Ssid; 1274 if ((!memcmp(dst_ssid, src_ssid, ndis_ssid.SsidLength)) 1275 && (pnetwork->network.Ssid.SsidLength == 1276 ndis_ssid.SsidLength)) { 1277 if (check_fwstate(pmlmepriv, 1278 WIFI_ADHOC_STATE)) { 1279 if (pnetwork->network. 1280 InfrastructureMode 1281 != 1282 padapter->mlmepriv. 1283 cur_network.network. 1284 InfrastructureMode) 1285 continue; 1286 } 1287 1288 r8712_set_802_11_infrastructure_mode( 1289 padapter, 1290 pnetwork->network.InfrastructureMode); 1291 break; 1292 } 1293 } 1294 r8712_set_802_11_authentication_mode(padapter, authmode); 1295 r8712_set_802_11_ssid(padapter, &ndis_ssid); 1296 } 1297 return -EINPROGRESS; 1298 } 1299 1300 static int r8711_wx_get_essid(struct net_device *dev, 1301 struct iw_request_info *a, 1302 union iwreq_data *wrqu, char *extra) 1303 { 1304 struct _adapter *padapter = netdev_priv(dev); 1305 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1306 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network; 1307 u32 len, ret = 0; 1308 1309 if (check_fwstate(pmlmepriv, _FW_LINKED | WIFI_ADHOC_MASTER_STATE)) { 1310 len = pcur_bss->Ssid.SsidLength; 1311 wrqu->essid.length = len; 1312 memcpy(extra, pcur_bss->Ssid.Ssid, len); 1313 wrqu->essid.flags = 1; 1314 } else { 1315 ret = -ENOLINK; 1316 } 1317 return ret; 1318 } 1319 1320 static int r8711_wx_set_rate(struct net_device *dev, 1321 struct iw_request_info *a, 1322 union iwreq_data *wrqu, char *extra) 1323 { 1324 struct _adapter *padapter = netdev_priv(dev); 1325 u32 target_rate = wrqu->bitrate.value; 1326 u32 fixed = wrqu->bitrate.fixed; 1327 u32 ratevalue = 0; 1328 u8 datarates[NumRates]; 1329 u8 mpdatarate[NumRates] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0xff}; 1330 int i; 1331 1332 if (target_rate == -1) { 1333 ratevalue = 11; 1334 goto set_rate; 1335 } 1336 target_rate = target_rate / 100000; 1337 switch (target_rate) { 1338 case 10: 1339 ratevalue = 0; 1340 break; 1341 case 20: 1342 ratevalue = 1; 1343 break; 1344 case 55: 1345 ratevalue = 2; 1346 break; 1347 case 60: 1348 ratevalue = 3; 1349 break; 1350 case 90: 1351 ratevalue = 4; 1352 break; 1353 case 110: 1354 ratevalue = 5; 1355 break; 1356 case 120: 1357 ratevalue = 6; 1358 break; 1359 case 180: 1360 ratevalue = 7; 1361 break; 1362 case 240: 1363 ratevalue = 8; 1364 break; 1365 case 360: 1366 ratevalue = 9; 1367 break; 1368 case 480: 1369 ratevalue = 10; 1370 break; 1371 case 540: 1372 ratevalue = 11; 1373 break; 1374 default: 1375 ratevalue = 11; 1376 break; 1377 } 1378 set_rate: 1379 for (i = 0; i < NumRates; i++) { 1380 if (ratevalue == mpdatarate[i]) { 1381 datarates[i] = mpdatarate[i]; 1382 if (fixed == 0) 1383 break; 1384 } else { 1385 datarates[i] = 0xff; 1386 } 1387 } 1388 return r8712_setdatarate_cmd(padapter, datarates); 1389 } 1390 1391 static int r8711_wx_get_rate(struct net_device *dev, 1392 struct iw_request_info *info, 1393 union iwreq_data *wrqu, char *extra) 1394 { 1395 struct _adapter *padapter = netdev_priv(dev); 1396 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1397 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network; 1398 struct ieee80211_ht_cap *pht_capie; 1399 unsigned char rf_type = padapter->registrypriv.rf_config; 1400 int i; 1401 u8 *p; 1402 u16 rate, max_rate = 0, ht_cap = false; 1403 u32 ht_ielen = 0; 1404 u8 bw_40MHz = 0, short_GI = 0; 1405 u16 mcs_rate = 0; 1406 1407 i = 0; 1408 if (!check_fwstate(pmlmepriv, _FW_LINKED | WIFI_ADHOC_MASTER_STATE)) 1409 return -ENOLINK; 1410 p = r8712_get_ie(&pcur_bss->IEs[12], _HT_CAPABILITY_IE_, &ht_ielen, 1411 pcur_bss->IELength - 12); 1412 if (p && ht_ielen > 0) { 1413 ht_cap = true; 1414 pht_capie = (struct ieee80211_ht_cap *)(p + 2); 1415 memcpy(&mcs_rate, pht_capie->supp_mcs_set, 2); 1416 bw_40MHz = (le16_to_cpu(pht_capie->cap_info) & 1417 IEEE80211_HT_CAP_SUP_WIDTH) ? 1 : 0; 1418 short_GI = (le16_to_cpu(pht_capie->cap_info) & 1419 (IEEE80211_HT_CAP_SGI_20 | 1420 IEEE80211_HT_CAP_SGI_40)) ? 1 : 0; 1421 } 1422 while ((pcur_bss->rates[i] != 0) && 1423 (pcur_bss->rates[i] != 0xFF)) { 1424 rate = pcur_bss->rates[i] & 0x7F; 1425 if (rate > max_rate) 1426 max_rate = rate; 1427 wrqu->bitrate.fixed = 0; /* no auto select */ 1428 wrqu->bitrate.value = rate * 500000; 1429 i++; 1430 } 1431 if (ht_cap) { 1432 if (mcs_rate & 0x8000 /* MCS15 */ 1433 && 1434 rf_type == RTL8712_RF_2T2R) 1435 max_rate = (bw_40MHz) ? ((short_GI) ? 300 : 270) : 1436 ((short_GI) ? 144 : 130); 1437 else /* default MCS7 */ 1438 max_rate = (bw_40MHz) ? ((short_GI) ? 150 : 135) : 1439 ((short_GI) ? 72 : 65); 1440 max_rate *= 2; /* Mbps/2 */ 1441 } 1442 wrqu->bitrate.value = max_rate * 500000; 1443 return 0; 1444 } 1445 1446 static int r8711_wx_get_rts(struct net_device *dev, 1447 struct iw_request_info *info, 1448 union iwreq_data *wrqu, char *extra) 1449 { 1450 struct _adapter *padapter = netdev_priv(dev); 1451 1452 wrqu->rts.value = padapter->registrypriv.rts_thresh; 1453 wrqu->rts.fixed = 0; /* no auto select */ 1454 return 0; 1455 } 1456 1457 static int r8711_wx_set_frag(struct net_device *dev, 1458 struct iw_request_info *info, 1459 union iwreq_data *wrqu, char *extra) 1460 { 1461 struct _adapter *padapter = netdev_priv(dev); 1462 1463 if (wrqu->frag.disabled) { 1464 padapter->xmitpriv.frag_len = MAX_FRAG_THRESHOLD; 1465 } else { 1466 if (wrqu->frag.value < MIN_FRAG_THRESHOLD || 1467 wrqu->frag.value > MAX_FRAG_THRESHOLD) 1468 return -EINVAL; 1469 padapter->xmitpriv.frag_len = wrqu->frag.value & ~0x1; 1470 } 1471 return 0; 1472 } 1473 1474 static int r8711_wx_get_frag(struct net_device *dev, 1475 struct iw_request_info *info, 1476 union iwreq_data *wrqu, char *extra) 1477 { 1478 struct _adapter *padapter = netdev_priv(dev); 1479 1480 wrqu->frag.value = padapter->xmitpriv.frag_len; 1481 wrqu->frag.fixed = 0; /* no auto select */ 1482 return 0; 1483 } 1484 1485 static int r8711_wx_get_retry(struct net_device *dev, 1486 struct iw_request_info *info, 1487 union iwreq_data *wrqu, char *extra) 1488 { 1489 wrqu->retry.value = 7; 1490 wrqu->retry.fixed = 0; /* no auto select */ 1491 wrqu->retry.disabled = 1; 1492 return 0; 1493 } 1494 1495 static int r8711_wx_set_enc(struct net_device *dev, 1496 struct iw_request_info *info, 1497 union iwreq_data *wrqu, char *keybuf) 1498 { 1499 u32 key; 1500 u32 keyindex_provided; 1501 struct NDIS_802_11_WEP wep; 1502 enum NDIS_802_11_AUTHENTICATION_MODE authmode; 1503 struct iw_point *erq = &(wrqu->encoding); 1504 struct _adapter *padapter = netdev_priv(dev); 1505 1506 key = erq->flags & IW_ENCODE_INDEX; 1507 memset(&wep, 0, sizeof(struct NDIS_802_11_WEP)); 1508 if (erq->flags & IW_ENCODE_DISABLED) { 1509 netdev_info(dev, "r8712u: %s: EncryptionDisabled\n", __func__); 1510 padapter->securitypriv.ndisencryptstatus = 1511 Ndis802_11EncryptionDisabled; 1512 padapter->securitypriv.PrivacyAlgrthm = _NO_PRIVACY_; 1513 padapter->securitypriv.XGrpPrivacy = _NO_PRIVACY_; 1514 padapter->securitypriv.AuthAlgrthm = 0; /* open system */ 1515 authmode = Ndis802_11AuthModeOpen; 1516 padapter->securitypriv.ndisauthtype = authmode; 1517 return 0; 1518 } 1519 if (key) { 1520 if (key > WEP_KEYS) 1521 return -EINVAL; 1522 key--; 1523 keyindex_provided = 1; 1524 } else { 1525 keyindex_provided = 0; 1526 key = padapter->securitypriv.PrivacyKeyIndex; 1527 } 1528 /* set authentication mode */ 1529 if (erq->flags & IW_ENCODE_OPEN) { 1530 netdev_info(dev, "r8712u: %s: IW_ENCODE_OPEN\n", __func__); 1531 padapter->securitypriv.ndisencryptstatus = 1532 Ndis802_11Encryption1Enabled; 1533 padapter->securitypriv.AuthAlgrthm = 0; /* open system */ 1534 padapter->securitypriv.PrivacyAlgrthm = _NO_PRIVACY_; 1535 padapter->securitypriv.XGrpPrivacy = _NO_PRIVACY_; 1536 authmode = Ndis802_11AuthModeOpen; 1537 padapter->securitypriv.ndisauthtype = authmode; 1538 } else if (erq->flags & IW_ENCODE_RESTRICTED) { 1539 netdev_info(dev, 1540 "r8712u: %s: IW_ENCODE_RESTRICTED\n", __func__); 1541 padapter->securitypriv.ndisencryptstatus = 1542 Ndis802_11Encryption1Enabled; 1543 padapter->securitypriv.AuthAlgrthm = 1; /* shared system */ 1544 padapter->securitypriv.PrivacyAlgrthm = _WEP40_; 1545 padapter->securitypriv.XGrpPrivacy = _WEP40_; 1546 authmode = Ndis802_11AuthModeShared; 1547 padapter->securitypriv.ndisauthtype = authmode; 1548 } else { 1549 padapter->securitypriv.ndisencryptstatus = 1550 Ndis802_11Encryption1Enabled; 1551 padapter->securitypriv.AuthAlgrthm = 0; /* open system */ 1552 padapter->securitypriv.PrivacyAlgrthm = _NO_PRIVACY_; 1553 padapter->securitypriv.XGrpPrivacy = _NO_PRIVACY_; 1554 authmode = Ndis802_11AuthModeOpen; 1555 padapter->securitypriv.ndisauthtype = authmode; 1556 } 1557 wep.KeyIndex = key; 1558 if (erq->length > 0) { 1559 wep.KeyLength = erq->length <= 5 ? 5 : 13; 1560 wep.Length = wep.KeyLength + 1561 FIELD_OFFSET(struct NDIS_802_11_WEP, KeyMaterial); 1562 } else { 1563 wep.KeyLength = 0; 1564 if (keyindex_provided == 1) { /* set key_id only, no given 1565 * KeyMaterial(erq->length==0). 1566 */ 1567 padapter->securitypriv.PrivacyKeyIndex = key; 1568 switch (padapter->securitypriv.DefKeylen[key]) { 1569 case 5: 1570 padapter->securitypriv.PrivacyAlgrthm = 1571 _WEP40_; 1572 break; 1573 case 13: 1574 padapter->securitypriv.PrivacyAlgrthm = 1575 _WEP104_; 1576 break; 1577 default: 1578 padapter->securitypriv.PrivacyAlgrthm = 1579 _NO_PRIVACY_; 1580 break; 1581 } 1582 return 0; 1583 } 1584 } 1585 wep.KeyIndex |= 0x80000000; /* transmit key */ 1586 memcpy(wep.KeyMaterial, keybuf, wep.KeyLength); 1587 if (r8712_set_802_11_add_wep(padapter, &wep)) 1588 return -EOPNOTSUPP; 1589 return 0; 1590 } 1591 1592 static int r8711_wx_get_enc(struct net_device *dev, 1593 struct iw_request_info *info, 1594 union iwreq_data *wrqu, char *keybuf) 1595 { 1596 uint key; 1597 struct _adapter *padapter = netdev_priv(dev); 1598 struct iw_point *erq = &(wrqu->encoding); 1599 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv); 1600 union Keytype *dk = padapter->securitypriv.DefKey; 1601 1602 if (!check_fwstate(pmlmepriv, _FW_LINKED)) { 1603 if (!check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) { 1604 erq->length = 0; 1605 erq->flags |= IW_ENCODE_DISABLED; 1606 return 0; 1607 } 1608 } 1609 key = erq->flags & IW_ENCODE_INDEX; 1610 if (key) { 1611 if (key > WEP_KEYS) 1612 return -EINVAL; 1613 key--; 1614 } else { 1615 key = padapter->securitypriv.PrivacyKeyIndex; 1616 } 1617 erq->flags = key + 1; 1618 switch (padapter->securitypriv.ndisencryptstatus) { 1619 case Ndis802_11EncryptionNotSupported: 1620 case Ndis802_11EncryptionDisabled: 1621 erq->length = 0; 1622 erq->flags |= IW_ENCODE_DISABLED; 1623 break; 1624 case Ndis802_11Encryption1Enabled: 1625 erq->length = padapter->securitypriv.DefKeylen[key]; 1626 if (erq->length) { 1627 memcpy(keybuf, dk[key].skey, 1628 padapter->securitypriv.DefKeylen[key]); 1629 erq->flags |= IW_ENCODE_ENABLED; 1630 if (padapter->securitypriv.ndisauthtype == 1631 Ndis802_11AuthModeOpen) 1632 erq->flags |= IW_ENCODE_OPEN; 1633 else if (padapter->securitypriv.ndisauthtype == 1634 Ndis802_11AuthModeShared) 1635 erq->flags |= IW_ENCODE_RESTRICTED; 1636 } else { 1637 erq->length = 0; 1638 erq->flags |= IW_ENCODE_DISABLED; 1639 } 1640 break; 1641 case Ndis802_11Encryption2Enabled: 1642 case Ndis802_11Encryption3Enabled: 1643 erq->length = 16; 1644 erq->flags |= (IW_ENCODE_ENABLED | IW_ENCODE_OPEN | 1645 IW_ENCODE_NOKEY); 1646 break; 1647 default: 1648 erq->length = 0; 1649 erq->flags |= IW_ENCODE_DISABLED; 1650 break; 1651 } 1652 return 0; 1653 } 1654 1655 static int r8711_wx_get_power(struct net_device *dev, 1656 struct iw_request_info *info, 1657 union iwreq_data *wrqu, char *extra) 1658 { 1659 wrqu->power.value = 0; 1660 wrqu->power.fixed = 0; /* no auto select */ 1661 wrqu->power.disabled = 1; 1662 return 0; 1663 } 1664 1665 static int r871x_wx_set_gen_ie(struct net_device *dev, 1666 struct iw_request_info *info, 1667 union iwreq_data *wrqu, char *extra) 1668 { 1669 struct _adapter *padapter = netdev_priv(dev); 1670 1671 return r871x_set_wpa_ie(padapter, extra, wrqu->data.length); 1672 } 1673 1674 static int r871x_wx_set_auth(struct net_device *dev, 1675 struct iw_request_info *info, 1676 union iwreq_data *wrqu, char *extra) 1677 { 1678 struct _adapter *padapter = netdev_priv(dev); 1679 struct iw_param *param = (struct iw_param *)&(wrqu->param); 1680 int paramid; 1681 int paramval; 1682 int ret = 0; 1683 1684 paramid = param->flags & IW_AUTH_INDEX; 1685 paramval = param->value; 1686 switch (paramid) { 1687 case IW_AUTH_WPA_VERSION: 1688 break; 1689 case IW_AUTH_CIPHER_PAIRWISE: 1690 break; 1691 case IW_AUTH_CIPHER_GROUP: 1692 break; 1693 case IW_AUTH_KEY_MGMT: 1694 /* 1695 * ??? does not use these parameters 1696 */ 1697 break; 1698 case IW_AUTH_TKIP_COUNTERMEASURES: 1699 if (paramval) { 1700 /* wpa_supplicant is enabling tkip countermeasure. */ 1701 padapter->securitypriv.btkip_countermeasure = true; 1702 } else { 1703 /* wpa_supplicant is disabling tkip countermeasure. */ 1704 padapter->securitypriv.btkip_countermeasure = false; 1705 } 1706 break; 1707 case IW_AUTH_DROP_UNENCRYPTED: 1708 /* HACK: 1709 * 1710 * wpa_supplicant calls set_wpa_enabled when the driver 1711 * is loaded and unloaded, regardless of if WPA is being 1712 * used. No other calls are made which can be used to 1713 * determine if encryption will be used or not prior to 1714 * association being expected. If encryption is not being 1715 * used, drop_unencrypted is set to false, else true -- we 1716 * can use this to determine if the CAP_PRIVACY_ON bit should 1717 * be set. 1718 */ 1719 if (padapter->securitypriv.ndisencryptstatus == 1720 Ndis802_11Encryption1Enabled) { 1721 /* it means init value, or using wep, 1722 * ndisencryptstatus = 1723 * Ndis802_11Encryption1Enabled, 1724 * then it needn't reset it; 1725 */ 1726 break; 1727 } 1728 1729 if (paramval) { 1730 padapter->securitypriv.ndisencryptstatus = 1731 Ndis802_11EncryptionDisabled; 1732 padapter->securitypriv.PrivacyAlgrthm = 1733 _NO_PRIVACY_; 1734 padapter->securitypriv.XGrpPrivacy = 1735 _NO_PRIVACY_; 1736 padapter->securitypriv.AuthAlgrthm = 0; 1737 padapter->securitypriv.ndisauthtype = 1738 Ndis802_11AuthModeOpen; 1739 } 1740 break; 1741 case IW_AUTH_80211_AUTH_ALG: 1742 ret = wpa_set_auth_algs(dev, (u32)paramval); 1743 break; 1744 case IW_AUTH_WPA_ENABLED: 1745 break; 1746 case IW_AUTH_RX_UNENCRYPTED_EAPOL: 1747 break; 1748 case IW_AUTH_PRIVACY_INVOKED: 1749 break; 1750 default: 1751 return -EOPNOTSUPP; 1752 } 1753 1754 return ret; 1755 } 1756 1757 static int r871x_wx_set_enc_ext(struct net_device *dev, 1758 struct iw_request_info *info, 1759 union iwreq_data *wrqu, char *extra) 1760 { 1761 struct iw_point *pencoding = &wrqu->encoding; 1762 struct iw_encode_ext *pext = (struct iw_encode_ext *)extra; 1763 struct ieee_param *param = NULL; 1764 char *alg_name; 1765 u32 param_len; 1766 int ret = 0; 1767 1768 switch (pext->alg) { 1769 case IW_ENCODE_ALG_NONE: 1770 alg_name = "none"; 1771 break; 1772 case IW_ENCODE_ALG_WEP: 1773 alg_name = "WEP"; 1774 break; 1775 case IW_ENCODE_ALG_TKIP: 1776 alg_name = "TKIP"; 1777 break; 1778 case IW_ENCODE_ALG_CCMP: 1779 alg_name = "CCMP"; 1780 break; 1781 default: 1782 return -EINVAL; 1783 } 1784 1785 param_len = sizeof(struct ieee_param) + pext->key_len; 1786 param = kzalloc(param_len, GFP_ATOMIC); 1787 if (!param) 1788 return -ENOMEM; 1789 param->cmd = IEEE_CMD_SET_ENCRYPTION; 1790 eth_broadcast_addr(param->sta_addr); 1791 strlcpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN); 1792 if (pext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) 1793 param->u.crypt.set_tx = 0; 1794 if (pext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) 1795 param->u.crypt.set_tx = 1; 1796 param->u.crypt.idx = (pencoding->flags & 0x00FF) - 1; 1797 if (pext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID) 1798 memcpy(param->u.crypt.seq, pext->rx_seq, 8); 1799 if (pext->key_len) { 1800 param->u.crypt.key_len = pext->key_len; 1801 memcpy(param + 1, pext + 1, pext->key_len); 1802 } 1803 ret = wpa_set_encryption(dev, param, param_len); 1804 kfree(param); 1805 return ret; 1806 } 1807 1808 static int r871x_wx_get_nick(struct net_device *dev, 1809 struct iw_request_info *info, 1810 union iwreq_data *wrqu, char *extra) 1811 { 1812 if (extra) { 1813 wrqu->data.length = 8; 1814 wrqu->data.flags = 1; 1815 memcpy(extra, "rtl_wifi", 8); 1816 } 1817 return 0; 1818 } 1819 1820 static int r8711_wx_read32(struct net_device *dev, 1821 struct iw_request_info *info, 1822 union iwreq_data *wrqu, char *keybuf) 1823 { 1824 struct _adapter *padapter = netdev_priv(dev); 1825 u32 addr; 1826 u32 data32; 1827 1828 get_user(addr, (u32 __user *)wrqu->data.pointer); 1829 data32 = r8712_read32(padapter, addr); 1830 put_user(data32, (u32 __user *)wrqu->data.pointer); 1831 wrqu->data.length = (data32 & 0xffff0000) >> 16; 1832 wrqu->data.flags = data32 & 0xffff; 1833 get_user(addr, (u32 __user *)wrqu->data.pointer); 1834 return 0; 1835 } 1836 1837 static int r8711_wx_write32(struct net_device *dev, 1838 struct iw_request_info *info, 1839 union iwreq_data *wrqu, char *keybuf) 1840 { 1841 struct _adapter *padapter = netdev_priv(dev); 1842 u32 addr; 1843 u32 data32; 1844 1845 get_user(addr, (u32 __user *)wrqu->data.pointer); 1846 data32 = ((u32)wrqu->data.length << 16) | (u32)wrqu->data.flags; 1847 r8712_write32(padapter, addr, data32); 1848 return 0; 1849 } 1850 1851 static int dummy(struct net_device *dev, 1852 struct iw_request_info *a, 1853 union iwreq_data *wrqu, char *b) 1854 { 1855 return -EINVAL; 1856 } 1857 1858 static int r8711_drvext_hdl(struct net_device *dev, 1859 struct iw_request_info *info, 1860 union iwreq_data *wrqu, char *extra) 1861 { 1862 return 0; 1863 } 1864 1865 static int r871x_mp_ioctl_hdl(struct net_device *dev, 1866 struct iw_request_info *info, 1867 union iwreq_data *wrqu, char *extra) 1868 { 1869 struct _adapter *padapter = netdev_priv(dev); 1870 struct iw_point *p = &wrqu->data; 1871 struct oid_par_priv oid_par; 1872 struct mp_ioctl_handler *phandler; 1873 struct mp_ioctl_param *poidparam; 1874 unsigned long BytesRead, BytesWritten, BytesNeeded; 1875 u8 *pparmbuf, bset; 1876 u16 len; 1877 uint status; 1878 int ret = 0; 1879 1880 if ((!p->length) || (!p->pointer)) 1881 return -EINVAL; 1882 1883 bset = (u8)(p->flags & 0xFFFF); 1884 len = p->length; 1885 pparmbuf = memdup_user(p->pointer, len); 1886 if (IS_ERR(pparmbuf)) 1887 return PTR_ERR(pparmbuf); 1888 1889 poidparam = (struct mp_ioctl_param *)pparmbuf; 1890 if (poidparam->subcode >= MAX_MP_IOCTL_SUBCODE) { 1891 ret = -EINVAL; 1892 goto _r871x_mp_ioctl_hdl_exit; 1893 } 1894 phandler = mp_ioctl_hdl + poidparam->subcode; 1895 if ((phandler->paramsize != 0) && 1896 (poidparam->len < phandler->paramsize)) { 1897 ret = -EINVAL; 1898 goto _r871x_mp_ioctl_hdl_exit; 1899 } 1900 if (phandler->oid == 0 && phandler->handler) { 1901 status = phandler->handler(&oid_par); 1902 } else if (phandler->handler) { 1903 oid_par.adapter_context = padapter; 1904 oid_par.oid = phandler->oid; 1905 oid_par.information_buf = poidparam->data; 1906 oid_par.information_buf_len = poidparam->len; 1907 oid_par.dbg = 0; 1908 BytesWritten = 0; 1909 BytesNeeded = 0; 1910 if (bset) { 1911 oid_par.bytes_rw = &BytesRead; 1912 oid_par.bytes_needed = &BytesNeeded; 1913 oid_par.type_of_oid = SET_OID; 1914 } else { 1915 oid_par.bytes_rw = &BytesWritten; 1916 oid_par.bytes_needed = &BytesNeeded; 1917 oid_par.type_of_oid = QUERY_OID; 1918 } 1919 status = phandler->handler(&oid_par); 1920 /* todo:check status, BytesNeeded, etc. */ 1921 } else { 1922 netdev_info(dev, "r8712u: %s: err!, subcode=%d, oid=%d, handler=%p\n", 1923 __func__, poidparam->subcode, phandler->oid, 1924 phandler->handler); 1925 ret = -EFAULT; 1926 goto _r871x_mp_ioctl_hdl_exit; 1927 } 1928 if (bset == 0x00) { /* query info */ 1929 if (copy_to_user(p->pointer, pparmbuf, len)) 1930 ret = -EFAULT; 1931 } 1932 if (status) { 1933 ret = -EFAULT; 1934 goto _r871x_mp_ioctl_hdl_exit; 1935 } 1936 _r871x_mp_ioctl_hdl_exit: 1937 kfree(pparmbuf); 1938 return ret; 1939 } 1940 1941 static int r871x_get_ap_info(struct net_device *dev, 1942 struct iw_request_info *info, 1943 union iwreq_data *wrqu, char *extra) 1944 { 1945 struct _adapter *padapter = netdev_priv(dev); 1946 struct mlme_priv *pmlmepriv = &padapter->mlmepriv; 1947 struct __queue *queue = &pmlmepriv->scanned_queue; 1948 struct iw_point *pdata = &wrqu->data; 1949 struct wlan_network *pnetwork = NULL; 1950 u32 cnt = 0, wpa_ielen; 1951 unsigned long irqL; 1952 struct list_head *plist, *phead; 1953 unsigned char *pbuf; 1954 u8 bssid[ETH_ALEN]; 1955 char data[33]; 1956 1957 if (padapter->driver_stopped || (pdata == NULL)) 1958 return -EINVAL; 1959 while (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY | 1960 _FW_UNDER_LINKING)) { 1961 msleep(30); 1962 cnt++; 1963 if (cnt > 100) 1964 break; 1965 } 1966 pdata->flags = 0; 1967 if (pdata->length < 32) 1968 return -EINVAL; 1969 if (copy_from_user(data, pdata->pointer, 32)) 1970 return -EINVAL; 1971 data[32] = 0; 1972 1973 spin_lock_irqsave(&(pmlmepriv->scanned_queue.lock), irqL); 1974 phead = &queue->queue; 1975 plist = phead->next; 1976 while (1) { 1977 if (end_of_queue_search(phead, plist)) 1978 break; 1979 pnetwork = container_of(plist, struct wlan_network, list); 1980 if (!mac_pton(data, bssid)) { 1981 netdev_info(dev, "r8712u: Invalid BSSID '%s'.\n", 1982 (u8 *)data); 1983 spin_unlock_irqrestore(&(pmlmepriv->scanned_queue.lock), 1984 irqL); 1985 return -EINVAL; 1986 } 1987 netdev_info(dev, "r8712u: BSSID:%pM\n", bssid); 1988 if (ether_addr_equal(bssid, pnetwork->network.MacAddress)) { 1989 /* BSSID match, then check if supporting wpa/wpa2 */ 1990 pbuf = r8712_get_wpa_ie(&pnetwork->network.IEs[12], 1991 &wpa_ielen, pnetwork->network.IELength - 12); 1992 if (pbuf && (wpa_ielen > 0)) { 1993 pdata->flags = 1; 1994 break; 1995 } 1996 pbuf = r8712_get_wpa2_ie(&pnetwork->network.IEs[12], 1997 &wpa_ielen, pnetwork->network.IELength - 12); 1998 if (pbuf && (wpa_ielen > 0)) { 1999 pdata->flags = 2; 2000 break; 2001 } 2002 } 2003 plist = plist->next; 2004 } 2005 spin_unlock_irqrestore(&(pmlmepriv->scanned_queue.lock), irqL); 2006 if (pdata->length >= 34) { 2007 if (copy_to_user((u8 __user *)pdata->pointer + 32, 2008 (u8 *)&pdata->flags, 1)) 2009 return -EINVAL; 2010 } 2011 return 0; 2012 } 2013 2014 static int r871x_set_pid(struct net_device *dev, 2015 struct iw_request_info *info, 2016 union iwreq_data *wrqu, char *extra) 2017 { 2018 struct _adapter *padapter = netdev_priv(dev); 2019 struct iw_point *pdata = &wrqu->data; 2020 2021 if ((padapter->driver_stopped) || (pdata == NULL)) 2022 return -EINVAL; 2023 if (copy_from_user(&padapter->pid, pdata->pointer, sizeof(int))) 2024 return -EINVAL; 2025 return 0; 2026 } 2027 2028 static int r871x_set_chplan(struct net_device *dev, 2029 struct iw_request_info *info, 2030 union iwreq_data *wrqu, char *extra) 2031 { 2032 int ret = 0; 2033 struct _adapter *padapter = netdev_priv(dev); 2034 struct iw_point *pdata = &wrqu->data; 2035 int ch_plan = -1; 2036 2037 if ((padapter->driver_stopped) || (pdata == NULL)) { 2038 ret = -EINVAL; 2039 goto exit; 2040 } 2041 ch_plan = (int)*extra; 2042 r8712_set_chplan_cmd(padapter, ch_plan); 2043 2044 exit: 2045 2046 return ret; 2047 } 2048 2049 static int r871x_wps_start(struct net_device *dev, 2050 struct iw_request_info *info, 2051 union iwreq_data *wrqu, char *extra) 2052 { 2053 struct _adapter *padapter = netdev_priv(dev); 2054 struct iw_point *pdata = &wrqu->data; 2055 u32 u32wps_start = 0; 2056 2057 if ((padapter->driver_stopped) || (pdata == NULL)) 2058 return -EINVAL; 2059 if (copy_from_user((void *)&u32wps_start, pdata->pointer, 4)) 2060 return -EFAULT; 2061 if (u32wps_start == 0) 2062 u32wps_start = *extra; 2063 if (u32wps_start == 1) /* WPS Start */ 2064 padapter->ledpriv.LedControlHandler(padapter, 2065 LED_CTL_START_WPS); 2066 else if (u32wps_start == 2) /* WPS Stop because of wps success */ 2067 padapter->ledpriv.LedControlHandler(padapter, 2068 LED_CTL_STOP_WPS); 2069 else if (u32wps_start == 3) /* WPS Stop because of wps fail */ 2070 padapter->ledpriv.LedControlHandler(padapter, 2071 LED_CTL_STOP_WPS_FAIL); 2072 return 0; 2073 } 2074 2075 static int wpa_set_param(struct net_device *dev, u8 name, u32 value) 2076 { 2077 struct _adapter *padapter = netdev_priv(dev); 2078 2079 switch (name) { 2080 case IEEE_PARAM_WPA_ENABLED: 2081 padapter->securitypriv.AuthAlgrthm = 2; /* 802.1x */ 2082 switch ((value) & 0xff) { 2083 case 1: /* WPA */ 2084 padapter->securitypriv.ndisauthtype = 2085 Ndis802_11AuthModeWPAPSK; /* WPA_PSK */ 2086 padapter->securitypriv.ndisencryptstatus = 2087 Ndis802_11Encryption2Enabled; 2088 break; 2089 case 2: /* WPA2 */ 2090 padapter->securitypriv.ndisauthtype = 2091 Ndis802_11AuthModeWPA2PSK; /* WPA2_PSK */ 2092 padapter->securitypriv.ndisencryptstatus = 2093 Ndis802_11Encryption3Enabled; 2094 break; 2095 } 2096 break; 2097 case IEEE_PARAM_TKIP_COUNTERMEASURES: 2098 break; 2099 case IEEE_PARAM_DROP_UNENCRYPTED: 2100 /* HACK: 2101 * 2102 * wpa_supplicant calls set_wpa_enabled when the driver 2103 * is loaded and unloaded, regardless of if WPA is being 2104 * used. No other calls are made which can be used to 2105 * determine if encryption will be used or not prior to 2106 * association being expected. If encryption is not being 2107 * used, drop_unencrypted is set to false, else true -- we 2108 * can use this to determine if the CAP_PRIVACY_ON bit should 2109 * be set. 2110 */ 2111 break; 2112 case IEEE_PARAM_PRIVACY_INVOKED: 2113 break; 2114 case IEEE_PARAM_AUTH_ALGS: 2115 return wpa_set_auth_algs(dev, value); 2116 case IEEE_PARAM_IEEE_802_1X: 2117 break; 2118 case IEEE_PARAM_WPAX_SELECT: 2119 /* added for WPA2 mixed mode */ 2120 break; 2121 default: 2122 return -EOPNOTSUPP; 2123 } 2124 return 0; 2125 } 2126 2127 static int wpa_mlme(struct net_device *dev, u32 command, u32 reason) 2128 { 2129 struct _adapter *padapter = netdev_priv(dev); 2130 2131 switch (command) { 2132 case IEEE_MLME_STA_DEAUTH: 2133 if (!r8712_set_802_11_disassociate(padapter)) 2134 return -1; 2135 break; 2136 case IEEE_MLME_STA_DISASSOC: 2137 if (!r8712_set_802_11_disassociate(padapter)) 2138 return -1; 2139 break; 2140 default: 2141 return -EOPNOTSUPP; 2142 } 2143 return 0; 2144 } 2145 2146 static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p) 2147 { 2148 struct ieee_param *param; 2149 int ret = 0; 2150 struct _adapter *padapter = netdev_priv(dev); 2151 2152 if (p->length < sizeof(struct ieee_param) || !p->pointer) 2153 return -EINVAL; 2154 param = memdup_user(p->pointer, p->length); 2155 if (IS_ERR(param)) 2156 return PTR_ERR(param); 2157 switch (param->cmd) { 2158 case IEEE_CMD_SET_WPA_PARAM: 2159 ret = wpa_set_param(dev, param->u.wpa_param.name, 2160 param->u.wpa_param.value); 2161 break; 2162 case IEEE_CMD_SET_WPA_IE: 2163 ret = r871x_set_wpa_ie(padapter, (char *)param->u.wpa_ie.data, 2164 (u16)param->u.wpa_ie.len); 2165 break; 2166 case IEEE_CMD_SET_ENCRYPTION: 2167 ret = wpa_set_encryption(dev, param, p->length); 2168 break; 2169 case IEEE_CMD_MLME: 2170 ret = wpa_mlme(dev, param->u.mlme.command, 2171 param->u.mlme.reason_code); 2172 break; 2173 default: 2174 ret = -EOPNOTSUPP; 2175 break; 2176 } 2177 if (ret == 0 && copy_to_user(p->pointer, param, p->length)) 2178 ret = -EFAULT; 2179 kfree(param); 2180 return ret; 2181 } 2182 2183 /* based on "driver_ipw" and for hostapd */ 2184 int r871x_ioctl(struct net_device *dev, struct ifreq *rq, int cmd) 2185 { 2186 struct iwreq *wrq = (struct iwreq *)rq; 2187 2188 switch (cmd) { 2189 case RTL_IOCTL_WPA_SUPPLICANT: 2190 return wpa_supplicant_ioctl(dev, &wrq->u.data); 2191 default: 2192 return -EOPNOTSUPP; 2193 } 2194 return 0; 2195 } 2196 2197 static iw_handler r8711_handlers[] = { 2198 NULL, /* SIOCSIWCOMMIT */ 2199 r8711_wx_get_name, /* SIOCGIWNAME */ 2200 dummy, /* SIOCSIWNWID */ 2201 dummy, /* SIOCGIWNWID */ 2202 r8711_wx_set_freq, /* SIOCSIWFREQ */ 2203 r8711_wx_get_freq, /* SIOCGIWFREQ */ 2204 r8711_wx_set_mode, /* SIOCSIWMODE */ 2205 r8711_wx_get_mode, /* SIOCGIWMODE */ 2206 dummy, /* SIOCSIWSENS */ 2207 r8711_wx_get_sens, /* SIOCGIWSENS */ 2208 NULL, /* SIOCSIWRANGE */ 2209 r8711_wx_get_range, /* SIOCGIWRANGE */ 2210 r871x_wx_set_priv, /* SIOCSIWPRIV */ 2211 NULL, /* SIOCGIWPRIV */ 2212 NULL, /* SIOCSIWSTATS */ 2213 NULL, /* SIOCGIWSTATS */ 2214 dummy, /* SIOCSIWSPY */ 2215 dummy, /* SIOCGIWSPY */ 2216 NULL, /* SIOCGIWTHRSPY */ 2217 NULL, /* SIOCWIWTHRSPY */ 2218 r8711_wx_set_wap, /* SIOCSIWAP */ 2219 r8711_wx_get_wap, /* SIOCGIWAP */ 2220 r871x_wx_set_mlme, /* request MLME operation; 2221 * uses struct iw_mlme 2222 */ 2223 dummy, /* SIOCGIWAPLIST -- deprecated */ 2224 r8711_wx_set_scan, /* SIOCSIWSCAN */ 2225 r8711_wx_get_scan, /* SIOCGIWSCAN */ 2226 r8711_wx_set_essid, /* SIOCSIWESSID */ 2227 r8711_wx_get_essid, /* SIOCGIWESSID */ 2228 dummy, /* SIOCSIWNICKN */ 2229 r871x_wx_get_nick, /* SIOCGIWNICKN */ 2230 NULL, /* -- hole -- */ 2231 NULL, /* -- hole -- */ 2232 r8711_wx_set_rate, /* SIOCSIWRATE */ 2233 r8711_wx_get_rate, /* SIOCGIWRATE */ 2234 dummy, /* SIOCSIWRTS */ 2235 r8711_wx_get_rts, /* SIOCGIWRTS */ 2236 r8711_wx_set_frag, /* SIOCSIWFRAG */ 2237 r8711_wx_get_frag, /* SIOCGIWFRAG */ 2238 dummy, /* SIOCSIWTXPOW */ 2239 dummy, /* SIOCGIWTXPOW */ 2240 dummy, /* SIOCSIWRETRY */ 2241 r8711_wx_get_retry, /* SIOCGIWRETRY */ 2242 r8711_wx_set_enc, /* SIOCSIWENCODE */ 2243 r8711_wx_get_enc, /* SIOCGIWENCODE */ 2244 dummy, /* SIOCSIWPOWER */ 2245 r8711_wx_get_power, /* SIOCGIWPOWER */ 2246 NULL, /*---hole---*/ 2247 NULL, /*---hole---*/ 2248 r871x_wx_set_gen_ie, /* SIOCSIWGENIE */ 2249 NULL, /* SIOCGIWGENIE */ 2250 r871x_wx_set_auth, /* SIOCSIWAUTH */ 2251 NULL, /* SIOCGIWAUTH */ 2252 r871x_wx_set_enc_ext, /* SIOCSIWENCODEEXT */ 2253 NULL, /* SIOCGIWENCODEEXT */ 2254 r871x_wx_set_pmkid, /* SIOCSIWPMKSA */ 2255 NULL, /*---hole---*/ 2256 }; 2257 2258 static const struct iw_priv_args r8711_private_args[] = { 2259 { 2260 SIOCIWFIRSTPRIV + 0x0, 2261 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "read32" 2262 }, 2263 { 2264 SIOCIWFIRSTPRIV + 0x1, 2265 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "write32" 2266 }, 2267 { 2268 SIOCIWFIRSTPRIV + 0x2, 0, 0, "driver_ext" 2269 }, 2270 { 2271 SIOCIWFIRSTPRIV + 0x3, 0, 0, "mp_ioctl" 2272 }, 2273 { 2274 SIOCIWFIRSTPRIV + 0x4, 2275 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "apinfo" 2276 }, 2277 { 2278 SIOCIWFIRSTPRIV + 0x5, 2279 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "setpid" 2280 }, 2281 { 2282 SIOCIWFIRSTPRIV + 0x6, 2283 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "wps_start" 2284 }, 2285 { 2286 SIOCIWFIRSTPRIV + 0x7, 2287 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, 0, "chplan" 2288 } 2289 }; 2290 2291 static iw_handler r8711_private_handler[] = { 2292 r8711_wx_read32, 2293 r8711_wx_write32, 2294 r8711_drvext_hdl, 2295 r871x_mp_ioctl_hdl, 2296 r871x_get_ap_info, /*for MM DTV platform*/ 2297 r871x_set_pid, 2298 r871x_wps_start, 2299 r871x_set_chplan 2300 }; 2301 2302 static struct iw_statistics *r871x_get_wireless_stats(struct net_device *dev) 2303 { 2304 struct _adapter *padapter = netdev_priv(dev); 2305 struct iw_statistics *piwstats = &padapter->iwstats; 2306 int tmp_level = 0; 2307 int tmp_qual = 0; 2308 int tmp_noise = 0; 2309 2310 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED) != true) { 2311 piwstats->qual.qual = 0; 2312 piwstats->qual.level = 0; 2313 piwstats->qual.noise = 0; 2314 } else { 2315 /* show percentage, we need transfer dbm to original value. */ 2316 tmp_level = padapter->recvpriv.fw_rssi; 2317 tmp_qual = padapter->recvpriv.signal; 2318 tmp_noise = padapter->recvpriv.noise; 2319 piwstats->qual.level = tmp_level; 2320 piwstats->qual.qual = tmp_qual; 2321 piwstats->qual.noise = tmp_noise; 2322 } 2323 piwstats->qual.updated = IW_QUAL_ALL_UPDATED; 2324 return &padapter->iwstats; 2325 } 2326 2327 struct iw_handler_def r871x_handlers_def = { 2328 .standard = r8711_handlers, 2329 .num_standard = ARRAY_SIZE(r8711_handlers), 2330 .private = r8711_private_handler, 2331 .private_args = (struct iw_priv_args *)r8711_private_args, 2332 .num_private = ARRAY_SIZE(r8711_private_handler), 2333 .num_private_args = sizeof(r8711_private_args) / 2334 sizeof(struct iw_priv_args), 2335 .get_wireless_stats = r871x_get_wireless_stats 2336 }; 2337