projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'core-objtool-for-linus' of git://git.kernel.org/pub/scm/linux/kernel...
[linux-block.git] / drivers / staging / rtl8188eu / os_dep / ioctl_linux.c
CommitLineData
71e9bd3f 1// SPDX-License-Identifier: GPL-2.0
a2c60d42
LF		 2/******************************************************************************
3 *
4 * Copyright(c) 2007 - 2012 Realtek Corporation. All rights reserved.
5 *
a2c60d42
LF		 6 ******************************************************************************/
7#define _IOCTL_LINUX_C_
8
04fbf979
PG		 9#include <linux/ieee80211.h>
10
a2c60d42
LF		 11#include <osdep_service.h>
12#include <drv_types.h>
13#include <wlan_bssdef.h>
14#include <rtw_debug.h>
15#include <wifi.h>
16#include <rtw_mlme.h>
17#include <rtw_mlme_ext.h>
18#include <rtw_ioctl.h>
19#include <rtw_ioctl_set.h>
a2c60d42
LF		 20#include <rtl8188e_hal.h>
21
d249db9e 22#include <linux/vmalloc.h>
8e5d9433
AM		 23#include <linux/etherdevice.h>
24
45c2fc82 25#include "osdep_intf.h"
a2c60d42
LF		 26
27#define RTL_IOCTL_WPA_SUPPLICANT (SIOCIWFIRSTPRIV + 30)
28
29#define SCAN_ITEM_SIZE 768
30#define MAX_CUSTOM_LEN 64
31#define RATE_COUNT 4
32
33/* combo scan */
34#define WEXT_CSCAN_AMOUNT 9
35#define WEXT_CSCAN_BUF_LEN 360
36#define WEXT_CSCAN_HEADER "CSCAN S\x01\x00\x00S\x00"
37#define WEXT_CSCAN_HEADER_SIZE 12
38#define WEXT_CSCAN_SSID_SECTION 'S'
39#define WEXT_CSCAN_CHANNEL_SECTION 'C'
40#define WEXT_CSCAN_NPROBE_SECTION 'N'
41#define WEXT_CSCAN_ACTV_DWELL_SECTION 'A'
42#define WEXT_CSCAN_PASV_DWELL_SECTION 'P'
43#define WEXT_CSCAN_HOME_DWELL_SECTION 'H'
44#define WEXT_CSCAN_TYPE_SECTION 'T'
45
a2c60d42
LF		 46static u32 rtw_rates[] = {1000000, 2000000, 5500000, 11000000,
47 6000000, 9000000, 12000000, 18000000, 24000000, 36000000,
48 48000000, 54000000};
49
50static const char * const iw_operation_mode[] = {
51 "Auto", "Ad-Hoc", "Managed", "Master", "Repeater",
52 "Secondary", "Monitor"
53};
54
a2c60d42
LF		 55void indicate_wx_scan_complete_event(struct adapter *padapter)
56{
57 union iwreq_data wrqu;
58
1ce39848 59 memset(&wrqu, 0, sizeof(union iwreq_data));
a2c60d42
LF		 60 wireless_send_event(padapter->pnetdev, SIOCGIWSCAN, &wrqu, NULL);
61}
62
63void rtw_indicate_wx_assoc_event(struct adapter *padapter)
64{
65 union iwreq_data wrqu;
66 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
67
1ce39848 68 memset(&wrqu, 0, sizeof(union iwreq_data));
a2c60d42
LF		 69
70 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
71
72 memcpy(wrqu.ap_addr.sa_data, pmlmepriv->cur_network.network.MacAddress, ETH_ALEN);
73
74 DBG_88E_LEVEL(_drv_always_, "assoc success\n");
75 wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL);
76}
77
78void rtw_indicate_wx_disassoc_event(struct adapter *padapter)
79{
80 union iwreq_data wrqu;
81
1ce39848 82 memset(&wrqu, 0, sizeof(union iwreq_data));
a2c60d42
LF		 83
84 wrqu.ap_addr.sa_family = ARPHRD_ETHER;
8e5d9433 85 eth_zero_addr(wrqu.ap_addr.sa_data);
a2c60d42
LF		 86
87 DBG_88E_LEVEL(_drv_always_, "indicate disassoc\n");
88 wireless_send_event(padapter->pnetdev, SIOCGIWAP, &wrqu, NULL);
89}
90
91static char *translate_scan(struct adapter *padapter,
92 struct iw_request_info *info,
93 struct wlan_network *pnetwork,
94 char *start, char *stop)
95{
96 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
97 struct iw_event iwe;
98 u16 cap;
99 __le16 le_tmp;
100 u32 ht_ielen = 0;
101 char custom[MAX_CUSTOM_LEN];
102 char *p;
103 u16 max_rate = 0, rate, ht_cap = false;
104 u32 i = 0;
105 u8 bw_40MHz = 0, short_GI = 0;
106 u16 mcs_rate = 0;
107 u8 ss, sq;
a2c60d42
LF		 108
109 /* AP MAC address */
110 iwe.cmd = SIOCGIWAP;
111 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
112
113 memcpy(iwe.u.ap_addr.sa_data, pnetwork->network.MacAddress, ETH_ALEN);
114 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_ADDR_LEN);
115
116 /* Add the ESSID */
117 iwe.cmd = SIOCGIWESSID;
118 iwe.u.data.flags = 1;
82f1cebe
FB		 119 iwe.u.data.length = min_t(u16, pnetwork->network.ssid.ssid_length, 32);
120 start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.ssid.ssid);
a2c60d42
LF		 121
122 /* parsing HT_CAP_IE */
341f27d0 123 p = rtw_get_ie(&pnetwork->network.ies[12], _HT_CAPABILITY_IE_, &ht_ielen, pnetwork->network.ie_length-12);
a2c60d42
LF		 124
125 if (p && ht_ielen > 0) {
da9090ad 126 struct ieee80211_ht_cap *pht_capie;
a2c60d42 127 ht_cap = true;
37ad17a4 128
da9090ad
IS		 129 pht_capie = (struct ieee80211_ht_cap *)(p + 2);
130 memcpy(&mcs_rate, pht_capie->mcs.rx_mask, 2);
131 bw_40MHz = !!(le16_to_cpu(pht_capie->cap_info) &
132 IEEE80211_HT_CAP_SUP_WIDTH);
133 short_GI = !!(le16_to_cpu(pht_capie->cap_info) &
134 (IEEE80211_HT_CAP_SGI_20 |
135 IEEE80211_HT_CAP_SGI_40));
a2c60d42
LF		 136 }
137
138 /* Add the protocol name */
139 iwe.cmd = SIOCGIWNAME;
140 if ((rtw_is_cckratesonly_included((u8 *)&pnetwork->network.SupportedRates))) {
141 if (ht_cap)
142 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bn");
143 else
4235d7d8 144 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11b");
a2c60d42
LF		 145 } else if ((rtw_is_cckrates_included((u8 *)&pnetwork->network.SupportedRates))) {
146 if (ht_cap)
147 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bgn");
148 else
149 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11bg");
150 } else {
79380bbf
MS		 151 if (ht_cap)
152 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11gn");
153 else
154 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11g");
a2c60d42
LF		 155 }
156
157 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_CHAR_LEN);
158
159 /* Add mode */
160 iwe.cmd = SIOCGIWMODE;
341f27d0 161 memcpy(&le_tmp, rtw_get_capability_from_ie(pnetwork->network.ies), 2);
a2c60d42
LF		 162
163 cap = le16_to_cpu(le_tmp);
164
027d3efd
JS		 165 if (!WLAN_CAPABILITY_IS_STA_BSS(cap)) {
166 if (cap & WLAN_CAPABILITY_ESS)
a2c60d42
LF		 167 iwe.u.mode = IW_MODE_MASTER;
168 else
169 iwe.u.mode = IW_MODE_ADHOC;
170
171 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_UINT_LEN);
172 }
173
174 if (pnetwork->network.Configuration.DSConfig < 1)
175 pnetwork->network.Configuration.DSConfig = 1;
176
177 /* Add frequency/channel */
178 iwe.cmd = SIOCGIWFREQ;
179 iwe.u.freq.m = rtw_ch2freq(pnetwork->network.Configuration.DSConfig) * 100000;
180 iwe.u.freq.e = 1;
181 iwe.u.freq.i = pnetwork->network.Configuration.DSConfig;
182 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_FREQ_LEN);
183
184 /* Add encryption capability */
185 iwe.cmd = SIOCGIWENCODE;
186 if (cap & WLAN_CAPABILITY_PRIVACY)
187 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
188 else
189 iwe.u.data.flags = IW_ENCODE_DISABLED;
190 iwe.u.data.length = 0;
82f1cebe 191 start = iwe_stream_add_point(info, start, stop, &iwe, pnetwork->network.ssid.ssid);
a2c60d42
LF		 192
193 /*Add basic and extended rates */
194 max_rate = 0;
195 p = custom;
72e7375c 196 p += scnprintf(p, MAX_CUSTOM_LEN - (p - custom), " Rates (Mb/s): ");
a2c60d42
LF		 197 while (pnetwork->network.SupportedRates[i] != 0) {
198 rate = pnetwork->network.SupportedRates[i]&0x7F;
199 if (rate > max_rate)
200 max_rate = rate;
72e7375c 201 p += scnprintf(p, MAX_CUSTOM_LEN - (p - custom),
a2c60d42
LF		 202 "%d%s ", rate >> 1, (rate & 1) ? ".5" : "");
203 i++;
204 }
205
206 if (ht_cap) {
207 if (mcs_rate&0x8000)/* MCS15 */
208 max_rate = (bw_40MHz) ? ((short_GI) ? 300 : 270) : ((short_GI) ? 144 : 130);
209 else if (mcs_rate&0x0080)/* MCS7 */
210 ;
211 else/* default MCS7 */
212 max_rate = (bw_40MHz) ? ((short_GI) ? 150 : 135) : ((short_GI) ? 72 : 65);
213
214 max_rate = max_rate*2;/* Mbps/2; */
215 }
216
217 iwe.cmd = SIOCGIWRATE;
218 iwe.u.bitrate.fixed = 0;
219 iwe.u.bitrate.disabled = 0;
220 iwe.u.bitrate.value = max_rate * 500000;
221 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_PARAM_LEN);
222
223 /* parsing WPA/WPA2 IE */
224 {
c497ae20 225 u8 *buf;
a2c60d42
LF		 226 u8 wpa_ie[255], rsn_ie[255];
227 u16 wpa_len = 0, rsn_len = 0;
228 u8 *p;
229
c497ae20
AB		 230 buf = kzalloc(MAX_WPA_IE_LEN, GFP_ATOMIC);
231 if (!buf)
232 return start;
233
341f27d0 234 rtw_get_sec_ie(pnetwork->network.ies, pnetwork->network.ie_length, rsn_ie, &rsn_len, wpa_ie, &wpa_len);
82f1cebe 235 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan: ssid =%s\n", pnetwork->network.ssid.ssid));
a2c60d42
LF		 236 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan: wpa_len =%d rsn_len =%d\n", wpa_len, rsn_len));
237
238 if (wpa_len > 0) {
239 p = buf;
ec03ab77 240 p += sprintf(p, "wpa_ie=");
a2c60d42
LF		 241 for (i = 0; i < wpa_len; i++)
242 p += sprintf(p, "%02x", wpa_ie[i]);
243
1ce39848 244 memset(&iwe, 0, sizeof(iwe));
a2c60d42
LF		 245 iwe.cmd = IWEVCUSTOM;
246 iwe.u.data.length = strlen(buf);
247 start = iwe_stream_add_point(info, start, stop, &iwe, buf);
248
1ce39848 249 memset(&iwe, 0, sizeof(iwe));
a2c60d42
LF		 250 iwe.cmd = IWEVGENIE;
251 iwe.u.data.length = wpa_len;
252 start = iwe_stream_add_point(info, start, stop, &iwe, wpa_ie);
253 }
254 if (rsn_len > 0) {
255 p = buf;
ec03ab77 256 p += sprintf(p, "rsn_ie=");
a2c60d42
LF		 257 for (i = 0; i < rsn_len; i++)
258 p += sprintf(p, "%02x", rsn_ie[i]);
1ce39848 259 memset(&iwe, 0, sizeof(iwe));
a2c60d42
LF		 260 iwe.cmd = IWEVCUSTOM;
261 iwe.u.data.length = strlen(buf);
262 start = iwe_stream_add_point(info, start, stop, &iwe, buf);
263
1ce39848 264 memset(&iwe, 0, sizeof(iwe));
a2c60d42
LF		 265 iwe.cmd = IWEVGENIE;
266 iwe.u.data.length = rsn_len;
267 start = iwe_stream_add_point(info, start, stop, &iwe, rsn_ie);
268 }
c497ae20 269 kfree(buf);
a2c60d42
LF		 270 }
271
272 {/* parsing WPS IE */
273 uint cnt = 0, total_ielen;
274 u8 *wpsie_ptr = NULL;
275 uint wps_ielen = 0;
341f27d0 276 u8 *ie_ptr = pnetwork->network.ies + _FIXED_IE_LENGTH_;
37ad17a4 277
341f27d0 278 total_ielen = pnetwork->network.ie_length - _FIXED_IE_LENGTH_;
a2c60d42
LF		 279
280 while (cnt < total_ielen) {
281 if (rtw_is_wps_ie(&ie_ptr[cnt], &wps_ielen) && (wps_ielen > 2)) {
282 wpsie_ptr = &ie_ptr[cnt];
283 iwe.cmd = IWEVGENIE;
284 iwe.u.data.length = (u16)wps_ielen;
285 start = iwe_stream_add_point(info, start, stop, &iwe, wpsie_ptr);
286 }
287 cnt += ie_ptr[cnt+1]+2; /* goto next */
288 }
289 }
290
291 /* Add quality statistics */
292 iwe.cmd = IWEVQUAL;
293 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED | IW_QUAL_NOISE_INVALID;
294
3f95106e 295 if (check_fwstate(pmlmepriv, _FW_LINKED) &&
a2c60d42
LF		 296 is_same_network(&pmlmepriv->cur_network.network, &pnetwork->network)) {
297 ss = padapter->recvpriv.signal_strength;
298 sq = padapter->recvpriv.signal_qual;
299 } else {
300 ss = pnetwork->network.PhyInfo.SignalStrength;
301 sq = pnetwork->network.PhyInfo.SignalQuality;
302 }
303
304 iwe.u.qual.level = (u8)ss;
305 iwe.u.qual.qual = (u8)sq; /* signal quality */
306 iwe.u.qual.noise = 0; /* noise level */
307 start = iwe_stream_add_event(info, start, stop, &iwe, IW_EV_QUAL_LEN);
308 return start;
309}
310
311static int wpa_set_auth_algs(struct net_device *dev, u32 value)
312{
313 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
314 int ret = 0;
315
316 if ((value & AUTH_ALG_SHARED_KEY) && (value & AUTH_ALG_OPEN_SYSTEM)) {
317 DBG_88E("wpa_set_auth_algs, AUTH_ALG_SHARED_KEY and AUTH_ALG_OPEN_SYSTEM [value:0x%x]\n", value);
318 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
319 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeAutoSwitch;
320 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Auto;
321 } else if (value & AUTH_ALG_SHARED_KEY) {
322 DBG_88E("wpa_set_auth_algs, AUTH_ALG_SHARED_KEY [value:0x%x]\n", value);
323 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
324
325 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeShared;
326 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
327 } else if (value & AUTH_ALG_OPEN_SYSTEM) {
328 DBG_88E("wpa_set_auth_algs, AUTH_ALG_OPEN_SYSTEM\n");
329 if (padapter->securitypriv.ndisauthtype < Ndis802_11AuthModeWPAPSK) {
330 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
331 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
332 }
333 } else if (value & AUTH_ALG_LEAP) {
334 DBG_88E("wpa_set_auth_algs, AUTH_ALG_LEAP\n");
335 } else {
336 DBG_88E("wpa_set_auth_algs, error!\n");
337 ret = -EINVAL;
338 }
339 return ret;
340}
341
342static int wpa_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
343{
344 int ret = 0;
345 u32 wep_key_idx, wep_key_len, wep_total_len;
346 struct ndis_802_11_wep *pwep = NULL;
347 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
348 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
349 struct security_priv *psecuritypriv = &padapter->securitypriv;
a2c60d42 350
a2c60d42
LF		 351 param->u.crypt.err = 0;
352 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
353
7be921a2 354 if (param_len < (u32)((u8 *)param->u.crypt.key - (u8 *)param) + param->u.crypt.key_len) {
a2c60d42
LF		 355 ret = -EINVAL;
356 goto exit;
357 }
358
8663b2e0 359 if (is_broadcast_ether_addr(param->sta_addr)) {
a2c60d42
LF		 360 if (param->u.crypt.idx >= WEP_KEYS) {
361 ret = -EINVAL;
362 goto exit;
363 }
364 } else {
365 ret = -EINVAL;
366 goto exit;
367 }
368
369 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
370 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("wpa_set_encryption, crypt.alg = WEP\n"));
371 DBG_88E("wpa_set_encryption, crypt.alg = WEP\n");
372
373 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
374 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
375 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
376
377 wep_key_idx = param->u.crypt.idx;
378 wep_key_len = param->u.crypt.key_len;
379
380 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("(1)wep_key_idx =%d\n", wep_key_idx));
381 DBG_88E("(1)wep_key_idx =%d\n", wep_key_idx);
382
383 if (wep_key_idx > WEP_KEYS)
384 return -EINVAL;
385
386 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("(2)wep_key_idx =%d\n", wep_key_idx));
387
388 if (wep_key_len > 0) {
389 wep_key_len = wep_key_len <= 5 ? 5 : 13;
5e3027b6 390 wep_total_len = wep_key_len + offsetof(struct ndis_802_11_wep, KeyMaterial);
a2c60d42 391 pwep = (struct ndis_802_11_wep *)rtw_malloc(wep_total_len);
4fe514dc 392 if (!pwep) {
a2c60d42
LF		 393 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, (" wpa_set_encryption: pwep allocate fail !!!\n"));
394 goto exit;
395 }
1ce39848 396 memset(pwep, 0, wep_total_len);
a2c60d42
LF		 397 pwep->KeyLength = wep_key_len;
398 pwep->Length = wep_total_len;
399 if (wep_key_len == 13) {
400 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
401 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
402 }
403 } else {
404 ret = -EINVAL;
405 goto exit;
406 }
407 pwep->KeyIndex = wep_key_idx;
408 pwep->KeyIndex |= 0x80000000;
409 memcpy(pwep->KeyMaterial, param->u.crypt.key, pwep->KeyLength);
410 if (param->u.crypt.set_tx) {
411 DBG_88E("wep, set_tx = 1\n");
412 if (rtw_set_802_11_add_wep(padapter, pwep) == (u8)_FAIL)
413 ret = -EOPNOTSUPP;
414 } else {
415 DBG_88E("wep, set_tx = 0\n");
416 if (wep_key_idx >= WEP_KEYS) {
417 ret = -EOPNOTSUPP;
418 goto exit;
419 }
859df6aa 420 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
a2c60d42
LF		 421 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength;
422 rtw_set_key(padapter, psecuritypriv, wep_key_idx, 0);
423 }
424 goto exit;
425 }
426
427 if (padapter->securitypriv.dot11AuthAlgrthm == dot11AuthAlgrthm_8021X) { /* 802_1x */
428 struct sta_info *psta, *pbcmc_sta;
429 struct sta_priv *pstapriv = &padapter->stapriv;
430
80c96e08 431 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE)) { /* sta mode */
a2c60d42 432 psta = rtw_get_stainfo(pstapriv, get_bssid(pmlmepriv));
4fe514dc 433 if (!psta) {
a2c60d42
LF		 434 ;
435 } else {
436 if (strcmp(param->u.crypt.alg, "none") != 0)
437 psta->ieee8021x_blocked = false;
438
439 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) ||
440 (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled))
441 psta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
442
443 if (param->u.crypt.set_tx == 1) { /* pairwise key */
ad8d8cd3 444 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
a2c60d42
LF		 445
446 if (strcmp(param->u.crypt.alg, "TKIP") == 0) { /* set mic key */
447 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
448 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
449 padapter->securitypriv.busetkipkey = false;
450 }
451
452 DBG_88E(" ~~~~set sta key:unicastkey\n");
453
454 rtw_setstakey_cmd(padapter, (unsigned char *)psta, true);
455 } else { /* group key */
ad8d8cd3 456 memcpy(padapter->securitypriv.dot118021XGrpKey[param->u.crypt.idx].skey, param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16 ));
a2c60d42
LF		 457 memcpy(padapter->securitypriv.dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
458 memcpy(padapter->securitypriv.dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
459 padapter->securitypriv.binstallGrpkey = true;
460 DBG_88E(" ~~~~set sta key:groupkey\n");
461
462 padapter->securitypriv.dot118021XGrpKeyid = param->u.crypt.idx;
463
464 rtw_set_key(padapter, &padapter->securitypriv, param->u.crypt.idx, 1);
a2c60d42
LF		 465 }
466 }
467 pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
4fe514dc 468 if (!pbcmc_sta) {
a2c60d42
LF		 469 ;
470 } else {
471 /* Jeff: don't disable ieee8021x_blocked while clearing key */
472 if (strcmp(param->u.crypt.alg, "none") != 0)
473 pbcmc_sta->ieee8021x_blocked = false;
474
475 if ((padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption2Enabled) ||
476 (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption3Enabled))
477 pbcmc_sta->dot118021XPrivacy = padapter->securitypriv.dot11PrivacyAlgrthm;
478 }
479 }
480 }
481
482exit:
483
484 kfree(pwep);
a2c60d42
LF		 485 return ret;
486}
487
488static int rtw_set_wpa_ie(struct adapter *padapter, char *pie, unsigned short ielen)
489{
490 u8 *buf = NULL;
491 int group_cipher = 0, pairwise_cipher = 0;
492 int ret = 0;
a2c60d42 493
4fe514dc 494 if ((ielen > MAX_WPA_IE_LEN) || (!pie)) {
a2c60d42 495 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
4fe514dc 496 if (!pie)
a2c60d42
LF		 497 return ret;
498 else
499 return -EINVAL;
500 }
501
502 if (ielen) {
705515cd 503 buf = kmemdup(pie, ielen, GFP_KERNEL);
4fe514dc 504 if (!buf) {
a2c60d42
LF		 505 ret = -ENOMEM;
506 goto exit;
507 }
508
a2c60d42
LF		 509 /* dump */
510 {
511 int i;
37ad17a4 512
a2c60d42
LF		 513 DBG_88E("\n wpa_ie(length:%d):\n", ielen);
514 for (i = 0; i < ielen; i += 8)
515 DBG_88E("0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x 0x%.2x\n", buf[i], buf[i+1], buf[i+2], buf[i+3], buf[i+4], buf[i+5], buf[i+6], buf[i+7]);
516 }
517
518 if (ielen < RSN_HEADER_LEN) {
519 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("Ie len too short %d\n", ielen));
520 ret = -1;
521 goto exit;
522 }
523
524 if (rtw_parse_wpa_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
525 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
526 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK;
527 memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen);
528 }
529
530 if (rtw_parse_wpa2_ie(buf, ielen, &group_cipher, &pairwise_cipher, NULL) == _SUCCESS) {
531 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X;
532 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK;
533 memcpy(padapter->securitypriv.supplicant_ie, &buf[0], ielen);
534 }
535
536 switch (group_cipher) {
537 case WPA_CIPHER_NONE:
538 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
539 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
540 break;
541 case WPA_CIPHER_WEP40:
542 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
543 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
544 break;
545 case WPA_CIPHER_TKIP:
546 padapter->securitypriv.dot118021XGrpPrivacy = _TKIP_;
547 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
548 break;
549 case WPA_CIPHER_CCMP:
550 padapter->securitypriv.dot118021XGrpPrivacy = _AES_;
551 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
552 break;
553 case WPA_CIPHER_WEP104:
554 padapter->securitypriv.dot118021XGrpPrivacy = _WEP104_;
555 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
556 break;
557 }
558
559 switch (pairwise_cipher) {
560 case WPA_CIPHER_NONE:
561 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
562 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
563 break;
564 case WPA_CIPHER_WEP40:
565 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
566 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
567 break;
568 case WPA_CIPHER_TKIP:
569 padapter->securitypriv.dot11PrivacyAlgrthm = _TKIP_;
570 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
571 break;
572 case WPA_CIPHER_CCMP:
573 padapter->securitypriv.dot11PrivacyAlgrthm = _AES_;
574 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
575 break;
576 case WPA_CIPHER_WEP104:
577 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
578 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
579 break;
580 }
581
582 _clr_fwstate_(&padapter->mlmepriv, WIFI_UNDER_WPS);
583 {/* set wps_ie */
584 u16 cnt = 0;
585 u8 eid, wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
586
587 while (cnt < ielen) {
588 eid = buf[cnt];
589 if ((eid == _VENDOR_SPECIFIC_IE_) && (!memcmp(&buf[cnt+2], wps_oui, 4))) {
590 DBG_88E("SET WPS_IE\n");
591
20e76531 592 padapter->securitypriv.wps_ie_len = min(buf[cnt + 1] + 2, MAX_WPA_IE_LEN << 2);
a2c60d42
LF		 593
594 memcpy(padapter->securitypriv.wps_ie, &buf[cnt], padapter->securitypriv.wps_ie_len);
595
596 set_fwstate(&padapter->mlmepriv, WIFI_UNDER_WPS);
a2c60d42
LF		 597 cnt += buf[cnt+1]+2;
598 break;
a2c60d42 599 }
0b4d1d0d 600 cnt += buf[cnt+1]+2; /* goto next */
a2c60d42
LF		 601 }
602 }
603 }
604
605 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
606 ("rtw_set_wpa_ie: pairwise_cipher = 0x%08x padapter->securitypriv.ndisencryptstatus =%d padapter->securitypriv.ndisauthtype =%d\n",
607 pairwise_cipher, padapter->securitypriv.ndisencryptstatus, padapter->securitypriv.ndisauthtype));
608exit:
609 kfree(buf);
610 return ret;
611}
612
613typedef unsigned char NDIS_802_11_RATES_EX[NDIS_802_11_LENGTH_RATES_EX];
614
615static int rtw_wx_get_name(struct net_device *dev,
616 struct iw_request_info *info,
617 union iwreq_data *wrqu, char *extra)
618{
619 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
620 u32 ht_ielen = 0;
621 char *p;
622 u8 ht_cap = false;
623 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
624 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
625 NDIS_802_11_RATES_EX *prates = NULL;
626
627 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("cmd_code =%x\n", info->cmd));
628
3f95106e 629 if (check_fwstate(pmlmepriv, _FW_LINKED | WIFI_ADHOC_MASTER_STATE)) {
a2c60d42 630 /* parsing HT_CAP_IE */
341f27d0 631 p = rtw_get_ie(&pcur_bss->ies[12], _HT_CAPABILITY_IE_, &ht_ielen, pcur_bss->ie_length-12);
a2c60d42
LF		 632 if (p && ht_ielen > 0)
633 ht_cap = true;
634
635 prates = &pcur_bss->SupportedRates;
636
8c438b73 637 if (rtw_is_cckratesonly_included((u8 *)prates)) {
a2c60d42
LF		 638 if (ht_cap)
639 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bn");
640 else
641 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11b");
8c438b73 642 } else if (rtw_is_cckrates_included((u8 *)prates)) {
a2c60d42
LF		 643 if (ht_cap)
644 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bgn");
645 else
646 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11bg");
647 } else {
79380bbf
MS		 648 if (ht_cap)
649 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11gn");
650 else
651 snprintf(wrqu->name, IFNAMSIZ, "IEEE 802.11g");
a2c60d42
LF		 652 }
653 } else {
654 snprintf(wrqu->name, IFNAMSIZ, "unassociated");
655 }
a2c60d42
LF		 656 return 0;
657}
658
659static int rtw_wx_set_freq(struct net_device *dev,
660 struct iw_request_info *info,
661 union iwreq_data *wrqu, char *extra)
662{
a2c60d42 663 RT_TRACE(_module_rtl871x_mlme_c_, _drv_notice_, ("+rtw_wx_set_freq\n"));
a2c60d42
LF		 664 return 0;
665}
666
667static int rtw_wx_get_freq(struct net_device *dev,
668 struct iw_request_info *info,
669 union iwreq_data *wrqu, char *extra)
670{
671 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
672 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
673 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
674
675 if (check_fwstate(pmlmepriv, _FW_LINKED)) {
676 /* wrqu->freq.m = ieee80211_wlan_frequencies[pcur_bss->Configuration.DSConfig-1] * 100000; */
677 wrqu->freq.m = rtw_ch2freq(pcur_bss->Configuration.DSConfig) * 100000;
678 wrqu->freq.e = 1;
679 wrqu->freq.i = pcur_bss->Configuration.DSConfig;
680 } else {
681 wrqu->freq.m = rtw_ch2freq(padapter->mlmeextpriv.cur_channel) * 100000;
682 wrqu->freq.e = 1;
683 wrqu->freq.i = padapter->mlmeextpriv.cur_channel;
684 }
685
686 return 0;
687}
688
689static int rtw_wx_set_mode(struct net_device *dev, struct iw_request_info *a,
690 union iwreq_data *wrqu, char *b)
691{
692 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
693 enum ndis_802_11_network_infra networkType;
694 int ret = 0;
695
a2c60d42
LF		 696 if (_FAIL == rtw_pwr_wakeup(padapter)) {
697 ret = -EPERM;
698 goto exit;
699 }
700
701 if (!padapter->hw_init_completed) {
702 ret = -EPERM;
703 goto exit;
704 }
705
706 switch (wrqu->mode) {
707 case IW_MODE_AUTO:
708 networkType = Ndis802_11AutoUnknown;
709 DBG_88E("set_mode = IW_MODE_AUTO\n");
710 break;
711 case IW_MODE_ADHOC:
712 networkType = Ndis802_11IBSS;
713 DBG_88E("set_mode = IW_MODE_ADHOC\n");
714 break;
715 case IW_MODE_MASTER:
716 networkType = Ndis802_11APMode;
717 DBG_88E("set_mode = IW_MODE_MASTER\n");
718 break;
719 case IW_MODE_INFRA:
720 networkType = Ndis802_11Infrastructure;
721 DBG_88E("set_mode = IW_MODE_INFRA\n");
722 break;
723 default:
724 ret = -EINVAL;
725 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_err_, ("\n Mode: %s is not supported\n", iw_operation_mode[wrqu->mode]));
726 goto exit;
727 }
bbf2f71e 728 if (!rtw_set_802_11_infrastructure_mode(padapter, networkType)) {
a2c60d42
LF		 729 ret = -EPERM;
730 goto exit;
731 }
732 rtw_setopmode_cmd(padapter, networkType);
733exit:
a2c60d42
LF		 734 return ret;
735}
736
737static int rtw_wx_get_mode(struct net_device *dev, struct iw_request_info *a,
738 union iwreq_data *wrqu, char *b)
739{
740 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
741 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
742
743 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, (" rtw_wx_get_mode\n"));
744
a2c60d42
LF		 745 if (check_fwstate(pmlmepriv, WIFI_STATION_STATE))
746 wrqu->mode = IW_MODE_INFRA;
747 else if ((check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) ||
748 (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)))
749 wrqu->mode = IW_MODE_ADHOC;
750 else if (check_fwstate(pmlmepriv, WIFI_AP_STATE))
751 wrqu->mode = IW_MODE_MASTER;
752 else
753 wrqu->mode = IW_MODE_AUTO;
754
a2c60d42
LF		 755 return 0;
756}
757
758static int rtw_wx_set_pmkid(struct net_device *dev,
759 struct iw_request_info *a,
760 union iwreq_data *wrqu, char *extra)
761{
762 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
763 u8 j, blInserted = false;
764 int ret = false;
765 struct security_priv *psecuritypriv = &padapter->securitypriv;
766 struct iw_pmksa *pPMK = (struct iw_pmksa *)extra;
767 u8 strZeroMacAddress[ETH_ALEN] = {0x00};
768 u8 strIssueBssid[ETH_ALEN] = {0x00};
769
770 memcpy(strIssueBssid, pPMK->bssid.sa_data, ETH_ALEN);
771 if (pPMK->cmd == IW_PMKSA_ADD) {
772 DBG_88E("[rtw_wx_set_pmkid] IW_PMKSA_ADD!\n");
dc14a626 773 if (!memcmp(strIssueBssid, strZeroMacAddress, ETH_ALEN))
a2c60d42 774 return ret;
0b4d1d0d 775 ret = true;
a2c60d42
LF		 776 blInserted = false;
777
778 /* overwrite PMKID */
779 for (j = 0; j < NUM_PMKID_CACHE; j++) {
780 if (!memcmp(psecuritypriv->PMKIDList[j].Bssid, strIssueBssid, ETH_ALEN)) {
781 /* BSSID is matched, the same AP => rewrite with new PMKID. */
782 DBG_88E("[rtw_wx_set_pmkid] BSSID exists in the PMKList.\n");
783 memcpy(psecuritypriv->PMKIDList[j].PMKID, pPMK->pmkid, IW_PMKID_LEN);
784 psecuritypriv->PMKIDList[j].bUsed = true;
785 psecuritypriv->PMKIDIndex = j+1;
786 blInserted = true;
787 break;
788 }
789 }
790
791 if (!blInserted) {
792 /* Find a new entry */
793 DBG_88E("[rtw_wx_set_pmkid] Use the new entry index = %d for this PMKID.\n",
794 psecuritypriv->PMKIDIndex);
795
796 memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].Bssid, strIssueBssid, ETH_ALEN);
797 memcpy(psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].PMKID, pPMK->pmkid, IW_PMKID_LEN);
798
799 psecuritypriv->PMKIDList[psecuritypriv->PMKIDIndex].bUsed = true;
800 psecuritypriv->PMKIDIndex++;
801 if (psecuritypriv->PMKIDIndex == 16)
802 psecuritypriv->PMKIDIndex = 0;
803 }
804 } else if (pPMK->cmd == IW_PMKSA_REMOVE) {
805 DBG_88E("[rtw_wx_set_pmkid] IW_PMKSA_REMOVE!\n");
806 ret = true;
807 for (j = 0; j < NUM_PMKID_CACHE; j++) {
808 if (!memcmp(psecuritypriv->PMKIDList[j].Bssid, strIssueBssid, ETH_ALEN)) {
809 /* BSSID is matched, the same AP => Remove this PMKID information and reset it. */
8e5d9433 810 eth_zero_addr(psecuritypriv->PMKIDList[j].Bssid);
a2c60d42
LF		 811 psecuritypriv->PMKIDList[j].bUsed = false;
812 break;
813 }
814 }
815 } else if (pPMK->cmd == IW_PMKSA_FLUSH) {
816 DBG_88E("[rtw_wx_set_pmkid] IW_PMKSA_FLUSH!\n");
1ce39848 817 memset(&psecuritypriv->PMKIDList[0], 0x00, sizeof(struct rt_pmkid_list) * NUM_PMKID_CACHE);
a2c60d42
LF		 818 psecuritypriv->PMKIDIndex = 0;
819 ret = true;
820 }
821 return ret;
822}
823
824static int rtw_wx_get_sens(struct net_device *dev,
825 struct iw_request_info *info,
826 union iwreq_data *wrqu, char *extra)
827{
828 wrqu->sens.value = 0;
829 wrqu->sens.fixed = 0; /* no auto select */
830 wrqu->sens.disabled = 1;
831 return 0;
832}
833
834static int rtw_wx_get_range(struct net_device *dev,
835 struct iw_request_info *info,
836 union iwreq_data *wrqu, char *extra)
837{
838 struct iw_range *range = (struct iw_range *)extra;
839 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
840 struct mlme_ext_priv *pmlmeext = &padapter->mlmeextpriv;
841
842 u16 val;
843 int i;
844
a2c60d42
LF		 845 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_range. cmd_code =%x\n", info->cmd));
846
847 wrqu->data.length = sizeof(*range);
1ce39848 848 memset(range, 0, sizeof(*range));
a2c60d42
LF		 849
850 /* Let's try to keep this struct in the same order as in
851 * linux/include/wireless.h
852 */
853
854 /* TODO: See what values we can set, and remove the ones we can't
855 * set, or fill them with some default data.
856 */
857
858 /* ~5 Mb/s real (802.11b) */
859 range->throughput = 5 * 1000 * 1000;
860
861 /* signal level threshold range */
862
863 /* percent values between 0 and 100. */
864 range->max_qual.qual = 100;
865 range->max_qual.level = 100;
866 range->max_qual.noise = 100;
867 range->max_qual.updated = 7; /* Updated all three */
868
869 range->avg_qual.qual = 92; /* > 8% missed beacons is 'bad' */
870 /* TODO: Find real 'good' to 'bad' threshol value for RSSI */
dc14a626 871 range->avg_qual.level = 178; /* -78 dBm */
a2c60d42
LF		 872 range->avg_qual.noise = 0;
873 range->avg_qual.updated = 7; /* Updated all three */
874
875 range->num_bitrates = RATE_COUNT;
876
877 for (i = 0; i < RATE_COUNT && i < IW_MAX_BITRATES; i++)
878 range->bitrate[i] = rtw_rates[i];
879
880 range->min_frag = MIN_FRAG_THRESHOLD;
881 range->max_frag = MAX_FRAG_THRESHOLD;
882
883 range->pm_capa = 0;
884
885 range->we_version_compiled = WIRELESS_EXT;
886 range->we_version_source = 16;
887
888 for (i = 0, val = 0; i < MAX_CHANNEL_NUM; i++) {
889 /* Include only legal frequencies for some countries */
890 if (pmlmeext->channel_set[i].ChannelNum != 0) {
891 range->freq[val].i = pmlmeext->channel_set[i].ChannelNum;
892 range->freq[val].m = rtw_ch2freq(pmlmeext->channel_set[i].ChannelNum) * 100000;
893 range->freq[val].e = 1;
894 val++;
895 }
896
897 if (val == IW_MAX_FREQUENCIES)
898 break;
899 }
900
901 range->num_channels = val;
902 range->num_frequency = val;
903
904/* The following code will proivde the security capability to network manager. */
905/* If the driver doesn't provide this capability to network manager, */
7efc02ca 906/* the WPA/WPA2 routers can't be chosen in the network manager. */
a2c60d42
LF		 907
908/*
909#define IW_SCAN_CAPA_NONE 0x00
910#define IW_SCAN_CAPA_ESSID 0x01
911#define IW_SCAN_CAPA_BSSID 0x02
912#define IW_SCAN_CAPA_CHANNEL 0x04
913#define IW_SCAN_CAPA_MODE 0x08
914#define IW_SCAN_CAPA_RATE 0x10
915#define IW_SCAN_CAPA_TYPE 0x20
916#define IW_SCAN_CAPA_TIME 0x40
917*/
918
919 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
920 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
921
922 range->scan_capa = IW_SCAN_CAPA_ESSID | IW_SCAN_CAPA_TYPE |
923 IW_SCAN_CAPA_BSSID | IW_SCAN_CAPA_CHANNEL |
924 IW_SCAN_CAPA_MODE | IW_SCAN_CAPA_RATE;
a2c60d42
LF		 925 return 0;
926}
927
928/* set bssid flow */
929/* s1. rtw_set_802_11_infrastructure_mode() */
930/* s2. rtw_set_802_11_authentication_mode() */
931/* s3. set_802_11_encryption_mode() */
932/* s4. rtw_set_802_11_bssid() */
933static int rtw_wx_set_wap(struct net_device *dev,
934 struct iw_request_info *info,
935 union iwreq_data *awrq,
936 char *extra)
937{
a2c60d42
LF		 938 uint ret = 0;
939 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
940 struct sockaddr *temp = (struct sockaddr *)awrq;
941 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
942 struct list_head *phead;
943 u8 *dst_bssid, *src_bssid;
944 struct __queue *queue = &(pmlmepriv->scanned_queue);
945 struct wlan_network *pnetwork = NULL;
946 enum ndis_802_11_auth_mode authmode;
947
a2c60d42
LF		 948 if (_FAIL == rtw_pwr_wakeup(padapter)) {
949 ret = -1;
950 goto exit;
951 }
952
953 if (!padapter->bup) {
954 ret = -1;
955 goto exit;
956 }
957
958 if (temp->sa_family != ARPHRD_ETHER) {
959 ret = -EINVAL;
960 goto exit;
961 }
962
963 authmode = padapter->securitypriv.ndisauthtype;
7057dcb3 964 spin_lock_bh(&queue->lock);
a2c60d42 965 phead = get_list_head(queue);
c44e5e39 966 pmlmepriv->pscanned = phead->next;
a2c60d42 967
84660700 968 while (phead != pmlmepriv->pscanned) {
bea88100 969 pnetwork = container_of(pmlmepriv->pscanned, struct wlan_network, list);
a2c60d42 970
c44e5e39 971 pmlmepriv->pscanned = pmlmepriv->pscanned->next;
a2c60d42
LF		 972
973 dst_bssid = pnetwork->network.MacAddress;
974
975 src_bssid = temp->sa_data;
976
977 if ((!memcmp(dst_bssid, src_bssid, ETH_ALEN))) {
978 if (!rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode)) {
979 ret = -1;
e02bcf61 980 spin_unlock_bh(&queue->lock);
a2c60d42
LF		 981 goto exit;
982 }
983
984 break;
985 }
986 }
e02bcf61 987 spin_unlock_bh(&queue->lock);
a2c60d42
LF		 988
989 rtw_set_802_11_authentication_mode(padapter, authmode);
bbf2f71e 990 if (!rtw_set_802_11_bssid(padapter, temp->sa_data)) {
a2c60d42
LF		 991 ret = -1;
992 goto exit;
993 }
994
995exit:
996
a2c60d42
LF		 997 return ret;
998}
999
1000static int rtw_wx_get_wap(struct net_device *dev,
1001 struct iw_request_info *info,
1002 union iwreq_data *wrqu, char *extra)
1003{
1004 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1005 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1006 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
1007
1008 wrqu->ap_addr.sa_family = ARPHRD_ETHER;
1009
8e5d9433 1010 eth_zero_addr(wrqu->ap_addr.sa_data);
a2c60d42
LF		 1011
1012 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_wap\n"));
1013
3f95106e
MS		 1014 if (check_fwstate(pmlmepriv, _FW_LINKED) ||
1015 check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE) ||
1016 check_fwstate(pmlmepriv, WIFI_AP_STATE))
a2c60d42
LF		 1017 memcpy(wrqu->ap_addr.sa_data, pcur_bss->MacAddress, ETH_ALEN);
1018 else
8e5d9433 1019 eth_zero_addr(wrqu->ap_addr.sa_data);
a2c60d42
LF		 1020 return 0;
1021}
1022
1023static int rtw_wx_set_mlme(struct net_device *dev,
1024 struct iw_request_info *info,
1025 union iwreq_data *wrqu, char *extra)
1026{
1027 int ret = 0;
1028 u16 reason;
1029 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1030 struct iw_mlme *mlme = (struct iw_mlme *)extra;
1031
4fe514dc 1032 if (!mlme)
a2c60d42
LF		 1033 return -1;
1034
1035 DBG_88E("%s\n", __func__);
1036
1037 reason = mlme->reason_code;
1038
1039 DBG_88E("%s, cmd =%d, reason =%d\n", __func__, mlme->cmd, reason);
1040
1041 switch (mlme->cmd) {
1042 case IW_MLME_DEAUTH:
1043 if (!rtw_set_802_11_disassociate(padapter))
1044 ret = -1;
1045 break;
1046 case IW_MLME_DISASSOC:
1047 if (!rtw_set_802_11_disassociate(padapter))
1048 ret = -1;
1049 break;
1050 default:
1051 return -EOPNOTSUPP;
1052 }
1053 return ret;
1054}
1055
1056static int rtw_wx_set_scan(struct net_device *dev, struct iw_request_info *a,
1057 union iwreq_data *wrqu, char *extra)
1058{
1059 u8 _status = false;
1060 int ret = 0;
1061 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1062 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1063 struct ndis_802_11_ssid ssid[RTW_SSID_SCAN_AMOUNT];
37ad17a4 1064
a2c60d42
LF		 1065 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_set_scan\n"));
1066
a2c60d42
LF		 1067 if (_FAIL == rtw_pwr_wakeup(padapter)) {
1068 ret = -1;
1069 goto exit;
1070 }
1071
1072 if (padapter->bDriverStopped) {
1073 DBG_88E("bDriverStopped =%d\n", padapter->bDriverStopped);
1074 ret = -1;
1075 goto exit;
1076 }
1077
1078 if (!padapter->bup) {
1079 ret = -1;
1080 goto exit;
1081 }
1082
1083 if (!padapter->hw_init_completed) {
1084 ret = -1;
1085 goto exit;
1086 }
1087
1088 /* When Busy Traffic, driver do not site survey. So driver return success. */
1089 /* wpa_supplicant will not issue SIOCSIWSCAN cmd again after scan timeout. */
1090 /* modify by thomas 2011-02-22. */
1091 if (pmlmepriv->LinkDetectInfo.bBusyTraffic) {
1092 indicate_wx_scan_complete_event(padapter);
1093 goto exit;
1094 }
1095
1096 if (check_fwstate(pmlmepriv, _FW_UNDER_SURVEY|_FW_UNDER_LINKING)) {
1097 indicate_wx_scan_complete_event(padapter);
1098 goto exit;
1099 }
1100
1101/* For the DMP WiFi Display project, the driver won't to scan because */
1102/* the pmlmepriv->scan_interval is always equal to 3. */
1103/* So, the wpa_supplicant won't find out the WPS SoftAP. */
1104
1ce39848 1105 memset(ssid, 0, sizeof(struct ndis_802_11_ssid)*RTW_SSID_SCAN_AMOUNT);
a2c60d42
LF		 1106
1107 if (wrqu->data.length == sizeof(struct iw_scan_req)) {
1108 struct iw_scan_req *req = (struct iw_scan_req *)extra;
1109
1110 if (wrqu->data.flags & IW_SCAN_THIS_ESSID) {
3fd511d9
GK		 1111 int len = min_t(int, req->essid_len,
1112 IW_ESSID_MAX_SIZE);
a2c60d42 1113
82f1cebe
FB		 1114 memcpy(ssid[0].ssid, req->essid, len);
1115 ssid[0].ssid_length = len;
a2c60d42
LF		 1116
1117 DBG_88E("IW_SCAN_THIS_ESSID, ssid =%s, len =%d\n", req->essid, req->essid_len);
1118
7057dcb3 1119 spin_lock_bh(&pmlmepriv->lock);
a2c60d42
LF		 1120
1121 _status = rtw_sitesurvey_cmd(padapter, ssid, 1, NULL, 0);
1122
e02bcf61 1123 spin_unlock_bh(&pmlmepriv->lock);
a2c60d42
LF		 1124 } else if (req->scan_type == IW_SCAN_TYPE_PASSIVE) {
1125 DBG_88E("rtw_wx_set_scan, req->scan_type == IW_SCAN_TYPE_PASSIVE\n");
1126 }
1127 } else {
1128 if (wrqu->data.length >= WEXT_CSCAN_HEADER_SIZE &&
1129 !memcmp(extra, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE)) {
1130 int len = wrqu->data.length - WEXT_CSCAN_HEADER_SIZE;
1131 char *pos = extra+WEXT_CSCAN_HEADER_SIZE;
1132 char section;
1133 char sec_len;
1134 int ssid_index = 0;
1135
1136 while (len >= 1) {
1137 section = *(pos++);
1138 len -= 1;
1139
1140 switch (section) {
1141 case WEXT_CSCAN_SSID_SECTION:
1142 if (len < 1) {
1143 len = 0;
1144 break;
1145 }
1146 sec_len = *(pos++); len -= 1;
1147 if (sec_len > 0 && sec_len <= len) {
82f1cebe
FB		 1148 ssid[ssid_index].ssid_length = sec_len;
1149 memcpy(ssid[ssid_index].ssid, pos, ssid[ssid_index].ssid_length);
a2c60d42
LF		 1150 ssid_index++;
1151 }
1152 pos += sec_len;
1153 len -= sec_len;
1154 break;
1155 case WEXT_CSCAN_TYPE_SECTION:
1156 case WEXT_CSCAN_CHANNEL_SECTION:
1157 pos += 1;
1158 len -= 1;
1159 break;
1160 case WEXT_CSCAN_PASV_DWELL_SECTION:
1161 case WEXT_CSCAN_HOME_DWELL_SECTION:
1162 case WEXT_CSCAN_ACTV_DWELL_SECTION:
1163 pos += 2;
1164 len -= 2;
1165 break;
1166 default:
1167 len = 0; /* stop parsing */
1168 }
1169 }
1170
7efc02ca 1171 /* it has still some scan parameter to parse, we only do this now... */
a2c60d42
LF		 1172 _status = rtw_set_802_11_bssid_list_scan(padapter, ssid, RTW_SSID_SCAN_AMOUNT);
1173 } else {
1174 _status = rtw_set_802_11_bssid_list_scan(padapter, NULL, 0);
1175 }
1176 }
1177
1178 if (!_status)
1179 ret = -1;
1180
1181exit:
1182
a2c60d42
LF		 1183 return ret;
1184}
1185
1186static int rtw_wx_get_scan(struct net_device *dev, struct iw_request_info *a,
1187 union iwreq_data *wrqu, char *extra)
1188{
a2c60d42
LF		 1189 struct list_head *plist, *phead;
1190 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1191 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1192 struct __queue *queue = &(pmlmepriv->scanned_queue);
1193 struct wlan_network *pnetwork = NULL;
1194 char *ev = extra;
1195 char *stop = ev + wrqu->data.length;
1196 u32 ret = 0;
1197 u32 cnt = 0;
1198 u32 wait_for_surveydone;
1199 int wait_status;
37ad17a4 1200
a2c60d42
LF		 1201 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_scan\n"));
1202 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, (" Start of Query SIOCGIWSCAN .\n"));
1203
a2c60d42
LF		 1204 if (padapter->pwrctrlpriv.brfoffbyhw && padapter->bDriverStopped) {
1205 ret = -EINVAL;
1206 goto exit;
1207 }
1208
2454e79a 1209 wait_for_surveydone = 100;
a2c60d42
LF		 1210
1211 wait_status = _FW_UNDER_SURVEY | _FW_UNDER_LINKING;
1212
1213 while (check_fwstate(pmlmepriv, wait_status)) {
0da46e6b 1214 msleep(30);
a2c60d42
LF		 1215 cnt++;
1216 if (cnt > wait_for_surveydone)
1217 break;
1218 }
1219
7057dcb3 1220 spin_lock_bh(&(pmlmepriv->scanned_queue.lock));
a2c60d42
LF		 1221
1222 phead = get_list_head(queue);
c44e5e39 1223 plist = phead->next;
a2c60d42 1224
84660700 1225 while (phead != plist) {
a2c60d42
LF		 1226 if ((stop - ev) < SCAN_ITEM_SIZE) {
1227 ret = -E2BIG;
1228 break;
1229 }
1230
bea88100 1231 pnetwork = container_of(plist, struct wlan_network, list);
a2c60d42
LF		 1232
1233 /* report network only if the current channel set contains the channel to which this network belongs */
1234 if (rtw_ch_set_search_ch(padapter->mlmeextpriv.channel_set, pnetwork->network.Configuration.DSConfig) >= 0)
1235 ev = translate_scan(padapter, a, pnetwork, ev, stop);
1236
c44e5e39 1237 plist = plist->next;
a2c60d42
LF		 1238 }
1239
e02bcf61 1240 spin_unlock_bh(&pmlmepriv->scanned_queue.lock);
a2c60d42
LF		 1241
1242 wrqu->data.length = ev-extra;
1243 wrqu->data.flags = 0;
1244
1245exit:
a2c60d42
LF		 1246 return ret;
1247}
1248
1249/* set ssid flow */
1250/* s1. rtw_set_802_11_infrastructure_mode() */
1251/* s2. set_802_11_authenticaion_mode() */
1252/* s3. set_802_11_encryption_mode() */
1253/* s4. rtw_set_802_11_ssid() */
1254static int rtw_wx_set_essid(struct net_device *dev,
1255 struct iw_request_info *a,
1256 union iwreq_data *wrqu, char *extra)
1257{
a2c60d42
LF		 1258 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1259 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
1260 struct __queue *queue = &pmlmepriv->scanned_queue;
1261 struct list_head *phead;
1262 struct wlan_network *pnetwork = NULL;
1263 enum ndis_802_11_auth_mode authmode;
1264 struct ndis_802_11_ssid ndis_ssid;
1265 u8 *dst_ssid, *src_ssid;
1266
1267 uint ret = 0, len;
1268
a2c60d42
LF		 1269 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1270 ("+rtw_wx_set_essid: fw_state = 0x%08x\n", get_fwstate(pmlmepriv)));
1271 if (_FAIL == rtw_pwr_wakeup(padapter)) {
1272 ret = -1;
1273 goto exit;
1274 }
1275
1276 if (!padapter->bup) {
1277 ret = -1;
1278 goto exit;
1279 }
1280
1281 if (wrqu->essid.length > IW_ESSID_MAX_SIZE) {
1282 ret = -E2BIG;
1283 goto exit;
1284 }
1285
1286 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
1287 ret = -1;
1288 goto exit;
1289 }
1290
1291 authmode = padapter->securitypriv.ndisauthtype;
1292 DBG_88E("=>%s\n", __func__);
1293 if (wrqu->essid.flags && wrqu->essid.length) {
ad8d8cd3 1294 len = min_t(uint, wrqu->essid.length, IW_ESSID_MAX_SIZE);
a2c60d42
LF		 1295
1296 if (wrqu->essid.length != 33)
1297 DBG_88E("ssid =%s, len =%d\n", extra, wrqu->essid.length);
1298
1ce39848 1299 memset(&ndis_ssid, 0, sizeof(struct ndis_802_11_ssid));
82f1cebe
FB		 1300 ndis_ssid.ssid_length = len;
1301 memcpy(ndis_ssid.ssid, extra, len);
1302 src_ssid = ndis_ssid.ssid;
a2c60d42
LF		 1303
1304 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("rtw_wx_set_essid: ssid =[%s]\n", src_ssid));
7057dcb3 1305 spin_lock_bh(&queue->lock);
859df6aa
MS		 1306 phead = get_list_head(queue);
1307 pmlmepriv->pscanned = phead->next;
a2c60d42 1308
84660700 1309 while (phead != pmlmepriv->pscanned) {
bea88100 1310 pnetwork = container_of(pmlmepriv->pscanned, struct wlan_network, list);
a2c60d42 1311
c44e5e39 1312 pmlmepriv->pscanned = pmlmepriv->pscanned->next;
a2c60d42 1313
82f1cebe 1314 dst_ssid = pnetwork->network.ssid.ssid;
a2c60d42
LF		 1315
1316 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1317 ("rtw_wx_set_essid: dst_ssid =%s\n",
82f1cebe 1318 pnetwork->network.ssid.ssid));
a2c60d42 1319
82f1cebe
FB		 1320 if ((!memcmp(dst_ssid, src_ssid, ndis_ssid.ssid_length)) &&
1321 (pnetwork->network.ssid.ssid_length == ndis_ssid.ssid_length)) {
a2c60d42
LF		 1322 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1323 ("rtw_wx_set_essid: find match, set infra mode\n"));
1324
3f95106e 1325 if (check_fwstate(pmlmepriv, WIFI_ADHOC_STATE)) {
a2c60d42
LF		 1326 if (pnetwork->network.InfrastructureMode != pmlmepriv->cur_network.network.InfrastructureMode)
1327 continue;
1328 }
1329
1330 if (!rtw_set_802_11_infrastructure_mode(padapter, pnetwork->network.InfrastructureMode)) {
1331 ret = -1;
e02bcf61 1332 spin_unlock_bh(&queue->lock);
a2c60d42
LF		 1333 goto exit;
1334 }
1335
1336 break;
1337 }
1338 }
e02bcf61 1339 spin_unlock_bh(&queue->lock);
a2c60d42
LF		 1340 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1341 ("set ssid: set_802_11_auth. mode =%d\n", authmode));
1342 rtw_set_802_11_authentication_mode(padapter, authmode);
bbf2f71e 1343 if (!rtw_set_802_11_ssid(padapter, &ndis_ssid)) {
a2c60d42
LF		 1344 ret = -1;
1345 goto exit;
1346 }
1347 }
1348
1349exit:
a2c60d42
LF		 1350 DBG_88E("<=%s, ret %d\n", __func__, ret);
1351
a2c60d42
LF		 1352 return ret;
1353}
1354
1355static int rtw_wx_get_essid(struct net_device *dev,
1356 struct iw_request_info *a,
1357 union iwreq_data *wrqu, char *extra)
1358{
fff12fcd 1359 u32 len;
a2c60d42
LF		 1360 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1361 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1362 struct wlan_bssid_ex *pcur_bss = &pmlmepriv->cur_network.network;
1363
1364 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, ("rtw_wx_get_essid\n"));
1365
a2c60d42
LF		 1366 if ((check_fwstate(pmlmepriv, _FW_LINKED)) ||
1367 (check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE))) {
82f1cebe
FB		 1368 len = pcur_bss->ssid.ssid_length;
1369 memcpy(extra, pcur_bss->ssid.ssid, len);
a2c60d42 1370 } else {
b77992d2
LF		 1371 len = 0;
1372 *extra = 0;
a2c60d42 1373 }
b77992d2
LF		 1374 wrqu->essid.length = len;
1375 wrqu->essid.flags = 1;
a2c60d42 1376
fff12fcd 1377 return 0;
a2c60d42
LF		 1378}
1379
1380static int rtw_wx_set_rate(struct net_device *dev,
1381 struct iw_request_info *a,
1382 union iwreq_data *wrqu, char *extra)
1383{
c78a964c 1384 int i;
a2c60d42
LF		 1385 u8 datarates[NumRates];
1386 u32 target_rate = wrqu->bitrate.value;
1387 u32 fixed = wrqu->bitrate.fixed;
1388 u32 ratevalue = 0;
859df6aa 1389 u8 mpdatarate[NumRates] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, 0xff};
a2c60d42 1390
a2c60d42
LF		 1391 RT_TRACE(_module_rtl871x_mlme_c_, _drv_info_, (" rtw_wx_set_rate\n"));
1392 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("target_rate = %d, fixed = %d\n", target_rate, fixed));
1393
1394 if (target_rate == -1) {
1395 ratevalue = 11;
1396 goto set_rate;
1397 }
1398 target_rate = target_rate/100000;
1399
1400 switch (target_rate) {
1401 case 10:
1402 ratevalue = 0;
1403 break;
1404 case 20:
1405 ratevalue = 1;
1406 break;
1407 case 55:
1408 ratevalue = 2;
1409 break;
1410 case 60:
1411 ratevalue = 3;
1412 break;
1413 case 90:
1414 ratevalue = 4;
1415 break;
1416 case 110:
1417 ratevalue = 5;
1418 break;
1419 case 120:
1420 ratevalue = 6;
1421 break;
1422 case 180:
1423 ratevalue = 7;
1424 break;
1425 case 240:
1426 ratevalue = 8;
1427 break;
1428 case 360:
1429 ratevalue = 9;
1430 break;
1431 case 480:
1432 ratevalue = 10;
1433 break;
1434 case 540:
1435 ratevalue = 11;
1436 break;
1437 default:
1438 ratevalue = 11;
1439 break;
1440 }
1441
1442set_rate:
1443
1444 for (i = 0; i < NumRates; i++) {
1445 if (ratevalue == mpdatarate[i]) {
1446 datarates[i] = mpdatarate[i];
1447 if (fixed == 0)
1448 break;
1449 } else {
1450 datarates[i] = 0xff;
1451 }
1452
1453 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_, ("datarate_inx =%d\n", datarates[i]));
1454 }
1455
c78a964c 1456 return 0;
a2c60d42
LF		 1457}
1458
1459static int rtw_wx_get_rate(struct net_device *dev,
1460 struct iw_request_info *info,
1461 union iwreq_data *wrqu, char *extra)
1462{
1463 u16 max_rate = 0;
1464
1465 max_rate = rtw_get_cur_max_rate((struct adapter *)rtw_netdev_priv(dev));
1466
1467 if (max_rate == 0)
1468 return -EPERM;
1469
1470 wrqu->bitrate.fixed = 0; /* no auto select */
1471 wrqu->bitrate.value = max_rate * 100000;
1472
1473 return 0;
1474}
1475
1476static int rtw_wx_set_rts(struct net_device *dev,
1477 struct iw_request_info *info,
1478 union iwreq_data *wrqu, char *extra)
1479{
1480 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1481
a2c60d42
LF		 1482 if (wrqu->rts.disabled) {
1483 padapter->registrypriv.rts_thresh = 2347;
1484 } else {
1485 if (wrqu->rts.value < 0 ||
1486 wrqu->rts.value > 2347)
1487 return -EINVAL;
1488
1489 padapter->registrypriv.rts_thresh = wrqu->rts.value;
1490 }
1491
1492 DBG_88E("%s, rts_thresh =%d\n", __func__, padapter->registrypriv.rts_thresh);
1493
a2c60d42
LF		 1494 return 0;
1495}
1496
1497static int rtw_wx_get_rts(struct net_device *dev,
1498 struct iw_request_info *info,
1499 union iwreq_data *wrqu, char *extra)
1500{
1501 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1502
a2c60d42
LF		 1503 DBG_88E("%s, rts_thresh =%d\n", __func__, padapter->registrypriv.rts_thresh);
1504
1505 wrqu->rts.value = padapter->registrypriv.rts_thresh;
1506 wrqu->rts.fixed = 0; /* no auto select */
1507 /* wrqu->rts.disabled = (wrqu->rts.value == DEFAULT_RTS_THRESHOLD); */
1508
a2c60d42
LF		 1509 return 0;
1510}
1511
1512static int rtw_wx_set_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 *)rtw_netdev_priv(dev);
1517
a2c60d42
LF		 1518 if (wrqu->frag.disabled) {
1519 padapter->xmitpriv.frag_len = MAX_FRAG_THRESHOLD;
1520 } else {
1521 if (wrqu->frag.value < MIN_FRAG_THRESHOLD ||
1522 wrqu->frag.value > MAX_FRAG_THRESHOLD)
1523 return -EINVAL;
1524
1525 padapter->xmitpriv.frag_len = wrqu->frag.value & ~0x1;
1526 }
1527
1528 DBG_88E("%s, frag_len =%d\n", __func__, padapter->xmitpriv.frag_len);
1529
a2c60d42
LF		 1530 return 0;
1531}
1532
1533static int rtw_wx_get_frag(struct net_device *dev,
1534 struct iw_request_info *info,
1535 union iwreq_data *wrqu, char *extra)
1536{
1537 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1538
a2c60d42
LF		 1539 DBG_88E("%s, frag_len =%d\n", __func__, padapter->xmitpriv.frag_len);
1540
1541 wrqu->frag.value = padapter->xmitpriv.frag_len;
1542 wrqu->frag.fixed = 0; /* no auto select */
1543
a2c60d42
LF		 1544 return 0;
1545}
1546
1547static int rtw_wx_get_retry(struct net_device *dev,
1548 struct iw_request_info *info,
1549 union iwreq_data *wrqu, char *extra)
1550{
1551 wrqu->retry.value = 7;
1552 wrqu->retry.fixed = 0; /* no auto select */
1553 wrqu->retry.disabled = 1;
1554
1555 return 0;
1556}
1557
1558static int rtw_wx_set_enc(struct net_device *dev,
1559 struct iw_request_info *info,
1560 union iwreq_data *wrqu, char *keybuf)
1561{
1562 u32 key, ret = 0;
1563 u32 keyindex_provided;
1564 struct ndis_802_11_wep wep;
1565 enum ndis_802_11_auth_mode authmode;
1566
1567 struct iw_point *erq = &(wrqu->encoding);
1568 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1569 struct pwrctrl_priv *pwrpriv = &padapter->pwrctrlpriv;
37ad17a4 1570
a2c60d42
LF		 1571 DBG_88E("+rtw_wx_set_enc, flags = 0x%x\n", erq->flags);
1572
1ce39848 1573 memset(&wep, 0, sizeof(struct ndis_802_11_wep));
a2c60d42
LF		 1574
1575 key = erq->flags & IW_ENCODE_INDEX;
1576
a2c60d42
LF		 1577 if (erq->flags & IW_ENCODE_DISABLED) {
1578 DBG_88E("EncryptionDisabled\n");
1579 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
1580 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1581 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
2ff4e79f 1582 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
a2c60d42
LF		 1583 authmode = Ndis802_11AuthModeOpen;
1584 padapter->securitypriv.ndisauthtype = authmode;
1585
1586 goto exit;
1587 }
1588
1589 if (key) {
1590 if (key > WEP_KEYS)
1591 return -EINVAL;
1592 key--;
1593 keyindex_provided = 1;
1594 } else {
1595 keyindex_provided = 0;
1596 key = padapter->securitypriv.dot11PrivacyKeyIndex;
1597 DBG_88E("rtw_wx_set_enc, key =%d\n", key);
1598 }
1599
1600 /* set authentication mode */
1601 if (erq->flags & IW_ENCODE_OPEN) {
1602 DBG_88E("rtw_wx_set_enc():IW_ENCODE_OPEN\n");
1603 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;/* Ndis802_11EncryptionDisabled; */
1604 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
1605 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1606 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1607 authmode = Ndis802_11AuthModeOpen;
1608 padapter->securitypriv.ndisauthtype = authmode;
1609 } else if (erq->flags & IW_ENCODE_RESTRICTED) {
1610 DBG_88E("rtw_wx_set_enc():IW_ENCODE_RESTRICTED\n");
1611 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;
1612 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Shared;
1613 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
1614 padapter->securitypriv.dot118021XGrpPrivacy = _WEP40_;
1615 authmode = Ndis802_11AuthModeShared;
1616 padapter->securitypriv.ndisauthtype = authmode;
1617 } else {
1618 DBG_88E("rtw_wx_set_enc():erq->flags = 0x%x\n", erq->flags);
1619
1620 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption1Enabled;/* Ndis802_11EncryptionDisabled; */
2ff4e79f 1621 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
a2c60d42
LF		 1622 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1623 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
1624 authmode = Ndis802_11AuthModeOpen;
1625 padapter->securitypriv.ndisauthtype = authmode;
1626 }
1627
1628 wep.KeyIndex = key;
1629 if (erq->length > 0) {
1630 wep.KeyLength = erq->length <= 5 ? 5 : 13;
1631
5e3027b6 1632 wep.Length = wep.KeyLength + offsetof(struct ndis_802_11_wep, KeyMaterial);
a2c60d42
LF		 1633 } else {
1634 wep.KeyLength = 0;
1635
1636 if (keyindex_provided == 1) {
1637 /* set key_id only, no given KeyMaterial(erq->length == 0). */
1638 padapter->securitypriv.dot11PrivacyKeyIndex = key;
1639
1640 DBG_88E("(keyindex_provided == 1), keyid =%d, key_len =%d\n", key, padapter->securitypriv.dot11DefKeylen[key]);
1641
1642 switch (padapter->securitypriv.dot11DefKeylen[key]) {
1643 case 5:
1644 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP40_;
1645 break;
1646 case 13:
1647 padapter->securitypriv.dot11PrivacyAlgrthm = _WEP104_;
1648 break;
1649 default:
1650 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1651 break;
1652 }
1653
1654 goto exit;
1655 }
1656 }
1657
1658 wep.KeyIndex |= 0x80000000;
1659
1660 memcpy(wep.KeyMaterial, keybuf, wep.KeyLength);
1661
bbf2f71e 1662 if (!rtw_set_802_11_add_wep(padapter, &wep)) {
a2c60d42
LF		 1663 if (rf_on == pwrpriv->rf_pwrstate)
1664 ret = -EOPNOTSUPP;
1665 goto exit;
1666 }
1667
1668exit:
a2c60d42
LF		 1669 return ret;
1670}
1671
1672static int rtw_wx_get_enc(struct net_device *dev,
1673 struct iw_request_info *info,
1674 union iwreq_data *wrqu, char *keybuf)
1675{
1f22b8f1 1676 uint key;
a2c60d42
LF		 1677 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1678 struct iw_point *erq = &(wrqu->encoding);
1679 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
1680
3f95106e 1681 if (!check_fwstate(pmlmepriv, _FW_LINKED)) {
a2c60d42
LF		 1682 if (!check_fwstate(pmlmepriv, WIFI_ADHOC_MASTER_STATE)) {
1683 erq->length = 0;
1684 erq->flags |= IW_ENCODE_DISABLED;
1685 return 0;
1686 }
1687 }
1688
1689 key = erq->flags & IW_ENCODE_INDEX;
1690
1691 if (key) {
1692 if (key > WEP_KEYS)
1693 return -EINVAL;
1694 key--;
1695 } else {
1696 key = padapter->securitypriv.dot11PrivacyKeyIndex;
1697 }
1698
1699 erq->flags = key + 1;
1700
1701 switch (padapter->securitypriv.ndisencryptstatus) {
1702 case Ndis802_11EncryptionNotSupported:
1703 case Ndis802_11EncryptionDisabled:
1704 erq->length = 0;
1705 erq->flags |= IW_ENCODE_DISABLED;
1706 break;
1707 case Ndis802_11Encryption1Enabled:
1708 erq->length = padapter->securitypriv.dot11DefKeylen[key];
1709 if (erq->length) {
1710 memcpy(keybuf, padapter->securitypriv.dot11DefKey[key].skey, padapter->securitypriv.dot11DefKeylen[key]);
1711
1712 erq->flags |= IW_ENCODE_ENABLED;
1713
1714 if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeOpen)
1715 erq->flags |= IW_ENCODE_OPEN;
1716 else if (padapter->securitypriv.ndisauthtype == Ndis802_11AuthModeShared)
1717 erq->flags |= IW_ENCODE_RESTRICTED;
1718 } else {
1719 erq->length = 0;
1720 erq->flags |= IW_ENCODE_DISABLED;
1721 }
1722 break;
1723 case Ndis802_11Encryption2Enabled:
1724 case Ndis802_11Encryption3Enabled:
1725 erq->length = 16;
1726 erq->flags |= (IW_ENCODE_ENABLED | IW_ENCODE_OPEN | IW_ENCODE_NOKEY);
1727 break;
1728 default:
1729 erq->length = 0;
1730 erq->flags |= IW_ENCODE_DISABLED;
1731 break;
1732 }
a2c60d42 1733
1f22b8f1 1734 return 0;
a2c60d42
LF		 1735}
1736
1737static int rtw_wx_get_power(struct net_device *dev,
1738 struct iw_request_info *info,
1739 union iwreq_data *wrqu, char *extra)
1740{
1741 wrqu->power.value = 0;
1742 wrqu->power.fixed = 0; /* no auto select */
1743 wrqu->power.disabled = 1;
1744
1745 return 0;
1746}
1747
1748static int rtw_wx_set_gen_ie(struct net_device *dev,
1749 struct iw_request_info *info,
1750 union iwreq_data *wrqu, char *extra)
1751{
a2c60d42
LF		 1752 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1753
5f70306b 1754 return rtw_set_wpa_ie(padapter, extra, wrqu->data.length);
a2c60d42
LF		 1755}
1756
1757static int rtw_wx_set_auth(struct net_device *dev,
1758 struct iw_request_info *info,
1759 union iwreq_data *wrqu, char *extra)
1760{
1761 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
1762 struct iw_param *param = (struct iw_param *)&(wrqu->param);
1763 int ret = 0;
1764
1765 switch (param->flags & IW_AUTH_INDEX) {
1766 case IW_AUTH_WPA_VERSION:
1767 break;
1768 case IW_AUTH_CIPHER_PAIRWISE:
1769
1770 break;
1771 case IW_AUTH_CIPHER_GROUP:
1772
1773 break;
1774 case IW_AUTH_KEY_MGMT:
1775 /*
1776 * ??? does not use these parameters
1777 */
1778 break;
1779 case IW_AUTH_TKIP_COUNTERMEASURES:
1780 if (param->value) {
1781 /* wpa_supplicant is enabling the tkip countermeasure. */
1782 padapter->securitypriv.btkip_countermeasure = true;
1783 } else {
1784 /* wpa_supplicant is disabling the tkip countermeasure. */
1785 padapter->securitypriv.btkip_countermeasure = false;
1786 }
1787 break;
1788 case IW_AUTH_DROP_UNENCRYPTED:
1789 /* HACK:
1790 *
1791 * wpa_supplicant calls set_wpa_enabled when the driver
1792 * is loaded and unloaded, regardless of if WPA is being
1793 * used. No other calls are made which can be used to
1794 * determine if encryption will be used or not prior to
1795 * association being expected. If encryption is not being
1796 * used, drop_unencrypted is set to false, else true -- we
1797 * can use this to determine if the CAP_PRIVACY_ON bit should
1798 * be set.
1799 */
1800
1801 if (padapter->securitypriv.ndisencryptstatus == Ndis802_11Encryption1Enabled)
1802 break;/* it means init value, or using wep, ndisencryptstatus = Ndis802_11Encryption1Enabled, */
1803 /* then it needn't reset it; */
1804
1805 if (param->value) {
1806 padapter->securitypriv.ndisencryptstatus = Ndis802_11EncryptionDisabled;
1807 padapter->securitypriv.dot11PrivacyAlgrthm = _NO_PRIVACY_;
1808 padapter->securitypriv.dot118021XGrpPrivacy = _NO_PRIVACY_;
2ff4e79f 1809 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_Open;
a2c60d42
LF		 1810 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeOpen;
1811 }
1812
1813 break;
1814 case IW_AUTH_80211_AUTH_ALG:
1815 /*
1816 * It's the starting point of a link layer connection using wpa_supplicant
1817 */
1818 if (check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
1819 LeaveAllPowerSaveMode(padapter);
1820 rtw_disassoc_cmd(padapter, 500, false);
1821 DBG_88E("%s...call rtw_indicate_disconnect\n ", __func__);
1822 rtw_indicate_disconnect(padapter);
b4ba3b57 1823 rtw_free_assoc_resources(padapter);
a2c60d42
LF		 1824 }
1825 ret = wpa_set_auth_algs(dev, (u32)param->value);
1826 break;
1827 case IW_AUTH_WPA_ENABLED:
1828 break;
1829 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1830 break;
1831 case IW_AUTH_PRIVACY_INVOKED:
1832 break;
1833 default:
1834 return -EOPNOTSUPP;
1835 }
1836
1837 return ret;
1838}
1839
1840static int rtw_wx_set_enc_ext(struct net_device *dev,
1841 struct iw_request_info *info,
1842 union iwreq_data *wrqu, char *extra)
1843{
1844 char *alg_name;
1845 u32 param_len;
1846 struct ieee_param *param = NULL;
1847 struct iw_point *pencoding = &wrqu->encoding;
1848 struct iw_encode_ext *pext = (struct iw_encode_ext *)extra;
1849 int ret = 0;
1850
1851 param_len = sizeof(struct ieee_param) + pext->key_len;
1852 param = (struct ieee_param *)rtw_malloc(param_len);
4fe514dc 1853 if (!param)
a2c60d42
LF		 1854 return -1;
1855
1ce39848 1856 memset(param, 0, param_len);
a2c60d42
LF		 1857
1858 param->cmd = IEEE_CMD_SET_ENCRYPTION;
a3124e7b 1859 eth_broadcast_addr(param->sta_addr);
a2c60d42
LF		 1860
1861 switch (pext->alg) {
1862 case IW_ENCODE_ALG_NONE:
1863 /* todo: remove key */
1864 /* remove = 1; */
1865 alg_name = "none";
1866 break;
1867 case IW_ENCODE_ALG_WEP:
1868 alg_name = "WEP";
1869 break;
1870 case IW_ENCODE_ALG_TKIP:
1871 alg_name = "TKIP";
1872 break;
1873 case IW_ENCODE_ALG_CCMP:
1874 alg_name = "CCMP";
1875 break;
1876 default:
5d57f1e8
CE		 1877 ret = -1;
1878 goto exit;
a2c60d42
LF		 1879 }
1880
de9b5840 1881 strlcpy((char *)param->u.crypt.alg, alg_name, IEEE_CRYPT_ALG_NAME_LEN);
a2c60d42
LF		 1882
1883 if (pext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
1884 param->u.crypt.set_tx = 1;
1885
1886 /* cliW: WEP does not have group key
1887 * just not checking GROUP key setting
1888 */
1889 if ((pext->alg != IW_ENCODE_ALG_WEP) &&
1890 (pext->ext_flags & IW_ENCODE_EXT_GROUP_KEY))
1891 param->u.crypt.set_tx = 0;
1892
1893 param->u.crypt.idx = (pencoding->flags&0x00FF) - 1;
1894
1895 if (pext->ext_flags & IW_ENCODE_EXT_RX_SEQ_VALID)
1896 memcpy(param->u.crypt.seq, pext->rx_seq, 8);
1897
1898 if (pext->key_len) {
1899 param->u.crypt.key_len = pext->key_len;
1900 memcpy(param->u.crypt.key, pext + 1, pext->key_len);
1901 }
1902
1903 ret = wpa_set_encryption(dev, param, param_len);
1904
5d57f1e8 1905exit:
a2c60d42
LF		 1906 kfree(param);
1907 return ret;
1908}
1909
1910static int rtw_wx_get_nick(struct net_device *dev,
1911 struct iw_request_info *info,
1912 union iwreq_data *wrqu, char *extra)
1913{
1914 if (extra) {
1915 wrqu->data.length = 14;
1916 wrqu->data.flags = 1;
1917 memcpy(extra, "<WIFI@REALTEK>", 14);
1918 }
1919
1920 /* dump debug info here */
1921 return 0;
1922}
1923
42ec30ef 1924static int dummy(struct net_device *dev, struct iw_request_info *a,
1925 union iwreq_data *wrqu, char *b)
a2c60d42 1926{
42ec30ef 1927 return -1;
1928}
a2c60d42 1929
42ec30ef 1930static int wpa_set_param(struct net_device *dev, u8 name, u32 value)
1931{
1932 uint ret = 0;
1933 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
a2c60d42 1934
42ec30ef 1935 switch (name) {
1936 case IEEE_PARAM_WPA_ENABLED:
1937 padapter->securitypriv.dot11AuthAlgrthm = dot11AuthAlgrthm_8021X; /* 802.1x */
1938 switch ((value)&0xff) {
1939 case 1: /* WPA */
1940 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPAPSK; /* WPA_PSK */
1941 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption2Enabled;
1942 break;
1943 case 2: /* WPA2 */
1944 padapter->securitypriv.ndisauthtype = Ndis802_11AuthModeWPA2PSK; /* WPA2_PSK */
1945 padapter->securitypriv.ndisencryptstatus = Ndis802_11Encryption3Enabled;
1946 break;
1947 }
1948 RT_TRACE(_module_rtl871x_ioctl_os_c, _drv_info_,
1949 ("wpa_set_param:padapter->securitypriv.ndisauthtype =%d\n", padapter->securitypriv.ndisauthtype));
1950 break;
1951 case IEEE_PARAM_TKIP_COUNTERMEASURES:
1952 break;
1953 case IEEE_PARAM_DROP_UNENCRYPTED: {
1954 /* HACK:
1955 *
1956 * wpa_supplicant calls set_wpa_enabled when the driver
1957 * is loaded and unloaded, regardless of if WPA is being
1958 * used. No other calls are made which can be used to
1959 * determine if encryption will be used or not prior to
1960 * association being expected. If encryption is not being
1961 * used, drop_unencrypted is set to false, else true -- we
1962 * can use this to determine if the CAP_PRIVACY_ON bit should
1963 * be set.
1964 */
a2c60d42 1965
42ec30ef 1966 break;
2a8efee2 1967 }
42ec30ef 1968 case IEEE_PARAM_PRIVACY_INVOKED:
1969 break;
a2c60d42 1970
42ec30ef 1971 case IEEE_PARAM_AUTH_ALGS:
1972 ret = wpa_set_auth_algs(dev, value);
a2c60d42 1973 break;
42ec30ef 1974 case IEEE_PARAM_IEEE_802_1X:
a2c60d42 1975 break;
42ec30ef 1976 case IEEE_PARAM_WPAX_SELECT:
a2c60d42
LF		 1977 break;
1978 default:
42ec30ef 1979 ret = -EOPNOTSUPP;
1980 break;
a2c60d42 1981 }
d6a6c916 1982 return ret;
a2c60d42
LF		 1983}
1984
42ec30ef 1985static int wpa_mlme(struct net_device *dev, u32 command, u32 reason)
a2c60d42 1986{
42ec30ef 1987 int ret = 0;
a2c60d42 1988 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
a2c60d42 1989
42ec30ef 1990 switch (command) {
1991 case IEEE_MLME_STA_DEAUTH:
1992 if (!rtw_set_802_11_disassociate(padapter))
1993 ret = -1;
a2c60d42 1994 break;
42ec30ef 1995 case IEEE_MLME_STA_DISASSOC:
1996 if (!rtw_set_802_11_disassociate(padapter))
1997 ret = -1;
a2c60d42
LF		 1998 break;
1999 default:
42ec30ef 2000 ret = -EOPNOTSUPP;
2001 break;
a2c60d42
LF		 2002 }
2003
42ec30ef 2004 return ret;
a2c60d42
LF		 2005}
2006
42ec30ef 2007static int wpa_supplicant_ioctl(struct net_device *dev, struct iw_point *p)
a2c60d42 2008{
42ec30ef 2009 struct ieee_param *param;
2010 uint ret = 0;
a2c60d42 2011
e40c6d0f
LF		 2012 if (!p->pointer || p->length != sizeof(struct ieee_param))
2013 return -EINVAL;
a2c60d42 2014
42ec30ef 2015 param = (struct ieee_param *)rtw_malloc(p->length);
e40c6d0f
LF		 2016 if (!param)
2017 return -ENOMEM;
a2c60d42 2018
42ec30ef 2019 if (copy_from_user(param, p->pointer, p->length)) {
2020 kfree(param);
e40c6d0f 2021 return -EFAULT;
42ec30ef 2022 }
a2c60d42 2023
42ec30ef 2024 switch (param->cmd) {
2025 case IEEE_CMD_SET_WPA_PARAM:
2026 ret = wpa_set_param(dev, param->u.wpa_param.name, param->u.wpa_param.value);
2027 break;
a2c60d42 2028
42ec30ef 2029 case IEEE_CMD_SET_WPA_IE:
2030 ret = rtw_set_wpa_ie((struct adapter *)rtw_netdev_priv(dev),
2031 (char *)param->u.wpa_ie.data, (u16)param->u.wpa_ie.len);
2032 break;
a2c60d42 2033
42ec30ef 2034 case IEEE_CMD_SET_ENCRYPTION:
2035 ret = wpa_set_encryption(dev, param, p->length);
2036 break;
a2c60d42 2037
42ec30ef 2038 case IEEE_CMD_MLME:
2039 ret = wpa_mlme(dev, param->u.mlme.command, param->u.mlme.reason_code);
2040 break;
a2c60d42 2041
42ec30ef 2042 default:
2043 DBG_88E("Unknown WPA supplicant request: %d\n", param->cmd);
2044 ret = -EOPNOTSUPP;
2045 break;
2046 }
a2c60d42 2047
42ec30ef 2048 if (ret == 0 && copy_to_user(p->pointer, param, p->length))
2049 ret = -EFAULT;
a2c60d42 2050
42ec30ef 2051 kfree(param);
42ec30ef 2052 return ret;
a2c60d42
LF		 2053}
2054
42ec30ef 2055#ifdef CONFIG_88EU_AP_MODE
2056static u8 set_pairwise_key(struct adapter *padapter, struct sta_info *psta)
a2c60d42 2057{
42ec30ef 2058 struct cmd_obj *ph2c;
2059 struct set_stakey_parm *psetstakey_para;
2060 struct cmd_priv *pcmdpriv = &padapter->cmdpriv;
2061 u8 res = _SUCCESS;
a2c60d42 2062
42ec30ef 2063 ph2c = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
4ada295d 2064 if (!ph2c) {
42ec30ef 2065 res = _FAIL;
2066 goto exit;
2067 }
a2c60d42 2068
42ec30ef 2069 psetstakey_para = kzalloc(sizeof(struct set_stakey_parm), GFP_KERNEL);
4ada295d 2070 if (!psetstakey_para) {
42ec30ef 2071 kfree(ph2c);
2072 res = _FAIL;
2073 goto exit;
2074 }
a2c60d42 2075
42ec30ef 2076 init_h2fwcmd_w_parm_no_rsp(ph2c, psetstakey_para, _SetStaKey_CMD_);
a2c60d42 2077
42ec30ef 2078 psetstakey_para->algorithm = (u8)psta->dot118021XPrivacy;
a2c60d42 2079
42ec30ef 2080 memcpy(psetstakey_para->addr, psta->hwaddr, ETH_ALEN);
a2c60d42 2081
42ec30ef 2082 memcpy(psetstakey_para->key, &psta->dot118021x_UncstKey, 16);
a2c60d42 2083
42ec30ef 2084 res = rtw_enqueue_cmd(pcmdpriv, ph2c);
a2c60d42 2085
42ec30ef 2086exit:
a2c60d42 2087
42ec30ef 2088 return res;
a2c60d42
LF		 2089}
2090
42ec30ef 2091static int set_group_key(struct adapter *padapter, u8 *key, u8 alg, int keyid)
a2c60d42 2092{
42ec30ef 2093 u8 keylen;
2094 struct cmd_obj *pcmd;
2095 struct setkey_parm *psetkeyparm;
2096 struct cmd_priv *pcmdpriv = &(padapter->cmdpriv);
2097 int res = _SUCCESS;
a2c60d42 2098
42ec30ef 2099 DBG_88E("%s\n", __func__);
a2c60d42 2100
42ec30ef 2101 pcmd = kzalloc(sizeof(struct cmd_obj), GFP_KERNEL);
4ada295d 2102 if (!pcmd) {
42ec30ef 2103 res = _FAIL;
2104 goto exit;
a2c60d42 2105 }
42ec30ef 2106 psetkeyparm = kzalloc(sizeof(struct setkey_parm), GFP_KERNEL);
4ada295d 2107 if (!psetkeyparm) {
42ec30ef 2108 kfree(pcmd);
2109 res = _FAIL;
2110 goto exit;
a2c60d42
LF		 2111 }
2112
42ec30ef 2113 psetkeyparm->keyid = (u8)keyid;
a2c60d42 2114
42ec30ef 2115 psetkeyparm->algorithm = alg;
a2c60d42 2116
42ec30ef 2117 psetkeyparm->set_tx = 1;
a2c60d42 2118
42ec30ef 2119 switch (alg) {
2120 case _WEP40_:
2121 keylen = 5;
2122 break;
2123 case _WEP104_:
2124 keylen = 13;
2125 break;
2126 case _TKIP_:
2127 case _TKIP_WTMIC_:
2128 case _AES_:
2129 default:
2130 keylen = 16;
a2c60d42
LF		 2131 }
2132
42ec30ef 2133 memcpy(&(psetkeyparm->key[0]), key, keylen);
a2c60d42 2134
42ec30ef 2135 pcmd->cmdcode = _SetKey_CMD_;
2136 pcmd->parmbuf = (u8 *)psetkeyparm;
2137 pcmd->cmdsz = (sizeof(struct setkey_parm));
2138 pcmd->rsp = NULL;
2139 pcmd->rspsz = 0;
2140
2141 INIT_LIST_HEAD(&pcmd->list);
a2c60d42 2142
42ec30ef 2143 res = rtw_enqueue_cmd(pcmdpriv, pcmd);
a2c60d42 2144
42ec30ef 2145exit:
2146
2147 return res;
2148}
2149
2150static int set_wep_key(struct adapter *padapter, u8 *key, u8 keylen, int keyid)
2151{
2152 u8 alg;
2153
2154 switch (keylen) {
2155 case 5:
2156 alg = _WEP40_;
2157 break;
2158 case 13:
2159 alg = _WEP104_;
2160 break;
2161 default:
2162 alg = _NO_PRIVACY_;
2163 }
2164
2165 return set_group_key(padapter, key, alg, keyid);
a2c60d42
LF		 2166}
2167
42ec30ef 2168static int rtw_set_encryption(struct net_device *dev, struct ieee_param *param, u32 param_len)
a2c60d42
LF		 2169{
2170 int ret = 0;
42ec30ef 2171 u32 wep_key_idx, wep_key_len, wep_total_len;
2172 struct ndis_802_11_wep *pwep = NULL;
2173 struct sta_info *psta = NULL, *pbcmc_sta = NULL;
a2c60d42 2174 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
42ec30ef 2175 struct mlme_priv *pmlmepriv = &padapter->mlmepriv;
2176 struct security_priv *psecuritypriv = &(padapter->securitypriv);
2177 struct sta_priv *pstapriv = &padapter->stapriv;
a2c60d42 2178
42ec30ef 2179 DBG_88E("%s\n", __func__);
2180 param->u.crypt.err = 0;
2181 param->u.crypt.alg[IEEE_CRYPT_ALG_NAME_LEN - 1] = '\0';
2182 if (param_len != sizeof(struct ieee_param) + param->u.crypt.key_len) {
2183 ret = -EINVAL;
a2c60d42
LF		 2184 goto exit;
2185 }
8663b2e0 2186 if (is_broadcast_ether_addr(param->sta_addr)) {
42ec30ef 2187 if (param->u.crypt.idx >= WEP_KEYS) {
a2c60d42
LF		 2188 ret = -EINVAL;
2189 goto exit;
2190 }
2191 } else {
42ec30ef 2192 psta = rtw_get_stainfo(pstapriv, param->sta_addr);
2193 if (!psta) {
2194 DBG_88E("rtw_set_encryption(), sta has already been removed or never been added\n");
2195 goto exit;
2196 }
a2c60d42
LF		 2197 }
2198
4fe514dc 2199 if (strcmp(param->u.crypt.alg, "none") == 0 && (!psta)) {
42ec30ef 2200 /* todo:clear default encryption keys */
a2c60d42 2201
42ec30ef 2202 DBG_88E("clear default encryption keys, keyid =%d\n", param->u.crypt.idx);
2203 goto exit;
2204 }
4fe514dc 2205 if (strcmp(param->u.crypt.alg, "WEP") == 0 && (!psta)) {
42ec30ef 2206 DBG_88E("r871x_set_encryption, crypt.alg = WEP\n");
2207 wep_key_idx = param->u.crypt.idx;
2208 wep_key_len = param->u.crypt.key_len;
2209 DBG_88E("r871x_set_encryption, wep_key_idx=%d, len=%d\n", wep_key_idx, wep_key_len);
2210 if ((wep_key_idx >= WEP_KEYS) || (wep_key_len <= 0)) {
2211 ret = -EINVAL;
2212 goto exit;
2213 }
a2c60d42 2214
42ec30ef 2215 if (wep_key_len > 0) {
2216 wep_key_len = wep_key_len <= 5 ? 5 : 13;
5e3027b6 2217 wep_total_len = wep_key_len + offsetof(struct ndis_802_11_wep, KeyMaterial);
42ec30ef 2218 pwep = (struct ndis_802_11_wep *)rtw_malloc(wep_total_len);
4fe514dc 2219 if (!pwep) {
42ec30ef 2220 DBG_88E(" r871x_set_encryption: pwep allocate fail !!!\n");
2221 goto exit;
2222 }
a2c60d42 2223
42ec30ef 2224 memset(pwep, 0, wep_total_len);
2225
2226 pwep->KeyLength = wep_key_len;
2227 pwep->Length = wep_total_len;
a2c60d42
LF		 2228 }
2229
42ec30ef 2230 pwep->KeyIndex = wep_key_idx;
a2c60d42 2231
42ec30ef 2232 memcpy(pwep->KeyMaterial, param->u.crypt.key, pwep->KeyLength);
a2c60d42 2233
42ec30ef 2234 if (param->u.crypt.set_tx) {
2235 DBG_88E("wep, set_tx = 1\n");
a2c60d42 2236
42ec30ef 2237 psecuritypriv->ndisencryptstatus = Ndis802_11Encryption1Enabled;
2238 psecuritypriv->dot11PrivacyAlgrthm = _WEP40_;
2239 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
a2c60d42 2240
42ec30ef 2241 if (pwep->KeyLength == 13) {
2242 psecuritypriv->dot11PrivacyAlgrthm = _WEP104_;
2243 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
2244 }
a2c60d42 2245
42ec30ef 2246 psecuritypriv->dot11PrivacyKeyIndex = wep_key_idx;
a2c60d42 2247
42ec30ef 2248 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
a2c60d42 2249
42ec30ef 2250 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength;
a2c60d42 2251
42ec30ef 2252 set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx);
2253 } else {
2254 DBG_88E("wep, set_tx = 0\n");
a2c60d42 2255
42ec30ef 2256 /* don't update "psecuritypriv->dot11PrivacyAlgrthm" and */
2257 /* psecuritypriv->dot11PrivacyKeyIndex = keyid", but can rtw_set_key to cam */
a2c60d42 2258
859df6aa 2259 memcpy(&(psecuritypriv->dot11DefKey[wep_key_idx].skey[0]), pwep->KeyMaterial, pwep->KeyLength);
a2c60d42 2260
42ec30ef 2261 psecuritypriv->dot11DefKeylen[wep_key_idx] = pwep->KeyLength;
a2c60d42 2262
42ec30ef 2263 set_wep_key(padapter, pwep->KeyMaterial, pwep->KeyLength, wep_key_idx);
2264 }
a2c60d42 2265
a2c60d42
LF		 2266 goto exit;
2267 }
2268
42ec30ef 2269 if (!psta && check_fwstate(pmlmepriv, WIFI_AP_STATE)) { /* group key */
2270 if (param->u.crypt.set_tx == 1) {
2271 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
2272 DBG_88E("%s, set group_key, WEP\n", __func__);
a2c60d42 2273
42ec30ef 2274 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
ad8d8cd3 2275 param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
a2c60d42 2276
42ec30ef 2277 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
2278 if (param->u.crypt.key_len == 13)
4235d7d8 2279 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
42ec30ef 2280 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
2281 DBG_88E("%s, set group_key, TKIP\n", __func__);
2282 psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
2283 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
ad8d8cd3 2284 param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
42ec30ef 2285 /* set mic key */
2286 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
2287 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
a2c60d42 2288
42ec30ef 2289 psecuritypriv->busetkipkey = true;
2290 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
2291 DBG_88E("%s, set group_key, CCMP\n", __func__);
2292 psecuritypriv->dot118021XGrpPrivacy = _AES_;
2293 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
ad8d8cd3 2294 param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
42ec30ef 2295 } else {
2296 DBG_88E("%s, set group_key, none\n", __func__);
2297 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
2298 }
2299 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
2300 psecuritypriv->binstallGrpkey = true;
2301 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */
2302 set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
2303 pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
2304 if (pbcmc_sta) {
2305 pbcmc_sta->ieee8021x_blocked = false;
2306 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
2307 }
2308 }
a2c60d42
LF		 2309 goto exit;
2310 }
2311
42ec30ef 2312 if (psecuritypriv->dot11AuthAlgrthm == dot11AuthAlgrthm_8021X && psta) { /* psk/802_1x */
2313 if (check_fwstate(pmlmepriv, WIFI_AP_STATE)) {
2314 if (param->u.crypt.set_tx == 1) {
ad8d8cd3 2315 memcpy(psta->dot118021x_UncstKey.skey, param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
a2c60d42 2316
42ec30ef 2317 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
2318 DBG_88E("%s, set pairwise key, WEP\n", __func__);
a2c60d42 2319
42ec30ef 2320 psta->dot118021XPrivacy = _WEP40_;
2321 if (param->u.crypt.key_len == 13)
2322 psta->dot118021XPrivacy = _WEP104_;
2323 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
2324 DBG_88E("%s, set pairwise key, TKIP\n", __func__);
a2c60d42 2325
42ec30ef 2326 psta->dot118021XPrivacy = _TKIP_;
a2c60d42 2327
42ec30ef 2328 /* set mic key */
2329 memcpy(psta->dot11tkiptxmickey.skey, &(param->u.crypt.key[16]), 8);
2330 memcpy(psta->dot11tkiprxmickey.skey, &(param->u.crypt.key[24]), 8);
a2c60d42 2331
42ec30ef 2332 psecuritypriv->busetkipkey = true;
2333 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
2334 DBG_88E("%s, set pairwise key, CCMP\n", __func__);
a2c60d42 2335
42ec30ef 2336 psta->dot118021XPrivacy = _AES_;
2337 } else {
2338 DBG_88E("%s, set pairwise key, none\n", __func__);
a2c60d42 2339
42ec30ef 2340 psta->dot118021XPrivacy = _NO_PRIVACY_;
a2c60d42 2341 }
a2c60d42 2342
42ec30ef 2343 set_pairwise_key(padapter, psta);
a2c60d42 2344
42ec30ef 2345 psta->ieee8021x_blocked = false;
2346 } else { /* group key??? */
2347 if (strcmp(param->u.crypt.alg, "WEP") == 0) {
2348 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
ad8d8cd3 2349 param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
42ec30ef 2350 psecuritypriv->dot118021XGrpPrivacy = _WEP40_;
2351 if (param->u.crypt.key_len == 13)
2352 psecuritypriv->dot118021XGrpPrivacy = _WEP104_;
2353 } else if (strcmp(param->u.crypt.alg, "TKIP") == 0) {
2354 psecuritypriv->dot118021XGrpPrivacy = _TKIP_;
a2c60d42 2355
42ec30ef 2356 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
ad8d8cd3 2357 param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
a2c60d42 2358
42ec30ef 2359 /* set mic key */
2360 memcpy(psecuritypriv->dot118021XGrptxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[16]), 8);
2361 memcpy(psecuritypriv->dot118021XGrprxmickey[param->u.crypt.idx].skey, &(param->u.crypt.key[24]), 8);
a2c60d42 2362
42ec30ef 2363 psecuritypriv->busetkipkey = true;
2364 } else if (strcmp(param->u.crypt.alg, "CCMP") == 0) {
2365 psecuritypriv->dot118021XGrpPrivacy = _AES_;
a2c60d42 2366
42ec30ef 2367 memcpy(psecuritypriv->dot118021XGrpKey[param->u.crypt.idx].skey,
ad8d8cd3 2368 param->u.crypt.key, min_t(u16, param->u.crypt.key_len, 16));
42ec30ef 2369 } else {
2370 psecuritypriv->dot118021XGrpPrivacy = _NO_PRIVACY_;
2371 }
a2c60d42 2372
42ec30ef 2373 psecuritypriv->dot118021XGrpKeyid = param->u.crypt.idx;
a2c60d42 2374
42ec30ef 2375 psecuritypriv->binstallGrpkey = true;
a2c60d42 2376
42ec30ef 2377 psecuritypriv->dot11PrivacyAlgrthm = psecuritypriv->dot118021XGrpPrivacy;/* */
a2c60d42 2378
42ec30ef 2379 set_group_key(padapter, param->u.crypt.key, psecuritypriv->dot118021XGrpPrivacy, param->u.crypt.idx);
a2c60d42 2380
42ec30ef 2381 pbcmc_sta = rtw_get_bcmc_stainfo(padapter);
2382 if (pbcmc_sta) {
2383 pbcmc_sta->ieee8021x_blocked = false;
2384 pbcmc_sta->dot118021XPrivacy = psecuritypriv->dot118021XGrpPrivacy;/* rx will use bmc_sta's dot118021XPrivacy */
2385 }
a2c60d42 2386 }
a2c60d42 2387 }
a2c60d42
LF		 2388 }
2389
42ec30ef 2390exit:
2391
2392 kfree(pwep);
2393
a2c60d42
LF		 2394 return ret;
2395}
2396
42ec30ef 2397static int rtw_set_beacon(struct net_device *dev, struct ieee_param *param, int len)
a2c60d42 2398{
42ec30ef 2399 int ret = 0;
2400 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2401 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2402 struct sta_priv *pstapriv = &padapter->stapriv;
2403 unsigned char *pbuf = param->u.bcn_ie.buf;
a2c60d42 2404
42ec30ef 2405 DBG_88E("%s, len =%d\n", __func__, len);
a2c60d42 2406
3f95106e 2407 if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
a2c60d42
LF		 2408 return -EINVAL;
2409
42ec30ef 2410 memcpy(&pstapriv->max_num_sta, param->u.bcn_ie.reserved, 2);
a2c60d42 2411
42ec30ef 2412 if ((pstapriv->max_num_sta > NUM_STA) || (pstapriv->max_num_sta <= 0))
2413 pstapriv->max_num_sta = NUM_STA;
a2c60d42 2414
42ec30ef 2415 if (rtw_check_beacon_data(padapter, pbuf, (len-12-2)) == _SUCCESS)/* 12 = param header, 2:no packed */
2416 ret = 0;
2417 else
2418 ret = -EINVAL;
a2c60d42 2419
42ec30ef 2420 return ret;
a2c60d42
LF		 2421}
2422
42ec30ef 2423static int rtw_hostapd_sta_flush(struct net_device *dev)
a2c60d42 2424{
42ec30ef 2425 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
a2c60d42 2426
42ec30ef 2427 DBG_88E("%s\n", __func__);
a2c60d42 2428
42ec30ef 2429 flush_all_cam_entry(padapter); /* clear CAM */
a2c60d42 2430
f523c7d7 2431 return rtw_sta_flush(padapter);
a2c60d42
LF		 2432}
2433
42ec30ef 2434static int rtw_add_sta(struct net_device *dev, struct ieee_param *param)
a2c60d42 2435{
42ec30ef 2436 int ret = 0;
2437 struct sta_info *psta = NULL;
2438 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2439 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2440 struct sta_priv *pstapriv = &padapter->stapriv;
a2c60d42 2441
42ec30ef 2442 DBG_88E("rtw_add_sta(aid =%d) =%pM\n", param->u.add_sta.aid, (param->sta_addr));
a2c60d42 2443
42ec30ef 2444 if (!check_fwstate(pmlmepriv, (_FW_LINKED|WIFI_AP_STATE)))
2445 return -EINVAL;
a2c60d42 2446
8663b2e0 2447 if (is_broadcast_ether_addr(param->sta_addr))
42ec30ef 2448 return -EINVAL;
a2c60d42 2449
42ec30ef 2450 psta = rtw_get_stainfo(pstapriv, param->sta_addr);
2451 if (psta) {
2452 int flags = param->u.add_sta.flags;
a733e467 2453
42ec30ef 2454 psta->aid = param->u.add_sta.aid;/* aid = 1~2007 */
a733e467 2455
42ec30ef 2456 memcpy(psta->bssrateset, param->u.add_sta.tx_supp_rates, 16);
a2c60d42 2457
42ec30ef 2458 /* check wmm cap. */
2459 if (WLAN_STA_WME&flags)
2460 psta->qos_option = 1;
2461 else
2462 psta->qos_option = 0;
a2c60d42 2463
42ec30ef 2464 if (pmlmepriv->qospriv.qos_option == 0)
2465 psta->qos_option = 0;
a2c60d42 2466
42ec30ef 2467 /* chec 802.11n ht cap. */
2468 if (WLAN_STA_HT&flags) {
2469 psta->htpriv.ht_option = true;
2470 psta->qos_option = 1;
81a2b8e4
IS		 2471 memcpy(&psta->htpriv.ht_cap, &param->u.add_sta.ht_cap,
2472 sizeof(struct ieee80211_ht_cap));
42ec30ef 2473 } else {
2474 psta->htpriv.ht_option = false;
2475 }
a2c60d42 2476
bbf2f71e 2477 if (!pmlmepriv->htpriv.ht_option)
42ec30ef 2478 psta->htpriv.ht_option = false;
a2c60d42 2479
42ec30ef 2480 update_sta_info_apmode(padapter, psta);
2481 } else {
2482 ret = -ENOMEM;
a2c60d42 2483 }
a733e467 2484
42ec30ef 2485 return ret;
a2c60d42
LF		 2486}
2487
42ec30ef 2488static int rtw_del_sta(struct net_device *dev, struct ieee_param *param)
a2c60d42 2489{
42ec30ef 2490 struct sta_info *psta = NULL;
2491 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2492 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2493 struct sta_priv *pstapriv = &padapter->stapriv;
2494 int updated = 0;
a2c60d42 2495
42ec30ef 2496 DBG_88E("rtw_del_sta =%pM\n", (param->sta_addr));
a2c60d42 2497
3f95106e 2498 if (!check_fwstate(pmlmepriv, _FW_LINKED | WIFI_AP_STATE))
42ec30ef 2499 return -EINVAL;
a2c60d42 2500
8663b2e0 2501 if (is_broadcast_ether_addr(param->sta_addr))
42ec30ef 2502 return -EINVAL;
a2c60d42 2503
42ec30ef 2504 psta = rtw_get_stainfo(pstapriv, param->sta_addr);
2505 if (psta) {
2506 spin_lock_bh(&pstapriv->asoc_list_lock);
2507 if (!list_empty(&psta->asoc_list)) {
2508 list_del_init(&psta->asoc_list);
2509 pstapriv->asoc_list_cnt--;
2510 updated = ap_free_sta(padapter, psta, true, WLAN_REASON_DEAUTH_LEAVING);
2511 }
2512 spin_unlock_bh(&pstapriv->asoc_list_lock);
2513 associated_clients_update(padapter, updated);
2514 psta = NULL;
2515 } else {
2516 DBG_88E("rtw_del_sta(), sta has already been removed or never been added\n");
2517 }
a2c60d42 2518
690a993f 2519 return 0;
a2c60d42
LF		 2520}
2521
42ec30ef 2522static int rtw_ioctl_get_sta_data(struct net_device *dev, struct ieee_param *param, int len)
a2c60d42 2523{
42ec30ef 2524 int ret = 0;
2525 struct sta_info *psta = NULL;
2526 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2527 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2528 struct sta_priv *pstapriv = &padapter->stapriv;
2529 struct ieee_param_ex *param_ex = (struct ieee_param_ex *)param;
2530 struct sta_data *psta_data = (struct sta_data *)param_ex->data;
a2c60d42 2531
42ec30ef 2532 DBG_88E("rtw_ioctl_get_sta_info, sta_addr: %pM\n", (param_ex->sta_addr));
a2c60d42 2533
3f95106e 2534 if (!check_fwstate(pmlmepriv, _FW_LINKED | WIFI_AP_STATE))
42ec30ef 2535 return -EINVAL;
a2c60d42 2536
8663b2e0 2537 if (is_broadcast_ether_addr(param_ex->sta_addr))
42ec30ef 2538 return -EINVAL;
a2c60d42 2539
42ec30ef 2540 psta = rtw_get_stainfo(pstapriv, param_ex->sta_addr);
2541 if (psta) {
2542 psta_data->aid = (u16)psta->aid;
2543 psta_data->capability = psta->capability;
2544 psta_data->flags = psta->flags;
a2c60d42 2545
42ec30ef 2546/*
2547 nonerp_set : BIT(0)
2548 no_short_slot_time_set : BIT(1)
2549 no_short_preamble_set : BIT(2)
2550 no_ht_gf_set : BIT(3)
2551 no_ht_set : BIT(4)
2552 ht_20mhz_set : BIT(5)
2553*/
a2c60d42 2554
42ec30ef 2555 psta_data->sta_set = ((psta->nonerp_set) |
2556 (psta->no_short_slot_time_set << 1) |
2557 (psta->no_short_preamble_set << 2) |
2558 (psta->no_ht_gf_set << 3) |
2559 (psta->no_ht_set << 4) |
2560 (psta->ht_20mhz_set << 5));
2561 psta_data->tx_supp_rates_len = psta->bssratelen;
2562 memcpy(psta_data->tx_supp_rates, psta->bssrateset, psta->bssratelen);
81a2b8e4
IS		 2563 memcpy(&psta_data->ht_cap,
2564 &psta->htpriv.ht_cap, sizeof(struct ieee80211_ht_cap));
42ec30ef 2565 psta_data->rx_pkts = psta->sta_stats.rx_data_pkts;
2566 psta_data->rx_bytes = psta->sta_stats.rx_bytes;
2567 psta_data->rx_drops = psta->sta_stats.rx_drops;
2568 psta_data->tx_pkts = psta->sta_stats.tx_pkts;
2569 psta_data->tx_bytes = psta->sta_stats.tx_bytes;
2570 psta_data->tx_drops = psta->sta_stats.tx_drops;
2571 } else {
2572 ret = -1;
a2c60d42 2573 }
a2c60d42 2574
42ec30ef 2575 return ret;
a2c60d42
LF		 2576}
2577
42ec30ef 2578static int rtw_get_sta_wpaie(struct net_device *dev, struct ieee_param *param)
a2c60d42 2579{
42ec30ef 2580 int ret = 0;
2581 struct sta_info *psta = NULL;
2582 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2583 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2584 struct sta_priv *pstapriv = &padapter->stapriv;
a2c60d42 2585
42ec30ef 2586 DBG_88E("rtw_get_sta_wpaie, sta_addr: %pM\n", (param->sta_addr));
a2c60d42 2587
3f95106e 2588 if (!check_fwstate(pmlmepriv, _FW_LINKED | WIFI_AP_STATE))
2a8efee2 2589 return -EINVAL;
a2c60d42 2590
8663b2e0 2591 if (is_broadcast_ether_addr(param->sta_addr))
42ec30ef 2592 return -EINVAL;
a2c60d42 2593
42ec30ef 2594 psta = rtw_get_stainfo(pstapriv, param->sta_addr);
2595 if (psta) {
63d6c969
JS		 2596 if (psta->wpa_ie[0] == WLAN_EID_RSN ||
2597 psta->wpa_ie[0] == WLAN_EID_VENDOR_SPECIFIC) {
42ec30ef 2598 int wpa_ie_len;
2599 int copy_len;
a2c60d42 2600
42ec30ef 2601 wpa_ie_len = psta->wpa_ie[1];
530c9b1b 2602 copy_len = min_t(int, wpa_ie_len + 2, sizeof(psta->wpa_ie));
42ec30ef 2603 param->u.wpa_ie.len = copy_len;
2604 memcpy(param->u.wpa_ie.reserved, psta->wpa_ie, copy_len);
a2c60d42 2605 } else {
42ec30ef 2606 DBG_88E("sta's wpa_ie is NONE\n");
a2c60d42 2607 }
a2c60d42 2608 } else {
42ec30ef 2609 ret = -1;
a2c60d42
LF		 2610 }
2611
42ec30ef 2612 return ret;
a2c60d42
LF		 2613}
2614
42ec30ef 2615static int rtw_set_wps_beacon(struct net_device *dev, struct ieee_param *param, int len)
a2c60d42 2616{
42ec30ef 2617 unsigned char wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
2618 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2619 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2620 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
2621 int ie_len;
a2c60d42 2622
42ec30ef 2623 DBG_88E("%s, len =%d\n", __func__, len);
a2c60d42 2624
3f95106e 2625 if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
42ec30ef 2626 return -EINVAL;
a2c60d42 2627
42ec30ef 2628 ie_len = len-12-2;/* 12 = param header, 2:no packed */
a2c60d42 2629
157b8e59
TP		 2630 kfree(pmlmepriv->wps_beacon_ie);
2631 pmlmepriv->wps_beacon_ie = NULL;
a2c60d42 2632
42ec30ef 2633 if (ie_len > 0) {
2634 pmlmepriv->wps_beacon_ie = rtw_malloc(ie_len);
2635 pmlmepriv->wps_beacon_ie_len = ie_len;
4fe514dc 2636 if (!pmlmepriv->wps_beacon_ie) {
42ec30ef 2637 DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
2638 return -EINVAL;
2639 }
e0e2c5cd 2640
42ec30ef 2641 memcpy(pmlmepriv->wps_beacon_ie, param->u.bcn_ie.buf, ie_len);
a2c60d42 2642
42ec30ef 2643 update_beacon(padapter, _VENDOR_SPECIFIC_IE_, wps_oui, true);
a2c60d42 2644
42ec30ef 2645 pmlmeext->bstart_bss = true;
a2c60d42
LF		 2646 }
2647
690a993f 2648 return 0;
a2c60d42
LF		 2649}
2650
42ec30ef 2651static int rtw_set_wps_probe_resp(struct net_device *dev, struct ieee_param *param, int len)
a2c60d42 2652{
42ec30ef 2653 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2654 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2655 int ie_len;
a2c60d42 2656
42ec30ef 2657 DBG_88E("%s, len =%d\n", __func__, len);
a2c60d42 2658
3f95106e 2659 if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
42ec30ef 2660 return -EINVAL;
a2c60d42 2661
42ec30ef 2662 ie_len = len-12-2;/* 12 = param header, 2:no packed */
a2c60d42 2663
157b8e59
TP		 2664 kfree(pmlmepriv->wps_probe_resp_ie);
2665 pmlmepriv->wps_probe_resp_ie = NULL;
a2c60d42 2666
42ec30ef 2667 if (ie_len > 0) {
2668 pmlmepriv->wps_probe_resp_ie = rtw_malloc(ie_len);
2669 pmlmepriv->wps_probe_resp_ie_len = ie_len;
4fe514dc 2670 if (!pmlmepriv->wps_probe_resp_ie) {
42ec30ef 2671 DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
2672 return -EINVAL;
1f9d82d2 2673 }
42ec30ef 2674 memcpy(pmlmepriv->wps_probe_resp_ie, param->u.bcn_ie.buf, ie_len);
1f9d82d2 2675 }
a2c60d42 2676
690a993f 2677 return 0;
a2c60d42
LF		 2678}
2679
42ec30ef 2680static int rtw_set_wps_assoc_resp(struct net_device *dev, struct ieee_param *param, int len)
a2c60d42 2681{
42ec30ef 2682 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2683 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2684 int ie_len;
a2c60d42 2685
42ec30ef 2686 DBG_88E("%s, len =%d\n", __func__, len);
a2c60d42 2687
3f95106e 2688 if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
42ec30ef 2689 return -EINVAL;
a2c60d42 2690
42ec30ef 2691 ie_len = len-12-2;/* 12 = param header, 2:no packed */
a2c60d42 2692
157b8e59
TP		 2693 kfree(pmlmepriv->wps_assoc_resp_ie);
2694 pmlmepriv->wps_assoc_resp_ie = NULL;
a2c60d42 2695
42ec30ef 2696 if (ie_len > 0) {
2697 pmlmepriv->wps_assoc_resp_ie = rtw_malloc(ie_len);
2698 pmlmepriv->wps_assoc_resp_ie_len = ie_len;
4fe514dc 2699 if (!pmlmepriv->wps_assoc_resp_ie) {
42ec30ef 2700 DBG_88E("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
2701 return -EINVAL;
a2c60d42
LF		 2702 }
2703
42ec30ef 2704 memcpy(pmlmepriv->wps_assoc_resp_ie, param->u.bcn_ie.buf, ie_len);
a2c60d42 2705 }
42ec30ef 2706
690a993f 2707 return 0;
a2c60d42
LF		 2708}
2709
42ec30ef 2710static int rtw_set_hidden_ssid(struct net_device *dev, struct ieee_param *param, int len)
a2c60d42 2711{
42ec30ef 2712 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2713 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2714 struct mlme_ext_priv *pmlmeext = &(padapter->mlmeextpriv);
2715 struct mlme_ext_info *pmlmeinfo = &(pmlmeext->mlmext_info);
a2c60d42 2716
42ec30ef 2717 u8 value;
a2c60d42 2718
3f95106e 2719 if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
2a8efee2 2720 return -EINVAL;
a2c60d42 2721
42ec30ef 2722 if (param->u.wpa_param.name != 0) /* dummy test... */
2723 DBG_88E("%s name(%u) != 0\n", __func__, param->u.wpa_param.name);
2724 value = param->u.wpa_param.value;
2725
2726 /* use the same definition of hostapd's ignore_broadcast_ssid */
2727 if (value != 1 && value != 2)
2728 value = 0;
2729 DBG_88E("%s value(%u)\n", __func__, value);
2730 pmlmeinfo->hidden_ssid_mode = value;
690a993f 2731 return 0;
a2c60d42
LF		 2732}
2733
42ec30ef 2734static int rtw_ioctl_acl_remove_sta(struct net_device *dev, struct ieee_param *param, int len)
a2c60d42 2735{
42ec30ef 2736 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2737 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
a2c60d42 2738
3f95106e 2739 if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
42ec30ef 2740 return -EINVAL;
c98acd00 2741
8663b2e0 2742 if (is_broadcast_ether_addr(param->sta_addr))
42ec30ef 2743 return -EINVAL;
8663b2e0 2744
f523c7d7 2745 return rtw_acl_remove_sta(padapter, param->sta_addr);
a2c60d42
LF		 2746}
2747
42ec30ef 2748static int rtw_ioctl_acl_add_sta(struct net_device *dev, struct ieee_param *param, int len)
a2c60d42 2749{
42ec30ef 2750 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2751 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
a2c60d42 2752
3f95106e 2753 if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
42ec30ef 2754 return -EINVAL;
a2c60d42 2755
8663b2e0 2756 if (is_broadcast_ether_addr(param->sta_addr))
42ec30ef 2757 return -EINVAL;
8663b2e0 2758
f523c7d7 2759 return rtw_acl_add_sta(padapter, param->sta_addr);
42ec30ef 2760}
a2c60d42 2761
42ec30ef 2762static int rtw_ioctl_set_macaddr_acl(struct net_device *dev, struct ieee_param *param, int len)
2763{
42ec30ef 2764 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2765 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
a2c60d42 2766
3f95106e 2767 if (!check_fwstate(pmlmepriv, WIFI_AP_STATE))
42ec30ef 2768 return -EINVAL;
a2c60d42 2769
42ec30ef 2770 rtw_set_macaddr_acl(padapter, param->u.mlme.command);
3dad0d1e 2771
690a993f 2772 return 0;
a2c60d42
LF		 2773}
2774
42ec30ef 2775static int rtw_hostapd_ioctl(struct net_device *dev, struct iw_point *p)
a2c60d42 2776{
42ec30ef 2777 struct ieee_param *param;
2778 int ret = 0;
2779 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
a2c60d42 2780
42ec30ef 2781 /*
2782 * this function is expect to call in master mode, which allows no power saving
2783 * so, we just check hw_init_completed
2784 */
a2c60d42 2785
e40c6d0f
LF		 2786 if (!padapter->hw_init_completed)
2787 return -EPERM;
a2c60d42 2788
e40c6d0f
LF		 2789 if (!p->pointer || p->length != sizeof(struct ieee_param))
2790 return -EINVAL;
a2c60d42 2791
42ec30ef 2792 param = (struct ieee_param *)rtw_malloc(p->length);
e40c6d0f
LF		 2793 if (!param)
2794 return -ENOMEM;
a2c60d42 2795
42ec30ef 2796 if (copy_from_user(param, p->pointer, p->length)) {
2797 kfree(param);
e40c6d0f 2798 return -EFAULT;
a2c60d42
LF		 2799 }
2800
42ec30ef 2801 switch (param->cmd) {
2802 case RTL871X_HOSTAPD_FLUSH:
2803 ret = rtw_hostapd_sta_flush(dev);
a2c60d42 2804 break;
42ec30ef 2805 case RTL871X_HOSTAPD_ADD_STA:
2806 ret = rtw_add_sta(dev, param);
a2c60d42 2807 break;
42ec30ef 2808 case RTL871X_HOSTAPD_REMOVE_STA:
2809 ret = rtw_del_sta(dev, param);
a2c60d42 2810 break;
42ec30ef 2811 case RTL871X_HOSTAPD_SET_BEACON:
2812 ret = rtw_set_beacon(dev, param, p->length);
a2c60d42 2813 break;
42ec30ef 2814 case RTL871X_SET_ENCRYPTION:
2815 ret = rtw_set_encryption(dev, param, p->length);
a2c60d42 2816 break;
42ec30ef 2817 case RTL871X_HOSTAPD_GET_WPAIE_STA:
2818 ret = rtw_get_sta_wpaie(dev, param);
a2c60d42 2819 break;
42ec30ef 2820 case RTL871X_HOSTAPD_SET_WPS_BEACON:
2821 ret = rtw_set_wps_beacon(dev, param, p->length);
a2c60d42 2822 break;
42ec30ef 2823 case RTL871X_HOSTAPD_SET_WPS_PROBE_RESP:
2824 ret = rtw_set_wps_probe_resp(dev, param, p->length);
a2c60d42 2825 break;
42ec30ef 2826 case RTL871X_HOSTAPD_SET_WPS_ASSOC_RESP:
2827 ret = rtw_set_wps_assoc_resp(dev, param, p->length);
a2c60d42 2828 break;
42ec30ef 2829 case RTL871X_HOSTAPD_SET_HIDDEN_SSID:
2830 ret = rtw_set_hidden_ssid(dev, param, p->length);
a2c60d42 2831 break;
42ec30ef 2832 case RTL871X_HOSTAPD_GET_INFO_STA:
2833 ret = rtw_ioctl_get_sta_data(dev, param, p->length);
a2c60d42 2834 break;
42ec30ef 2835 case RTL871X_HOSTAPD_SET_MACADDR_ACL:
2836 ret = rtw_ioctl_set_macaddr_acl(dev, param, p->length);
a2c60d42 2837 break;
42ec30ef 2838 case RTL871X_HOSTAPD_ACL_ADD_STA:
2839 ret = rtw_ioctl_acl_add_sta(dev, param, p->length);
a2c60d42 2840 break;
42ec30ef 2841 case RTL871X_HOSTAPD_ACL_REMOVE_STA:
2842 ret = rtw_ioctl_acl_remove_sta(dev, param, p->length);
a2c60d42 2843 break;
42ec30ef 2844 default:
2845 DBG_88E("Unknown hostapd request: %d\n", param->cmd);
2846 ret = -EOPNOTSUPP;
a2c60d42
LF		 2847 break;
2848 }
2849
42ec30ef 2850 if (ret == 0 && copy_to_user(p->pointer, param, p->length))
2851 ret = -EFAULT;
2852 kfree(param);
42ec30ef 2853 return ret;
a2c60d42 2854}
42ec30ef 2855#endif
a2c60d42 2856
42ec30ef 2857#include <rtw_android.h>
2858static int rtw_wx_set_priv(struct net_device *dev,
a2c60d42 2859 struct iw_request_info *info,
42ec30ef 2860 union iwreq_data *awrq,
2861 char *extra)
a2c60d42 2862{
42ec30ef 2863 int ret = 0;
2864 int len = 0;
2865 char *ext;
2866 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2867 struct iw_point *dwrq = (struct iw_point *)awrq;
a2c60d42 2868
42ec30ef 2869 if (dwrq->length == 0)
2870 return -EFAULT;
a2c60d42 2871
42ec30ef 2872 len = dwrq->length;
2873 ext = vmalloc(len);
2874 if (!ext)
a2c60d42 2875 return -ENOMEM;
a2c60d42 2876
42ec30ef 2877 if (copy_from_user(ext, dwrq->pointer, len)) {
2878 vfree(ext);
a2c60d42
LF		 2879 return -EFAULT;
2880 }
a2c60d42 2881
42ec30ef 2882 /* added for wps2.0 @20110524 */
2883 if (dwrq->flags == 0x8766 && len > 8) {
2884 u32 cp_sz;
2885 struct mlme_priv *pmlmepriv = &(padapter->mlmepriv);
2886 u8 *probereq_wpsie = ext;
2887 int probereq_wpsie_len = len;
2888 u8 wps_oui[4] = {0x0, 0x50, 0xf2, 0x04};
2889
2890 if ((_VENDOR_SPECIFIC_IE_ == probereq_wpsie[0]) &&
2891 (!memcmp(&probereq_wpsie[2], wps_oui, 4))) {
20e76531 2892 cp_sz = min(probereq_wpsie_len, MAX_WPS_IE_LEN);
42ec30ef 2893
2894 pmlmepriv->wps_probe_req_ie_len = 0;
2895 kfree(pmlmepriv->wps_probe_req_ie);
2896 pmlmepriv->wps_probe_req_ie = NULL;
2897
2898 pmlmepriv->wps_probe_req_ie = rtw_malloc(cp_sz);
4fe514dc 2899 if (!pmlmepriv->wps_probe_req_ie) {
42ec30ef 2900 pr_info("%s()-%d: rtw_malloc() ERROR!\n", __func__, __LINE__);
2901 ret = -EINVAL;
2902 goto FREE_EXT;
2903 }
2904 memcpy(pmlmepriv->wps_probe_req_ie, probereq_wpsie, cp_sz);
2905 pmlmepriv->wps_probe_req_ie_len = cp_sz;
2906 }
2907 goto FREE_EXT;
a2c60d42 2908 }
42ec30ef 2909
2910 if (len >= WEXT_CSCAN_HEADER_SIZE &&
2911 !memcmp(ext, WEXT_CSCAN_HEADER, WEXT_CSCAN_HEADER_SIZE)) {
2912 ret = rtw_wx_set_scan(dev, info, awrq, ext);
2913 goto FREE_EXT;
2914 }
2915
2916FREE_EXT:
2917
2918 vfree(ext);
2919
2920 return ret;
a2c60d42
LF		 2921}
2922
2923static iw_handler rtw_handlers[] = {
2924 NULL, /* SIOCSIWCOMMIT */
2925 rtw_wx_get_name, /* SIOCGIWNAME */
2926 dummy, /* SIOCSIWNWID */
2927 dummy, /* SIOCGIWNWID */
2928 rtw_wx_set_freq, /* SIOCSIWFREQ */
2929 rtw_wx_get_freq, /* SIOCGIWFREQ */
2930 rtw_wx_set_mode, /* SIOCSIWMODE */
2931 rtw_wx_get_mode, /* SIOCGIWMODE */
2932 dummy, /* SIOCSIWSENS */
2933 rtw_wx_get_sens, /* SIOCGIWSENS */
2934 NULL, /* SIOCSIWRANGE */
2935 rtw_wx_get_range, /* SIOCGIWRANGE */
2936 rtw_wx_set_priv, /* SIOCSIWPRIV */
2937 NULL, /* SIOCGIWPRIV */
2938 NULL, /* SIOCSIWSTATS */
2939 NULL, /* SIOCGIWSTATS */
2940 dummy, /* SIOCSIWSPY */
2941 dummy, /* SIOCGIWSPY */
2942 NULL, /* SIOCGIWTHRSPY */
2943 NULL, /* SIOCWIWTHRSPY */
2944 rtw_wx_set_wap, /* SIOCSIWAP */
2945 rtw_wx_get_wap, /* SIOCGIWAP */
2946 rtw_wx_set_mlme, /* request MLME operation; uses struct iw_mlme */
2947 dummy, /* SIOCGIWAPLIST -- depricated */
2948 rtw_wx_set_scan, /* SIOCSIWSCAN */
2949 rtw_wx_get_scan, /* SIOCGIWSCAN */
2950 rtw_wx_set_essid, /* SIOCSIWESSID */
2951 rtw_wx_get_essid, /* SIOCGIWESSID */
2952 dummy, /* SIOCSIWNICKN */
2953 rtw_wx_get_nick, /* SIOCGIWNICKN */
2954 NULL, /* -- hole -- */
2955 NULL, /* -- hole -- */
2956 rtw_wx_set_rate, /* SIOCSIWRATE */
2957 rtw_wx_get_rate, /* SIOCGIWRATE */
2958 rtw_wx_set_rts, /* SIOCSIWRTS */
2959 rtw_wx_get_rts, /* SIOCGIWRTS */
2960 rtw_wx_set_frag, /* SIOCSIWFRAG */
2961 rtw_wx_get_frag, /* SIOCGIWFRAG */
2962 dummy, /* SIOCSIWTXPOW */
2963 dummy, /* SIOCGIWTXPOW */
2964 dummy, /* SIOCSIWRETRY */
2965 rtw_wx_get_retry, /* SIOCGIWRETRY */
2966 rtw_wx_set_enc, /* SIOCSIWENCODE */
2967 rtw_wx_get_enc, /* SIOCGIWENCODE */
2968 dummy, /* SIOCSIWPOWER */
2969 rtw_wx_get_power, /* SIOCGIWPOWER */
2970 NULL, /*---hole---*/
2971 NULL, /*---hole---*/
2972 rtw_wx_set_gen_ie, /* SIOCSIWGENIE */
2973 NULL, /* SIOCGWGENIE */
2974 rtw_wx_set_auth, /* SIOCSIWAUTH */
2975 NULL, /* SIOCGIWAUTH */
2976 rtw_wx_set_enc_ext, /* SIOCSIWENCODEEXT */
2977 NULL, /* SIOCGIWENCODEEXT */
2978 rtw_wx_set_pmkid, /* SIOCSIWPMKSA */
2979 NULL, /*---hole---*/
2980};
2981
a2c60d42
LF		 2982static struct iw_statistics *rtw_get_wireless_stats(struct net_device *dev)
2983{
2984 struct adapter *padapter = (struct adapter *)rtw_netdev_priv(dev);
2985 struct iw_statistics *piwstats = &padapter->iwstats;
2986 int tmp_level = 0;
2987 int tmp_qual = 0;
2988 int tmp_noise = 0;
2989
2990 if (!check_fwstate(&padapter->mlmepriv, _FW_LINKED)) {
2991 piwstats->qual.qual = 0;
2992 piwstats->qual.level = 0;
2993 piwstats->qual.noise = 0;
2994 } else {
2995 tmp_level = padapter->recvpriv.signal_strength;
2996 tmp_qual = padapter->recvpriv.signal_qual;
2997 tmp_noise = padapter->recvpriv.noise;
2998
2999 piwstats->qual.level = tmp_level;
3000 piwstats->qual.qual = tmp_qual;
3001 piwstats->qual.noise = tmp_noise;
3002 }
3003 piwstats->qual.updated = IW_QUAL_ALL_UPDATED;/* IW_QUAL_DBM; */
3004 return &padapter->iwstats;
3005}
3006
3007struct iw_handler_def rtw_handlers_def = {
3008 .standard = rtw_handlers,
bbef4729 3009 .num_standard = ARRAY_SIZE(rtw_handlers),
a2c60d42
LF		 3010 .get_wireless_stats = rtw_get_wireless_stats,
3011};
3012
a2c60d42
LF		 3013int rtw_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
3014{
3015 struct iwreq *wrq = (struct iwreq *)rq;
3016 int ret = 0;
3017
3018 switch (cmd) {
3019 case RTL_IOCTL_WPA_SUPPLICANT:
3020 ret = wpa_supplicant_ioctl(dev, &wrq->u.data);
3021 break;
3022#ifdef CONFIG_88EU_AP_MODE
3023 case RTL_IOCTL_HOSTAPD:
3024 ret = rtw_hostapd_ioctl(dev, &wrq->u.data);
3025 break;
3026#endif /* CONFIG_88EU_AP_MODE */
a2c60d42
LF		 3027 case (SIOCDEVPRIVATE+1):
3028 ret = rtw_android_priv_cmd(dev, rq, cmd);
3029 break;
3030 default:
3031 ret = -EOPNOTSUPP;
3032 break;
3033 }
3034 return ret;
3035}
Linux 6.x block layer and io_uring tree(s)