]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/staging/rtl8712/rtl871x_ioctl_linux.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:


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