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