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