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