?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
PCI: fix rom.c kernel-doc warning
[linux-2.6/libata-dev.git] / drivers / staging / rt2870 / sta_ioctl.c
blob91f0fab11313912dd2f05d9afb3c8bc4d234412c
1 /*
2 *************************************************************************
3 * Ralink Tech Inc.
4 * 5F., No.36, Taiyuan St., Jhubei City,
5 * Hsinchu County 302,
6 * Taiwan, R.O.C.
7 *
8 * (c) Copyright 2002-2007, Ralink Technology, Inc.
9 *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 * This program is distributed in the hope that it will be useful, *
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18 * GNU General Public License for more details. *
19 * *
20 * You should have received a copy of the GNU General Public License *
21 * along with this program; if not, write to the *
22 * Free Software Foundation, Inc., *
23 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
24 * *
25 *************************************************************************
26
27 Module Name:
28 sta_ioctl.c
29
30 Abstract:
31 IOCTL related subroutines
32
33 Revision History:
34 Who When What
35 -------- ---------- ----------------------------------------------
36 Rory Chen 01-03-2003 created
37 Rory Chen 02-14-2005 modify to support RT61
38 */
39
40 #include "rt_config.h"
41
42 #ifdef DBG
43 extern ULONG RTDebugLevel;
44 #endif
45
46 #define NR_WEP_KEYS 4
47 #define WEP_SMALL_KEY_LEN (40/8)
48 #define WEP_LARGE_KEY_LEN (104/8)
49
50 #define GROUP_KEY_NO 4
51
52 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)
53 #define IWE_STREAM_ADD_EVENT(_A, _B, _C, _D, _E) iwe_stream_add_event(_A, _B, _C, _D, _E)
54 #define IWE_STREAM_ADD_POINT(_A, _B, _C, _D, _E) iwe_stream_add_point(_A, _B, _C, _D, _E)
55 #define IWE_STREAM_ADD_VALUE(_A, _B, _C, _D, _E, _F) iwe_stream_add_value(_A, _B, _C, _D, _E, _F)
56 #else
57 #define IWE_STREAM_ADD_EVENT(_A, _B, _C, _D, _E) iwe_stream_add_event(_B, _C, _D, _E)
58 #define IWE_STREAM_ADD_POINT(_A, _B, _C, _D, _E) iwe_stream_add_point(_B, _C, _D, _E)
59 #define IWE_STREAM_ADD_VALUE(_A, _B, _C, _D, _E, _F) iwe_stream_add_value(_B, _C, _D, _E, _F)
60 #endif
61
62 extern UCHAR CipherWpa2Template[];
63 extern UCHAR CipherWpaPskTkip[];
64 extern UCHAR CipherWpaPskTkipLen;
65
66 typedef struct PACKED _RT_VERSION_INFO{
67 UCHAR DriverVersionW;
68 UCHAR DriverVersionX;
69 UCHAR DriverVersionY;
70 UCHAR DriverVersionZ;
71 UINT DriverBuildYear;
72 UINT DriverBuildMonth;
73 UINT DriverBuildDay;
74 } RT_VERSION_INFO, *PRT_VERSION_INFO;
75
76 struct iw_priv_args privtab[] = {
77 { RTPRIV_IOCTL_SET,
78 IW_PRIV_TYPE_CHAR | 1024, 0,
79 "set"},
80
81 { RTPRIV_IOCTL_SHOW, 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK,
82 ""},
83 { RTPRIV_IOCTL_SHOW, IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK,
84 ""},
85 /* --- sub-ioctls definitions --- */
86 { SHOW_CONN_STATUS,
87 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "connStatus" },
88 { SHOW_DRVIER_VERION,
89 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "driverVer" },
90 { SHOW_BA_INFO,
91 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "bainfo" },
92 { SHOW_DESC_INFO,
93 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "descinfo" },
94 { RAIO_OFF,
95 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "radio_off" },
96 { RAIO_ON,
97 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "radio_on" },
98 #ifdef QOS_DLS_SUPPORT
99 { SHOW_DLS_ENTRY_INFO,
100 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "dlsentryinfo" },
101 #endif // QOS_DLS_SUPPORT //
102 { SHOW_CFG_VALUE,
103 IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "show" },
104 { SHOW_ADHOC_ENTRY_INFO,
105 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, "adhocEntry" },
106
107 /* --- sub-ioctls relations --- */
108
109 #ifdef DBG
110 { RTPRIV_IOCTL_BBP,
111 IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK,
112 "bbp"},
113 { RTPRIV_IOCTL_MAC,
114 IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | 1024,
115 "mac"},
116 { RTPRIV_IOCTL_E2P,
117 IW_PRIV_TYPE_CHAR | 1024, IW_PRIV_TYPE_CHAR | 1024,
118 "e2p"},
119 #endif /* DBG */
120
121 { RTPRIV_IOCTL_STATISTICS,
122 0, IW_PRIV_TYPE_CHAR | IW_PRIV_SIZE_MASK,
123 "stat"},
124 { RTPRIV_IOCTL_GSITESURVEY,
125 0, IW_PRIV_TYPE_CHAR | 1024,
126 "get_site_survey"},
127 };
128
129 INT Set_SSID_Proc(
130 IN PRTMP_ADAPTER pAdapter,
131 IN PUCHAR arg);
132
133 #ifdef WMM_SUPPORT
134 INT Set_WmmCapable_Proc(
135 IN PRTMP_ADAPTER pAd,
136 IN PUCHAR arg);
137 #endif
138
139 INT Set_NetworkType_Proc(
140 IN PRTMP_ADAPTER pAdapter,
141 IN PUCHAR arg);
142
143 INT Set_AuthMode_Proc(
144 IN PRTMP_ADAPTER pAdapter,
145 IN PUCHAR arg);
146
147 INT Set_EncrypType_Proc(
148 IN PRTMP_ADAPTER pAdapter,
149 IN PUCHAR arg);
150
151 INT Set_DefaultKeyID_Proc(
152 IN PRTMP_ADAPTER pAdapter,
153 IN PUCHAR arg);
154
155 INT Set_Key1_Proc(
156 IN PRTMP_ADAPTER pAdapter,
157 IN PUCHAR arg);
158
159 INT Set_Key2_Proc(
160 IN PRTMP_ADAPTER pAdapter,
161 IN PUCHAR arg);
162
163 INT Set_Key3_Proc(
164 IN PRTMP_ADAPTER pAdapter,
165 IN PUCHAR arg);
166
167 INT Set_Key4_Proc(
168 IN PRTMP_ADAPTER pAdapter,
169 IN PUCHAR arg);
170
171 INT Set_WPAPSK_Proc(
172 IN PRTMP_ADAPTER pAdapter,
173 IN PUCHAR arg);
174
175
176 INT Set_PSMode_Proc(
177 IN PRTMP_ADAPTER pAdapter,
178 IN PUCHAR arg);
179
180 #ifdef WPA_SUPPLICANT_SUPPORT
181 INT Set_Wpa_Support(
182 IN PRTMP_ADAPTER pAd,
183 IN PUCHAR arg);
184 #endif // WPA_SUPPLICANT_SUPPORT //
185
186 #ifdef DBG
187 VOID RTMPIoctlBBP(
188 IN PRTMP_ADAPTER pAdapter,
189 IN struct iwreq *wrq);
190
191 VOID RTMPIoctlMAC(
192 IN PRTMP_ADAPTER pAdapter,
193 IN struct iwreq *wrq);
194
195 VOID RTMPIoctlE2PROM(
196 IN PRTMP_ADAPTER pAdapter,
197 IN struct iwreq *wrq);
198 #endif // DBG //
199
200
201 NDIS_STATUS RTMPWPANoneAddKeyProc(
202 IN PRTMP_ADAPTER pAd,
203 IN PVOID pBuf);
204
205 INT Set_FragTest_Proc(
206 IN PRTMP_ADAPTER pAdapter,
207 IN PUCHAR arg);
208
209 #ifdef DOT11_N_SUPPORT
210 INT Set_TGnWifiTest_Proc(
211 IN PRTMP_ADAPTER pAd,
212 IN PUCHAR arg);
213 #endif // DOT11_N_SUPPORT //
214
215 INT Set_LongRetryLimit_Proc(
216 IN PRTMP_ADAPTER pAdapter,
217 IN PUCHAR arg);
218
219 INT Set_ShortRetryLimit_Proc(
220 IN PRTMP_ADAPTER pAdapter,
221 IN PUCHAR arg);
222
223 #ifdef EXT_BUILD_CHANNEL_LIST
224 INT Set_Ieee80211dClientMode_Proc(
225 IN PRTMP_ADAPTER pAdapter,
226 IN PUCHAR arg);
227 #endif // EXT_BUILD_CHANNEL_LIST //
228
229 #ifdef CARRIER_DETECTION_SUPPORT
230 INT Set_CarrierDetect_Proc(
231 IN PRTMP_ADAPTER pAd,
232 IN PUCHAR arg);
233 #endif // CARRIER_DETECTION_SUPPORT //
234
235 INT Show_Adhoc_MacTable_Proc(
236 IN PRTMP_ADAPTER pAd,
237 IN PCHAR extra);
238
239 static struct {
240 CHAR *name;
241 INT (*set_proc)(PRTMP_ADAPTER pAdapter, PUCHAR arg);
242 } *PRTMP_PRIVATE_SET_PROC, RTMP_PRIVATE_SUPPORT_PROC[] = {
243 {"DriverVersion", Set_DriverVersion_Proc},
244 {"CountryRegion", Set_CountryRegion_Proc},
245 {"CountryRegionABand", Set_CountryRegionABand_Proc},
246 {"SSID", Set_SSID_Proc},
247 {"WirelessMode", Set_WirelessMode_Proc},
248 {"TxBurst", Set_TxBurst_Proc},
249 {"TxPreamble", Set_TxPreamble_Proc},
250 {"TxPower", Set_TxPower_Proc},
251 {"Channel", Set_Channel_Proc},
252 {"BGProtection", Set_BGProtection_Proc},
253 {"RTSThreshold", Set_RTSThreshold_Proc},
254 {"FragThreshold", Set_FragThreshold_Proc},
255 #ifdef DOT11_N_SUPPORT
256 {"HtBw", Set_HtBw_Proc},
257 {"HtMcs", Set_HtMcs_Proc},
258 {"HtGi", Set_HtGi_Proc},
259 {"HtOpMode", Set_HtOpMode_Proc},
260 {"HtExtcha", Set_HtExtcha_Proc},
261 {"HtMpduDensity", Set_HtMpduDensity_Proc},
262 {"HtBaWinSize", Set_HtBaWinSize_Proc},
263 {"HtRdg", Set_HtRdg_Proc},
264 {"HtAmsdu", Set_HtAmsdu_Proc},
265 {"HtAutoBa", Set_HtAutoBa_Proc},
266 {"HtBaDecline", Set_BADecline_Proc},
267 {"HtProtect", Set_HtProtect_Proc},
268 {"HtMimoPs", Set_HtMimoPs_Proc},
269 #endif // DOT11_N_SUPPORT //
270
271 #ifdef AGGREGATION_SUPPORT
272 {"PktAggregate", Set_PktAggregate_Proc},
273 #endif
274
275 #ifdef WMM_SUPPORT
276 {"WmmCapable", Set_WmmCapable_Proc},
277 #endif
278 {"IEEE80211H", Set_IEEE80211H_Proc},
279 {"NetworkType", Set_NetworkType_Proc},
280 {"AuthMode", Set_AuthMode_Proc},
281 {"EncrypType", Set_EncrypType_Proc},
282 {"DefaultKeyID", Set_DefaultKeyID_Proc},
283 {"Key1", Set_Key1_Proc},
284 {"Key2", Set_Key2_Proc},
285 {"Key3", Set_Key3_Proc},
286 {"Key4", Set_Key4_Proc},
287 {"WPAPSK", Set_WPAPSK_Proc},
288 {"ResetCounter", Set_ResetStatCounter_Proc},
289 {"PSMode", Set_PSMode_Proc},
290 #ifdef DBG
291 {"Debug", Set_Debug_Proc},
292 #endif
293
294 #ifdef RALINK_ATE
295 {"ATE", Set_ATE_Proc},
296 {"ATEDA", Set_ATE_DA_Proc},
297 {"ATESA", Set_ATE_SA_Proc},
298 {"ATEBSSID", Set_ATE_BSSID_Proc},
299 {"ATECHANNEL", Set_ATE_CHANNEL_Proc},
300 {"ATETXPOW0", Set_ATE_TX_POWER0_Proc},
301 {"ATETXPOW1", Set_ATE_TX_POWER1_Proc},
302 {"ATETXANT", Set_ATE_TX_Antenna_Proc},
303 {"ATERXANT", Set_ATE_RX_Antenna_Proc},
304 {"ATETXFREQOFFSET", Set_ATE_TX_FREQOFFSET_Proc},
305 {"ATETXBW", Set_ATE_TX_BW_Proc},
306 {"ATETXLEN", Set_ATE_TX_LENGTH_Proc},
307 {"ATETXCNT", Set_ATE_TX_COUNT_Proc},
308 {"ATETXMCS", Set_ATE_TX_MCS_Proc},
309 {"ATETXMODE", Set_ATE_TX_MODE_Proc},
310 {"ATETXGI", Set_ATE_TX_GI_Proc},
311 {"ATERXFER", Set_ATE_RX_FER_Proc},
312 {"ATERRF", Set_ATE_Read_RF_Proc},
313 {"ATEWRF1", Set_ATE_Write_RF1_Proc},
314 {"ATEWRF2", Set_ATE_Write_RF2_Proc},
315 {"ATEWRF3", Set_ATE_Write_RF3_Proc},
316 {"ATEWRF4", Set_ATE_Write_RF4_Proc},
317 {"ATELDE2P", Set_ATE_Load_E2P_Proc},
318 {"ATERE2P", Set_ATE_Read_E2P_Proc},
319 {"ATESHOW", Set_ATE_Show_Proc},
320 {"ATEHELP", Set_ATE_Help_Proc},
321
322 #ifdef RALINK_28xx_QA
323 {"TxStop", Set_TxStop_Proc},
324 {"RxStop", Set_RxStop_Proc},
325 #endif // RALINK_28xx_QA //
326 #endif // RALINK_ATE //
327
328 #ifdef WPA_SUPPLICANT_SUPPORT
329 {"WpaSupport", Set_Wpa_Support},
330 #endif // WPA_SUPPLICANT_SUPPORT //
331
332
333
334 {"FixedTxMode", Set_FixedTxMode_Proc},
335 #ifdef CONFIG_APSTA_MIXED_SUPPORT
336 {"OpMode", Set_OpMode_Proc},
337 #endif // CONFIG_APSTA_MIXED_SUPPORT //
338 #ifdef DOT11_N_SUPPORT
339 {"TGnWifiTest", Set_TGnWifiTest_Proc},
340 {"ForceGF", Set_ForceGF_Proc},
341 #endif // DOT11_N_SUPPORT //
342 #ifdef QOS_DLS_SUPPORT
343 {"DlsAddEntry", Set_DlsAddEntry_Proc},
344 {"DlsTearDownEntry", Set_DlsTearDownEntry_Proc},
345 #endif // QOS_DLS_SUPPORT //
346 {"LongRetry", Set_LongRetryLimit_Proc},
347 {"ShortRetry", Set_ShortRetryLimit_Proc},
348 #ifdef EXT_BUILD_CHANNEL_LIST
349 {"11dClientMode", Set_Ieee80211dClientMode_Proc},
350 #endif // EXT_BUILD_CHANNEL_LIST //
351 #ifdef CARRIER_DETECTION_SUPPORT
352 {"CarrierDetect", Set_CarrierDetect_Proc},
353 #endif // CARRIER_DETECTION_SUPPORT //
354
355 {NULL,}
356 };
357
358
359 VOID RTMPAddKey(
360 IN PRTMP_ADAPTER pAd,
361 IN PNDIS_802_11_KEY pKey)
362 {
363 ULONG KeyIdx;
364 MAC_TABLE_ENTRY *pEntry;
365
366 DBGPRINT(RT_DEBUG_TRACE, ("RTMPAddKey ------>\n"));
367
368 if (pAd->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
369 {
370 if (pKey->KeyIndex & 0x80000000)
371 {
372 if (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPANone)
373 {
374 NdisZeroMemory(pAd->StaCfg.PMK, 32);
375 NdisMoveMemory(pAd->StaCfg.PMK, pKey->KeyMaterial, pKey->KeyLength);
376 goto end;
377 }
378 // Update PTK
379 NdisZeroMemory(&pAd->SharedKey[BSS0][0], sizeof(CIPHER_KEY));
380 pAd->SharedKey[BSS0][0].KeyLen = LEN_TKIP_EK;
381 NdisMoveMemory(pAd->SharedKey[BSS0][0].Key, pKey->KeyMaterial, LEN_TKIP_EK);
382 #ifdef WPA_SUPPLICANT_SUPPORT
383 if (pAd->StaCfg.PairCipher == Ndis802_11Encryption2Enabled)
384 {
385 NdisMoveMemory(pAd->SharedKey[BSS0][0].RxMic, pKey->KeyMaterial + LEN_TKIP_EK, LEN_TKIP_TXMICK);
386 NdisMoveMemory(pAd->SharedKey[BSS0][0].TxMic, pKey->KeyMaterial + LEN_TKIP_EK + LEN_TKIP_TXMICK, LEN_TKIP_RXMICK);
387 }
388 else
389 #endif // WPA_SUPPLICANT_SUPPORT //
390 {
391 NdisMoveMemory(pAd->SharedKey[BSS0][0].TxMic, pKey->KeyMaterial + LEN_TKIP_EK, LEN_TKIP_TXMICK);
392 NdisMoveMemory(pAd->SharedKey[BSS0][0].RxMic, pKey->KeyMaterial + LEN_TKIP_EK + LEN_TKIP_TXMICK, LEN_TKIP_RXMICK);
393 }
394
395 // Decide its ChiperAlg
396 if (pAd->StaCfg.PairCipher == Ndis802_11Encryption2Enabled)
397 pAd->SharedKey[BSS0][0].CipherAlg = CIPHER_TKIP;
398 else if (pAd->StaCfg.PairCipher == Ndis802_11Encryption3Enabled)
399 pAd->SharedKey[BSS0][0].CipherAlg = CIPHER_AES;
400 else
401 pAd->SharedKey[BSS0][0].CipherAlg = CIPHER_NONE;
402
403 // Update these related information to MAC_TABLE_ENTRY
404 pEntry = &pAd->MacTab.Content[BSSID_WCID];
405 NdisMoveMemory(pEntry->PairwiseKey.Key, pAd->SharedKey[BSS0][0].Key, LEN_TKIP_EK);
406 NdisMoveMemory(pEntry->PairwiseKey.RxMic, pAd->SharedKey[BSS0][0].RxMic, LEN_TKIP_RXMICK);
407 NdisMoveMemory(pEntry->PairwiseKey.TxMic, pAd->SharedKey[BSS0][0].TxMic, LEN_TKIP_TXMICK);
408 pEntry->PairwiseKey.CipherAlg = pAd->SharedKey[BSS0][0].CipherAlg;
409
410 // Update pairwise key information to ASIC Shared Key Table
411 AsicAddSharedKeyEntry(pAd,
412 BSS0,
413 0,
414 pAd->SharedKey[BSS0][0].CipherAlg,
415 pAd->SharedKey[BSS0][0].Key,
416 pAd->SharedKey[BSS0][0].TxMic,
417 pAd->SharedKey[BSS0][0].RxMic);
418
419 // Update ASIC WCID attribute table and IVEIV table
420 RTMPAddWcidAttributeEntry(pAd,
421 BSS0,
422 0,
423 pAd->SharedKey[BSS0][0].CipherAlg,
424 pEntry);
425
426 if (pAd->StaCfg.AuthMode >= Ndis802_11AuthModeWPA2)
427 {
428 // set 802.1x port control
429 //pAd->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
430 STA_PORT_SECURED(pAd);
431
432 // Indicate Connected for GUI
433 pAd->IndicateMediaState = NdisMediaStateConnected;
434 }
435 }
436 else
437 {
438 // Update GTK
439 pAd->StaCfg.DefaultKeyId = (pKey->KeyIndex & 0xFF);
440 NdisZeroMemory(&pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId], sizeof(CIPHER_KEY));
441 pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].KeyLen = LEN_TKIP_EK;
442 NdisMoveMemory(pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].Key, pKey->KeyMaterial, LEN_TKIP_EK);
443 #ifdef WPA_SUPPLICANT_SUPPORT
444 if (pAd->StaCfg.GroupCipher == Ndis802_11Encryption2Enabled)
445 {
446 NdisMoveMemory(pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].RxMic, pKey->KeyMaterial + LEN_TKIP_EK, LEN_TKIP_TXMICK);
447 NdisMoveMemory(pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].TxMic, pKey->KeyMaterial + LEN_TKIP_EK + LEN_TKIP_TXMICK, LEN_TKIP_RXMICK);
448 }
449 else
450 #endif // WPA_SUPPLICANT_SUPPORT //
451 {
452 NdisMoveMemory(pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].TxMic, pKey->KeyMaterial + LEN_TKIP_EK, LEN_TKIP_TXMICK);
453 NdisMoveMemory(pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].RxMic, pKey->KeyMaterial + LEN_TKIP_EK + LEN_TKIP_TXMICK, LEN_TKIP_RXMICK);
454 }
455
456 // Update Shared Key CipherAlg
457 pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].CipherAlg = CIPHER_NONE;
458 if (pAd->StaCfg.GroupCipher == Ndis802_11Encryption2Enabled)
459 pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].CipherAlg = CIPHER_TKIP;
460 else if (pAd->StaCfg.GroupCipher == Ndis802_11Encryption3Enabled)
461 pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].CipherAlg = CIPHER_AES;
462
463 // Update group key information to ASIC Shared Key Table
464 AsicAddSharedKeyEntry(pAd,
465 BSS0,
466 pAd->StaCfg.DefaultKeyId,
467 pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].CipherAlg,
468 pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].Key,
469 pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].TxMic,
470 pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].RxMic);
471
472 // Update ASIC WCID attribute table and IVEIV table
473 RTMPAddWcidAttributeEntry(pAd,
474 BSS0,
475 pAd->StaCfg.DefaultKeyId,
476 pAd->SharedKey[BSS0][pAd->StaCfg.DefaultKeyId].CipherAlg,
477 NULL);
478
479 // set 802.1x port control
480 //pAd->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
481 STA_PORT_SECURED(pAd);
482
483 // Indicate Connected for GUI
484 pAd->IndicateMediaState = NdisMediaStateConnected;
485 }
486 }
487 else // dynamic WEP from wpa_supplicant
488 {
489 UCHAR CipherAlg;
490 PUCHAR Key;
491
492 if(pKey->KeyLength == 32)
493 goto end;
494
495 KeyIdx = pKey->KeyIndex & 0x0fffffff;
496
497 if (KeyIdx < 4)
498 {
499 // it is a default shared key, for Pairwise key setting
500 if (pKey->KeyIndex & 0x80000000)
501 {
502 pEntry = MacTableLookup(pAd, pKey->BSSID);
503
504 if (pEntry)
505 {
506 DBGPRINT(RT_DEBUG_TRACE, ("RTMPAddKey: Set Pair-wise Key\n"));
507
508 // set key material and key length
509 pEntry->PairwiseKey.KeyLen = (UCHAR)pKey->KeyLength;
510 NdisMoveMemory(pEntry->PairwiseKey.Key, &pKey->KeyMaterial, pKey->KeyLength);
511
512 // set Cipher type
513 if (pKey->KeyLength == 5)
514 pEntry->PairwiseKey.CipherAlg = CIPHER_WEP64;
515 else
516 pEntry->PairwiseKey.CipherAlg = CIPHER_WEP128;
517
518 // Add Pair-wise key to Asic
519 AsicAddPairwiseKeyEntry(
520 pAd,
521 pEntry->Addr,
522 (UCHAR)pEntry->Aid,
523 &pEntry->PairwiseKey);
524
525 // update WCID attribute table and IVEIV table for this entry
526 RTMPAddWcidAttributeEntry(
527 pAd,
528 BSS0,
529 KeyIdx, // The value may be not zero
530 pEntry->PairwiseKey.CipherAlg,
531 pEntry);
532
533 }
534 }
535 else
536 {
537 // Default key for tx (shared key)
538 pAd->StaCfg.DefaultKeyId = (UCHAR) KeyIdx;
539
540 // set key material and key length
541 pAd->SharedKey[BSS0][KeyIdx].KeyLen = (UCHAR) pKey->KeyLength;
542 NdisMoveMemory(pAd->SharedKey[BSS0][KeyIdx].Key, &pKey->KeyMaterial, pKey->KeyLength);
543
544 // Set Ciper type
545 if (pKey->KeyLength == 5)
546 pAd->SharedKey[BSS0][KeyIdx].CipherAlg = CIPHER_WEP64;
547 else
548 pAd->SharedKey[BSS0][KeyIdx].CipherAlg = CIPHER_WEP128;
549
550 CipherAlg = pAd->SharedKey[BSS0][KeyIdx].CipherAlg;
551 Key = pAd->SharedKey[BSS0][KeyIdx].Key;
552
553 // Set Group key material to Asic
554 AsicAddSharedKeyEntry(pAd, BSS0, KeyIdx, CipherAlg, Key, NULL, NULL);
555
556 // Update WCID attribute table and IVEIV table for this group key table
557 RTMPAddWcidAttributeEntry(pAd, BSS0, KeyIdx, CipherAlg, NULL);
558
559 }
560 }
561 }
562 end:
563 return;
564 }
565
566 char * rtstrchr(const char * s, int c)
567 {
568 for(; *s != (char) c; ++s)
569 if (*s == '\0')
570 return NULL;
571 return (char *) s;
572 }
573
574 /*
575 This is required for LinEX2004/kernel2.6.7 to provide iwlist scanning function
576 */
577
578 int
579 rt_ioctl_giwname(struct net_device *dev,
580 struct iw_request_info *info,
581 char *name, char *extra)
582 {
583 // PRTMP_ADAPTER pAdapter = dev->ml_priv;
584
585 #ifdef RT2870
586 strncpy(name, "RT2870 Wireless", IFNAMSIZ);
587 #endif // RT2870 //
588 return 0;
589 }
590
591 int rt_ioctl_siwfreq(struct net_device *dev,
592 struct iw_request_info *info,
593 struct iw_freq *freq, char *extra)
594 {
595 PRTMP_ADAPTER pAdapter = dev->ml_priv;
596 int chan = -1;
597
598 //check if the interface is down
599 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
600 {
601 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
602 return -ENETDOWN;
603 }
604
605
606 if (freq->e > 1)
607 return -EINVAL;
608
609 if((freq->e == 0) && (freq->m <= 1000))
610 chan = freq->m; // Setting by channel number
611 else
612 MAP_KHZ_TO_CHANNEL_ID( (freq->m /100) , chan); // Setting by frequency - search the table , like 2.412G, 2.422G,
613
614 if (ChannelSanity(pAdapter, chan) == TRUE)
615 {
616 pAdapter->CommonCfg.Channel = chan;
617 DBGPRINT(RT_DEBUG_ERROR, ("==>rt_ioctl_siwfreq::SIOCSIWFREQ[cmd=0x%x] (Channel=%d)\n", SIOCSIWFREQ, pAdapter->CommonCfg.Channel));
618 }
619 else
620 return -EINVAL;
621
622 return 0;
623 }
624 int rt_ioctl_giwfreq(struct net_device *dev,
625 struct iw_request_info *info,
626 struct iw_freq *freq, char *extra)
627 {
628 VIRTUAL_ADAPTER *pVirtualAd = NULL;
629 PRTMP_ADAPTER pAdapter = NULL;
630 UCHAR ch;
631 ULONG m;
632
633 if (dev->priv_flags == INT_MAIN)
634 {
635 pAdapter = dev->ml_priv;
636 }
637 else
638 {
639 pVirtualAd = dev->ml_priv;
640 if (pVirtualAd && pVirtualAd->RtmpDev)
641 pAdapter = pVirtualAd->RtmpDev->ml_priv;
642 }
643
644 if (pAdapter == NULL)
645 {
646 /* if 1st open fail, pAd will be free;
647 So the net_dev->ml_priv will be NULL in 2rd open */
648 return -ENETDOWN;
649 }
650
651 ch = pAdapter->CommonCfg.Channel;
652
653 DBGPRINT(RT_DEBUG_TRACE,("==>rt_ioctl_giwfreq %d\n", ch));
654
655 MAP_CHANNEL_ID_TO_KHZ(ch, m);
656 freq->m = m * 100;
657 freq->e = 1;
658 return 0;
659 }
660
661 int rt_ioctl_siwmode(struct net_device *dev,
662 struct iw_request_info *info,
663 __u32 *mode, char *extra)
664 {
665 PRTMP_ADAPTER pAdapter = dev->ml_priv;
666
667 //check if the interface is down
668 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
669 {
670 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
671 return -ENETDOWN;
672 }
673
674 switch (*mode)
675 {
676 case IW_MODE_ADHOC:
677 Set_NetworkType_Proc(pAdapter, "Adhoc");
678 break;
679 case IW_MODE_INFRA:
680 Set_NetworkType_Proc(pAdapter, "Infra");
681 break;
682 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,20))
683 case IW_MODE_MONITOR:
684 Set_NetworkType_Proc(pAdapter, "Monitor");
685 break;
686 #endif
687 default:
688 DBGPRINT(RT_DEBUG_TRACE, ("===>rt_ioctl_siwmode::SIOCSIWMODE (unknown %d)\n", *mode));
689 return -EINVAL;
690 }
691
692 // Reset Ralink supplicant to not use, it will be set to start when UI set PMK key
693 pAdapter->StaCfg.WpaState = SS_NOTUSE;
694
695 return 0;
696 }
697
698 int rt_ioctl_giwmode(struct net_device *dev,
699 struct iw_request_info *info,
700 __u32 *mode, char *extra)
701 {
702 PRTMP_ADAPTER pAdapter = NULL;
703 VIRTUAL_ADAPTER *pVirtualAd = NULL;
704
705 if (dev->priv_flags == INT_MAIN)
706 {
707 pAdapter = dev->ml_priv;
708 }
709 else
710 {
711 pVirtualAd = dev->ml_priv;
712 if (pVirtualAd && pVirtualAd->RtmpDev)
713 pAdapter = pVirtualAd->RtmpDev->ml_priv;
714 }
715
716 if (pAdapter == NULL)
717 {
718 /* if 1st open fail, pAd will be free;
719 So the net_dev->ml_priv will be NULL in 2rd open */
720 return -ENETDOWN;
721 }
722
723 if (ADHOC_ON(pAdapter))
724 *mode = IW_MODE_ADHOC;
725 else if (INFRA_ON(pAdapter))
726 *mode = IW_MODE_INFRA;
727 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,20))
728 else if (MONITOR_ON(pAdapter))
729 {
730 *mode = IW_MODE_MONITOR;
731 }
732 #endif
733 else
734 *mode = IW_MODE_AUTO;
735
736 DBGPRINT(RT_DEBUG_TRACE, ("==>rt_ioctl_giwmode(mode=%d)\n", *mode));
737 return 0;
738 }
739
740 int rt_ioctl_siwsens(struct net_device *dev,
741 struct iw_request_info *info,
742 char *name, char *extra)
743 {
744 PRTMP_ADAPTER pAdapter = dev->ml_priv;
745
746 //check if the interface is down
747 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
748 {
749 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
750 return -ENETDOWN;
751 }
752
753 return 0;
754 }
755
756 int rt_ioctl_giwsens(struct net_device *dev,
757 struct iw_request_info *info,
758 char *name, char *extra)
759 {
760 return 0;
761 }
762
763 int rt_ioctl_giwrange(struct net_device *dev,
764 struct iw_request_info *info,
765 struct iw_point *data, char *extra)
766 {
767 PRTMP_ADAPTER pAdapter = NULL;
768 VIRTUAL_ADAPTER *pVirtualAd = NULL;
769 struct iw_range *range = (struct iw_range *) extra;
770 u16 val;
771 int i;
772
773 if (dev->priv_flags == INT_MAIN)
774 {
775 pAdapter = dev->ml_priv;
776 }
777 else
778 {
779 pVirtualAd = dev->ml_priv;
780 if (pVirtualAd && pVirtualAd->RtmpDev)
781 pAdapter = pVirtualAd->RtmpDev->ml_priv;
782 }
783
784 if (pAdapter == NULL)
785 {
786 /* if 1st open fail, pAd will be free;
787 So the net_dev->ml_priv will be NULL in 2rd open */
788 return -ENETDOWN;
789 }
790
791 DBGPRINT(RT_DEBUG_TRACE ,("===>rt_ioctl_giwrange\n"));
792 data->length = sizeof(struct iw_range);
793 memset(range, 0, sizeof(struct iw_range));
794
795 range->txpower_capa = IW_TXPOW_DBM;
796
797 if (INFRA_ON(pAdapter)||ADHOC_ON(pAdapter))
798 {
799 range->min_pmp = 1 * 1024;
800 range->max_pmp = 65535 * 1024;
801 range->min_pmt = 1 * 1024;
802 range->max_pmt = 1000 * 1024;
803 range->pmp_flags = IW_POWER_PERIOD;
804 range->pmt_flags = IW_POWER_TIMEOUT;
805 range->pm_capa = IW_POWER_PERIOD | IW_POWER_TIMEOUT |
806 IW_POWER_UNICAST_R | IW_POWER_ALL_R;
807 }
808
809 range->we_version_compiled = WIRELESS_EXT;
810 range->we_version_source = 14;
811
812 range->retry_capa = IW_RETRY_LIMIT;
813 range->retry_flags = IW_RETRY_LIMIT;
814 range->min_retry = 0;
815 range->max_retry = 255;
816
817 range->num_channels = pAdapter->ChannelListNum;
818
819 val = 0;
820 for (i = 1; i <= range->num_channels; i++)
821 {
822 u32 m;
823 range->freq[val].i = pAdapter->ChannelList[i-1].Channel;
824 MAP_CHANNEL_ID_TO_KHZ(pAdapter->ChannelList[i-1].Channel, m);
825 range->freq[val].m = m * 100; /* HZ */
826
827 range->freq[val].e = 1;
828 val++;
829 if (val == IW_MAX_FREQUENCIES)
830 break;
831 }
832 range->num_frequency = val;
833
834 range->max_qual.qual = 100; /* what is correct max? This was not
835 * documented exactly. At least
836 * 69 has been observed. */
837 range->max_qual.level = 0; /* dB */
838 range->max_qual.noise = 0; /* dB */
839
840 /* What would be suitable values for "average/typical" qual? */
841 range->avg_qual.qual = 20;
842 range->avg_qual.level = -60;
843 range->avg_qual.noise = -95;
844 range->sensitivity = 3;
845
846 range->max_encoding_tokens = NR_WEP_KEYS;
847 range->num_encoding_sizes = 2;
848 range->encoding_size[0] = 5;
849 range->encoding_size[1] = 13;
850
851 range->min_rts = 0;
852 range->max_rts = 2347;
853 range->min_frag = 256;
854 range->max_frag = 2346;
855
856 #if WIRELESS_EXT > 17
857 /* IW_ENC_CAPA_* bit field */
858 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
859 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
860 #endif
861
862 return 0;
863 }
864
865 int rt_ioctl_siwap(struct net_device *dev,
866 struct iw_request_info *info,
867 struct sockaddr *ap_addr, char *extra)
868 {
869 PRTMP_ADAPTER pAdapter = dev->ml_priv;
870 NDIS_802_11_MAC_ADDRESS Bssid;
871
872 //check if the interface is down
873 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
874 {
875 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
876 return -ENETDOWN;
877 }
878
879 if (pAdapter->Mlme.CntlMachine.CurrState != CNTL_IDLE)
880 {
881 RT28XX_MLME_RESET_STATE_MACHINE(pAdapter);
882 DBGPRINT(RT_DEBUG_TRACE, ("!!! MLME busy, reset MLME state machine !!!\n"));
883 }
884
885 // tell CNTL state machine to call NdisMSetInformationComplete() after completing
886 // this request, because this request is initiated by NDIS.
887 pAdapter->MlmeAux.CurrReqIsFromNdis = FALSE;
888 // Prevent to connect AP again in STAMlmePeriodicExec
889 pAdapter->MlmeAux.AutoReconnectSsidLen= 32;
890
891 memset(Bssid, 0, MAC_ADDR_LEN);
892 memcpy(Bssid, ap_addr->sa_data, MAC_ADDR_LEN);
893 MlmeEnqueue(pAdapter,
894 MLME_CNTL_STATE_MACHINE,
895 OID_802_11_BSSID,
896 sizeof(NDIS_802_11_MAC_ADDRESS),
897 (VOID *)&Bssid);
898
899 DBGPRINT(RT_DEBUG_TRACE, ("IOCTL::SIOCSIWAP %02x:%02x:%02x:%02x:%02x:%02x\n",
900 Bssid[0], Bssid[1], Bssid[2], Bssid[3], Bssid[4], Bssid[5]));
901
902 return 0;
903 }
904
905 int rt_ioctl_giwap(struct net_device *dev,
906 struct iw_request_info *info,
907 struct sockaddr *ap_addr, char *extra)
908 {
909 PRTMP_ADAPTER pAdapter = NULL;
910 VIRTUAL_ADAPTER *pVirtualAd = NULL;
911
912 if (dev->priv_flags == INT_MAIN)
913 {
914 pAdapter = dev->ml_priv;
915 }
916 else
917 {
918 pVirtualAd = dev->ml_priv;
919 if (pVirtualAd && pVirtualAd->RtmpDev)
920 pAdapter = pVirtualAd->RtmpDev->ml_priv;
921 }
922
923 if (pAdapter == NULL)
924 {
925 /* if 1st open fail, pAd will be free;
926 So the net_dev->ml_priv will be NULL in 2rd open */
927 return -ENETDOWN;
928 }
929
930 if (INFRA_ON(pAdapter) || ADHOC_ON(pAdapter))
931 {
932 ap_addr->sa_family = ARPHRD_ETHER;
933 memcpy(ap_addr->sa_data, &pAdapter->CommonCfg.Bssid, ETH_ALEN);
934 }
935 #ifdef WPA_SUPPLICANT_SUPPORT
936 // Add for RT2870
937 else if (pAdapter->StaCfg.WpaSupplicantUP != WPA_SUPPLICANT_DISABLE)
938 {
939 ap_addr->sa_family = ARPHRD_ETHER;
940 memcpy(ap_addr->sa_data, &pAdapter->MlmeAux.Bssid, ETH_ALEN);
941 }
942 #endif // WPA_SUPPLICANT_SUPPORT //
943 else
944 {
945 DBGPRINT(RT_DEBUG_TRACE, ("IOCTL::SIOCGIWAP(=EMPTY)\n"));
946 return -ENOTCONN;
947 }
948
949 return 0;
950 }
951
952 /*
953 * Units are in db above the noise floor. That means the
954 * rssi values reported in the tx/rx descriptors in the
955 * driver are the SNR expressed in db.
956 *
957 * If you assume that the noise floor is -95, which is an
958 * excellent assumption 99.5 % of the time, then you can
959 * derive the absolute signal level (i.e. -95 + rssi).
960 * There are some other slight factors to take into account
961 * depending on whether the rssi measurement is from 11b,
962 * 11g, or 11a. These differences are at most 2db and
963 * can be documented.
964 *
965 * NB: various calculations are based on the orinoco/wavelan
966 * drivers for compatibility
967 */
968 static void set_quality(PRTMP_ADAPTER pAdapter,
969 struct iw_quality *iq,
970 signed char rssi)
971 {
972 __u8 ChannelQuality;
973
974 // Normalize Rssi
975 if (rssi >= -50)
976 ChannelQuality = 100;
977 else if (rssi >= -80) // between -50 ~ -80dbm
978 ChannelQuality = (__u8)(24 + ((rssi + 80) * 26)/10);
979 else if (rssi >= -90) // between -80 ~ -90dbm
980 ChannelQuality = (__u8)((rssi + 90) * 26)/10;
981 else
982 ChannelQuality = 0;
983
984 iq->qual = (__u8)ChannelQuality;
985
986 iq->level = (__u8)(rssi);
987 iq->noise = (pAdapter->BbpWriteLatch[66] > pAdapter->BbpTuning.FalseCcaUpperThreshold) ? ((__u8)pAdapter->BbpTuning.FalseCcaUpperThreshold) : ((__u8) pAdapter->BbpWriteLatch[66]); // noise level (dBm)
988 iq->noise += 256 - 143;
989 iq->updated = pAdapter->iw_stats.qual.updated;
990 }
991
992 int rt_ioctl_iwaplist(struct net_device *dev,
993 struct iw_request_info *info,
994 struct iw_point *data, char *extra)
995 {
996 PRTMP_ADAPTER pAdapter = dev->ml_priv;
997
998 struct sockaddr addr[IW_MAX_AP];
999 struct iw_quality qual[IW_MAX_AP];
1000 int i;
1001
1002 //check if the interface is down
1003 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1004 {
1005 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
1006 data->length = 0;
1007 return 0;
1008 //return -ENETDOWN;
1009 }
1010
1011 for (i = 0; i <IW_MAX_AP ; i++)
1012 {
1013 if (i >= pAdapter->ScanTab.BssNr)
1014 break;
1015 addr[i].sa_family = ARPHRD_ETHER;
1016 memcpy(addr[i].sa_data, &pAdapter->ScanTab.BssEntry[i].Bssid, MAC_ADDR_LEN);
1017 set_quality(pAdapter, &qual[i], pAdapter->ScanTab.BssEntry[i].Rssi);
1018 }
1019 data->length = i;
1020 memcpy(extra, &addr, i*sizeof(addr[0]));
1021 data->flags = 1; /* signal quality present (sort of) */
1022 memcpy(extra + i*sizeof(addr[0]), &qual, i*sizeof(qual[i]));
1023
1024 return 0;
1025 }
1026
1027 #ifdef SIOCGIWSCAN
1028 int rt_ioctl_siwscan(struct net_device *dev,
1029 struct iw_request_info *info,
1030 struct iw_point *data, char *extra)
1031 {
1032 PRTMP_ADAPTER pAdapter = dev->ml_priv;
1033
1034 ULONG Now;
1035 int Status = NDIS_STATUS_SUCCESS;
1036
1037 //check if the interface is down
1038 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1039 {
1040 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
1041 return -ENETDOWN;
1042 }
1043
1044 if (MONITOR_ON(pAdapter))
1045 {
1046 DBGPRINT(RT_DEBUG_TRACE, ("!!! Driver is in Monitor Mode now !!!\n"));
1047 return -EINVAL;
1048 }
1049
1050
1051 #ifdef WPA_SUPPLICANT_SUPPORT
1052 if (pAdapter->StaCfg.WpaSupplicantUP == WPA_SUPPLICANT_ENABLE)
1053 {
1054 pAdapter->StaCfg.WpaSupplicantScanCount++;
1055 }
1056 #endif // WPA_SUPPLICANT_SUPPORT //
1057
1058 pAdapter->StaCfg.bScanReqIsFromWebUI = TRUE;
1059 if (RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
1060 return 0;
1061 do{
1062 Now = jiffies;
1063
1064 #ifdef WPA_SUPPLICANT_SUPPORT
1065 if ((pAdapter->StaCfg.WpaSupplicantUP == WPA_SUPPLICANT_ENABLE) &&
1066 (pAdapter->StaCfg.WpaSupplicantScanCount > 3))
1067 {
1068 DBGPRINT(RT_DEBUG_TRACE, ("!!! WpaSupplicantScanCount > 3\n"));
1069 Status = NDIS_STATUS_SUCCESS;
1070 break;
1071 }
1072 #endif // WPA_SUPPLICANT_SUPPORT //
1073
1074 if ((OPSTATUS_TEST_FLAG(pAdapter, fOP_STATUS_MEDIA_STATE_CONNECTED)) &&
1075 ((pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPA) ||
1076 (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK)) &&
1077 (pAdapter->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED))
1078 {
1079 DBGPRINT(RT_DEBUG_TRACE, ("!!! Link UP, Port Not Secured! ignore this set::OID_802_11_BSSID_LIST_SCAN\n"));
1080 Status = NDIS_STATUS_SUCCESS;
1081 break;
1082 }
1083
1084 if (pAdapter->Mlme.CntlMachine.CurrState != CNTL_IDLE)
1085 {
1086 RT28XX_MLME_RESET_STATE_MACHINE(pAdapter);
1087 DBGPRINT(RT_DEBUG_TRACE, ("!!! MLME busy, reset MLME state machine !!!\n"));
1088 }
1089
1090 // tell CNTL state machine to call NdisMSetInformationComplete() after completing
1091 // this request, because this request is initiated by NDIS.
1092 pAdapter->MlmeAux.CurrReqIsFromNdis = FALSE;
1093 // Reset allowed scan retries
1094 pAdapter->StaCfg.ScanCnt = 0;
1095 pAdapter->StaCfg.LastScanTime = Now;
1096
1097 MlmeEnqueue(pAdapter,
1098 MLME_CNTL_STATE_MACHINE,
1099 OID_802_11_BSSID_LIST_SCAN,
1100 0,
1101 NULL);
1102
1103 Status = NDIS_STATUS_SUCCESS;
1104 RT28XX_MLME_HANDLER(pAdapter);
1105 }while(0);
1106 return 0;
1107 }
1108
1109 int rt_ioctl_giwscan(struct net_device *dev,
1110 struct iw_request_info *info,
1111 struct iw_point *data, char *extra)
1112 {
1113
1114 PRTMP_ADAPTER pAdapter = dev->ml_priv;
1115 int i=0;
1116 char *current_ev = extra, *previous_ev = extra;
1117 char *end_buf;
1118 char *current_val, custom[MAX_CUSTOM_LEN] = {0};
1119 #ifndef IWEVGENIE
1120 char idx;
1121 #endif // IWEVGENIE //
1122 struct iw_event iwe;
1123
1124 if (RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
1125 {
1126 /*
1127 * Still scanning, indicate the caller should try again.
1128 */
1129 return -EAGAIN;
1130 }
1131
1132
1133 #ifdef WPA_SUPPLICANT_SUPPORT
1134 if (pAdapter->StaCfg.WpaSupplicantUP == WPA_SUPPLICANT_ENABLE)
1135 {
1136 pAdapter->StaCfg.WpaSupplicantScanCount = 0;
1137 }
1138 #endif // WPA_SUPPLICANT_SUPPORT //
1139
1140 if (pAdapter->ScanTab.BssNr == 0)
1141 {
1142 data->length = 0;
1143 return 0;
1144 }
1145
1146 #if WIRELESS_EXT >= 17
1147 if (data->length > 0)
1148 end_buf = extra + data->length;
1149 else
1150 end_buf = extra + IW_SCAN_MAX_DATA;
1151 #else
1152 end_buf = extra + IW_SCAN_MAX_DATA;
1153 #endif
1154
1155 for (i = 0; i < pAdapter->ScanTab.BssNr; i++)
1156 {
1157 if (current_ev >= end_buf)
1158 {
1159 #if WIRELESS_EXT >= 17
1160 return -E2BIG;
1161 #else
1162 break;
1163 #endif
1164 }
1165
1166 //MAC address
1167 //================================
1168 memset(&iwe, 0, sizeof(iwe));
1169 iwe.cmd = SIOCGIWAP;
1170 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1171 memcpy(iwe.u.ap_addr.sa_data, &pAdapter->ScanTab.BssEntry[i].Bssid, ETH_ALEN);
1172
1173 previous_ev = current_ev;
1174 current_ev = IWE_STREAM_ADD_EVENT(info, current_ev,end_buf, &iwe, IW_EV_ADDR_LEN);
1175 if (current_ev == previous_ev)
1176 #if WIRELESS_EXT >= 17
1177 return -E2BIG;
1178 #else
1179 break;
1180 #endif
1181
1182 //ESSID
1183 //================================
1184 memset(&iwe, 0, sizeof(iwe));
1185 iwe.cmd = SIOCGIWESSID;
1186 iwe.u.data.length = pAdapter->ScanTab.BssEntry[i].SsidLen;
1187 iwe.u.data.flags = 1;
1188
1189 previous_ev = current_ev;
1190 current_ev = IWE_STREAM_ADD_POINT(info, current_ev,end_buf, &iwe, pAdapter->ScanTab.BssEntry[i].Ssid);
1191 if (current_ev == previous_ev)
1192 #if WIRELESS_EXT >= 17
1193 return -E2BIG;
1194 #else
1195 break;
1196 #endif
1197
1198 //Network Type
1199 //================================
1200 memset(&iwe, 0, sizeof(iwe));
1201 iwe.cmd = SIOCGIWMODE;
1202 if (pAdapter->ScanTab.BssEntry[i].BssType == Ndis802_11IBSS)
1203 {
1204 iwe.u.mode = IW_MODE_ADHOC;
1205 }
1206 else if (pAdapter->ScanTab.BssEntry[i].BssType == Ndis802_11Infrastructure)
1207 {
1208 iwe.u.mode = IW_MODE_INFRA;
1209 }
1210 else
1211 {
1212 iwe.u.mode = IW_MODE_AUTO;
1213 }
1214 iwe.len = IW_EV_UINT_LEN;
1215
1216 previous_ev = current_ev;
1217 current_ev = IWE_STREAM_ADD_EVENT(info, current_ev, end_buf, &iwe, IW_EV_UINT_LEN);
1218 if (current_ev == previous_ev)
1219 #if WIRELESS_EXT >= 17
1220 return -E2BIG;
1221 #else
1222 break;
1223 #endif
1224
1225 //Channel and Frequency
1226 //================================
1227 memset(&iwe, 0, sizeof(iwe));
1228 iwe.cmd = SIOCGIWFREQ;
1229 if (INFRA_ON(pAdapter) || ADHOC_ON(pAdapter))
1230 iwe.u.freq.m = pAdapter->ScanTab.BssEntry[i].Channel;
1231 else
1232 iwe.u.freq.m = pAdapter->ScanTab.BssEntry[i].Channel;
1233 iwe.u.freq.e = 0;
1234 iwe.u.freq.i = 0;
1235
1236 previous_ev = current_ev;
1237 current_ev = IWE_STREAM_ADD_EVENT(info, current_ev,end_buf, &iwe, IW_EV_FREQ_LEN);
1238 if (current_ev == previous_ev)
1239 #if WIRELESS_EXT >= 17
1240 return -E2BIG;
1241 #else
1242 break;
1243 #endif
1244
1245 //Add quality statistics
1246 //================================
1247 memset(&iwe, 0, sizeof(iwe));
1248 iwe.cmd = IWEVQUAL;
1249 iwe.u.qual.level = 0;
1250 iwe.u.qual.noise = 0;
1251 set_quality(pAdapter, &iwe.u.qual, pAdapter->ScanTab.BssEntry[i].Rssi);
1252 current_ev = IWE_STREAM_ADD_EVENT(info, current_ev, end_buf, &iwe, IW_EV_QUAL_LEN);
1253 if (current_ev == previous_ev)
1254 #if WIRELESS_EXT >= 17
1255 return -E2BIG;
1256 #else
1257 break;
1258 #endif
1259
1260 //Encyption key
1261 //================================
1262 memset(&iwe, 0, sizeof(iwe));
1263 iwe.cmd = SIOCGIWENCODE;
1264 if (CAP_IS_PRIVACY_ON (pAdapter->ScanTab.BssEntry[i].CapabilityInfo ))
1265 iwe.u.data.flags =IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1266 else
1267 iwe.u.data.flags = IW_ENCODE_DISABLED;
1268
1269 previous_ev = current_ev;
1270 current_ev = IWE_STREAM_ADD_POINT(info, current_ev, end_buf,&iwe, (char *)pAdapter->SharedKey[BSS0][(iwe.u.data.flags & IW_ENCODE_INDEX)-1].Key);
1271 if (current_ev == previous_ev)
1272 #if WIRELESS_EXT >= 17
1273 return -E2BIG;
1274 #else
1275 break;
1276 #endif
1277
1278 //Bit Rate
1279 //================================
1280 if (pAdapter->ScanTab.BssEntry[i].SupRateLen)
1281 {
1282 UCHAR tmpRate = pAdapter->ScanTab.BssEntry[i].SupRate[pAdapter->ScanTab.BssEntry[i].SupRateLen-1];
1283 memset(&iwe, 0, sizeof(iwe));
1284 iwe.cmd = SIOCGIWRATE;
1285 current_val = current_ev + IW_EV_LCP_LEN;
1286 if (tmpRate == 0x82)
1287 iwe.u.bitrate.value = 1 * 1000000;
1288 else if (tmpRate == 0x84)
1289 iwe.u.bitrate.value = 2 * 1000000;
1290 else if (tmpRate == 0x8B)
1291 iwe.u.bitrate.value = 5.5 * 1000000;
1292 else if (tmpRate == 0x96)
1293 iwe.u.bitrate.value = 11 * 1000000;
1294 else
1295 iwe.u.bitrate.value = (tmpRate/2) * 1000000;
1296
1297 iwe.u.bitrate.disabled = 0;
1298 current_val = IWE_STREAM_ADD_VALUE(info, current_ev,
1299 current_val, end_buf, &iwe,
1300 IW_EV_PARAM_LEN);
1301
1302 if((current_val-current_ev)>IW_EV_LCP_LEN)
1303 current_ev = current_val;
1304 else
1305 #if WIRELESS_EXT >= 17
1306 return -E2BIG;
1307 #else
1308 break;
1309 #endif
1310 }
1311
1312 #ifdef IWEVGENIE
1313 //WPA IE
1314 if (pAdapter->ScanTab.BssEntry[i].WpaIE.IELen > 0)
1315 {
1316 memset(&iwe, 0, sizeof(iwe));
1317 memset(&custom[0], 0, MAX_CUSTOM_LEN);
1318 memcpy(custom, &(pAdapter->ScanTab.BssEntry[i].WpaIE.IE[0]),
1319 pAdapter->ScanTab.BssEntry[i].WpaIE.IELen);
1320 iwe.cmd = IWEVGENIE;
1321 iwe.u.data.length = pAdapter->ScanTab.BssEntry[i].WpaIE.IELen;
1322 current_ev = IWE_STREAM_ADD_POINT(info, current_ev, end_buf, &iwe, custom);
1323 if (current_ev == previous_ev)
1324 #if WIRELESS_EXT >= 17
1325 return -E2BIG;
1326 #else
1327 break;
1328 #endif
1329 }
1330
1331 //WPA2 IE
1332 if (pAdapter->ScanTab.BssEntry[i].RsnIE.IELen > 0)
1333 {
1334 memset(&iwe, 0, sizeof(iwe));
1335 memset(&custom[0], 0, MAX_CUSTOM_LEN);
1336 memcpy(custom, &(pAdapter->ScanTab.BssEntry[i].RsnIE.IE[0]),
1337 pAdapter->ScanTab.BssEntry[i].RsnIE.IELen);
1338 iwe.cmd = IWEVGENIE;
1339 iwe.u.data.length = pAdapter->ScanTab.BssEntry[i].RsnIE.IELen;
1340 current_ev = IWE_STREAM_ADD_POINT(info, current_ev, end_buf, &iwe, custom);
1341 if (current_ev == previous_ev)
1342 #if WIRELESS_EXT >= 17
1343 return -E2BIG;
1344 #else
1345 break;
1346 #endif
1347 }
1348 #else
1349 //WPA IE
1350 //================================
1351 if (pAdapter->ScanTab.BssEntry[i].WpaIE.IELen > 0)
1352 {
1353 NdisZeroMemory(&iwe, sizeof(iwe));
1354 memset(&custom[0], 0, MAX_CUSTOM_LEN);
1355 iwe.cmd = IWEVCUSTOM;
1356 iwe.u.data.length = (pAdapter->ScanTab.BssEntry[i].WpaIE.IELen * 2) + 7;
1357 NdisMoveMemory(custom, "wpa_ie=", 7);
1358 for (idx = 0; idx < pAdapter->ScanTab.BssEntry[i].WpaIE.IELen; idx++)
1359 sprintf(custom, "%s%02x", custom, pAdapter->ScanTab.BssEntry[i].WpaIE.IE[idx]);
1360 previous_ev = current_ev;
1361 current_ev = IWE_STREAM_ADD_POINT(info, current_ev, end_buf, &iwe, custom);
1362 if (current_ev == previous_ev)
1363 #if WIRELESS_EXT >= 17
1364 return -E2BIG;
1365 #else
1366 break;
1367 #endif
1368 }
1369
1370 //WPA2 IE
1371 if (pAdapter->ScanTab.BssEntry[i].RsnIE.IELen > 0)
1372 {
1373 NdisZeroMemory(&iwe, sizeof(iwe));
1374 memset(&custom[0], 0, MAX_CUSTOM_LEN);
1375 iwe.cmd = IWEVCUSTOM;
1376 iwe.u.data.length = (pAdapter->ScanTab.BssEntry[i].RsnIE.IELen * 2) + 7;
1377 NdisMoveMemory(custom, "rsn_ie=", 7);
1378 for (idx = 0; idx < pAdapter->ScanTab.BssEntry[i].RsnIE.IELen; idx++)
1379 sprintf(custom, "%s%02x", custom, pAdapter->ScanTab.BssEntry[i].RsnIE.IE[idx]);
1380 previous_ev = current_ev;
1381 current_ev = IWE_STREAM_ADD_POINT(info, current_ev, end_buf, &iwe, custom);
1382 if (current_ev == previous_ev)
1383 #if WIRELESS_EXT >= 17
1384 return -E2BIG;
1385 #else
1386 break;
1387 #endif
1388 }
1389 #endif // IWEVGENIE //
1390 }
1391
1392 data->length = current_ev - extra;
1393 pAdapter->StaCfg.bScanReqIsFromWebUI = FALSE;
1394 DBGPRINT(RT_DEBUG_ERROR ,("===>rt_ioctl_giwscan. %d(%d) BSS returned, data->length = %d\n",i , pAdapter->ScanTab.BssNr, data->length));
1395 return 0;
1396 }
1397 #endif
1398
1399 int rt_ioctl_siwessid(struct net_device *dev,
1400 struct iw_request_info *info,
1401 struct iw_point *data, char *essid)
1402 {
1403 PRTMP_ADAPTER pAdapter = dev->ml_priv;
1404
1405 //check if the interface is down
1406 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1407 {
1408 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
1409 return -ENETDOWN;
1410 }
1411
1412 if (data->flags)
1413 {
1414 PCHAR pSsidString = NULL;
1415
1416 // Includes null character.
1417 if (data->length > (IW_ESSID_MAX_SIZE + 1))
1418 return -E2BIG;
1419
1420 pSsidString = (CHAR *) kmalloc(MAX_LEN_OF_SSID+1, MEM_ALLOC_FLAG);
1421 if (pSsidString)
1422 {
1423 NdisZeroMemory(pSsidString, MAX_LEN_OF_SSID+1);
1424 NdisMoveMemory(pSsidString, essid, data->length);
1425 if (Set_SSID_Proc(pAdapter, pSsidString) == FALSE)
1426 return -EINVAL;
1427 }
1428 else
1429 return -ENOMEM;
1430 }
1431 else
1432 {
1433 // ANY ssid
1434 if (Set_SSID_Proc(pAdapter, "") == FALSE)
1435 return -EINVAL;
1436 }
1437 return 0;
1438 }
1439
1440 int rt_ioctl_giwessid(struct net_device *dev,
1441 struct iw_request_info *info,
1442 struct iw_point *data, char *essid)
1443 {
1444 PRTMP_ADAPTER pAdapter = NULL;
1445 VIRTUAL_ADAPTER *pVirtualAd = NULL;
1446
1447 if (dev->priv_flags == INT_MAIN)
1448 {
1449 pAdapter = dev->ml_priv;
1450 }
1451 else
1452 {
1453 pVirtualAd = dev->ml_priv;
1454 if (pVirtualAd && pVirtualAd->RtmpDev)
1455 pAdapter = pVirtualAd->RtmpDev->ml_priv;
1456 }
1457
1458 if (pAdapter == NULL)
1459 {
1460 /* if 1st open fail, pAd will be free;
1461 So the net_dev->ml_priv will be NULL in 2rd open */
1462 return -ENETDOWN;
1463 }
1464
1465 data->flags = 1;
1466 if (MONITOR_ON(pAdapter))
1467 {
1468 data->length = 0;
1469 return 0;
1470 }
1471
1472 if (OPSTATUS_TEST_FLAG(pAdapter, fOP_STATUS_MEDIA_STATE_CONNECTED))
1473 {
1474 DBGPRINT(RT_DEBUG_TRACE ,("MediaState is connected\n"));
1475 data->length = pAdapter->CommonCfg.SsidLen;
1476 memcpy(essid, pAdapter->CommonCfg.Ssid, pAdapter->CommonCfg.SsidLen);
1477 }
1478 #ifdef RT2870
1479 #ifdef WPA_SUPPLICANT_SUPPORT
1480 // Add for RT2870
1481 else if (pAdapter->StaCfg.WpaSupplicantUP != WPA_SUPPLICANT_DISABLE)
1482 {
1483 data->length = pAdapter->CommonCfg.SsidLen;
1484 memcpy(essid, pAdapter->CommonCfg.Ssid, pAdapter->CommonCfg.SsidLen);
1485 }
1486 #endif // WPA_SUPPLICANT_SUPPORT //
1487 #endif // RT2870 //
1488 else
1489 {//the ANY ssid was specified
1490 data->length = 0;
1491 DBGPRINT(RT_DEBUG_TRACE ,("MediaState is not connected, ess\n"));
1492 }
1493
1494 return 0;
1495
1496 }
1497
1498 int rt_ioctl_siwnickn(struct net_device *dev,
1499 struct iw_request_info *info,
1500 struct iw_point *data, char *nickname)
1501 {
1502 PRTMP_ADAPTER pAdapter = dev->ml_priv;
1503
1504 //check if the interface is down
1505 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1506 {
1507 DBGPRINT(RT_DEBUG_TRACE ,("INFO::Network is down!\n"));
1508 return -ENETDOWN;
1509 }
1510
1511 if (data->length > IW_ESSID_MAX_SIZE)
1512 return -EINVAL;
1513
1514 memset(pAdapter->nickname, 0, IW_ESSID_MAX_SIZE + 1);
1515 memcpy(pAdapter->nickname, nickname, data->length);
1516
1517
1518 return 0;
1519 }
1520
1521 int rt_ioctl_giwnickn(struct net_device *dev,
1522 struct iw_request_info *info,
1523 struct iw_point *data, char *nickname)
1524 {
1525 PRTMP_ADAPTER pAdapter = NULL;
1526 VIRTUAL_ADAPTER *pVirtualAd = NULL;
1527
1528 if (dev->priv_flags == INT_MAIN)
1529 {
1530 pAdapter = dev->ml_priv;
1531 }
1532 else
1533 {
1534 pVirtualAd = dev->ml_priv;
1535 if (pVirtualAd && pVirtualAd->RtmpDev)
1536 pAdapter = pVirtualAd->RtmpDev->ml_priv;
1537 }
1538
1539 if (pAdapter == NULL)
1540 {
1541 /* if 1st open fail, pAd will be free;
1542 So the net_dev->ml_priv will be NULL in 2rd open */
1543 return -ENETDOWN;
1544 }
1545
1546 if (data->length > strlen(pAdapter->nickname) + 1)
1547 data->length = strlen(pAdapter->nickname) + 1;
1548 if (data->length > 0) {
1549 memcpy(nickname, pAdapter->nickname, data->length-1);
1550 nickname[data->length-1] = '\0';
1551 }
1552 return 0;
1553 }
1554
1555 int rt_ioctl_siwrts(struct net_device *dev,
1556 struct iw_request_info *info,
1557 struct iw_param *rts, char *extra)
1558 {
1559 PRTMP_ADAPTER pAdapter = dev->ml_priv;
1560 u16 val;
1561
1562 //check if the interface is down
1563 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1564 {
1565 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
1566 return -ENETDOWN;
1567 }
1568
1569 if (rts->disabled)
1570 val = MAX_RTS_THRESHOLD;
1571 else if (rts->value < 0 || rts->value > MAX_RTS_THRESHOLD)
1572 return -EINVAL;
1573 else if (rts->value == 0)
1574 val = MAX_RTS_THRESHOLD;
1575 else
1576 val = rts->value;
1577
1578 if (val != pAdapter->CommonCfg.RtsThreshold)
1579 pAdapter->CommonCfg.RtsThreshold = val;
1580
1581 return 0;
1582 }
1583
1584 int rt_ioctl_giwrts(struct net_device *dev,
1585 struct iw_request_info *info,
1586 struct iw_param *rts, char *extra)
1587 {
1588 PRTMP_ADAPTER pAdapter = NULL;
1589 VIRTUAL_ADAPTER *pVirtualAd = NULL;
1590
1591 if (dev->priv_flags == INT_MAIN)
1592 {
1593 pAdapter = dev->ml_priv;
1594 }
1595 else
1596 {
1597 pVirtualAd = dev->ml_priv;
1598 if (pVirtualAd && pVirtualAd->RtmpDev)
1599 pAdapter = pVirtualAd->RtmpDev->ml_priv;
1600 }
1601
1602 if (pAdapter == NULL)
1603 {
1604 /* if 1st open fail, pAd will be free;
1605 So the net_dev->ml_priv will be NULL in 2rd open */
1606 return -ENETDOWN;
1607 }
1608
1609 //check if the interface is down
1610 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1611 {
1612 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
1613 return -ENETDOWN;
1614 }
1615
1616 rts->value = pAdapter->CommonCfg.RtsThreshold;
1617 rts->disabled = (rts->value == MAX_RTS_THRESHOLD);
1618 rts->fixed = 1;
1619
1620 return 0;
1621 }
1622
1623 int rt_ioctl_siwfrag(struct net_device *dev,
1624 struct iw_request_info *info,
1625 struct iw_param *frag, char *extra)
1626 {
1627 PRTMP_ADAPTER pAdapter = dev->ml_priv;
1628 u16 val;
1629
1630 //check if the interface is down
1631 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1632 {
1633 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
1634 return -ENETDOWN;
1635 }
1636
1637 if (frag->disabled)
1638 val = MAX_FRAG_THRESHOLD;
1639 else if (frag->value >= MIN_FRAG_THRESHOLD || frag->value <= MAX_FRAG_THRESHOLD)
1640 val = __cpu_to_le16(frag->value & ~0x1); /* even numbers only */
1641 else if (frag->value == 0)
1642 val = MAX_FRAG_THRESHOLD;
1643 else
1644 return -EINVAL;
1645
1646 pAdapter->CommonCfg.FragmentThreshold = val;
1647 return 0;
1648 }
1649
1650 int rt_ioctl_giwfrag(struct net_device *dev,
1651 struct iw_request_info *info,
1652 struct iw_param *frag, char *extra)
1653 {
1654 PRTMP_ADAPTER pAdapter = NULL;
1655 VIRTUAL_ADAPTER *pVirtualAd = NULL;
1656
1657 if (dev->priv_flags == INT_MAIN)
1658 {
1659 pAdapter = dev->ml_priv;
1660 }
1661 else
1662 {
1663 pVirtualAd = dev->ml_priv;
1664 if (pVirtualAd && pVirtualAd->RtmpDev)
1665 pAdapter = pVirtualAd->RtmpDev->ml_priv;
1666 }
1667
1668 if (pAdapter == NULL)
1669 {
1670 /* if 1st open fail, pAd will be free;
1671 So the net_dev->ml_priv will be NULL in 2rd open */
1672 return -ENETDOWN;
1673 }
1674
1675 //check if the interface is down
1676 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1677 {
1678 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
1679 return -ENETDOWN;
1680 }
1681
1682 frag->value = pAdapter->CommonCfg.FragmentThreshold;
1683 frag->disabled = (frag->value == MAX_FRAG_THRESHOLD);
1684 frag->fixed = 1;
1685
1686 return 0;
1687 }
1688
1689 #define MAX_WEP_KEY_SIZE 13
1690 #define MIN_WEP_KEY_SIZE 5
1691 int rt_ioctl_siwencode(struct net_device *dev,
1692 struct iw_request_info *info,
1693 struct iw_point *erq, char *extra)
1694 {
1695 PRTMP_ADAPTER pAdapter = dev->ml_priv;
1696
1697 //check if the interface is down
1698 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1699 {
1700 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
1701 return -ENETDOWN;
1702 }
1703
1704 if ((erq->length == 0) &&
1705 (erq->flags & IW_ENCODE_DISABLED))
1706 {
1707 pAdapter->StaCfg.PairCipher = Ndis802_11WEPDisabled;
1708 pAdapter->StaCfg.GroupCipher = Ndis802_11WEPDisabled;
1709 pAdapter->StaCfg.WepStatus = Ndis802_11WEPDisabled;
1710 pAdapter->StaCfg.OrigWepStatus = pAdapter->StaCfg.WepStatus;
1711 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeOpen;
1712 goto done;
1713 }
1714 else if ((erq->length == 0) &&
1715 (erq->flags & IW_ENCODE_RESTRICTED || erq->flags & IW_ENCODE_OPEN))
1716 {
1717 //pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
1718 STA_PORT_SECURED(pAdapter);
1719 pAdapter->StaCfg.PairCipher = Ndis802_11WEPEnabled;
1720 pAdapter->StaCfg.GroupCipher = Ndis802_11WEPEnabled;
1721 pAdapter->StaCfg.WepStatus = Ndis802_11WEPEnabled;
1722 pAdapter->StaCfg.OrigWepStatus = pAdapter->StaCfg.WepStatus;
1723 if (erq->flags & IW_ENCODE_RESTRICTED)
1724 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeShared;
1725 else
1726 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeOpen;
1727 goto done;
1728 }
1729
1730 if (erq->length > 0)
1731 {
1732 int keyIdx = (erq->flags & IW_ENCODE_INDEX) - 1;
1733 /* Check the size of the key */
1734 if (erq->length > MAX_WEP_KEY_SIZE) {
1735 return -EINVAL;
1736 }
1737 /* Check key index */
1738 if ((keyIdx < 0) || (keyIdx >= NR_WEP_KEYS))
1739 {
1740 DBGPRINT(RT_DEBUG_TRACE ,("==>rt_ioctl_siwencode::Wrong keyIdx=%d! Using default key instead (%d)\n",
1741 keyIdx, pAdapter->StaCfg.DefaultKeyId));
1742
1743 //Using default key
1744 keyIdx = pAdapter->StaCfg.DefaultKeyId;
1745 }
1746
1747 NdisZeroMemory(pAdapter->SharedKey[BSS0][keyIdx].Key, 16);
1748
1749 if (erq->length == MAX_WEP_KEY_SIZE)
1750 {
1751 pAdapter->SharedKey[BSS0][keyIdx].KeyLen = MAX_WEP_KEY_SIZE;
1752 pAdapter->SharedKey[BSS0][keyIdx].CipherAlg = CIPHER_WEP128;
1753 }
1754 else if (erq->length == MIN_WEP_KEY_SIZE)
1755 {
1756 pAdapter->SharedKey[BSS0][keyIdx].KeyLen = MIN_WEP_KEY_SIZE;
1757 pAdapter->SharedKey[BSS0][keyIdx].CipherAlg = CIPHER_WEP64;
1758 }
1759 else
1760 /* Disable the key */
1761 pAdapter->SharedKey[BSS0][keyIdx].KeyLen = 0;
1762
1763 /* Check if the key is not marked as invalid */
1764 if(!(erq->flags & IW_ENCODE_NOKEY)) {
1765 /* Copy the key in the driver */
1766 NdisMoveMemory(pAdapter->SharedKey[BSS0][keyIdx].Key, extra, erq->length);
1767 }
1768 }
1769 else
1770 {
1771 /* Do we want to just set the transmit key index ? */
1772 int index = (erq->flags & IW_ENCODE_INDEX) - 1;
1773 if ((index >= 0) && (index < 4))
1774 {
1775 pAdapter->StaCfg.DefaultKeyId = index;
1776 }
1777 else
1778 /* Don't complain if only change the mode */
1779 if(!erq->flags & IW_ENCODE_MODE) {
1780 return -EINVAL;
1781 }
1782 }
1783
1784 done:
1785 DBGPRINT(RT_DEBUG_TRACE ,("==>rt_ioctl_siwencode::erq->flags=%x\n",erq->flags));
1786 DBGPRINT(RT_DEBUG_TRACE ,("==>rt_ioctl_siwencode::AuthMode=%x\n",pAdapter->StaCfg.AuthMode));
1787 DBGPRINT(RT_DEBUG_TRACE ,("==>rt_ioctl_siwencode::DefaultKeyId=%x, KeyLen = %d\n",pAdapter->StaCfg.DefaultKeyId , pAdapter->SharedKey[BSS0][pAdapter->StaCfg.DefaultKeyId].KeyLen));
1788 DBGPRINT(RT_DEBUG_TRACE ,("==>rt_ioctl_siwencode::WepStatus=%x\n",pAdapter->StaCfg.WepStatus));
1789 return 0;
1790 }
1791
1792 int
1793 rt_ioctl_giwencode(struct net_device *dev,
1794 struct iw_request_info *info,
1795 struct iw_point *erq, char *key)
1796 {
1797 int kid;
1798 PRTMP_ADAPTER pAdapter = NULL;
1799 VIRTUAL_ADAPTER *pVirtualAd = NULL;
1800
1801 if (dev->priv_flags == INT_MAIN)
1802 {
1803 pAdapter = dev->ml_priv;
1804 }
1805 else
1806 {
1807 pVirtualAd = dev->ml_priv;
1808 if (pVirtualAd && pVirtualAd->RtmpDev)
1809 pAdapter = pVirtualAd->RtmpDev->ml_priv;
1810 }
1811
1812 if (pAdapter == NULL)
1813 {
1814 /* if 1st open fail, pAd will be free;
1815 So the net_dev->ml_priv will be NULL in 2rd open */
1816 return -ENETDOWN;
1817 }
1818
1819 //check if the interface is down
1820 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1821 {
1822 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
1823 return -ENETDOWN;
1824 }
1825
1826 kid = erq->flags & IW_ENCODE_INDEX;
1827 DBGPRINT(RT_DEBUG_TRACE, ("===>rt_ioctl_giwencode %d\n", erq->flags & IW_ENCODE_INDEX));
1828
1829 if (pAdapter->StaCfg.WepStatus == Ndis802_11WEPDisabled)
1830 {
1831 erq->length = 0;
1832 erq->flags = IW_ENCODE_DISABLED;
1833 }
1834 else if ((kid > 0) && (kid <=4))
1835 {
1836 // copy wep key
1837 erq->flags = kid ; /* NB: base 1 */
1838 if (erq->length > pAdapter->SharedKey[BSS0][kid-1].KeyLen)
1839 erq->length = pAdapter->SharedKey[BSS0][kid-1].KeyLen;
1840 memcpy(key, pAdapter->SharedKey[BSS0][kid-1].Key, erq->length);
1841 //if ((kid == pAdapter->PortCfg.DefaultKeyId))
1842 //erq->flags |= IW_ENCODE_ENABLED; /* XXX */
1843 if (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeShared)
1844 erq->flags |= IW_ENCODE_RESTRICTED; /* XXX */
1845 else
1846 erq->flags |= IW_ENCODE_OPEN; /* XXX */
1847
1848 }
1849 else if (kid == 0)
1850 {
1851 if (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeShared)
1852 erq->flags |= IW_ENCODE_RESTRICTED; /* XXX */
1853 else
1854 erq->flags |= IW_ENCODE_OPEN; /* XXX */
1855 erq->length = pAdapter->SharedKey[BSS0][pAdapter->StaCfg.DefaultKeyId].KeyLen;
1856 memcpy(key, pAdapter->SharedKey[BSS0][pAdapter->StaCfg.DefaultKeyId].Key, erq->length);
1857 // copy default key ID
1858 if (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeShared)
1859 erq->flags |= IW_ENCODE_RESTRICTED; /* XXX */
1860 else
1861 erq->flags |= IW_ENCODE_OPEN; /* XXX */
1862 erq->flags = pAdapter->StaCfg.DefaultKeyId + 1; /* NB: base 1 */
1863 erq->flags |= IW_ENCODE_ENABLED; /* XXX */
1864 }
1865
1866 return 0;
1867
1868 }
1869
1870 static int
1871 rt_ioctl_setparam(struct net_device *dev, struct iw_request_info *info,
1872 void *w, char *extra)
1873 {
1874 VIRTUAL_ADAPTER *pVirtualAd = NULL;
1875 PRTMP_ADAPTER pAdapter;
1876 POS_COOKIE pObj;
1877 char *this_char = extra;
1878 char *value;
1879 int Status=0;
1880
1881 if (dev->priv_flags == INT_MAIN)
1882 {
1883 pAdapter = dev->ml_priv;
1884 }
1885 else
1886 {
1887 pVirtualAd = dev->ml_priv;
1888 pAdapter = pVirtualAd->RtmpDev->ml_priv;
1889 }
1890 pObj = (POS_COOKIE) pAdapter->OS_Cookie;
1891
1892 if (pAdapter == NULL)
1893 {
1894 /* if 1st open fail, pAd will be free;
1895 So the net_dev->ml_priv will be NULL in 2rd open */
1896 return -ENETDOWN;
1897 }
1898
1899 {
1900 pObj->ioctl_if_type = INT_MAIN;
1901 pObj->ioctl_if = MAIN_MBSSID;
1902 }
1903
1904 //check if the interface is down
1905 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
1906 {
1907 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
1908 return -ENETDOWN;
1909 }
1910
1911 if (!*this_char)
1912 return -EINVAL;
1913
1914 if ((value = rtstrchr(this_char, '=')) != NULL)
1915 *value++ = 0;
1916
1917 if (!value)
1918 return -EINVAL;
1919
1920 // reject setting nothing besides ANY ssid(ssidLen=0)
1921 if (!*value && (strcmp(this_char, "SSID") != 0))
1922 return -EINVAL;
1923
1924 for (PRTMP_PRIVATE_SET_PROC = RTMP_PRIVATE_SUPPORT_PROC; PRTMP_PRIVATE_SET_PROC->name; PRTMP_PRIVATE_SET_PROC++)
1925 {
1926 if (strcmp(this_char, PRTMP_PRIVATE_SET_PROC->name) == 0)
1927 {
1928 if(!PRTMP_PRIVATE_SET_PROC->set_proc(pAdapter, value))
1929 { //FALSE:Set private failed then return Invalid argument
1930 Status = -EINVAL;
1931 }
1932 break; //Exit for loop.
1933 }
1934 }
1935
1936 if(PRTMP_PRIVATE_SET_PROC->name == NULL)
1937 { //Not found argument
1938 Status = -EINVAL;
1939 DBGPRINT(RT_DEBUG_TRACE, ("===>rt_ioctl_setparam:: (iwpriv) Not Support Set Command [%s=%s]\n", this_char, value));
1940 }
1941
1942 return Status;
1943 }
1944
1945
1946 static int
1947 rt_private_get_statistics(struct net_device *dev, struct iw_request_info *info,
1948 struct iw_point *wrq, char *extra)
1949 {
1950 INT Status = 0;
1951 PRTMP_ADAPTER pAd = dev->ml_priv;
1952
1953 if (extra == NULL)
1954 {
1955 wrq->length = 0;
1956 return -EIO;
1957 }
1958
1959 memset(extra, 0x00, IW_PRIV_SIZE_MASK);
1960 sprintf(extra, "\n\n");
1961
1962 #ifdef RALINK_ATE
1963 if (ATE_ON(pAd))
1964 {
1965 sprintf(extra+strlen(extra), "Tx success = %ld\n", (ULONG)pAd->ate.TxDoneCount);
1966 //sprintf(extra+strlen(extra), "Tx success without retry = %ld\n", (ULONG)pAd->ate.TxDoneCount);
1967 }
1968 else
1969 #endif // RALINK_ATE //
1970 {
1971 sprintf(extra+strlen(extra), "Tx success = %ld\n", (ULONG)pAd->WlanCounters.TransmittedFragmentCount.QuadPart);
1972 sprintf(extra+strlen(extra), "Tx success without retry = %ld\n", (ULONG)pAd->WlanCounters.TransmittedFragmentCount.QuadPart - (ULONG)pAd->WlanCounters.RetryCount.QuadPart);
1973 }
1974 sprintf(extra+strlen(extra), "Tx success after retry = %ld\n", (ULONG)pAd->WlanCounters.RetryCount.QuadPart);
1975 sprintf(extra+strlen(extra), "Tx fail to Rcv ACK after retry = %ld\n", (ULONG)pAd->WlanCounters.FailedCount.QuadPart);
1976 sprintf(extra+strlen(extra), "RTS Success Rcv CTS = %ld\n", (ULONG)pAd->WlanCounters.RTSSuccessCount.QuadPart);
1977 sprintf(extra+strlen(extra), "RTS Fail Rcv CTS = %ld\n", (ULONG)pAd->WlanCounters.RTSFailureCount.QuadPart);
1978
1979 sprintf(extra+strlen(extra), "Rx success = %ld\n", (ULONG)pAd->WlanCounters.ReceivedFragmentCount.QuadPart);
1980 sprintf(extra+strlen(extra), "Rx with CRC = %ld\n", (ULONG)pAd->WlanCounters.FCSErrorCount.QuadPart);
1981 sprintf(extra+strlen(extra), "Rx drop due to out of resource = %ld\n", (ULONG)pAd->Counters8023.RxNoBuffer);
1982 sprintf(extra+strlen(extra), "Rx duplicate frame = %ld\n", (ULONG)pAd->WlanCounters.FrameDuplicateCount.QuadPart);
1983
1984 sprintf(extra+strlen(extra), "False CCA (one second) = %ld\n", (ULONG)pAd->RalinkCounters.OneSecFalseCCACnt);
1985 #ifdef RALINK_ATE
1986 if (ATE_ON(pAd))
1987 {
1988 if (pAd->ate.RxAntennaSel == 0)
1989 {
1990 sprintf(extra+strlen(extra), "RSSI-A = %ld\n", (LONG)(pAd->ate.LastRssi0 - pAd->BbpRssiToDbmDelta));
1991 sprintf(extra+strlen(extra), "RSSI-B (if available) = %ld\n", (LONG)(pAd->ate.LastRssi1 - pAd->BbpRssiToDbmDelta));
1992 sprintf(extra+strlen(extra), "RSSI-C (if available) = %ld\n\n", (LONG)(pAd->ate.LastRssi2 - pAd->BbpRssiToDbmDelta));
1993 }
1994 else
1995 {
1996 sprintf(extra+strlen(extra), "RSSI = %ld\n", (LONG)(pAd->ate.LastRssi0 - pAd->BbpRssiToDbmDelta));
1997 }
1998 }
1999 else
2000 #endif // RALINK_ATE //
2001 {
2002 sprintf(extra+strlen(extra), "RSSI-A = %ld\n", (LONG)(pAd->StaCfg.RssiSample.LastRssi0 - pAd->BbpRssiToDbmDelta));
2003 sprintf(extra+strlen(extra), "RSSI-B (if available) = %ld\n", (LONG)(pAd->StaCfg.RssiSample.LastRssi1 - pAd->BbpRssiToDbmDelta));
2004 sprintf(extra+strlen(extra), "RSSI-C (if available) = %ld\n\n", (LONG)(pAd->StaCfg.RssiSample.LastRssi2 - pAd->BbpRssiToDbmDelta));
2005 }
2006 #ifdef WPA_SUPPLICANT_SUPPORT
2007 sprintf(extra+strlen(extra), "WpaSupplicantUP = %d\n\n", pAd->StaCfg.WpaSupplicantUP);
2008 #endif // WPA_SUPPLICANT_SUPPORT //
2009
2010
2011 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2012 DBGPRINT(RT_DEBUG_TRACE, ("<== rt_private_get_statistics, wrq->length = %d\n", wrq->length));
2013
2014 return Status;
2015 }
2016
2017 #ifdef DOT11_N_SUPPORT
2018 void getBaInfo(
2019 IN PRTMP_ADAPTER pAd,
2020 IN PUCHAR pOutBuf)
2021 {
2022 INT i, j;
2023 BA_ORI_ENTRY *pOriBAEntry;
2024 BA_REC_ENTRY *pRecBAEntry;
2025
2026 for (i=0; i<MAX_LEN_OF_MAC_TABLE; i++)
2027 {
2028 PMAC_TABLE_ENTRY pEntry = &pAd->MacTab.Content[i];
2029 if (((pEntry->ValidAsCLI || pEntry->ValidAsApCli) && (pEntry->Sst == SST_ASSOC))
2030 || (pEntry->ValidAsWDS) || (pEntry->ValidAsMesh))
2031 {
2032 sprintf(pOutBuf, "%s\n%02X:%02X:%02X:%02X:%02X:%02X (Aid = %d) (AP) -\n",
2033 pOutBuf,
2034 pEntry->Addr[0], pEntry->Addr[1], pEntry->Addr[2],
2035 pEntry->Addr[3], pEntry->Addr[4], pEntry->Addr[5], pEntry->Aid);
2036
2037 sprintf(pOutBuf, "%s[Recipient]\n", pOutBuf);
2038 for (j=0; j < NUM_OF_TID; j++)
2039 {
2040 if (pEntry->BARecWcidArray[j] != 0)
2041 {
2042 pRecBAEntry =&pAd->BATable.BARecEntry[pEntry->BARecWcidArray[j]];
2043 sprintf(pOutBuf, "%sTID=%d, BAWinSize=%d, LastIndSeq=%d, ReorderingPkts=%d\n", pOutBuf, j, pRecBAEntry->BAWinSize, pRecBAEntry->LastIndSeq, pRecBAEntry->list.qlen);
2044 }
2045 }
2046 sprintf(pOutBuf, "%s\n", pOutBuf);
2047
2048 sprintf(pOutBuf, "%s[Originator]\n", pOutBuf);
2049 for (j=0; j < NUM_OF_TID; j++)
2050 {
2051 if (pEntry->BAOriWcidArray[j] != 0)
2052 {
2053 pOriBAEntry =&pAd->BATable.BAOriEntry[pEntry->BAOriWcidArray[j]];
2054 sprintf(pOutBuf, "%sTID=%d, BAWinSize=%d, StartSeq=%d, CurTxSeq=%d\n", pOutBuf, j, pOriBAEntry->BAWinSize, pOriBAEntry->Sequence, pEntry->TxSeq[j]);
2055 }
2056 }
2057 sprintf(pOutBuf, "%s\n\n", pOutBuf);
2058 }
2059 if (strlen(pOutBuf) > (IW_PRIV_SIZE_MASK - 30))
2060 break;
2061 }
2062
2063 return;
2064 }
2065 #endif // DOT11_N_SUPPORT //
2066
2067 static int
2068 rt_private_show(struct net_device *dev, struct iw_request_info *info,
2069 struct iw_point *wrq, char *extra)
2070 {
2071 INT Status = 0;
2072 VIRTUAL_ADAPTER *pVirtualAd = NULL;
2073 PRTMP_ADAPTER pAd;
2074 POS_COOKIE pObj;
2075 u32 subcmd = wrq->flags;
2076
2077 if (dev->priv_flags == INT_MAIN)
2078 pAd = dev->ml_priv;
2079 else
2080 {
2081 pVirtualAd = dev->ml_priv;
2082 pAd = pVirtualAd->RtmpDev->ml_priv;
2083 }
2084 pObj = (POS_COOKIE) pAd->OS_Cookie;
2085
2086 if (pAd == NULL)
2087 {
2088 /* if 1st open fail, pAd will be free;
2089 So the net_dev->ml_priv will be NULL in 2rd open */
2090 return -ENETDOWN;
2091 }
2092
2093 if (extra == NULL)
2094 {
2095 wrq->length = 0;
2096 return -EIO;
2097 }
2098 memset(extra, 0x00, IW_PRIV_SIZE_MASK);
2099
2100 {
2101 pObj->ioctl_if_type = INT_MAIN;
2102 pObj->ioctl_if = MAIN_MBSSID;
2103 }
2104
2105 switch(subcmd)
2106 {
2107
2108 case SHOW_CONN_STATUS:
2109 if (MONITOR_ON(pAd))
2110 {
2111 #ifdef DOT11_N_SUPPORT
2112 if (pAd->CommonCfg.PhyMode >= PHY_11ABGN_MIXED &&
2113 pAd->CommonCfg.RegTransmitSetting.field.BW)
2114 sprintf(extra, "Monitor Mode(CentralChannel %d)\n", pAd->CommonCfg.CentralChannel);
2115 else
2116 #endif // DOT11_N_SUPPORT //
2117 sprintf(extra, "Monitor Mode(Channel %d)\n", pAd->CommonCfg.Channel);
2118 }
2119 else
2120 {
2121 if (pAd->IndicateMediaState == NdisMediaStateConnected)
2122 {
2123 if (INFRA_ON(pAd))
2124 {
2125 sprintf(extra, "Connected(AP: %s[%02X:%02X:%02X:%02X:%02X:%02X])\n",
2126 pAd->CommonCfg.Ssid,
2127 pAd->CommonCfg.Bssid[0],
2128 pAd->CommonCfg.Bssid[1],
2129 pAd->CommonCfg.Bssid[2],
2130 pAd->CommonCfg.Bssid[3],
2131 pAd->CommonCfg.Bssid[4],
2132 pAd->CommonCfg.Bssid[5]);
2133 DBGPRINT(RT_DEBUG_TRACE ,("Ssid=%s ,Ssidlen = %d\n",pAd->CommonCfg.Ssid, pAd->CommonCfg.SsidLen));
2134 }
2135 else if (ADHOC_ON(pAd))
2136 sprintf(extra, "Connected\n");
2137 }
2138 else
2139 {
2140 sprintf(extra, "Disconnected\n");
2141 DBGPRINT(RT_DEBUG_TRACE ,("ConnStatus is not connected\n"));
2142 }
2143 }
2144 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2145 break;
2146 case SHOW_DRVIER_VERION:
2147 sprintf(extra, "Driver version-%s, %s %s\n", STA_DRIVER_VERSION, __DATE__, __TIME__ );
2148 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2149 break;
2150 #ifdef DOT11_N_SUPPORT
2151 case SHOW_BA_INFO:
2152 getBaInfo(pAd, extra);
2153 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2154 break;
2155 #endif // DOT11_N_SUPPORT //
2156 case SHOW_DESC_INFO:
2157 {
2158 Show_DescInfo_Proc(pAd, NULL);
2159 wrq->length = 0; // 1: size of '\0'
2160 }
2161 break;
2162 case RAIO_OFF:
2163 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
2164 {
2165 sprintf(extra, "Scanning\n");
2166 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2167 break;
2168 }
2169 pAd->StaCfg.bSwRadio = FALSE;
2170 if (pAd->StaCfg.bRadio != (pAd->StaCfg.bHwRadio && pAd->StaCfg.bSwRadio))
2171 {
2172 pAd->StaCfg.bRadio = (pAd->StaCfg.bHwRadio && pAd->StaCfg.bSwRadio);
2173 if (pAd->StaCfg.bRadio == FALSE)
2174 {
2175 MlmeRadioOff(pAd);
2176 // Update extra information
2177 pAd->ExtraInfo = SW_RADIO_OFF;
2178 }
2179 }
2180 sprintf(extra, "Radio Off\n");
2181 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2182 break;
2183 case RAIO_ON:
2184 if (RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
2185 {
2186 sprintf(extra, "Scanning\n");
2187 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2188 break;
2189 }
2190 pAd->StaCfg.bSwRadio = TRUE;
2191 //if (pAd->StaCfg.bRadio != (pAd->StaCfg.bHwRadio && pAd->StaCfg.bSwRadio))
2192 {
2193 pAd->StaCfg.bRadio = (pAd->StaCfg.bHwRadio && pAd->StaCfg.bSwRadio);
2194 if (pAd->StaCfg.bRadio == TRUE)
2195 {
2196 MlmeRadioOn(pAd);
2197 // Update extra information
2198 pAd->ExtraInfo = EXTRA_INFO_CLEAR;
2199 }
2200 }
2201 sprintf(extra, "Radio On\n");
2202 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2203 break;
2204
2205
2206 #ifdef QOS_DLS_SUPPORT
2207 case SHOW_DLS_ENTRY_INFO:
2208 {
2209 Set_DlsEntryInfo_Display_Proc(pAd, NULL);
2210 wrq->length = 0; // 1: size of '\0'
2211 }
2212 break;
2213 #endif // QOS_DLS_SUPPORT //
2214
2215 case SHOW_CFG_VALUE:
2216 {
2217 Status = RTMPShowCfgValue(pAd, wrq->pointer, extra);
2218 if (Status == 0)
2219 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2220 }
2221 break;
2222 case SHOW_ADHOC_ENTRY_INFO:
2223 Show_Adhoc_MacTable_Proc(pAd, extra);
2224 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2225 break;
2226 default:
2227 DBGPRINT(RT_DEBUG_TRACE, ("%s - unknow subcmd = %d\n", __func__, subcmd));
2228 break;
2229 }
2230
2231 return Status;
2232 }
2233
2234 #ifdef SIOCSIWMLME
2235 int rt_ioctl_siwmlme(struct net_device *dev,
2236 struct iw_request_info *info,
2237 union iwreq_data *wrqu,
2238 char *extra)
2239 {
2240 PRTMP_ADAPTER pAd = dev->ml_priv;
2241 struct iw_mlme *pMlme = (struct iw_mlme *)wrqu->data.pointer;
2242 MLME_QUEUE_ELEM MsgElem;
2243 MLME_DISASSOC_REQ_STRUCT DisAssocReq;
2244 MLME_DEAUTH_REQ_STRUCT DeAuthReq;
2245
2246 DBGPRINT(RT_DEBUG_TRACE, ("====> %s\n", __func__));
2247
2248 if (pMlme == NULL)
2249 return -EINVAL;
2250
2251 switch(pMlme->cmd)
2252 {
2253 #ifdef IW_MLME_DEAUTH
2254 case IW_MLME_DEAUTH:
2255 DBGPRINT(RT_DEBUG_TRACE, ("====> %s - IW_MLME_DEAUTH\n", __func__));
2256 COPY_MAC_ADDR(DeAuthReq.Addr, pAd->CommonCfg.Bssid);
2257 DeAuthReq.Reason = pMlme->reason_code;
2258 MsgElem.MsgLen = sizeof(MLME_DEAUTH_REQ_STRUCT);
2259 NdisMoveMemory(MsgElem.Msg, &DeAuthReq, sizeof(MLME_DEAUTH_REQ_STRUCT));
2260 MlmeDeauthReqAction(pAd, &MsgElem);
2261 if (INFRA_ON(pAd))
2262 {
2263 LinkDown(pAd, FALSE);
2264 pAd->Mlme.AssocMachine.CurrState = ASSOC_IDLE;
2265 }
2266 break;
2267 #endif // IW_MLME_DEAUTH //
2268 #ifdef IW_MLME_DISASSOC
2269 case IW_MLME_DISASSOC:
2270 DBGPRINT(RT_DEBUG_TRACE, ("====> %s - IW_MLME_DISASSOC\n", __func__));
2271 COPY_MAC_ADDR(DisAssocReq.Addr, pAd->CommonCfg.Bssid);
2272 DisAssocReq.Reason = pMlme->reason_code;
2273
2274 MsgElem.Machine = ASSOC_STATE_MACHINE;
2275 MsgElem.MsgType = MT2_MLME_DISASSOC_REQ;
2276 MsgElem.MsgLen = sizeof(MLME_DISASSOC_REQ_STRUCT);
2277 NdisMoveMemory(MsgElem.Msg, &DisAssocReq, sizeof(MLME_DISASSOC_REQ_STRUCT));
2278
2279 pAd->Mlme.CntlMachine.CurrState = CNTL_WAIT_OID_DISASSOC;
2280 MlmeDisassocReqAction(pAd, &MsgElem);
2281 break;
2282 #endif // IW_MLME_DISASSOC //
2283 default:
2284 DBGPRINT(RT_DEBUG_TRACE, ("====> %s - Unknow Command\n", __func__));
2285 break;
2286 }
2287
2288 return 0;
2289 }
2290 #endif // SIOCSIWMLME //
2291
2292 #if WIRELESS_EXT > 17
2293 int rt_ioctl_siwauth(struct net_device *dev,
2294 struct iw_request_info *info,
2295 union iwreq_data *wrqu, char *extra)
2296 {
2297 PRTMP_ADAPTER pAdapter = dev->ml_priv;
2298 struct iw_param *param = &wrqu->param;
2299
2300 //check if the interface is down
2301 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
2302 {
2303 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
2304 return -ENETDOWN;
2305 }
2306 switch (param->flags & IW_AUTH_INDEX) {
2307 case IW_AUTH_WPA_VERSION:
2308 if (param->value == IW_AUTH_WPA_VERSION_WPA)
2309 {
2310 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeWPAPSK;
2311 if (pAdapter->StaCfg.BssType == BSS_ADHOC)
2312 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeWPANone;
2313 }
2314 else if (param->value == IW_AUTH_WPA_VERSION_WPA2)
2315 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeWPA2PSK;
2316
2317 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_AUTH_WPA_VERSION - param->value = %d!\n", __func__, param->value));
2318 break;
2319 case IW_AUTH_CIPHER_PAIRWISE:
2320 if (param->value == IW_AUTH_CIPHER_NONE)
2321 {
2322 pAdapter->StaCfg.WepStatus = Ndis802_11WEPDisabled;
2323 pAdapter->StaCfg.OrigWepStatus = pAdapter->StaCfg.WepStatus;
2324 pAdapter->StaCfg.PairCipher = Ndis802_11WEPDisabled;
2325 }
2326 else if (param->value == IW_AUTH_CIPHER_WEP40 ||
2327 param->value == IW_AUTH_CIPHER_WEP104)
2328 {
2329 pAdapter->StaCfg.WepStatus = Ndis802_11WEPEnabled;
2330 pAdapter->StaCfg.OrigWepStatus = pAdapter->StaCfg.WepStatus;
2331 pAdapter->StaCfg.PairCipher = Ndis802_11WEPEnabled;
2332 #ifdef WPA_SUPPLICANT_SUPPORT
2333 pAdapter->StaCfg.IEEE8021X = FALSE;
2334 #endif // WPA_SUPPLICANT_SUPPORT //
2335 }
2336 else if (param->value == IW_AUTH_CIPHER_TKIP)
2337 {
2338 pAdapter->StaCfg.WepStatus = Ndis802_11Encryption2Enabled;
2339 pAdapter->StaCfg.OrigWepStatus = pAdapter->StaCfg.WepStatus;
2340 pAdapter->StaCfg.PairCipher = Ndis802_11Encryption2Enabled;
2341 }
2342 else if (param->value == IW_AUTH_CIPHER_CCMP)
2343 {
2344 pAdapter->StaCfg.WepStatus = Ndis802_11Encryption3Enabled;
2345 pAdapter->StaCfg.OrigWepStatus = pAdapter->StaCfg.WepStatus;
2346 pAdapter->StaCfg.PairCipher = Ndis802_11Encryption3Enabled;
2347 }
2348 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_AUTH_CIPHER_PAIRWISE - param->value = %d!\n", __func__, param->value));
2349 break;
2350 case IW_AUTH_CIPHER_GROUP:
2351 if (param->value == IW_AUTH_CIPHER_NONE)
2352 {
2353 pAdapter->StaCfg.GroupCipher = Ndis802_11WEPDisabled;
2354 }
2355 else if (param->value == IW_AUTH_CIPHER_WEP40 ||
2356 param->value == IW_AUTH_CIPHER_WEP104)
2357 {
2358 pAdapter->StaCfg.GroupCipher = Ndis802_11WEPEnabled;
2359 }
2360 else if (param->value == IW_AUTH_CIPHER_TKIP)
2361 {
2362 pAdapter->StaCfg.GroupCipher = Ndis802_11Encryption2Enabled;
2363 }
2364 else if (param->value == IW_AUTH_CIPHER_CCMP)
2365 {
2366 pAdapter->StaCfg.GroupCipher = Ndis802_11Encryption3Enabled;
2367 }
2368 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_AUTH_CIPHER_GROUP - param->value = %d!\n", __func__, param->value));
2369 break;
2370 case IW_AUTH_KEY_MGMT:
2371 if (param->value == IW_AUTH_KEY_MGMT_802_1X)
2372 {
2373 if (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK)
2374 {
2375 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeWPA;
2376 #ifdef WPA_SUPPLICANT_SUPPORT
2377 pAdapter->StaCfg.IEEE8021X = FALSE;
2378 #endif // WPA_SUPPLICANT_SUPPORT //
2379 }
2380 else if (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK)
2381 {
2382 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeWPA2;
2383 #ifdef WPA_SUPPLICANT_SUPPORT
2384 pAdapter->StaCfg.IEEE8021X = FALSE;
2385 #endif // WPA_SUPPLICANT_SUPPORT //
2386 }
2387 #ifdef WPA_SUPPLICANT_SUPPORT
2388 else
2389 // WEP 1x
2390 pAdapter->StaCfg.IEEE8021X = TRUE;
2391 #endif // WPA_SUPPLICANT_SUPPORT //
2392 }
2393 else if (param->value == 0)
2394 {
2395 //pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
2396 STA_PORT_SECURED(pAdapter);
2397 }
2398 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_AUTH_KEY_MGMT - param->value = %d!\n", __func__, param->value));
2399 break;
2400 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
2401 break;
2402 case IW_AUTH_PRIVACY_INVOKED:
2403 /*if (param->value == 0)
2404 {
2405 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeOpen;
2406 pAdapter->StaCfg.WepStatus = Ndis802_11WEPDisabled;
2407 pAdapter->StaCfg.OrigWepStatus = pAdapter->StaCfg.WepStatus;
2408 pAdapter->StaCfg.PairCipher = Ndis802_11WEPDisabled;
2409 pAdapter->StaCfg.GroupCipher = Ndis802_11WEPDisabled;
2410 }*/
2411 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_AUTH_PRIVACY_INVOKED - param->value = %d!\n", __func__, param->value));
2412 break;
2413 case IW_AUTH_DROP_UNENCRYPTED:
2414 if (param->value != 0)
2415 pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_NOT_SECURED;
2416 else
2417 {
2418 //pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
2419 STA_PORT_SECURED(pAdapter);
2420 }
2421 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_AUTH_WPA_VERSION - param->value = %d!\n", __func__, param->value));
2422 break;
2423 case IW_AUTH_80211_AUTH_ALG:
2424 if (param->value & IW_AUTH_ALG_SHARED_KEY)
2425 {
2426 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeShared;
2427 }
2428 else if (param->value & IW_AUTH_ALG_OPEN_SYSTEM)
2429 {
2430 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeOpen;
2431 }
2432 else
2433 return -EINVAL;
2434 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_AUTH_80211_AUTH_ALG - param->value = %d!\n", __func__, param->value));
2435 break;
2436 case IW_AUTH_WPA_ENABLED:
2437 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_AUTH_WPA_ENABLED - Driver supports WPA!(param->value = %d)\n", __func__, param->value));
2438 break;
2439 default:
2440 return -EOPNOTSUPP;
2441 }
2442
2443 return 0;
2444 }
2445
2446 int rt_ioctl_giwauth(struct net_device *dev,
2447 struct iw_request_info *info,
2448 union iwreq_data *wrqu, char *extra)
2449 {
2450 PRTMP_ADAPTER pAdapter = dev->ml_priv;
2451 struct iw_param *param = &wrqu->param;
2452
2453 //check if the interface is down
2454 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
2455 {
2456 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
2457 return -ENETDOWN;
2458 }
2459
2460 switch (param->flags & IW_AUTH_INDEX) {
2461 case IW_AUTH_DROP_UNENCRYPTED:
2462 param->value = (pAdapter->StaCfg.WepStatus == Ndis802_11WEPDisabled) ? 0 : 1;
2463 break;
2464
2465 case IW_AUTH_80211_AUTH_ALG:
2466 param->value = (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeShared) ? IW_AUTH_ALG_SHARED_KEY : IW_AUTH_ALG_OPEN_SYSTEM;
2467 break;
2468
2469 case IW_AUTH_WPA_ENABLED:
2470 param->value = (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA) ? 1 : 0;
2471 break;
2472
2473 default:
2474 return -EOPNOTSUPP;
2475 }
2476 DBGPRINT(RT_DEBUG_TRACE, ("rt_ioctl_giwauth::param->value = %d!\n", param->value));
2477 return 0;
2478 }
2479
2480 void fnSetCipherKey(
2481 IN PRTMP_ADAPTER pAdapter,
2482 IN INT keyIdx,
2483 IN UCHAR CipherAlg,
2484 IN BOOLEAN bGTK,
2485 IN struct iw_encode_ext *ext)
2486 {
2487 NdisZeroMemory(&pAdapter->SharedKey[BSS0][keyIdx], sizeof(CIPHER_KEY));
2488 pAdapter->SharedKey[BSS0][keyIdx].KeyLen = LEN_TKIP_EK;
2489 NdisMoveMemory(pAdapter->SharedKey[BSS0][keyIdx].Key, ext->key, LEN_TKIP_EK);
2490 NdisMoveMemory(pAdapter->SharedKey[BSS0][keyIdx].TxMic, ext->key + LEN_TKIP_EK, LEN_TKIP_TXMICK);
2491 NdisMoveMemory(pAdapter->SharedKey[BSS0][keyIdx].RxMic, ext->key + LEN_TKIP_EK + LEN_TKIP_TXMICK, LEN_TKIP_RXMICK);
2492 pAdapter->SharedKey[BSS0][keyIdx].CipherAlg = CipherAlg;
2493
2494 // Update group key information to ASIC Shared Key Table
2495 AsicAddSharedKeyEntry(pAdapter,
2496 BSS0,
2497 keyIdx,
2498 pAdapter->SharedKey[BSS0][keyIdx].CipherAlg,
2499 pAdapter->SharedKey[BSS0][keyIdx].Key,
2500 pAdapter->SharedKey[BSS0][keyIdx].TxMic,
2501 pAdapter->SharedKey[BSS0][keyIdx].RxMic);
2502
2503 if (bGTK)
2504 // Update ASIC WCID attribute table and IVEIV table
2505 RTMPAddWcidAttributeEntry(pAdapter,
2506 BSS0,
2507 keyIdx,
2508 pAdapter->SharedKey[BSS0][keyIdx].CipherAlg,
2509 NULL);
2510 else
2511 // Update ASIC WCID attribute table and IVEIV table
2512 RTMPAddWcidAttributeEntry(pAdapter,
2513 BSS0,
2514 keyIdx,
2515 pAdapter->SharedKey[BSS0][keyIdx].CipherAlg,
2516 &pAdapter->MacTab.Content[BSSID_WCID]);
2517 }
2518
2519 int rt_ioctl_siwencodeext(struct net_device *dev,
2520 struct iw_request_info *info,
2521 union iwreq_data *wrqu,
2522 char *extra)
2523 {
2524 PRTMP_ADAPTER pAdapter = dev->ml_priv;
2525 struct iw_point *encoding = &wrqu->encoding;
2526 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
2527 int keyIdx, alg = ext->alg;
2528
2529 //check if the interface is down
2530 if(!RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_INTERRUPT_IN_USE))
2531 {
2532 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
2533 return -ENETDOWN;
2534 }
2535
2536 if (encoding->flags & IW_ENCODE_DISABLED)
2537 {
2538 keyIdx = (encoding->flags & IW_ENCODE_INDEX) - 1;
2539 // set BSSID wcid entry of the Pair-wise Key table as no-security mode
2540 AsicRemovePairwiseKeyEntry(pAdapter, BSS0, BSSID_WCID);
2541 pAdapter->SharedKey[BSS0][keyIdx].KeyLen = 0;
2542 pAdapter->SharedKey[BSS0][keyIdx].CipherAlg = CIPHER_NONE;
2543 AsicRemoveSharedKeyEntry(pAdapter, 0, (UCHAR)keyIdx);
2544 NdisZeroMemory(&pAdapter->SharedKey[BSS0][keyIdx], sizeof(CIPHER_KEY));
2545 DBGPRINT(RT_DEBUG_TRACE, ("%s::Remove all keys!(encoding->flags = %x)\n", __func__, encoding->flags));
2546 }
2547 else
2548 {
2549 // Get Key Index and convet to our own defined key index
2550 keyIdx = (encoding->flags & IW_ENCODE_INDEX) - 1;
2551 if((keyIdx < 0) || (keyIdx >= NR_WEP_KEYS))
2552 return -EINVAL;
2553
2554 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
2555 {
2556 pAdapter->StaCfg.DefaultKeyId = keyIdx;
2557 DBGPRINT(RT_DEBUG_TRACE, ("%s::DefaultKeyId = %d\n", __func__, pAdapter->StaCfg.DefaultKeyId));
2558 }
2559
2560 switch (alg) {
2561 case IW_ENCODE_ALG_NONE:
2562 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_ENCODE_ALG_NONE\n", __func__));
2563 break;
2564 case IW_ENCODE_ALG_WEP:
2565 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_ENCODE_ALG_WEP - ext->key_len = %d, keyIdx = %d\n", __func__, ext->key_len, keyIdx));
2566 if (ext->key_len == MAX_WEP_KEY_SIZE)
2567 {
2568 pAdapter->SharedKey[BSS0][keyIdx].KeyLen = MAX_WEP_KEY_SIZE;
2569 pAdapter->SharedKey[BSS0][keyIdx].CipherAlg = CIPHER_WEP128;
2570 }
2571 else if (ext->key_len == MIN_WEP_KEY_SIZE)
2572 {
2573 pAdapter->SharedKey[BSS0][keyIdx].KeyLen = MIN_WEP_KEY_SIZE;
2574 pAdapter->SharedKey[BSS0][keyIdx].CipherAlg = CIPHER_WEP64;
2575 }
2576 else
2577 return -EINVAL;
2578
2579 NdisZeroMemory(pAdapter->SharedKey[BSS0][keyIdx].Key, 16);
2580 NdisMoveMemory(pAdapter->SharedKey[BSS0][keyIdx].Key, ext->key, ext->key_len);
2581
2582 if (pAdapter->StaCfg.GroupCipher == Ndis802_11GroupWEP40Enabled ||
2583 pAdapter->StaCfg.GroupCipher == Ndis802_11GroupWEP104Enabled)
2584 {
2585 // Set Group key material to Asic
2586 AsicAddSharedKeyEntry(pAdapter, BSS0, keyIdx, pAdapter->SharedKey[BSS0][keyIdx].CipherAlg, pAdapter->SharedKey[BSS0][keyIdx].Key, NULL, NULL);
2587
2588 // Update WCID attribute table and IVEIV table for this group key table
2589 RTMPAddWcidAttributeEntry(pAdapter, BSS0, keyIdx, pAdapter->SharedKey[BSS0][keyIdx].CipherAlg, NULL);
2590
2591 STA_PORT_SECURED(pAdapter);
2592
2593 // Indicate Connected for GUI
2594 pAdapter->IndicateMediaState = NdisMediaStateConnected;
2595 }
2596 break;
2597 case IW_ENCODE_ALG_TKIP:
2598 DBGPRINT(RT_DEBUG_TRACE, ("%s::IW_ENCODE_ALG_TKIP - keyIdx = %d, ext->key_len = %d\n", __func__, keyIdx, ext->key_len));
2599 if (ext->key_len == 32)
2600 {
2601 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
2602 {
2603 fnSetCipherKey(pAdapter, keyIdx, CIPHER_TKIP, FALSE, ext);
2604 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA2)
2605 {
2606 //pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
2607 STA_PORT_SECURED(pAdapter);
2608 }
2609 }
2610 else if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
2611 {
2612 fnSetCipherKey(pAdapter, keyIdx, CIPHER_TKIP, TRUE, ext);
2613
2614 // set 802.1x port control
2615 //pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
2616 STA_PORT_SECURED(pAdapter);
2617 }
2618 }
2619 else
2620 return -EINVAL;
2621 break;
2622 case IW_ENCODE_ALG_CCMP:
2623 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY)
2624 {
2625 fnSetCipherKey(pAdapter, keyIdx, CIPHER_AES, FALSE, ext);
2626 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA2)
2627 //pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
2628 STA_PORT_SECURED(pAdapter);
2629 }
2630 else if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
2631 {
2632 fnSetCipherKey(pAdapter, keyIdx, CIPHER_AES, TRUE, ext);
2633
2634 // set 802.1x port control
2635 //pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
2636 STA_PORT_SECURED(pAdapter);
2637 }
2638 break;
2639 default:
2640 return -EINVAL;
2641 }
2642 }
2643
2644 return 0;
2645 }
2646
2647 int
2648 rt_ioctl_giwencodeext(struct net_device *dev,
2649 struct iw_request_info *info,
2650 union iwreq_data *wrqu, char *extra)
2651 {
2652 PRTMP_ADAPTER pAd = dev->ml_priv;
2653 PCHAR pKey = NULL;
2654 struct iw_point *encoding = &wrqu->encoding;
2655 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
2656 int idx, max_key_len;
2657
2658 DBGPRINT(RT_DEBUG_TRACE ,("===> rt_ioctl_giwencodeext\n"));
2659
2660 max_key_len = encoding->length - sizeof(*ext);
2661 if (max_key_len < 0)
2662 return -EINVAL;
2663
2664 idx = encoding->flags & IW_ENCODE_INDEX;
2665 if (idx)
2666 {
2667 if (idx < 1 || idx > 4)
2668 return -EINVAL;
2669 idx--;
2670
2671 if ((pAd->StaCfg.WepStatus == Ndis802_11Encryption2Enabled) ||
2672 (pAd->StaCfg.WepStatus == Ndis802_11Encryption3Enabled))
2673 {
2674 if (idx != pAd->StaCfg.DefaultKeyId)
2675 {
2676 ext->key_len = 0;
2677 return 0;
2678 }
2679 }
2680 }
2681 else
2682 idx = pAd->StaCfg.DefaultKeyId;
2683
2684 encoding->flags = idx + 1;
2685 memset(ext, 0, sizeof(*ext));
2686
2687 ext->key_len = 0;
2688 switch(pAd->StaCfg.WepStatus) {
2689 case Ndis802_11WEPDisabled:
2690 ext->alg = IW_ENCODE_ALG_NONE;
2691 encoding->flags |= IW_ENCODE_DISABLED;
2692 break;
2693 case Ndis802_11WEPEnabled:
2694 ext->alg = IW_ENCODE_ALG_WEP;
2695 if (pAd->SharedKey[BSS0][idx].KeyLen > max_key_len)
2696 return -E2BIG;
2697 else
2698 {
2699 ext->key_len = pAd->SharedKey[BSS0][idx].KeyLen;
2700 pKey = &(pAd->SharedKey[BSS0][idx].Key[0]);
2701 }
2702 break;
2703 case Ndis802_11Encryption2Enabled:
2704 case Ndis802_11Encryption3Enabled:
2705 if (pAd->StaCfg.WepStatus == Ndis802_11Encryption2Enabled)
2706 ext->alg = IW_ENCODE_ALG_TKIP;
2707 else
2708 ext->alg = IW_ENCODE_ALG_CCMP;
2709
2710 if (max_key_len < 32)
2711 return -E2BIG;
2712 else
2713 {
2714 ext->key_len = 32;
2715 pKey = &pAd->StaCfg.PMK[0];
2716 }
2717 break;
2718 default:
2719 return -EINVAL;
2720 }
2721
2722 if (ext->key_len && pKey)
2723 {
2724 encoding->flags |= IW_ENCODE_ENABLED;
2725 memcpy(ext->key, pKey, ext->key_len);
2726 }
2727
2728 return 0;
2729 }
2730
2731 #ifdef SIOCSIWGENIE
2732 int rt_ioctl_siwgenie(struct net_device *dev,
2733 struct iw_request_info *info,
2734 union iwreq_data *wrqu, char *extra)
2735 {
2736 PRTMP_ADAPTER pAd = dev->ml_priv;
2737
2738 if (wrqu->data.length > MAX_LEN_OF_RSNIE ||
2739 (wrqu->data.length && extra == NULL))
2740 return -EINVAL;
2741
2742 if (wrqu->data.length)
2743 {
2744 pAd->StaCfg.RSNIE_Len = wrqu->data.length;
2745 NdisMoveMemory(&pAd->StaCfg.RSN_IE[0], extra, pAd->StaCfg.RSNIE_Len);
2746 }
2747 else
2748 {
2749 pAd->StaCfg.RSNIE_Len = 0;
2750 NdisZeroMemory(&pAd->StaCfg.RSN_IE[0], MAX_LEN_OF_RSNIE);
2751 }
2752
2753 return 0;
2754 }
2755 #endif // SIOCSIWGENIE //
2756
2757 int rt_ioctl_giwgenie(struct net_device *dev,
2758 struct iw_request_info *info,
2759 union iwreq_data *wrqu, char *extra)
2760 {
2761 PRTMP_ADAPTER pAd = dev->ml_priv;
2762
2763 if ((pAd->StaCfg.RSNIE_Len == 0) ||
2764 (pAd->StaCfg.AuthMode < Ndis802_11AuthModeWPA))
2765 {
2766 wrqu->data.length = 0;
2767 return 0;
2768 }
2769
2770 #ifdef NATIVE_WPA_SUPPLICANT_SUPPORT
2771 #ifdef SIOCSIWGENIE
2772 if (pAd->StaCfg.WpaSupplicantUP == WPA_SUPPLICANT_ENABLE)
2773 {
2774 if (wrqu->data.length < pAd->StaCfg.RSNIE_Len)
2775 return -E2BIG;
2776
2777 wrqu->data.length = pAd->StaCfg.RSNIE_Len;
2778 memcpy(extra, &pAd->StaCfg.RSN_IE[0], pAd->StaCfg.RSNIE_Len);
2779 }
2780 else
2781 #endif // SIOCSIWGENIE //
2782 #endif // NATIVE_WPA_SUPPLICANT_SUPPORT //
2783 {
2784 UCHAR RSNIe = IE_WPA;
2785
2786 if (wrqu->data.length < (pAd->StaCfg.RSNIE_Len + 2)) // ID, Len
2787 return -E2BIG;
2788 wrqu->data.length = pAd->StaCfg.RSNIE_Len + 2;
2789
2790 if ((pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK) ||
2791 (pAd->StaCfg.AuthMode == Ndis802_11AuthModeWPA2))
2792 RSNIe = IE_RSN;
2793
2794 extra[0] = (char)RSNIe;
2795 extra[1] = pAd->StaCfg.RSNIE_Len;
2796 memcpy(extra+2, &pAd->StaCfg.RSN_IE[0], pAd->StaCfg.RSNIE_Len);
2797 }
2798
2799 return 0;
2800 }
2801
2802 int rt_ioctl_siwpmksa(struct net_device *dev,
2803 struct iw_request_info *info,
2804 union iwreq_data *wrqu,
2805 char *extra)
2806 {
2807 PRTMP_ADAPTER pAd = dev->ml_priv;
2808 struct iw_pmksa *pPmksa = (struct iw_pmksa *)wrqu->data.pointer;
2809 INT CachedIdx = 0, idx = 0;
2810
2811 if (pPmksa == NULL)
2812 return -EINVAL;
2813
2814 DBGPRINT(RT_DEBUG_TRACE ,("===> rt_ioctl_siwpmksa\n"));
2815 switch(pPmksa->cmd)
2816 {
2817 case IW_PMKSA_FLUSH:
2818 NdisZeroMemory(pAd->StaCfg.SavedPMK, sizeof(BSSID_INFO)*PMKID_NO);
2819 DBGPRINT(RT_DEBUG_TRACE ,("rt_ioctl_siwpmksa - IW_PMKSA_FLUSH\n"));
2820 break;
2821 case IW_PMKSA_REMOVE:
2822 for (CachedIdx = 0; CachedIdx < pAd->StaCfg.SavedPMKNum; CachedIdx++)
2823 {
2824 // compare the BSSID
2825 if (NdisEqualMemory(pPmksa->bssid.sa_data, pAd->StaCfg.SavedPMK[CachedIdx].BSSID, MAC_ADDR_LEN))
2826 {
2827 NdisZeroMemory(pAd->StaCfg.SavedPMK[CachedIdx].BSSID, MAC_ADDR_LEN);
2828 NdisZeroMemory(pAd->StaCfg.SavedPMK[CachedIdx].PMKID, 16);
2829 for (idx = CachedIdx; idx < (pAd->StaCfg.SavedPMKNum - 1); idx++)
2830 {
2831 NdisMoveMemory(&pAd->StaCfg.SavedPMK[idx].BSSID[0], &pAd->StaCfg.SavedPMK[idx+1].BSSID[0], MAC_ADDR_LEN);
2832 NdisMoveMemory(&pAd->StaCfg.SavedPMK[idx].PMKID[0], &pAd->StaCfg.SavedPMK[idx+1].PMKID[0], 16);
2833 }
2834 pAd->StaCfg.SavedPMKNum--;
2835 break;
2836 }
2837 }
2838
2839 DBGPRINT(RT_DEBUG_TRACE ,("rt_ioctl_siwpmksa - IW_PMKSA_REMOVE\n"));
2840 break;
2841 case IW_PMKSA_ADD:
2842 for (CachedIdx = 0; CachedIdx < pAd->StaCfg.SavedPMKNum; CachedIdx++)
2843 {
2844 // compare the BSSID
2845 if (NdisEqualMemory(pPmksa->bssid.sa_data, pAd->StaCfg.SavedPMK[CachedIdx].BSSID, MAC_ADDR_LEN))
2846 break;
2847 }
2848
2849 // Found, replace it
2850 if (CachedIdx < PMKID_NO)
2851 {
2852 DBGPRINT(RT_DEBUG_OFF, ("Update PMKID, idx = %d\n", CachedIdx));
2853 NdisMoveMemory(&pAd->StaCfg.SavedPMK[CachedIdx].BSSID[0], pPmksa->bssid.sa_data, MAC_ADDR_LEN);
2854 NdisMoveMemory(&pAd->StaCfg.SavedPMK[CachedIdx].PMKID[0], pPmksa->pmkid, 16);
2855 pAd->StaCfg.SavedPMKNum++;
2856 }
2857 // Not found, replace the last one
2858 else
2859 {
2860 // Randomly replace one
2861 CachedIdx = (pPmksa->bssid.sa_data[5] % PMKID_NO);
2862 DBGPRINT(RT_DEBUG_OFF, ("Update PMKID, idx = %d\n", CachedIdx));
2863 NdisMoveMemory(&pAd->StaCfg.SavedPMK[CachedIdx].BSSID[0], pPmksa->bssid.sa_data, MAC_ADDR_LEN);
2864 NdisMoveMemory(&pAd->StaCfg.SavedPMK[CachedIdx].PMKID[0], pPmksa->pmkid, 16);
2865 }
2866
2867 DBGPRINT(RT_DEBUG_TRACE ,("rt_ioctl_siwpmksa - IW_PMKSA_ADD\n"));
2868 break;
2869 default:
2870 DBGPRINT(RT_DEBUG_TRACE ,("rt_ioctl_siwpmksa - Unknow Command!!\n"));
2871 break;
2872 }
2873
2874 return 0;
2875 }
2876 #endif // #if WIRELESS_EXT > 17
2877
2878 #ifdef DBG
2879 static int
2880 rt_private_ioctl_bbp(struct net_device *dev, struct iw_request_info *info,
2881 struct iw_point *wrq, char *extra)
2882 {
2883 CHAR *this_char;
2884 CHAR *value = NULL;
2885 UCHAR regBBP = 0;
2886 // CHAR arg[255]={0};
2887 UINT32 bbpId;
2888 UINT32 bbpValue;
2889 BOOLEAN bIsPrintAllBBP = FALSE;
2890 INT Status = 0;
2891 PRTMP_ADAPTER pAdapter = dev->ml_priv;
2892
2893
2894 memset(extra, 0x00, IW_PRIV_SIZE_MASK);
2895
2896 if (wrq->length > 1) //No parameters.
2897 {
2898 sprintf(extra, "\n");
2899
2900 //Parsing Read or Write
2901 this_char = wrq->pointer;
2902 DBGPRINT(RT_DEBUG_TRACE, ("this_char=%s\n", this_char));
2903 if (!*this_char)
2904 goto next;
2905
2906 if ((value = rtstrchr(this_char, '=')) != NULL)
2907 *value++ = 0;
2908
2909 if (!value || !*value)
2910 { //Read
2911 DBGPRINT(RT_DEBUG_TRACE, ("this_char=%s, value=%s\n", this_char, value));
2912 if (sscanf(this_char, "%d", &(bbpId)) == 1)
2913 {
2914 if (bbpId <= 136)
2915 {
2916 #ifdef RALINK_ATE
2917 if (ATE_ON(pAdapter))
2918 {
2919 ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, bbpId, &regBBP);
2920 }
2921 else
2922 #endif // RALINK_ATE //
2923 {
2924 RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, bbpId, &regBBP);
2925 }
2926 sprintf(extra+strlen(extra), "R%02d[0x%02X]:%02X\n", bbpId, bbpId*2, regBBP);
2927 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2928 DBGPRINT(RT_DEBUG_TRACE, ("msg=%s\n", extra));
2929 }
2930 else
2931 {//Invalid parametes, so default printk all bbp
2932 bIsPrintAllBBP = TRUE;
2933 goto next;
2934 }
2935 }
2936 else
2937 { //Invalid parametes, so default printk all bbp
2938 bIsPrintAllBBP = TRUE;
2939 goto next;
2940 }
2941 }
2942 else
2943 { //Write
2944 if ((sscanf(this_char, "%d", &(bbpId)) == 1) && (sscanf(value, "%x", &(bbpValue)) == 1))
2945 {
2946 if (bbpId <= 136)
2947 {
2948 #ifdef RALINK_ATE
2949 if (ATE_ON(pAdapter))
2950 {
2951 ATE_BBP_IO_WRITE8_BY_REG_ID(pAdapter, bbpId, bbpValue);
2952 //Read it back for showing
2953 ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, bbpId, &regBBP);
2954 }
2955 else
2956 #endif // RALINK_ATE //
2957 {
2958 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, bbpId, bbpValue);
2959 //Read it back for showing
2960 RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, bbpId, &regBBP);
2961 }
2962 sprintf(extra+strlen(extra), "R%02d[0x%02X]:%02X\n", bbpId, bbpId*2, regBBP);
2963 wrq->length = strlen(extra) + 1; // 1: size of '\0'
2964 DBGPRINT(RT_DEBUG_TRACE, ("msg=%s\n", extra));
2965 }
2966 else
2967 {//Invalid parametes, so default printk all bbp
2968 bIsPrintAllBBP = TRUE;
2969 goto next;
2970 }
2971 }
2972 else
2973 { //Invalid parametes, so default printk all bbp
2974 bIsPrintAllBBP = TRUE;
2975 goto next;
2976 }
2977 }
2978 }
2979 else
2980 bIsPrintAllBBP = TRUE;
2981
2982 next:
2983 if (bIsPrintAllBBP)
2984 {
2985 memset(extra, 0x00, IW_PRIV_SIZE_MASK);
2986 sprintf(extra, "\n");
2987 for (bbpId = 0; bbpId <= 136; bbpId++)
2988 {
2989 if (strlen(extra) >= (IW_PRIV_SIZE_MASK - 10))
2990 break;
2991 #ifdef RALINK_ATE
2992 if (ATE_ON(pAdapter))
2993 {
2994 ATE_BBP_IO_READ8_BY_REG_ID(pAdapter, bbpId, &regBBP);
2995 }
2996 else
2997 #endif // RALINK_ATE //
2998 RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, bbpId, &regBBP);
2999 sprintf(extra+strlen(extra), "R%02d[0x%02X]:%02X ", bbpId, bbpId*2, regBBP);
3000 if (bbpId%5 == 4)
3001 sprintf(extra+strlen(extra), "\n");
3002 }
3003
3004 wrq->length = strlen(extra) + 1; // 1: size of '\0'
3005 DBGPRINT(RT_DEBUG_TRACE, ("wrq->length = %d\n", wrq->length));
3006 }
3007
3008 DBGPRINT(RT_DEBUG_TRACE, ("<==rt_private_ioctl_bbp\n\n"));
3009
3010 return Status;
3011 }
3012 #endif // DBG //
3013
3014 int rt_ioctl_siwrate(struct net_device *dev,
3015 struct iw_request_info *info,
3016 union iwreq_data *wrqu, char *extra)
3017 {
3018 PRTMP_ADAPTER pAd = dev->ml_priv;
3019 UINT32 rate = wrqu->bitrate.value, fixed = wrqu->bitrate.fixed;
3020
3021 //check if the interface is down
3022 if(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_INTERRUPT_IN_USE))
3023 {
3024 DBGPRINT(RT_DEBUG_TRACE, ("rt_ioctl_siwrate::Network is down!\n"));
3025 return -ENETDOWN;
3026 }
3027
3028 DBGPRINT(RT_DEBUG_TRACE, ("rt_ioctl_siwrate::(rate = %d, fixed = %d)\n", rate, fixed));
3029 /* rate = -1 => auto rate
3030 rate = X, fixed = 1 => (fixed rate X)
3031 */
3032 if (rate == -1)
3033 {
3034 //Auto Rate
3035 pAd->StaCfg.DesiredTransmitSetting.field.MCS = MCS_AUTO;
3036 pAd->StaCfg.bAutoTxRateSwitch = TRUE;
3037 if ((pAd->CommonCfg.PhyMode <= PHY_11G) ||
3038 (pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.MODE <= MODE_OFDM))
3039 RTMPSetDesiredRates(pAd, -1);
3040
3041 #ifdef DOT11_N_SUPPORT
3042 SetCommonHT(pAd);
3043 #endif // DOT11_N_SUPPORT //
3044 }
3045 else
3046 {
3047 if (fixed)
3048 {
3049 pAd->StaCfg.bAutoTxRateSwitch = FALSE;
3050 if ((pAd->CommonCfg.PhyMode <= PHY_11G) ||
3051 (pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.MODE <= MODE_OFDM))
3052 RTMPSetDesiredRates(pAd, rate);
3053 else
3054 {
3055 pAd->StaCfg.DesiredTransmitSetting.field.MCS = MCS_AUTO;
3056 #ifdef DOT11_N_SUPPORT
3057 SetCommonHT(pAd);
3058 #endif // DOT11_N_SUPPORT //
3059 }
3060 DBGPRINT(RT_DEBUG_TRACE, ("rt_ioctl_siwrate::(HtMcs=%d)\n",pAd->StaCfg.DesiredTransmitSetting.field.MCS));
3061 }
3062 else
3063 {
3064 // TODO: rate = X, fixed = 0 => (rates <= X)
3065 return -EOPNOTSUPP;
3066 }
3067 }
3068
3069 return 0;
3070 }
3071
3072 int rt_ioctl_giwrate(struct net_device *dev,
3073 struct iw_request_info *info,
3074 union iwreq_data *wrqu, char *extra)
3075 {
3076 PRTMP_ADAPTER pAd = dev->ml_priv;
3077 int rate_index = 0, rate_count = 0;
3078 HTTRANSMIT_SETTING ht_setting;
3079 __s32 ralinkrate[] =
3080 {2, 4, 11, 22, // CCK
3081 12, 18, 24, 36, 48, 72, 96, 108, // OFDM
3082 13, 26, 39, 52, 78, 104, 117, 130, 26, 52, 78, 104, 156, 208, 234, 260, // 20MHz, 800ns GI, MCS: 0 ~ 15
3083 39, 78, 117, 156, 234, 312, 351, 390, // 20MHz, 800ns GI, MCS: 16 ~ 23
3084 27, 54, 81, 108, 162, 216, 243, 270, 54, 108, 162, 216, 324, 432, 486, 540, // 40MHz, 800ns GI, MCS: 0 ~ 15
3085 81, 162, 243, 324, 486, 648, 729, 810, // 40MHz, 800ns GI, MCS: 16 ~ 23
3086 14, 29, 43, 57, 87, 115, 130, 144, 29, 59, 87, 115, 173, 230, 260, 288, // 20MHz, 400ns GI, MCS: 0 ~ 15
3087 43, 87, 130, 173, 260, 317, 390, 433, // 20MHz, 400ns GI, MCS: 16 ~ 23
3088 30, 60, 90, 120, 180, 240, 270, 300, 60, 120, 180, 240, 360, 480, 540, 600, // 40MHz, 400ns GI, MCS: 0 ~ 15
3089 90, 180, 270, 360, 540, 720, 810, 900}; // 40MHz, 400ns GI, MCS: 16 ~ 23
3090
3091 rate_count = sizeof(ralinkrate)/sizeof(__s32);
3092 //check if the interface is down
3093 if(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_INTERRUPT_IN_USE))
3094 {
3095 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
3096 return -ENETDOWN;
3097 }
3098
3099 if ((pAd->StaCfg.bAutoTxRateSwitch == FALSE) &&
3100 (INFRA_ON(pAd)) &&
3101 ((pAd->CommonCfg.PhyMode <= PHY_11G) || (pAd->MacTab.Content[BSSID_WCID].HTPhyMode.field.MODE <= MODE_OFDM)))
3102 ht_setting.word = pAd->StaCfg.HTPhyMode.word;
3103 else
3104 ht_setting.word = pAd->MacTab.Content[BSSID_WCID].HTPhyMode.word;
3105
3106 #ifdef DOT11_N_SUPPORT
3107 if (ht_setting.field.MODE >= MODE_HTMIX)
3108 {
3109 // rate_index = 12 + ((UCHAR)ht_setting.field.BW *16) + ((UCHAR)ht_setting.field.ShortGI *32) + ((UCHAR)ht_setting.field.MCS);
3110 rate_index = 12 + ((UCHAR)ht_setting.field.BW *24) + ((UCHAR)ht_setting.field.ShortGI *48) + ((UCHAR)ht_setting.field.MCS);
3111 }
3112 else
3113 #endif // DOT11_N_SUPPORT //
3114 if (ht_setting.field.MODE == MODE_OFDM)
3115 rate_index = (UCHAR)(ht_setting.field.MCS) + 4;
3116 else if (ht_setting.field.MODE == MODE_CCK)
3117 rate_index = (UCHAR)(ht_setting.field.MCS);
3118
3119 if (rate_index < 0)
3120 rate_index = 0;
3121
3122 if (rate_index > rate_count)
3123 rate_index = rate_count;
3124
3125 wrqu->bitrate.value = ralinkrate[rate_index] * 500000;
3126 wrqu->bitrate.disabled = 0;
3127
3128 return 0;
3129 }
3130
3131 static const iw_handler rt_handler[] =
3132 {
3133 (iw_handler) NULL, /* SIOCSIWCOMMIT */
3134 (iw_handler) rt_ioctl_giwname, /* SIOCGIWNAME */
3135 (iw_handler) NULL, /* SIOCSIWNWID */
3136 (iw_handler) NULL, /* SIOCGIWNWID */
3137 (iw_handler) rt_ioctl_siwfreq, /* SIOCSIWFREQ */
3138 (iw_handler) rt_ioctl_giwfreq, /* SIOCGIWFREQ */
3139 (iw_handler) rt_ioctl_siwmode, /* SIOCSIWMODE */
3140 (iw_handler) rt_ioctl_giwmode, /* SIOCGIWMODE */
3141 (iw_handler) NULL, /* SIOCSIWSENS */
3142 (iw_handler) NULL, /* SIOCGIWSENS */
3143 (iw_handler) NULL /* not used */, /* SIOCSIWRANGE */
3144 (iw_handler) rt_ioctl_giwrange, /* SIOCGIWRANGE */
3145 (iw_handler) NULL /* not used */, /* SIOCSIWPRIV */
3146 (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */
3147 (iw_handler) NULL /* not used */, /* SIOCSIWSTATS */
3148 (iw_handler) rt28xx_get_wireless_stats /* kernel code */, /* SIOCGIWSTATS */
3149 (iw_handler) NULL, /* SIOCSIWSPY */
3150 (iw_handler) NULL, /* SIOCGIWSPY */
3151 (iw_handler) NULL, /* SIOCSIWTHRSPY */
3152 (iw_handler) NULL, /* SIOCGIWTHRSPY */
3153 (iw_handler) rt_ioctl_siwap, /* SIOCSIWAP */
3154 (iw_handler) rt_ioctl_giwap, /* SIOCGIWAP */
3155 #ifdef SIOCSIWMLME
3156 (iw_handler) rt_ioctl_siwmlme, /* SIOCSIWMLME */
3157 #else
3158 (iw_handler) NULL, /* SIOCSIWMLME */
3159 #endif // SIOCSIWMLME //
3160 (iw_handler) rt_ioctl_iwaplist, /* SIOCGIWAPLIST */
3161 #ifdef SIOCGIWSCAN
3162 (iw_handler) rt_ioctl_siwscan, /* SIOCSIWSCAN */
3163 (iw_handler) rt_ioctl_giwscan, /* SIOCGIWSCAN */
3164 #else
3165 (iw_handler) NULL, /* SIOCSIWSCAN */
3166 (iw_handler) NULL, /* SIOCGIWSCAN */
3167 #endif /* SIOCGIWSCAN */
3168 (iw_handler) rt_ioctl_siwessid, /* SIOCSIWESSID */
3169 (iw_handler) rt_ioctl_giwessid, /* SIOCGIWESSID */
3170 (iw_handler) rt_ioctl_siwnickn, /* SIOCSIWNICKN */
3171 (iw_handler) rt_ioctl_giwnickn, /* SIOCGIWNICKN */
3172 (iw_handler) NULL, /* -- hole -- */
3173 (iw_handler) NULL, /* -- hole -- */
3174 (iw_handler) rt_ioctl_siwrate, /* SIOCSIWRATE */
3175 (iw_handler) rt_ioctl_giwrate, /* SIOCGIWRATE */
3176 (iw_handler) rt_ioctl_siwrts, /* SIOCSIWRTS */
3177 (iw_handler) rt_ioctl_giwrts, /* SIOCGIWRTS */
3178 (iw_handler) rt_ioctl_siwfrag, /* SIOCSIWFRAG */
3179 (iw_handler) rt_ioctl_giwfrag, /* SIOCGIWFRAG */
3180 (iw_handler) NULL, /* SIOCSIWTXPOW */
3181 (iw_handler) NULL, /* SIOCGIWTXPOW */
3182 (iw_handler) NULL, /* SIOCSIWRETRY */
3183 (iw_handler) NULL, /* SIOCGIWRETRY */
3184 (iw_handler) rt_ioctl_siwencode, /* SIOCSIWENCODE */
3185 (iw_handler) rt_ioctl_giwencode, /* SIOCGIWENCODE */
3186 (iw_handler) NULL, /* SIOCSIWPOWER */
3187 (iw_handler) NULL, /* SIOCGIWPOWER */
3188 (iw_handler) NULL, /* -- hole -- */
3189 (iw_handler) NULL, /* -- hole -- */
3190 #if WIRELESS_EXT > 17
3191 (iw_handler) rt_ioctl_siwgenie, /* SIOCSIWGENIE */
3192 (iw_handler) rt_ioctl_giwgenie, /* SIOCGIWGENIE */
3193 (iw_handler) rt_ioctl_siwauth, /* SIOCSIWAUTH */
3194 (iw_handler) rt_ioctl_giwauth, /* SIOCGIWAUTH */
3195 (iw_handler) rt_ioctl_siwencodeext, /* SIOCSIWENCODEEXT */
3196 (iw_handler) rt_ioctl_giwencodeext, /* SIOCGIWENCODEEXT */
3197 (iw_handler) rt_ioctl_siwpmksa, /* SIOCSIWPMKSA */
3198 #endif
3199 };
3200
3201 static const iw_handler rt_priv_handlers[] = {
3202 (iw_handler) NULL, /* + 0x00 */
3203 (iw_handler) NULL, /* + 0x01 */
3204 #ifndef CONFIG_AP_SUPPORT
3205 (iw_handler) rt_ioctl_setparam, /* + 0x02 */
3206 #else
3207 (iw_handler) NULL, /* + 0x02 */
3208 #endif // CONFIG_AP_SUPPORT //
3209 #ifdef DBG
3210 (iw_handler) rt_private_ioctl_bbp, /* + 0x03 */
3211 #else
3212 (iw_handler) NULL, /* + 0x03 */
3213 #endif
3214 (iw_handler) NULL, /* + 0x04 */
3215 (iw_handler) NULL, /* + 0x05 */
3216 (iw_handler) NULL, /* + 0x06 */
3217 (iw_handler) NULL, /* + 0x07 */
3218 (iw_handler) NULL, /* + 0x08 */
3219 (iw_handler) rt_private_get_statistics, /* + 0x09 */
3220 (iw_handler) NULL, /* + 0x0A */
3221 (iw_handler) NULL, /* + 0x0B */
3222 (iw_handler) NULL, /* + 0x0C */
3223 (iw_handler) NULL, /* + 0x0D */
3224 (iw_handler) NULL, /* + 0x0E */
3225 (iw_handler) NULL, /* + 0x0F */
3226 (iw_handler) NULL, /* + 0x10 */
3227 (iw_handler) rt_private_show, /* + 0x11 */
3228 (iw_handler) NULL, /* + 0x12 */
3229 (iw_handler) NULL, /* + 0x13 */
3230 (iw_handler) NULL, /* + 0x15 */
3231 (iw_handler) NULL, /* + 0x17 */
3232 (iw_handler) NULL, /* + 0x18 */
3233 };
3234
3235 const struct iw_handler_def rt28xx_iw_handler_def =
3236 {
3237 #define N(a) (sizeof (a) / sizeof (a[0]))
3238 .standard = (iw_handler *) rt_handler,
3239 .num_standard = sizeof(rt_handler) / sizeof(iw_handler),
3240 .private = (iw_handler *) rt_priv_handlers,
3241 .num_private = N(rt_priv_handlers),
3242 .private_args = (struct iw_priv_args *) privtab,
3243 .num_private_args = N(privtab),
3244 #if IW_HANDLER_VERSION >= 7
3245 .get_wireless_stats = rt28xx_get_wireless_stats,
3246 #endif
3247 };
3248
3249 INT RTMPSetInformation(
3250 IN PRTMP_ADAPTER pAdapter,
3251 IN OUT struct ifreq *rq,
3252 IN INT cmd)
3253 {
3254 struct iwreq *wrq = (struct iwreq *) rq;
3255 NDIS_802_11_SSID Ssid;
3256 NDIS_802_11_MAC_ADDRESS Bssid;
3257 RT_802_11_PHY_MODE PhyMode;
3258 RT_802_11_STA_CONFIG StaConfig;
3259 NDIS_802_11_RATES aryRates;
3260 RT_802_11_PREAMBLE Preamble;
3261 NDIS_802_11_WEP_STATUS WepStatus;
3262 NDIS_802_11_AUTHENTICATION_MODE AuthMode = Ndis802_11AuthModeMax;
3263 NDIS_802_11_NETWORK_INFRASTRUCTURE BssType;
3264 NDIS_802_11_RTS_THRESHOLD RtsThresh;
3265 NDIS_802_11_FRAGMENTATION_THRESHOLD FragThresh;
3266 NDIS_802_11_POWER_MODE PowerMode;
3267 PNDIS_802_11_KEY pKey = NULL;
3268 PNDIS_802_11_WEP pWepKey =NULL;
3269 PNDIS_802_11_REMOVE_KEY pRemoveKey = NULL;
3270 NDIS_802_11_CONFIGURATION Config, *pConfig = NULL;
3271 NDIS_802_11_NETWORK_TYPE NetType;
3272 ULONG Now;
3273 UINT KeyIdx = 0;
3274 INT Status = NDIS_STATUS_SUCCESS, MaxPhyMode = PHY_11G;
3275 ULONG PowerTemp;
3276 BOOLEAN RadioState;
3277 BOOLEAN StateMachineTouched = FALSE;
3278 #ifdef DOT11_N_SUPPORT
3279 OID_SET_HT_PHYMODE HT_PhyMode; //11n ,kathy
3280 #endif // DOT11_N_SUPPORT //
3281 #ifdef WPA_SUPPLICANT_SUPPORT
3282 PNDIS_802_11_PMKID pPmkId = NULL;
3283 BOOLEAN IEEE8021xState = FALSE;
3284 BOOLEAN IEEE8021x_required_keys = FALSE;
3285 UCHAR wpa_supplicant_enable = 0;
3286 #endif // WPA_SUPPLICANT_SUPPORT //
3287
3288 #ifdef SNMP_SUPPORT
3289 TX_RTY_CFG_STRUC tx_rty_cfg;
3290 ULONG ShortRetryLimit, LongRetryLimit;
3291 UCHAR ctmp;
3292 #endif // SNMP_SUPPORT //
3293
3294
3295
3296 #ifdef DOT11_N_SUPPORT
3297 MaxPhyMode = PHY_11N_5G;
3298 #endif // DOT11_N_SUPPORT //
3299
3300
3301 DBGPRINT(RT_DEBUG_TRACE, ("-->RTMPSetInformation(), 0x%08x\n", cmd&0x7FFF));
3302 switch(cmd & 0x7FFF) {
3303 case RT_OID_802_11_COUNTRY_REGION:
3304 if (wrq->u.data.length < sizeof(UCHAR))
3305 Status = -EINVAL;
3306 // Only avaliable when EEPROM not programming
3307 else if (!(pAdapter->CommonCfg.CountryRegion & 0x80) && !(pAdapter->CommonCfg.CountryRegionForABand & 0x80))
3308 {
3309 ULONG Country;
3310 UCHAR TmpPhy;
3311
3312 Status = copy_from_user(&Country, wrq->u.data.pointer, wrq->u.data.length);
3313 pAdapter->CommonCfg.CountryRegion = (UCHAR)(Country & 0x000000FF);
3314 pAdapter->CommonCfg.CountryRegionForABand = (UCHAR)((Country >> 8) & 0x000000FF);
3315 TmpPhy = pAdapter->CommonCfg.PhyMode;
3316 pAdapter->CommonCfg.PhyMode = 0xff;
3317 // Build all corresponding channel information
3318 RTMPSetPhyMode(pAdapter, TmpPhy);
3319 #ifdef DOT11_N_SUPPORT
3320 SetCommonHT(pAdapter);
3321 #endif // DOT11_N_SUPPORT //
3322 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_COUNTRY_REGION (A:%d B/G:%d)\n", pAdapter->CommonCfg.CountryRegionForABand,
3323 pAdapter->CommonCfg.CountryRegion));
3324 }
3325 break;
3326 case OID_802_11_BSSID_LIST_SCAN:
3327 #ifdef RALINK_ATE
3328 if (ATE_ON(pAdapter))
3329 {
3330 DBGPRINT(RT_DEBUG_TRACE, ("The driver is in ATE mode now\n"));
3331 break;
3332 }
3333 #endif // RALINK_ATE //
3334 Now = jiffies;
3335 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_BSSID_LIST_SCAN, TxCnt = %d \n", pAdapter->RalinkCounters.LastOneSecTotalTxCount));
3336
3337 if (MONITOR_ON(pAdapter))
3338 {
3339 DBGPRINT(RT_DEBUG_TRACE, ("!!! Driver is in Monitor Mode now !!!\n"));
3340 break;
3341 }
3342
3343 //Benson add 20080527, when radio off, sta don't need to scan
3344 if (RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_RADIO_OFF))
3345 break;
3346
3347 if (RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
3348 {
3349 DBGPRINT(RT_DEBUG_TRACE, ("!!! Driver is scanning now !!!\n"));
3350 pAdapter->StaCfg.bScanReqIsFromWebUI = TRUE;
3351 Status = NDIS_STATUS_SUCCESS;
3352 break;
3353 }
3354
3355 if (pAdapter->RalinkCounters.LastOneSecTotalTxCount > 100)
3356 {
3357 DBGPRINT(RT_DEBUG_TRACE, ("!!! Link UP, ignore this set::OID_802_11_BSSID_LIST_SCAN\n"));
3358 Status = NDIS_STATUS_SUCCESS;
3359 pAdapter->StaCfg.ScanCnt = 99; // Prevent auto scan triggered by this OID
3360 break;
3361 }
3362
3363 if ((OPSTATUS_TEST_FLAG(pAdapter, fOP_STATUS_MEDIA_STATE_CONNECTED)) &&
3364 ((pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPA) ||
3365 (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK) ||
3366 (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPA2) ||
3367 (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK)) &&
3368 (pAdapter->StaCfg.PortSecured == WPA_802_1X_PORT_NOT_SECURED))
3369 {
3370 DBGPRINT(RT_DEBUG_TRACE, ("!!! Link UP, Port Not Secured! ignore this set::OID_802_11_BSSID_LIST_SCAN\n"));
3371 Status = NDIS_STATUS_SUCCESS;
3372 pAdapter->StaCfg.ScanCnt = 99; // Prevent auto scan triggered by this OID
3373 break;
3374 }
3375
3376
3377 if (pAdapter->Mlme.CntlMachine.CurrState != CNTL_IDLE)
3378 {
3379 RT28XX_MLME_RESET_STATE_MACHINE(pAdapter);
3380 DBGPRINT(RT_DEBUG_TRACE, ("!!! MLME busy, reset MLME state machine !!!\n"));
3381 }
3382
3383 // tell CNTL state machine to call NdisMSetInformationComplete() after completing
3384 // this request, because this request is initiated by NDIS.
3385 pAdapter->MlmeAux.CurrReqIsFromNdis = FALSE;
3386 // Reset allowed scan retries
3387 pAdapter->StaCfg.ScanCnt = 0;
3388 pAdapter->StaCfg.LastScanTime = Now;
3389
3390 pAdapter->StaCfg.bScanReqIsFromWebUI = TRUE;
3391 RTMP_SET_FLAG(pAdapter, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS);
3392 MlmeEnqueue(pAdapter,
3393 MLME_CNTL_STATE_MACHINE,
3394 OID_802_11_BSSID_LIST_SCAN,
3395 0,
3396 NULL);
3397
3398 Status = NDIS_STATUS_SUCCESS;
3399 StateMachineTouched = TRUE;
3400 break;
3401 case OID_802_11_SSID:
3402 if (wrq->u.data.length != sizeof(NDIS_802_11_SSID))
3403 Status = -EINVAL;
3404 else
3405 {
3406 PCHAR pSsidString = NULL;
3407 Status = copy_from_user(&Ssid, wrq->u.data.pointer, wrq->u.data.length);
3408
3409 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_SSID (Len=%d,Ssid=%s)\n", Ssid.SsidLength, Ssid.Ssid));
3410 if (Ssid.SsidLength > MAX_LEN_OF_SSID)
3411 Status = -EINVAL;
3412 else
3413 {
3414 if (Ssid.SsidLength == 0)
3415 {
3416 Set_SSID_Proc(pAdapter, "");
3417 }
3418 else
3419 {
3420 pSsidString = (CHAR *) kmalloc(MAX_LEN_OF_SSID+1, MEM_ALLOC_FLAG);
3421 if (pSsidString)
3422 {
3423 NdisZeroMemory(pSsidString, MAX_LEN_OF_SSID+1);
3424 NdisMoveMemory(pSsidString, Ssid.Ssid, Ssid.SsidLength);
3425 Set_SSID_Proc(pAdapter, pSsidString);
3426 kfree(pSsidString);
3427 }
3428 else
3429 Status = -ENOMEM;
3430 }
3431 }
3432 }
3433 break;
3434 case OID_802_11_BSSID:
3435 #ifdef RALINK_ATE
3436 if (ATE_ON(pAdapter))
3437 {
3438 DBGPRINT(RT_DEBUG_TRACE, ("The driver is in ATE mode now\n"));
3439 break;
3440 }
3441 #endif // RALINK_ATE //
3442 if (wrq->u.data.length != sizeof(NDIS_802_11_MAC_ADDRESS))
3443 Status = -EINVAL;
3444 else
3445 {
3446 Status = copy_from_user(&Bssid, wrq->u.data.pointer, wrq->u.data.length);
3447
3448 // tell CNTL state machine to call NdisMSetInformationComplete() after completing
3449 // this request, because this request is initiated by NDIS.
3450 pAdapter->MlmeAux.CurrReqIsFromNdis = FALSE;
3451
3452 // Prevent to connect AP again in STAMlmePeriodicExec
3453 pAdapter->MlmeAux.AutoReconnectSsidLen= 32;
3454
3455 // Reset allowed scan retries
3456 pAdapter->StaCfg.ScanCnt = 0;
3457
3458 if (pAdapter->Mlme.CntlMachine.CurrState != CNTL_IDLE)
3459 {
3460 RT28XX_MLME_RESET_STATE_MACHINE(pAdapter);
3461 DBGPRINT(RT_DEBUG_TRACE, ("!!! MLME busy, reset MLME state machine !!!\n"));
3462 }
3463 MlmeEnqueue(pAdapter,
3464 MLME_CNTL_STATE_MACHINE,
3465 OID_802_11_BSSID,
3466 sizeof(NDIS_802_11_MAC_ADDRESS),
3467 (VOID *)&Bssid);
3468 Status = NDIS_STATUS_SUCCESS;
3469 StateMachineTouched = TRUE;
3470
3471 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_BSSID %02x:%02x:%02x:%02x:%02x:%02x\n",
3472 Bssid[0], Bssid[1], Bssid[2], Bssid[3], Bssid[4], Bssid[5]));
3473 }
3474 break;
3475 case RT_OID_802_11_RADIO:
3476 if (wrq->u.data.length != sizeof(BOOLEAN))
3477 Status = -EINVAL;
3478 else
3479 {
3480 Status = copy_from_user(&RadioState, wrq->u.data.pointer, wrq->u.data.length);
3481 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_RADIO (=%d)\n", RadioState));
3482 if (pAdapter->StaCfg.bSwRadio != RadioState)
3483 {
3484 pAdapter->StaCfg.bSwRadio = RadioState;
3485 if (pAdapter->StaCfg.bRadio != (pAdapter->StaCfg.bHwRadio && pAdapter->StaCfg.bSwRadio))
3486 {
3487 pAdapter->StaCfg.bRadio = (pAdapter->StaCfg.bHwRadio && pAdapter->StaCfg.bSwRadio);
3488 if (pAdapter->StaCfg.bRadio == TRUE)
3489 {
3490 MlmeRadioOn(pAdapter);
3491 // Update extra information
3492 pAdapter->ExtraInfo = EXTRA_INFO_CLEAR;
3493 }
3494 else
3495 {
3496 MlmeRadioOff(pAdapter);
3497 // Update extra information
3498 pAdapter->ExtraInfo = SW_RADIO_OFF;
3499 }
3500 }
3501 }
3502 }
3503 break;
3504 case RT_OID_802_11_PHY_MODE:
3505 if (wrq->u.data.length != sizeof(RT_802_11_PHY_MODE))
3506 Status = -EINVAL;
3507 else
3508 {
3509 Status = copy_from_user(&PhyMode, wrq->u.data.pointer, wrq->u.data.length);
3510 if (PhyMode <= MaxPhyMode)
3511 {
3512 RTMPSetPhyMode(pAdapter, PhyMode);
3513 #ifdef DOT11_N_SUPPORT
3514 SetCommonHT(pAdapter);
3515 #endif // DOT11_N_SUPPORT //
3516 }
3517 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_PHY_MODE (=%d)\n", PhyMode));
3518 }
3519 break;
3520 case RT_OID_802_11_STA_CONFIG:
3521 if (wrq->u.data.length != sizeof(RT_802_11_STA_CONFIG))
3522 Status = -EINVAL;
3523 else
3524 {
3525 Status = copy_from_user(&StaConfig, wrq->u.data.pointer, wrq->u.data.length);
3526 pAdapter->CommonCfg.bEnableTxBurst = StaConfig.EnableTxBurst;
3527 pAdapter->CommonCfg.UseBGProtection = StaConfig.UseBGProtection;
3528 pAdapter->CommonCfg.bUseShortSlotTime = 1; // 2003-10-30 always SHORT SLOT capable
3529 if ((pAdapter->CommonCfg.PhyMode != StaConfig.AdhocMode) &&
3530 (StaConfig.AdhocMode <= MaxPhyMode))
3531 {
3532 // allow dynamic change of "USE OFDM rate or not" in ADHOC mode
3533 // if setting changed, need to reset current TX rate as well as BEACON frame format
3534 if (pAdapter->StaCfg.BssType == BSS_ADHOC)
3535 {
3536 pAdapter->CommonCfg.PhyMode = StaConfig.AdhocMode;
3537 RTMPSetPhyMode(pAdapter, PhyMode);
3538 MlmeUpdateTxRates(pAdapter, FALSE, 0);
3539 MakeIbssBeacon(pAdapter); // re-build BEACON frame
3540 AsicEnableIbssSync(pAdapter); // copy to on-chip memory
3541 }
3542 }
3543 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_SET_STA_CONFIG (Burst=%d, Protection=%ld,ShortSlot=%d\n",
3544 pAdapter->CommonCfg.bEnableTxBurst,
3545 pAdapter->CommonCfg.UseBGProtection,
3546 pAdapter->CommonCfg.bUseShortSlotTime));
3547 }
3548 break;
3549 case OID_802_11_DESIRED_RATES:
3550 if (wrq->u.data.length != sizeof(NDIS_802_11_RATES))
3551 Status = -EINVAL;
3552 else
3553 {
3554 Status = copy_from_user(&aryRates, wrq->u.data.pointer, wrq->u.data.length);
3555 NdisZeroMemory(pAdapter->CommonCfg.DesireRate, MAX_LEN_OF_SUPPORTED_RATES);
3556 NdisMoveMemory(pAdapter->CommonCfg.DesireRate, &aryRates, sizeof(NDIS_802_11_RATES));
3557 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_DESIRED_RATES (%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x)\n",
3558 pAdapter->CommonCfg.DesireRate[0],pAdapter->CommonCfg.DesireRate[1],
3559 pAdapter->CommonCfg.DesireRate[2],pAdapter->CommonCfg.DesireRate[3],
3560 pAdapter->CommonCfg.DesireRate[4],pAdapter->CommonCfg.DesireRate[5],
3561 pAdapter->CommonCfg.DesireRate[6],pAdapter->CommonCfg.DesireRate[7] ));
3562 // Changing DesiredRate may affect the MAX TX rate we used to TX frames out
3563 MlmeUpdateTxRates(pAdapter, FALSE, 0);
3564 }
3565 break;
3566 case RT_OID_802_11_PREAMBLE:
3567 if (wrq->u.data.length != sizeof(RT_802_11_PREAMBLE))
3568 Status = -EINVAL;
3569 else
3570 {
3571 Status = copy_from_user(&Preamble, wrq->u.data.pointer, wrq->u.data.length);
3572 if (Preamble == Rt802_11PreambleShort)
3573 {
3574 pAdapter->CommonCfg.TxPreamble = Preamble;
3575 MlmeSetTxPreamble(pAdapter, Rt802_11PreambleShort);
3576 }
3577 else if ((Preamble == Rt802_11PreambleLong) || (Preamble == Rt802_11PreambleAuto))
3578 {
3579 // if user wants AUTO, initialize to LONG here, then change according to AP's
3580 // capability upon association.
3581 pAdapter->CommonCfg.TxPreamble = Preamble;
3582 MlmeSetTxPreamble(pAdapter, Rt802_11PreambleLong);
3583 }
3584 else
3585 {
3586 Status = -EINVAL;
3587 break;
3588 }
3589 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_PREAMBLE (=%d)\n", Preamble));
3590 }
3591 break;
3592 case OID_802_11_WEP_STATUS:
3593 if (wrq->u.data.length != sizeof(NDIS_802_11_WEP_STATUS))
3594 Status = -EINVAL;
3595 else
3596 {
3597 Status = copy_from_user(&WepStatus, wrq->u.data.pointer, wrq->u.data.length);
3598 // Since TKIP, AES, WEP are all supported. It should not have any invalid setting
3599 if (WepStatus <= Ndis802_11Encryption3KeyAbsent)
3600 {
3601 if (pAdapter->StaCfg.WepStatus != WepStatus)
3602 {
3603 // Config has changed
3604 pAdapter->bConfigChanged = TRUE;
3605 }
3606 pAdapter->StaCfg.WepStatus = WepStatus;
3607 pAdapter->StaCfg.OrigWepStatus = WepStatus;
3608 pAdapter->StaCfg.PairCipher = WepStatus;
3609 pAdapter->StaCfg.GroupCipher = WepStatus;
3610 }
3611 else
3612 {
3613 Status = -EINVAL;
3614 break;
3615 }
3616 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_WEP_STATUS (=%d)\n",WepStatus));
3617 }
3618 break;
3619 case OID_802_11_AUTHENTICATION_MODE:
3620 if (wrq->u.data.length != sizeof(NDIS_802_11_AUTHENTICATION_MODE))
3621 Status = -EINVAL;
3622 else
3623 {
3624 Status = copy_from_user(&AuthMode, wrq->u.data.pointer, wrq->u.data.length);
3625 if (AuthMode > Ndis802_11AuthModeMax)
3626 {
3627 Status = -EINVAL;
3628 break;
3629 }
3630 else
3631 {
3632 if (pAdapter->StaCfg.AuthMode != AuthMode)
3633 {
3634 // Config has changed
3635 pAdapter->bConfigChanged = TRUE;
3636 }
3637 pAdapter->StaCfg.AuthMode = AuthMode;
3638 }
3639 pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_NOT_SECURED;
3640 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_AUTHENTICATION_MODE (=%d) \n",pAdapter->StaCfg.AuthMode));
3641 }
3642 break;
3643 case OID_802_11_INFRASTRUCTURE_MODE:
3644 if (wrq->u.data.length != sizeof(NDIS_802_11_NETWORK_INFRASTRUCTURE))
3645 Status = -EINVAL;
3646 else
3647 {
3648 Status = copy_from_user(&BssType, wrq->u.data.pointer, wrq->u.data.length);
3649
3650 if (BssType == Ndis802_11IBSS)
3651 Set_NetworkType_Proc(pAdapter, "Adhoc");
3652 else if (BssType == Ndis802_11Infrastructure)
3653 Set_NetworkType_Proc(pAdapter, "Infra");
3654 else if (BssType == Ndis802_11Monitor)
3655 Set_NetworkType_Proc(pAdapter, "Monitor");
3656 else
3657 {
3658 Status = -EINVAL;
3659 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_INFRASTRUCTURE_MODE (unknown)\n"));
3660 }
3661 }
3662 break;
3663 case OID_802_11_REMOVE_WEP:
3664 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_REMOVE_WEP\n"));
3665 if (wrq->u.data.length != sizeof(NDIS_802_11_KEY_INDEX))
3666 {
3667 Status = -EINVAL;
3668 }
3669 else
3670 {
3671 KeyIdx = *(NDIS_802_11_KEY_INDEX *) wrq->u.data.pointer;
3672
3673 if (KeyIdx & 0x80000000)
3674 {
3675 // Should never set default bit when remove key
3676 Status = -EINVAL;
3677 }
3678 else
3679 {
3680 KeyIdx = KeyIdx & 0x0fffffff;
3681 if (KeyIdx >= 4){
3682 Status = -EINVAL;
3683 }
3684 else
3685 {
3686 pAdapter->SharedKey[BSS0][KeyIdx].KeyLen = 0;
3687 pAdapter->SharedKey[BSS0][KeyIdx].CipherAlg = CIPHER_NONE;
3688 AsicRemoveSharedKeyEntry(pAdapter, 0, (UCHAR)KeyIdx);
3689 }
3690 }
3691 }
3692 break;
3693 case RT_OID_802_11_RESET_COUNTERS:
3694 NdisZeroMemory(&pAdapter->WlanCounters, sizeof(COUNTER_802_11));
3695 NdisZeroMemory(&pAdapter->Counters8023, sizeof(COUNTER_802_3));
3696 NdisZeroMemory(&pAdapter->RalinkCounters, sizeof(COUNTER_RALINK));
3697 pAdapter->Counters8023.RxNoBuffer = 0;
3698 pAdapter->Counters8023.GoodReceives = 0;
3699 pAdapter->Counters8023.RxNoBuffer = 0;
3700 #ifdef RT2870
3701 pAdapter->BulkOutComplete = 0;
3702 pAdapter->BulkOutCompleteOther= 0;
3703 pAdapter->BulkOutCompleteCancel = 0;
3704 pAdapter->BulkOutReq = 0;
3705 pAdapter->BulkInReq= 0;
3706 pAdapter->BulkInComplete = 0;
3707 pAdapter->BulkInCompleteFail = 0;
3708 #endif // RT2870 //
3709 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_RESET_COUNTERS \n"));
3710 break;
3711 case OID_802_11_RTS_THRESHOLD:
3712 if (wrq->u.data.length != sizeof(NDIS_802_11_RTS_THRESHOLD))
3713 Status = -EINVAL;
3714 else
3715 {
3716 Status = copy_from_user(&RtsThresh, wrq->u.data.pointer, wrq->u.data.length);
3717 if (RtsThresh > MAX_RTS_THRESHOLD)
3718 Status = -EINVAL;
3719 else
3720 pAdapter->CommonCfg.RtsThreshold = (USHORT)RtsThresh;
3721 }
3722 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_RTS_THRESHOLD (=%ld)\n",RtsThresh));
3723 break;
3724 case OID_802_11_FRAGMENTATION_THRESHOLD:
3725 if (wrq->u.data.length != sizeof(NDIS_802_11_FRAGMENTATION_THRESHOLD))
3726 Status = -EINVAL;
3727 else
3728 {
3729 Status = copy_from_user(&FragThresh, wrq->u.data.pointer, wrq->u.data.length);
3730 pAdapter->CommonCfg.bUseZeroToDisableFragment = FALSE;
3731 if (FragThresh > MAX_FRAG_THRESHOLD || FragThresh < MIN_FRAG_THRESHOLD)
3732 {
3733 if (FragThresh == 0)
3734 {
3735 pAdapter->CommonCfg.FragmentThreshold = MAX_FRAG_THRESHOLD;
3736 pAdapter->CommonCfg.bUseZeroToDisableFragment = TRUE;
3737 }
3738 else
3739 Status = -EINVAL;
3740 }
3741 else
3742 pAdapter->CommonCfg.FragmentThreshold = (USHORT)FragThresh;
3743 }
3744 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_FRAGMENTATION_THRESHOLD (=%ld) \n",FragThresh));
3745 break;
3746 case OID_802_11_POWER_MODE:
3747 if (wrq->u.data.length != sizeof(NDIS_802_11_POWER_MODE))
3748 Status = -EINVAL;
3749 else
3750 {
3751 Status = copy_from_user(&PowerMode, wrq->u.data.pointer, wrq->u.data.length);
3752 if (PowerMode == Ndis802_11PowerModeCAM)
3753 Set_PSMode_Proc(pAdapter, "CAM");
3754 else if (PowerMode == Ndis802_11PowerModeMAX_PSP)
3755 Set_PSMode_Proc(pAdapter, "Max_PSP");
3756 else if (PowerMode == Ndis802_11PowerModeFast_PSP)
3757 Set_PSMode_Proc(pAdapter, "Fast_PSP");
3758 else if (PowerMode == Ndis802_11PowerModeLegacy_PSP)
3759 Set_PSMode_Proc(pAdapter, "Legacy_PSP");
3760 else
3761 Status = -EINVAL;
3762 }
3763 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_POWER_MODE (=%d)\n",PowerMode));
3764 break;
3765 case RT_OID_802_11_TX_POWER_LEVEL_1:
3766 if (wrq->u.data.length < sizeof(ULONG))
3767 Status = -EINVAL;
3768 else
3769 {
3770 Status = copy_from_user(&PowerTemp, wrq->u.data.pointer, wrq->u.data.length);
3771 if (PowerTemp > 100)
3772 PowerTemp = 0xffffffff; // AUTO
3773 pAdapter->CommonCfg.TxPowerDefault = PowerTemp; //keep current setting.
3774 pAdapter->CommonCfg.TxPowerPercentage = pAdapter->CommonCfg.TxPowerDefault;
3775 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_TX_POWER_LEVEL_1 (=%ld)\n", pAdapter->CommonCfg.TxPowerPercentage));
3776 }
3777 break;
3778 case OID_802_11_NETWORK_TYPE_IN_USE:
3779 if (wrq->u.data.length != sizeof(NDIS_802_11_NETWORK_TYPE))
3780 Status = -EINVAL;
3781 else
3782 {
3783 Status = copy_from_user(&NetType, wrq->u.data.pointer, wrq->u.data.length);
3784
3785 if (NetType == Ndis802_11DS)
3786 RTMPSetPhyMode(pAdapter, PHY_11B);
3787 else if (NetType == Ndis802_11OFDM24)
3788 RTMPSetPhyMode(pAdapter, PHY_11BG_MIXED);
3789 else if (NetType == Ndis802_11OFDM5)
3790 RTMPSetPhyMode(pAdapter, PHY_11A);
3791 else
3792 Status = -EINVAL;
3793 #ifdef DOT11_N_SUPPORT
3794 if (Status == NDIS_STATUS_SUCCESS)
3795 SetCommonHT(pAdapter);
3796 #endif // DOT11_N_SUPPORT //
3797 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_NETWORK_TYPE_IN_USE (=%d)\n",NetType));
3798 }
3799 break;
3800 // For WPA PSK PMK key
3801 case RT_OID_802_11_ADD_WPA:
3802 pKey = kmalloc(wrq->u.data.length, MEM_ALLOC_FLAG);
3803 if(pKey == NULL)
3804 {
3805 Status = -ENOMEM;
3806 break;
3807 }
3808
3809 Status = copy_from_user(pKey, wrq->u.data.pointer, wrq->u.data.length);
3810 if (pKey->Length != wrq->u.data.length)
3811 {
3812 Status = -EINVAL;
3813 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_ADD_WPA, Failed!!\n"));
3814 }
3815 else
3816 {
3817 if ((pAdapter->StaCfg.AuthMode != Ndis802_11AuthModeWPAPSK) &&
3818 (pAdapter->StaCfg.AuthMode != Ndis802_11AuthModeWPA2PSK) &&
3819 (pAdapter->StaCfg.AuthMode != Ndis802_11AuthModeWPANone) )
3820 {
3821 Status = -EOPNOTSUPP;
3822 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_ADD_WPA, Failed!! [AuthMode != WPAPSK/WPA2PSK/WPANONE]\n"));
3823 }
3824 else if ((pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPAPSK) ||
3825 (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPA2PSK) ||
3826 (pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPANone) ) // Only for WPA PSK mode
3827 {
3828 NdisMoveMemory(pAdapter->StaCfg.PMK, &pKey->KeyMaterial, pKey->KeyLength);
3829 // Use RaConfig as PSK agent.
3830 // Start STA supplicant state machine
3831 if (pAdapter->StaCfg.AuthMode != Ndis802_11AuthModeWPANone)
3832 pAdapter->StaCfg.WpaState = SS_START;
3833
3834 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_ADD_WPA (id=0x%x, Len=%d-byte)\n", pKey->KeyIndex, pKey->KeyLength));
3835 }
3836 else
3837 {
3838 pAdapter->StaCfg.WpaState = SS_NOTUSE;
3839 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_ADD_WPA (id=0x%x, Len=%d-byte)\n", pKey->KeyIndex, pKey->KeyLength));
3840 }
3841 }
3842 kfree(pKey);
3843 break;
3844 case OID_802_11_REMOVE_KEY:
3845 pRemoveKey = kmalloc(wrq->u.data.length, MEM_ALLOC_FLAG);
3846 if(pRemoveKey == NULL)
3847 {
3848 Status = -ENOMEM;
3849 break;
3850 }
3851
3852 Status = copy_from_user(pRemoveKey, wrq->u.data.pointer, wrq->u.data.length);
3853 if (pRemoveKey->Length != wrq->u.data.length)
3854 {
3855 Status = -EINVAL;
3856 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_REMOVE_KEY, Failed!!\n"));
3857 }
3858 else
3859 {
3860 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
3861 {
3862 RTMPWPARemoveKeyProc(pAdapter, pRemoveKey);
3863 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_REMOVE_KEY, Remove WPA Key!!\n"));
3864 }
3865 else
3866 {
3867 KeyIdx = pRemoveKey->KeyIndex;
3868
3869 if (KeyIdx & 0x80000000)
3870 {
3871 // Should never set default bit when remove key
3872 Status = -EINVAL;
3873 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_REMOVE_KEY, Failed!!(Should never set default bit when remove key)\n"));
3874 }
3875 else
3876 {
3877 KeyIdx = KeyIdx & 0x0fffffff;
3878 if (KeyIdx > 3)
3879 {
3880 Status = -EINVAL;
3881 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_REMOVE_KEY, Failed!!(KeyId[%d] out of range)\n", KeyIdx));
3882 }
3883 else
3884 {
3885 pAdapter->SharedKey[BSS0][KeyIdx].KeyLen = 0;
3886 pAdapter->SharedKey[BSS0][KeyIdx].CipherAlg = CIPHER_NONE;
3887 AsicRemoveSharedKeyEntry(pAdapter, 0, (UCHAR)KeyIdx);
3888 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_REMOVE_KEY (id=0x%x, Len=%d-byte)\n", pRemoveKey->KeyIndex, pRemoveKey->Length));
3889 }
3890 }
3891 }
3892 }
3893 kfree(pRemoveKey);
3894 break;
3895 // New for WPA
3896 case OID_802_11_ADD_KEY:
3897 pKey = kmalloc(wrq->u.data.length, MEM_ALLOC_FLAG);
3898 if(pKey == NULL)
3899 {
3900 Status = -ENOMEM;
3901 break;
3902 }
3903 Status = copy_from_user(pKey, wrq->u.data.pointer, wrq->u.data.length);
3904 if (pKey->Length != wrq->u.data.length)
3905 {
3906 Status = -EINVAL;
3907 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_ADD_KEY, Failed!!\n"));
3908 }
3909 else
3910 {
3911 RTMPAddKey(pAdapter, pKey);
3912 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_ADD_KEY (id=0x%x, Len=%d-byte)\n", pKey->KeyIndex, pKey->KeyLength));
3913 }
3914 kfree(pKey);
3915 break;
3916 case OID_802_11_CONFIGURATION:
3917 if (wrq->u.data.length != sizeof(NDIS_802_11_CONFIGURATION))
3918 Status = -EINVAL;
3919 else
3920 {
3921 Status = copy_from_user(&Config, wrq->u.data.pointer, wrq->u.data.length);
3922 pConfig = &Config;
3923
3924 if ((pConfig->BeaconPeriod >= 20) && (pConfig->BeaconPeriod <=400))
3925 pAdapter->CommonCfg.BeaconPeriod = (USHORT) pConfig->BeaconPeriod;
3926
3927 pAdapter->StaActive.AtimWin = (USHORT) pConfig->ATIMWindow;
3928 MAP_KHZ_TO_CHANNEL_ID(pConfig->DSConfig, pAdapter->CommonCfg.Channel);
3929 //
3930 // Save the channel on MlmeAux for CntlOidRTBssidProc used.
3931 //
3932 pAdapter->MlmeAux.Channel = pAdapter->CommonCfg.Channel;
3933
3934 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_CONFIGURATION (BeacnPeriod=%ld,AtimW=%ld,Ch=%d)\n",
3935 pConfig->BeaconPeriod, pConfig->ATIMWindow, pAdapter->CommonCfg.Channel));
3936 // Config has changed
3937 pAdapter->bConfigChanged = TRUE;
3938 }
3939 break;
3940 #ifdef DOT11_N_SUPPORT
3941 case RT_OID_802_11_SET_HT_PHYMODE:
3942 if (wrq->u.data.length != sizeof(OID_SET_HT_PHYMODE))
3943 Status = -EINVAL;
3944 else
3945 {
3946 POID_SET_HT_PHYMODE pHTPhyMode = &HT_PhyMode;
3947
3948 Status = copy_from_user(&HT_PhyMode, wrq->u.data.pointer, wrq->u.data.length);
3949 DBGPRINT(RT_DEBUG_TRACE, ("Set::pHTPhyMode (PhyMode = %d,TransmitNo = %d, HtMode = %d, ExtOffset = %d , MCS = %d, BW = %d, STBC = %d, SHORTGI = %d) \n",
3950 pHTPhyMode->PhyMode, pHTPhyMode->TransmitNo,pHTPhyMode->HtMode,pHTPhyMode->ExtOffset,
3951 pHTPhyMode->MCS, pHTPhyMode->BW, pHTPhyMode->STBC, pHTPhyMode->SHORTGI));
3952 if (pAdapter->CommonCfg.PhyMode >= PHY_11ABGN_MIXED)
3953 RTMPSetHT(pAdapter, pHTPhyMode);
3954 }
3955 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_SET_HT_PHYMODE(MCS=%d,BW=%d,SGI=%d,STBC=%d)\n",
3956 pAdapter->StaCfg.HTPhyMode.field.MCS, pAdapter->StaCfg.HTPhyMode.field.BW, pAdapter->StaCfg.HTPhyMode.field.ShortGI,
3957 pAdapter->StaCfg.HTPhyMode.field.STBC));
3958 break;
3959 #endif // DOT11_N_SUPPORT //
3960 case RT_OID_802_11_SET_APSD_SETTING:
3961 if (wrq->u.data.length != sizeof(ULONG))
3962 Status = -EINVAL;
3963 else
3964 {
3965 ULONG apsd ;
3966 Status = copy_from_user(&apsd, wrq->u.data.pointer, wrq->u.data.length);
3967
3968 /*-------------------------------------------------------------------
3969 |B31~B7 | B6~B5 | B4 | B3 | B2 | B1 | B0 |
3970 ---------------------------------------------------------------------
3971 | Rsvd | Max SP Len | AC_VO | AC_VI | AC_BK | AC_BE | APSD Capable |
3972 ---------------------------------------------------------------------*/
3973 pAdapter->CommonCfg.bAPSDCapable = (apsd & 0x00000001) ? TRUE : FALSE;
3974 pAdapter->CommonCfg.bAPSDAC_BE = ((apsd & 0x00000002) >> 1) ? TRUE : FALSE;
3975 pAdapter->CommonCfg.bAPSDAC_BK = ((apsd & 0x00000004) >> 2) ? TRUE : FALSE;
3976 pAdapter->CommonCfg.bAPSDAC_VI = ((apsd & 0x00000008) >> 3) ? TRUE : FALSE;
3977 pAdapter->CommonCfg.bAPSDAC_VO = ((apsd & 0x00000010) >> 4) ? TRUE : FALSE;
3978 pAdapter->CommonCfg.MaxSPLength = (UCHAR)((apsd & 0x00000060) >> 5);
3979
3980 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_SET_APSD_SETTING (apsd=0x%lx, APSDCap=%d, [BE,BK,VI,VO]=[%d/%d/%d/%d], MaxSPLen=%d)\n", apsd, pAdapter->CommonCfg.bAPSDCapable,
3981 pAdapter->CommonCfg.bAPSDAC_BE, pAdapter->CommonCfg.bAPSDAC_BK, pAdapter->CommonCfg.bAPSDAC_VI, pAdapter->CommonCfg.bAPSDAC_VO, pAdapter->CommonCfg.MaxSPLength));
3982 }
3983 break;
3984
3985 case RT_OID_802_11_SET_APSD_PSM:
3986 if (wrq->u.data.length != sizeof(ULONG))
3987 Status = -EINVAL;
3988 else
3989 {
3990 // Driver needs to notify AP when PSM changes
3991 Status = copy_from_user(&pAdapter->CommonCfg.bAPSDForcePowerSave, wrq->u.data.pointer, wrq->u.data.length);
3992 if (pAdapter->CommonCfg.bAPSDForcePowerSave != pAdapter->StaCfg.Psm)
3993 {
3994 MlmeSetPsmBit(pAdapter, pAdapter->CommonCfg.bAPSDForcePowerSave);
3995 RTMPSendNullFrame(pAdapter, pAdapter->CommonCfg.TxRate, TRUE);
3996 }
3997 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_SET_APSD_PSM (bAPSDForcePowerSave:%d)\n", pAdapter->CommonCfg.bAPSDForcePowerSave));
3998 }
3999 break;
4000 #ifdef QOS_DLS_SUPPORT
4001 case RT_OID_802_11_SET_DLS:
4002 if (wrq->u.data.length != sizeof(ULONG))
4003 Status = -EINVAL;
4004 else
4005 {
4006 BOOLEAN oldvalue = pAdapter->CommonCfg.bDLSCapable;
4007 Status = copy_from_user(&pAdapter->CommonCfg.bDLSCapable, wrq->u.data.pointer, wrq->u.data.length);
4008 if (oldvalue && !pAdapter->CommonCfg.bDLSCapable)
4009 {
4010 int i;
4011 // tear down local dls table entry
4012 for (i=0; i<MAX_NUM_OF_INIT_DLS_ENTRY; i++)
4013 {
4014 if (pAdapter->StaCfg.DLSEntry[i].Valid && (pAdapter->StaCfg.DLSEntry[i].Status == DLS_FINISH))
4015 {
4016 pAdapter->StaCfg.DLSEntry[i].Status = DLS_NONE;
4017 pAdapter->StaCfg.DLSEntry[i].Valid = FALSE;
4018 RTMPSendDLSTearDownFrame(pAdapter, pAdapter->StaCfg.DLSEntry[i].MacAddr);
4019 }
4020 }
4021
4022 // tear down peer dls table entry
4023 for (i=MAX_NUM_OF_INIT_DLS_ENTRY; i<MAX_NUM_OF_DLS_ENTRY; i++)
4024 {
4025 if (pAdapter->StaCfg.DLSEntry[i].Valid && (pAdapter->StaCfg.DLSEntry[i].Status == DLS_FINISH))
4026 {
4027 pAdapter->StaCfg.DLSEntry[i].Status = DLS_NONE;
4028 pAdapter->StaCfg.DLSEntry[i].Valid = FALSE;
4029 RTMPSendDLSTearDownFrame(pAdapter, pAdapter->StaCfg.DLSEntry[i].MacAddr);
4030 }
4031 }
4032 }
4033
4034 DBGPRINT(RT_DEBUG_TRACE,("Set::RT_OID_802_11_SET_DLS (=%d)\n", pAdapter->CommonCfg.bDLSCapable));
4035 }
4036 break;
4037
4038 case RT_OID_802_11_SET_DLS_PARAM:
4039 if (wrq->u.data.length != sizeof(RT_802_11_DLS_UI))
4040 Status = -EINVAL;
4041 else
4042 {
4043 RT_802_11_DLS Dls;
4044
4045 NdisZeroMemory(&Dls, sizeof(RT_802_11_DLS));
4046 RTMPMoveMemory(&Dls, wrq->u.data.pointer, sizeof(RT_802_11_DLS_UI));
4047 MlmeEnqueue(pAdapter,
4048 MLME_CNTL_STATE_MACHINE,
4049 RT_OID_802_11_SET_DLS_PARAM,
4050 sizeof(RT_802_11_DLS),
4051 &Dls);
4052 DBGPRINT(RT_DEBUG_TRACE,("Set::RT_OID_802_11_SET_DLS_PARAM \n"));
4053 }
4054 break;
4055 #endif // QOS_DLS_SUPPORT //
4056 case RT_OID_802_11_SET_WMM:
4057 if (wrq->u.data.length != sizeof(BOOLEAN))
4058 Status = -EINVAL;
4059 else
4060 {
4061 Status = copy_from_user(&pAdapter->CommonCfg.bWmmCapable, wrq->u.data.pointer, wrq->u.data.length);
4062 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_SET_WMM (=%d) \n", pAdapter->CommonCfg.bWmmCapable));
4063 }
4064 break;
4065
4066 case OID_802_11_DISASSOCIATE:
4067 #ifdef RALINK_ATE
4068 if (ATE_ON(pAdapter))
4069 {
4070 DBGPRINT(RT_DEBUG_TRACE, ("The driver is in ATE mode now\n"));
4071 break;
4072 }
4073 #endif // RALINK_ATE //
4074 //
4075 // Set NdisRadioStateOff to TRUE, instead of called MlmeRadioOff.
4076 // Later on, NDIS_802_11_BSSID_LIST_EX->NumberOfItems should be 0
4077 // when query OID_802_11_BSSID_LIST.
4078 //
4079 // TRUE: NumberOfItems will set to 0.
4080 // FALSE: NumberOfItems no change.
4081 //
4082 pAdapter->CommonCfg.NdisRadioStateOff = TRUE;
4083 // Set to immediately send the media disconnect event
4084 pAdapter->MlmeAux.CurrReqIsFromNdis = TRUE;
4085 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_DISASSOCIATE \n"));
4086
4087 if (INFRA_ON(pAdapter))
4088 {
4089 if (pAdapter->Mlme.CntlMachine.CurrState != CNTL_IDLE)
4090 {
4091 RT28XX_MLME_RESET_STATE_MACHINE(pAdapter);
4092 DBGPRINT(RT_DEBUG_TRACE, ("!!! MLME busy, reset MLME state machine !!!\n"));
4093 }
4094
4095 MlmeEnqueue(pAdapter,
4096 MLME_CNTL_STATE_MACHINE,
4097 OID_802_11_DISASSOCIATE,
4098 0,
4099 NULL);
4100
4101 StateMachineTouched = TRUE;
4102 }
4103 break;
4104
4105 #ifdef DOT11_N_SUPPORT
4106 case RT_OID_802_11_SET_IMME_BA_CAP:
4107 if (wrq->u.data.length != sizeof(OID_BACAP_STRUC))
4108 Status = -EINVAL;
4109 else
4110 {
4111 OID_BACAP_STRUC Orde ;
4112 Status = copy_from_user(&Orde, wrq->u.data.pointer, wrq->u.data.length);
4113 if (Orde.Policy > BA_NOTUSE)
4114 {
4115 Status = NDIS_STATUS_INVALID_DATA;
4116 }
4117 else if (Orde.Policy == BA_NOTUSE)
4118 {
4119 pAdapter->CommonCfg.BACapability.field.Policy = BA_NOTUSE;
4120 pAdapter->CommonCfg.BACapability.field.MpduDensity = Orde.MpduDensity;
4121 pAdapter->CommonCfg.DesiredHtPhy.MpduDensity = Orde.MpduDensity;
4122 pAdapter->CommonCfg.DesiredHtPhy.AmsduEnable = Orde.AmsduEnable;
4123 pAdapter->CommonCfg.DesiredHtPhy.AmsduSize= Orde.AmsduSize;
4124 pAdapter->CommonCfg.DesiredHtPhy.MimoPs= Orde.MMPSmode;
4125 pAdapter->CommonCfg.BACapability.field.MMPSmode = Orde.MMPSmode;
4126 // UPdata to HT IE
4127 pAdapter->CommonCfg.HtCapability.HtCapInfo.MimoPs = Orde.MMPSmode;
4128 pAdapter->CommonCfg.HtCapability.HtCapInfo.AMsduSize = Orde.AmsduSize;
4129 pAdapter->CommonCfg.HtCapability.HtCapParm.MpduDensity = Orde.MpduDensity;
4130 }
4131 else
4132 {
4133 pAdapter->CommonCfg.BACapability.field.AutoBA = Orde.AutoBA;
4134 pAdapter->CommonCfg.BACapability.field.Policy = IMMED_BA; // we only support immediate BA.
4135 pAdapter->CommonCfg.BACapability.field.MpduDensity = Orde.MpduDensity;
4136 pAdapter->CommonCfg.DesiredHtPhy.MpduDensity = Orde.MpduDensity;
4137 pAdapter->CommonCfg.DesiredHtPhy.AmsduEnable = Orde.AmsduEnable;
4138 pAdapter->CommonCfg.DesiredHtPhy.AmsduSize= Orde.AmsduSize;
4139 pAdapter->CommonCfg.DesiredHtPhy.MimoPs = Orde.MMPSmode;
4140 pAdapter->CommonCfg.BACapability.field.MMPSmode = Orde.MMPSmode;
4141
4142 // UPdata to HT IE
4143 pAdapter->CommonCfg.HtCapability.HtCapInfo.MimoPs = Orde.MMPSmode;
4144 pAdapter->CommonCfg.HtCapability.HtCapInfo.AMsduSize = Orde.AmsduSize;
4145 pAdapter->CommonCfg.HtCapability.HtCapParm.MpduDensity = Orde.MpduDensity;
4146
4147 if (pAdapter->CommonCfg.BACapability.field.RxBAWinLimit > MAX_RX_REORDERBUF)
4148 pAdapter->CommonCfg.BACapability.field.RxBAWinLimit = MAX_RX_REORDERBUF;
4149
4150 }
4151
4152 pAdapter->CommonCfg.REGBACapability.word = pAdapter->CommonCfg.BACapability.word;
4153 DBGPRINT(RT_DEBUG_TRACE, ("Set::(Orde.AutoBA = %d) (Policy=%d)(ReBAWinLimit=%d)(TxBAWinLimit=%d)(AutoMode=%d)\n",Orde.AutoBA, pAdapter->CommonCfg.BACapability.field.Policy,
4154 pAdapter->CommonCfg.BACapability.field.RxBAWinLimit,pAdapter->CommonCfg.BACapability.field.TxBAWinLimit, pAdapter->CommonCfg.BACapability.field.AutoBA));
4155 DBGPRINT(RT_DEBUG_TRACE, ("Set::(MimoPs = %d)(AmsduEnable = %d) (AmsduSize=%d)(MpduDensity=%d)\n",pAdapter->CommonCfg.DesiredHtPhy.MimoPs, pAdapter->CommonCfg.DesiredHtPhy.AmsduEnable,
4156 pAdapter->CommonCfg.DesiredHtPhy.AmsduSize, pAdapter->CommonCfg.DesiredHtPhy.MpduDensity));
4157 }
4158
4159 break;
4160 case RT_OID_802_11_ADD_IMME_BA:
4161 DBGPRINT(RT_DEBUG_TRACE, (" Set :: RT_OID_802_11_ADD_IMME_BA \n"));
4162 if (wrq->u.data.length != sizeof(OID_ADD_BA_ENTRY))
4163 Status = -EINVAL;
4164 else
4165 {
4166 UCHAR index;
4167 OID_ADD_BA_ENTRY BA;
4168 MAC_TABLE_ENTRY *pEntry;
4169
4170 Status = copy_from_user(&BA, wrq->u.data.pointer, wrq->u.data.length);
4171 if (BA.TID > 15)
4172 {
4173 Status = NDIS_STATUS_INVALID_DATA;
4174 break;
4175 }
4176 else
4177 {
4178 //BATableInsertEntry
4179 //As ad-hoc mode, BA pair is not limited to only BSSID. so add via OID.
4180 index = BA.TID;
4181 // in ad hoc mode, when adding BA pair, we should insert this entry into MACEntry too
4182 pEntry = MacTableLookup(pAdapter, BA.MACAddr);
4183 if (!pEntry)
4184 {
4185 DBGPRINT(RT_DEBUG_TRACE, ("RT_OID_802_11_ADD_IMME_BA. break on no connection.----:%x:%x\n", BA.MACAddr[4], BA.MACAddr[5]));
4186 break;
4187 }
4188 if (BA.IsRecipient == FALSE)
4189 {
4190 if (pEntry->bIAmBadAtheros == TRUE)
4191 pAdapter->CommonCfg.BACapability.field.RxBAWinLimit = 0x10;
4192
4193 BAOriSessionSetUp(pAdapter, pEntry, index, 0, 100, TRUE);
4194 }
4195 else
4196 {
4197 //BATableInsertEntry(pAdapter, pEntry->Aid, BA.MACAddr, 0, 0xffff, BA.TID, BA.nMSDU, BA.IsRecipient);
4198 }
4199
4200 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_802_11_ADD_IMME_BA. Rec = %d. Mac = %x:%x:%x:%x:%x:%x . \n",
4201 BA.IsRecipient, BA.MACAddr[0], BA.MACAddr[1], BA.MACAddr[2], BA.MACAddr[2]
4202 , BA.MACAddr[4], BA.MACAddr[5]));
4203 }
4204 }
4205 break;
4206
4207 case RT_OID_802_11_TEAR_IMME_BA:
4208 DBGPRINT(RT_DEBUG_TRACE, ("Set :: RT_OID_802_11_TEAR_IMME_BA \n"));
4209 if (wrq->u.data.length != sizeof(OID_ADD_BA_ENTRY))
4210 Status = -EINVAL;
4211 else
4212 {
4213 POID_ADD_BA_ENTRY pBA;
4214 MAC_TABLE_ENTRY *pEntry;
4215
4216 pBA = kmalloc(wrq->u.data.length, MEM_ALLOC_FLAG);
4217
4218 if (pBA == NULL)
4219 {
4220 DBGPRINT(RT_DEBUG_TRACE, ("Set :: RT_OID_802_11_TEAR_IMME_BA kmalloc() can't allocate enough memory\n"));
4221 Status = NDIS_STATUS_FAILURE;
4222 }
4223 else
4224 {
4225 Status = copy_from_user(pBA, wrq->u.data.pointer, wrq->u.data.length);
4226 DBGPRINT(RT_DEBUG_TRACE, ("Set :: RT_OID_802_11_TEAR_IMME_BA(TID=%d, bAllTid=%d)\n", pBA->TID, pBA->bAllTid));
4227
4228 if (!pBA->bAllTid && (pBA->TID > NUM_OF_TID))
4229 {
4230 Status = NDIS_STATUS_INVALID_DATA;
4231 break;
4232 }
4233
4234 if (pBA->IsRecipient == FALSE)
4235 {
4236 pEntry = MacTableLookup(pAdapter, pBA->MACAddr);
4237 DBGPRINT(RT_DEBUG_TRACE, (" pBA->IsRecipient == FALSE\n"));
4238 if (pEntry)
4239 {
4240 DBGPRINT(RT_DEBUG_TRACE, (" pBA->pEntry\n"));
4241 BAOriSessionTearDown(pAdapter, pEntry->Aid, pBA->TID, FALSE, TRUE);
4242 }
4243 else
4244 DBGPRINT(RT_DEBUG_TRACE, ("Set :: Not found pEntry \n"));
4245 }
4246 else
4247 {
4248 pEntry = MacTableLookup(pAdapter, pBA->MACAddr);
4249 if (pEntry)
4250 {
4251 BARecSessionTearDown( pAdapter, (UCHAR)pEntry->Aid, pBA->TID, TRUE);
4252 }
4253 else
4254 DBGPRINT(RT_DEBUG_TRACE, ("Set :: Not found pEntry \n"));
4255 }
4256 kfree(pBA);
4257 }
4258 }
4259 break;
4260 #endif // DOT11_N_SUPPORT //
4261
4262 // For WPA_SUPPLICANT to set static wep key
4263 case OID_802_11_ADD_WEP:
4264 pWepKey = kmalloc(wrq->u.data.length, MEM_ALLOC_FLAG);
4265
4266 if(pWepKey == NULL)
4267 {
4268 Status = -ENOMEM;
4269 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_ADD_WEP, Failed!!\n"));
4270 break;
4271 }
4272 Status = copy_from_user(pWepKey, wrq->u.data.pointer, wrq->u.data.length);
4273 if (Status)
4274 {
4275 Status = -EINVAL;
4276 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_ADD_WEP, Failed (length mismatch)!!\n"));
4277 }
4278 else
4279 {
4280 KeyIdx = pWepKey->KeyIndex & 0x0fffffff;
4281 // KeyIdx must be 0 ~ 3
4282 if (KeyIdx > 4)
4283 {
4284 Status = -EINVAL;
4285 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_ADD_WEP, Failed (KeyIdx must be smaller than 4)!!\n"));
4286 }
4287 else
4288 {
4289 UCHAR CipherAlg = 0;
4290 PUCHAR Key;
4291
4292 // set key material and key length
4293 NdisZeroMemory(pAdapter->SharedKey[BSS0][KeyIdx].Key, 16);
4294 pAdapter->SharedKey[BSS0][KeyIdx].KeyLen = (UCHAR) pWepKey->KeyLength;
4295 NdisMoveMemory(pAdapter->SharedKey[BSS0][KeyIdx].Key, &pWepKey->KeyMaterial, pWepKey->KeyLength);
4296
4297 switch(pWepKey->KeyLength)
4298 {
4299 case 5:
4300 CipherAlg = CIPHER_WEP64;
4301 break;
4302 case 13:
4303 CipherAlg = CIPHER_WEP128;
4304 break;
4305 default:
4306 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_ADD_WEP, only support CIPHER_WEP64(len:5) & CIPHER_WEP128(len:13)!!\n"));
4307 Status = -EINVAL;
4308 break;
4309 }
4310 pAdapter->SharedKey[BSS0][KeyIdx].CipherAlg = CipherAlg;
4311
4312 // Default key for tx (shared key)
4313 if (pWepKey->KeyIndex & 0x80000000)
4314 {
4315 #ifdef WPA_SUPPLICANT_SUPPORT
4316 // set key material and key length
4317 NdisZeroMemory(pAdapter->StaCfg.DesireSharedKey[KeyIdx].Key, 16);
4318 pAdapter->StaCfg.DesireSharedKey[KeyIdx].KeyLen = (UCHAR) pWepKey->KeyLength;
4319 NdisMoveMemory(pAdapter->StaCfg.DesireSharedKey[KeyIdx].Key, &pWepKey->KeyMaterial, pWepKey->KeyLength);
4320 pAdapter->StaCfg.DesireSharedKeyId = KeyIdx;
4321 pAdapter->StaCfg.DesireSharedKey[KeyIdx].CipherAlg = CipherAlg;
4322 #endif // WPA_SUPPLICANT_SUPPORT //
4323 pAdapter->StaCfg.DefaultKeyId = (UCHAR) KeyIdx;
4324 }
4325
4326 #ifdef WPA_SUPPLICANT_SUPPORT
4327 if ((pAdapter->StaCfg.WpaSupplicantUP != WPA_SUPPLICANT_DISABLE) &&
4328 (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA))
4329 {
4330 Key = pWepKey->KeyMaterial;
4331
4332 // Set Group key material to Asic
4333 AsicAddSharedKeyEntry(pAdapter, BSS0, KeyIdx, CipherAlg, Key, NULL, NULL);
4334
4335 // Update WCID attribute table and IVEIV table for this group key table
4336 RTMPAddWcidAttributeEntry(pAdapter, BSS0, KeyIdx, CipherAlg, NULL);
4337
4338 STA_PORT_SECURED(pAdapter);
4339
4340 // Indicate Connected for GUI
4341 pAdapter->IndicateMediaState = NdisMediaStateConnected;
4342 }
4343 else if (pAdapter->StaCfg.PortSecured == WPA_802_1X_PORT_SECURED)
4344 #endif // WPA_SUPPLICANT_SUPPORT
4345 {
4346 Key = pAdapter->SharedKey[BSS0][KeyIdx].Key;
4347
4348 // Set key material and cipherAlg to Asic
4349 AsicAddSharedKeyEntry(pAdapter, BSS0, KeyIdx, CipherAlg, Key, NULL, NULL);
4350
4351 if (pWepKey->KeyIndex & 0x80000000)
4352 {
4353 PMAC_TABLE_ENTRY pEntry = &pAdapter->MacTab.Content[BSSID_WCID];
4354 // Assign group key info
4355 RTMPAddWcidAttributeEntry(pAdapter, BSS0, KeyIdx, CipherAlg, NULL);
4356 // Assign pairwise key info
4357 RTMPAddWcidAttributeEntry(pAdapter, BSS0, KeyIdx, CipherAlg, pEntry);
4358 }
4359 }
4360 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_ADD_WEP (id=0x%x, Len=%d-byte), %s\n", pWepKey->KeyIndex, pWepKey->KeyLength, (pAdapter->StaCfg.PortSecured == WPA_802_1X_PORT_SECURED) ? "Port Secured":"Port NOT Secured"));
4361 }
4362 }
4363 kfree(pWepKey);
4364 break;
4365 #ifdef WPA_SUPPLICANT_SUPPORT
4366 case OID_SET_COUNTERMEASURES:
4367 if (wrq->u.data.length != sizeof(int))
4368 Status = -EINVAL;
4369 else
4370 {
4371 int enabled = 0;
4372 Status = copy_from_user(&enabled, wrq->u.data.pointer, wrq->u.data.length);
4373 if (enabled == 1)
4374 pAdapter->StaCfg.bBlockAssoc = TRUE;
4375 else
4376 // WPA MIC error should block association attempt for 60 seconds
4377 pAdapter->StaCfg.bBlockAssoc = FALSE;
4378 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_SET_COUNTERMEASURES bBlockAssoc=%s\n", pAdapter->StaCfg.bBlockAssoc ? "TRUE":"FALSE"));
4379 }
4380 break;
4381 case RT_OID_WPA_SUPPLICANT_SUPPORT:
4382 if (wrq->u.data.length != sizeof(UCHAR))
4383 Status = -EINVAL;
4384 else
4385 {
4386 Status = copy_from_user(&wpa_supplicant_enable, wrq->u.data.pointer, wrq->u.data.length);
4387 pAdapter->StaCfg.WpaSupplicantUP = wpa_supplicant_enable;
4388 DBGPRINT(RT_DEBUG_TRACE, ("Set::RT_OID_WPA_SUPPLICANT_SUPPORT (=%d)\n", pAdapter->StaCfg.WpaSupplicantUP));
4389 }
4390 break;
4391 case OID_802_11_DEAUTHENTICATION:
4392 if (wrq->u.data.length != sizeof(MLME_DEAUTH_REQ_STRUCT))
4393 Status = -EINVAL;
4394 else
4395 {
4396 MLME_DEAUTH_REQ_STRUCT *pInfo;
4397 MLME_QUEUE_ELEM *MsgElem = (MLME_QUEUE_ELEM *) kmalloc(sizeof(MLME_QUEUE_ELEM), MEM_ALLOC_FLAG);
4398
4399 pInfo = (MLME_DEAUTH_REQ_STRUCT *) MsgElem->Msg;
4400 Status = copy_from_user(pInfo, wrq->u.data.pointer, wrq->u.data.length);
4401 MlmeDeauthReqAction(pAdapter, MsgElem);
4402 kfree(MsgElem);
4403
4404 if (INFRA_ON(pAdapter))
4405 {
4406 LinkDown(pAdapter, FALSE);
4407 pAdapter->Mlme.AssocMachine.CurrState = ASSOC_IDLE;
4408 }
4409 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_DEAUTHENTICATION (Reason=%d)\n", pInfo->Reason));
4410 }
4411 break;
4412 case OID_802_11_DROP_UNENCRYPTED:
4413 if (wrq->u.data.length != sizeof(int))
4414 Status = -EINVAL;
4415 else
4416 {
4417 int enabled = 0;
4418 Status = copy_from_user(&enabled, wrq->u.data.pointer, wrq->u.data.length);
4419 if (enabled == 1)
4420 pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_NOT_SECURED;
4421 else
4422 pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_SECURED;
4423 NdisAcquireSpinLock(&pAdapter->MacTabLock);
4424 pAdapter->MacTab.Content[BSSID_WCID].PortSecured = pAdapter->StaCfg.PortSecured;
4425 NdisReleaseSpinLock(&pAdapter->MacTabLock);
4426 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_DROP_UNENCRYPTED (=%d)\n", enabled));
4427 }
4428 break;
4429 case OID_802_11_SET_IEEE8021X:
4430 if (wrq->u.data.length != sizeof(BOOLEAN))
4431 Status = -EINVAL;
4432 else
4433 {
4434 Status = copy_from_user(&IEEE8021xState, wrq->u.data.pointer, wrq->u.data.length);
4435 pAdapter->StaCfg.IEEE8021X = IEEE8021xState;
4436 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_SET_IEEE8021X (=%d)\n", IEEE8021xState));
4437 }
4438 break;
4439 case OID_802_11_SET_IEEE8021X_REQUIRE_KEY:
4440 if (wrq->u.data.length != sizeof(BOOLEAN))
4441 Status = -EINVAL;
4442 else
4443 {
4444 Status = copy_from_user(&IEEE8021x_required_keys, wrq->u.data.pointer, wrq->u.data.length);
4445 pAdapter->StaCfg.IEEE8021x_required_keys = IEEE8021x_required_keys;
4446 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_SET_IEEE8021X_REQUIRE_KEY (%d)\n", IEEE8021x_required_keys));
4447 }
4448 break;
4449 case OID_802_11_PMKID:
4450 pPmkId = kmalloc(wrq->u.data.length, MEM_ALLOC_FLAG);
4451
4452 if(pPmkId == NULL) {
4453 Status = -ENOMEM;
4454 break;
4455 }
4456 Status = copy_from_user(pPmkId, wrq->u.data.pointer, wrq->u.data.length);
4457
4458 // check the PMKID information
4459 if (pPmkId->BSSIDInfoCount == 0)
4460 NdisZeroMemory(pAdapter->StaCfg.SavedPMK, sizeof(BSSID_INFO)*PMKID_NO);
4461 else
4462 {
4463 PBSSID_INFO pBssIdInfo;
4464 UINT BssIdx;
4465 UINT CachedIdx;
4466
4467 for (BssIdx = 0; BssIdx < pPmkId->BSSIDInfoCount; BssIdx++)
4468 {
4469 // point to the indexed BSSID_INFO structure
4470 pBssIdInfo = (PBSSID_INFO) ((PUCHAR) pPmkId + 2 * sizeof(UINT) + BssIdx * sizeof(BSSID_INFO));
4471 // Find the entry in the saved data base.
4472 for (CachedIdx = 0; CachedIdx < pAdapter->StaCfg.SavedPMKNum; CachedIdx++)
4473 {
4474 // compare the BSSID
4475 if (NdisEqualMemory(pBssIdInfo->BSSID, pAdapter->StaCfg.SavedPMK[CachedIdx].BSSID, sizeof(NDIS_802_11_MAC_ADDRESS)))
4476 break;
4477 }
4478
4479 // Found, replace it
4480 if (CachedIdx < PMKID_NO)
4481 {
4482 DBGPRINT(RT_DEBUG_OFF, ("Update OID_802_11_PMKID, idx = %d\n", CachedIdx));
4483 NdisMoveMemory(&pAdapter->StaCfg.SavedPMK[CachedIdx], pBssIdInfo, sizeof(BSSID_INFO));
4484 pAdapter->StaCfg.SavedPMKNum++;
4485 }
4486 // Not found, replace the last one
4487 else
4488 {
4489 // Randomly replace one
4490 CachedIdx = (pBssIdInfo->BSSID[5] % PMKID_NO);
4491 DBGPRINT(RT_DEBUG_OFF, ("Update OID_802_11_PMKID, idx = %d\n", CachedIdx));
4492 NdisMoveMemory(&pAdapter->StaCfg.SavedPMK[CachedIdx], pBssIdInfo, sizeof(BSSID_INFO));
4493 }
4494 }
4495 }
4496 if(pPmkId)
4497 kfree(pPmkId);
4498 break;
4499 #endif // WPA_SUPPLICANT_SUPPORT //
4500
4501
4502
4503 #ifdef SNMP_SUPPORT
4504 case OID_802_11_SHORTRETRYLIMIT:
4505 if (wrq->u.data.length != sizeof(ULONG))
4506 Status = -EINVAL;
4507 else
4508 {
4509 Status = copy_from_user(&ShortRetryLimit, wrq->u.data.pointer, wrq->u.data.length);
4510 RTMP_IO_READ32(pAdapter, TX_RTY_CFG, &tx_rty_cfg.word);
4511 tx_rty_cfg.field.ShortRtyLimit = ShortRetryLimit;
4512 RTMP_IO_WRITE32(pAdapter, TX_RTY_CFG, tx_rty_cfg.word);
4513 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_SHORTRETRYLIMIT (tx_rty_cfg.field.ShortRetryLimit=%d, ShortRetryLimit=%ld)\n", tx_rty_cfg.field.ShortRtyLimit, ShortRetryLimit));
4514 }
4515 break;
4516
4517 case OID_802_11_LONGRETRYLIMIT:
4518 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_LONGRETRYLIMIT \n"));
4519 if (wrq->u.data.length != sizeof(ULONG))
4520 Status = -EINVAL;
4521 else
4522 {
4523 Status = copy_from_user(&LongRetryLimit, wrq->u.data.pointer, wrq->u.data.length);
4524 RTMP_IO_READ32(pAdapter, TX_RTY_CFG, &tx_rty_cfg.word);
4525 tx_rty_cfg.field.LongRtyLimit = LongRetryLimit;
4526 RTMP_IO_WRITE32(pAdapter, TX_RTY_CFG, tx_rty_cfg.word);
4527 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_LONGRETRYLIMIT (tx_rty_cfg.field.LongRetryLimit= %d,LongRetryLimit=%ld)\n", tx_rty_cfg.field.LongRtyLimit, LongRetryLimit));
4528 }
4529 break;
4530
4531 case OID_802_11_WEPDEFAULTKEYVALUE:
4532 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_WEPDEFAULTKEYVALUE\n"));
4533 pKey = kmalloc(wrq->u.data.length, GFP_KERNEL);
4534 Status = copy_from_user(pKey, wrq->u.data.pointer, wrq->u.data.length);
4535 //pKey = &WepKey;
4536
4537 if ( pKey->Length != wrq->u.data.length)
4538 {
4539 Status = -EINVAL;
4540 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_WEPDEFAULTKEYVALUE, Failed!!\n"));
4541 }
4542 KeyIdx = pKey->KeyIndex & 0x0fffffff;
4543 DBGPRINT(RT_DEBUG_TRACE,("pKey->KeyIndex =%d, pKey->KeyLength=%d\n", pKey->KeyIndex, pKey->KeyLength));
4544
4545 // it is a shared key
4546 if (KeyIdx > 4)
4547 Status = -EINVAL;
4548 else
4549 {
4550 pAdapter->SharedKey[BSS0][pAdapter->StaCfg.DefaultKeyId].KeyLen = (UCHAR) pKey->KeyLength;
4551 NdisMoveMemory(&pAdapter->SharedKey[BSS0][pAdapter->StaCfg.DefaultKeyId].Key, &pKey->KeyMaterial, pKey->KeyLength);
4552 if (pKey->KeyIndex & 0x80000000)
4553 {
4554 // Default key for tx (shared key)
4555 pAdapter->StaCfg.DefaultKeyId = (UCHAR) KeyIdx;
4556 }
4557 //RestartAPIsRequired = TRUE;
4558 }
4559 break;
4560
4561
4562 case OID_802_11_WEPDEFAULTKEYID:
4563 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_WEPDEFAULTKEYID \n"));
4564
4565 if (wrq->u.data.length != sizeof(UCHAR))
4566 Status = -EINVAL;
4567 else
4568 Status = copy_from_user(&pAdapter->StaCfg.DefaultKeyId, wrq->u.data.pointer, wrq->u.data.length);
4569
4570 break;
4571
4572
4573 case OID_802_11_CURRENTCHANNEL:
4574 DBGPRINT(RT_DEBUG_TRACE, ("Set::OID_802_11_CURRENTCHANNEL \n"));
4575 if (wrq->u.data.length != sizeof(UCHAR))
4576 Status = -EINVAL;
4577 else
4578 {
4579 Status = copy_from_user(&ctmp, wrq->u.data.pointer, wrq->u.data.length);
4580 sprintf(&ctmp,"%d", ctmp);
4581 Set_Channel_Proc(pAdapter, &ctmp);
4582 }
4583 break;
4584 #endif
4585
4586
4587
4588 default:
4589 DBGPRINT(RT_DEBUG_TRACE, ("Set::unknown IOCTL's subcmd = 0x%08x\n", cmd));
4590 Status = -EOPNOTSUPP;
4591 break;
4592 }
4593
4594
4595 return Status;
4596 }
4597
4598 INT RTMPQueryInformation(
4599 IN PRTMP_ADAPTER pAdapter,
4600 IN OUT struct ifreq *rq,
4601 IN INT cmd)
4602 {
4603 struct iwreq *wrq = (struct iwreq *) rq;
4604 NDIS_802_11_BSSID_LIST_EX *pBssidList = NULL;
4605 PNDIS_WLAN_BSSID_EX pBss;
4606 NDIS_802_11_SSID Ssid;
4607 NDIS_802_11_CONFIGURATION *pConfiguration = NULL;
4608 RT_802_11_LINK_STATUS *pLinkStatus = NULL;
4609 RT_802_11_STA_CONFIG *pStaConfig = NULL;
4610 NDIS_802_11_STATISTICS *pStatistics = NULL;
4611 NDIS_802_11_RTS_THRESHOLD RtsThresh;
4612 NDIS_802_11_FRAGMENTATION_THRESHOLD FragThresh;
4613 NDIS_802_11_POWER_MODE PowerMode;
4614 NDIS_802_11_NETWORK_INFRASTRUCTURE BssType;
4615 RT_802_11_PREAMBLE PreamType;
4616 NDIS_802_11_AUTHENTICATION_MODE AuthMode;
4617 NDIS_802_11_WEP_STATUS WepStatus;
4618 NDIS_MEDIA_STATE MediaState;
4619 ULONG BssBufSize, ulInfo=0, NetworkTypeList[4], apsd = 0;
4620 USHORT BssLen = 0;
4621 PUCHAR pBuf = NULL, pPtr;
4622 INT Status = NDIS_STATUS_SUCCESS;
4623 UINT we_version_compiled;
4624 UCHAR i, Padding = 0;
4625 BOOLEAN RadioState;
4626 UCHAR driverVersion[8];
4627 OID_SET_HT_PHYMODE *pHTPhyMode = NULL;
4628
4629
4630 #ifdef SNMP_SUPPORT
4631 //for snmp, kathy
4632 DefaultKeyIdxValue *pKeyIdxValue;
4633 INT valueLen;
4634 TX_RTY_CFG_STRUC tx_rty_cfg;
4635 ULONG ShortRetryLimit, LongRetryLimit;
4636 UCHAR tmp[64];
4637 #endif //SNMP
4638
4639 switch(cmd)
4640 {
4641 case RT_OID_DEVICE_NAME:
4642 wrq->u.data.length = sizeof(STA_NIC_DEVICE_NAME);
4643 Status = copy_to_user(wrq->u.data.pointer, STA_NIC_DEVICE_NAME, wrq->u.data.length);
4644 break;
4645 case RT_OID_VERSION_INFO:
4646 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_VERSION_INFO \n"));
4647 wrq->u.data.length = 8*sizeof(UCHAR);
4648 sprintf(&driverVersion[0], "%s", STA_DRIVER_VERSION);
4649 driverVersion[7] = '\0';
4650 if (copy_to_user(wrq->u.data.pointer, &driverVersion, wrq->u.data.length))
4651 {
4652 Status = -EFAULT;
4653 }
4654 break;
4655 #ifdef RALINK_ATE
4656 case RT_QUERY_ATE_TXDONE_COUNT:
4657 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_QUERY_ATE_TXDONE_COUNT \n"));
4658 wrq->u.data.length = sizeof(UINT32);
4659 if (copy_to_user(wrq->u.data.pointer, &pAdapter->ate.TxDoneCount, wrq->u.data.length))
4660 {
4661 Status = -EFAULT;
4662 }
4663 break;
4664 #endif // RALINK_ATE //
4665 case OID_802_11_BSSID_LIST:
4666 if (RTMP_TEST_FLAG(pAdapter, fRTMP_ADAPTER_BSS_SCAN_IN_PROGRESS))
4667 {
4668 /*
4669 * Still scanning, indicate the caller should try again.
4670 */
4671 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_BSSID_LIST (Still scanning)\n"));
4672 return -EAGAIN;
4673 }
4674 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_BSSID_LIST (%d BSS returned)\n",pAdapter->ScanTab.BssNr));
4675 pAdapter->StaCfg.bScanReqIsFromWebUI = FALSE;
4676 // Claculate total buffer size required
4677 BssBufSize = sizeof(ULONG);
4678
4679 for (i = 0; i < pAdapter->ScanTab.BssNr; i++)
4680 {
4681 // Align pointer to 4 bytes boundary.
4682 //Padding = 4 - (pAdapter->ScanTab.BssEntry[i].VarIELen & 0x0003);
4683 //if (Padding == 4)
4684 // Padding = 0;
4685 BssBufSize += (sizeof(NDIS_WLAN_BSSID_EX) - 1 + sizeof(NDIS_802_11_FIXED_IEs) + pAdapter->ScanTab.BssEntry[i].VarIELen + Padding);
4686 }
4687
4688 // For safety issue, we add 256 bytes just in case
4689 BssBufSize += 256;
4690 // Allocate the same size as passed from higher layer
4691 pBuf = kmalloc(BssBufSize, MEM_ALLOC_FLAG);
4692 if(pBuf == NULL)
4693 {
4694 Status = -ENOMEM;
4695 break;
4696 }
4697 // Init 802_11_BSSID_LIST_EX structure
4698 NdisZeroMemory(pBuf, BssBufSize);
4699 pBssidList = (PNDIS_802_11_BSSID_LIST_EX) pBuf;
4700 pBssidList->NumberOfItems = pAdapter->ScanTab.BssNr;
4701
4702 // Calculate total buffer length
4703 BssLen = 4; // Consist of NumberOfItems
4704 // Point to start of NDIS_WLAN_BSSID_EX
4705 // pPtr = pBuf + sizeof(ULONG);
4706 pPtr = (PUCHAR) &pBssidList->Bssid[0];
4707 for (i = 0; i < pAdapter->ScanTab.BssNr; i++)
4708 {
4709 pBss = (PNDIS_WLAN_BSSID_EX) pPtr;
4710 NdisMoveMemory(&pBss->MacAddress, &pAdapter->ScanTab.BssEntry[i].Bssid, MAC_ADDR_LEN);
4711 if ((pAdapter->ScanTab.BssEntry[i].Hidden == 1) && (pAdapter->StaCfg.bShowHiddenSSID == FALSE))
4712 {
4713 //
4714 // We must return this SSID during 4way handshaking, otherwise Aegis will failed to parse WPA infomation
4715 // and then failed to send EAPOl farame.
4716 //
4717 if ((pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA) && (pAdapter->StaCfg.PortSecured != WPA_802_1X_PORT_SECURED))
4718 {
4719 pBss->Ssid.SsidLength = pAdapter->ScanTab.BssEntry[i].SsidLen;
4720 NdisMoveMemory(pBss->Ssid.Ssid, pAdapter->ScanTab.BssEntry[i].Ssid, pAdapter->ScanTab.BssEntry[i].SsidLen);
4721 }
4722 else
4723 pBss->Ssid.SsidLength = 0;
4724 }
4725 else
4726 {
4727 pBss->Ssid.SsidLength = pAdapter->ScanTab.BssEntry[i].SsidLen;
4728 NdisMoveMemory(pBss->Ssid.Ssid, pAdapter->ScanTab.BssEntry[i].Ssid, pAdapter->ScanTab.BssEntry[i].SsidLen);
4729 }
4730 pBss->Privacy = pAdapter->ScanTab.BssEntry[i].Privacy;
4731 pBss->Rssi = pAdapter->ScanTab.BssEntry[i].Rssi - pAdapter->BbpRssiToDbmDelta;
4732 pBss->NetworkTypeInUse = NetworkTypeInUseSanity(&pAdapter->ScanTab.BssEntry[i]);
4733 pBss->Configuration.Length = sizeof(NDIS_802_11_CONFIGURATION);
4734 pBss->Configuration.BeaconPeriod = pAdapter->ScanTab.BssEntry[i].BeaconPeriod;
4735 pBss->Configuration.ATIMWindow = pAdapter->ScanTab.BssEntry[i].AtimWin;
4736
4737 MAP_CHANNEL_ID_TO_KHZ(pAdapter->ScanTab.BssEntry[i].Channel, pBss->Configuration.DSConfig);
4738
4739 if (pAdapter->ScanTab.BssEntry[i].BssType == BSS_INFRA)
4740 pBss->InfrastructureMode = Ndis802_11Infrastructure;
4741 else
4742 pBss->InfrastructureMode = Ndis802_11IBSS;
4743
4744 NdisMoveMemory(pBss->SupportedRates, pAdapter->ScanTab.BssEntry[i].SupRate, pAdapter->ScanTab.BssEntry[i].SupRateLen);
4745 NdisMoveMemory(pBss->SupportedRates + pAdapter->ScanTab.BssEntry[i].SupRateLen,
4746 pAdapter->ScanTab.BssEntry[i].ExtRate,
4747 pAdapter->ScanTab.BssEntry[i].ExtRateLen);
4748
4749 if (pAdapter->ScanTab.BssEntry[i].VarIELen == 0)
4750 {
4751 pBss->IELength = sizeof(NDIS_802_11_FIXED_IEs);
4752 NdisMoveMemory(pBss->IEs, &pAdapter->ScanTab.BssEntry[i].FixIEs, sizeof(NDIS_802_11_FIXED_IEs));
4753 pPtr = pPtr + sizeof(NDIS_WLAN_BSSID_EX) - 1 + sizeof(NDIS_802_11_FIXED_IEs);
4754 }
4755 else
4756 {
4757 pBss->IELength = (ULONG)(sizeof(NDIS_802_11_FIXED_IEs) + pAdapter->ScanTab.BssEntry[i].VarIELen);
4758 pPtr = pPtr + sizeof(NDIS_WLAN_BSSID_EX) - 1 + sizeof(NDIS_802_11_FIXED_IEs);
4759 NdisMoveMemory(pBss->IEs, &pAdapter->ScanTab.BssEntry[i].FixIEs, sizeof(NDIS_802_11_FIXED_IEs));
4760 NdisMoveMemory(pBss->IEs + sizeof(NDIS_802_11_FIXED_IEs), pAdapter->ScanTab.BssEntry[i].VarIEs, pAdapter->ScanTab.BssEntry[i].VarIELen);
4761 pPtr += pAdapter->ScanTab.BssEntry[i].VarIELen;
4762 }
4763 pBss->Length = (ULONG)(sizeof(NDIS_WLAN_BSSID_EX) - 1 + sizeof(NDIS_802_11_FIXED_IEs) + pAdapter->ScanTab.BssEntry[i].VarIELen + Padding);
4764
4765 #if WIRELESS_EXT < 17
4766 if ((BssLen + pBss->Length) < wrq->u.data.length)
4767 BssLen += pBss->Length;
4768 else
4769 {
4770 pBssidList->NumberOfItems = i;
4771 break;
4772 }
4773 #else
4774 BssLen += pBss->Length;
4775 #endif
4776 }
4777
4778 #if WIRELESS_EXT < 17
4779 wrq->u.data.length = BssLen;
4780 #else
4781 if (BssLen > wrq->u.data.length)
4782 {
4783 kfree(pBssidList);
4784 return -E2BIG;
4785 }
4786 else
4787 wrq->u.data.length = BssLen;
4788 #endif
4789 Status = copy_to_user(wrq->u.data.pointer, pBssidList, BssLen);
4790 kfree(pBssidList);
4791 break;
4792 case OID_802_3_CURRENT_ADDRESS:
4793 wrq->u.data.length = MAC_ADDR_LEN;
4794 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CurrentAddress, wrq->u.data.length);
4795 break;
4796 case OID_GEN_MEDIA_CONNECT_STATUS:
4797 if (pAdapter->IndicateMediaState == NdisMediaStateConnected)
4798 MediaState = NdisMediaStateConnected;
4799 else
4800 MediaState = NdisMediaStateDisconnected;
4801
4802 wrq->u.data.length = sizeof(NDIS_MEDIA_STATE);
4803 Status = copy_to_user(wrq->u.data.pointer, &MediaState, wrq->u.data.length);
4804 break;
4805 case OID_802_11_BSSID:
4806 #ifdef RALINK_ATE
4807 if (ATE_ON(pAdapter))
4808 {
4809 DBGPRINT(RT_DEBUG_TRACE, ("The driver is in ATE mode now\n"));
4810 Status = NDIS_STATUS_RESOURCES;
4811 break;
4812 }
4813 #endif // RALINK_ATE //
4814 if (INFRA_ON(pAdapter) || ADHOC_ON(pAdapter))
4815 {
4816 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CommonCfg.Bssid, sizeof(NDIS_802_11_MAC_ADDRESS));
4817
4818 }
4819 else
4820 {
4821 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_BSSID(=EMPTY)\n"));
4822 Status = -ENOTCONN;
4823 }
4824 break;
4825 case OID_802_11_SSID:
4826 NdisZeroMemory(&Ssid, sizeof(NDIS_802_11_SSID));
4827 NdisZeroMemory(Ssid.Ssid, MAX_LEN_OF_SSID);
4828 Ssid.SsidLength = pAdapter->CommonCfg.SsidLen;
4829 memcpy(Ssid.Ssid, pAdapter->CommonCfg.Ssid, Ssid.SsidLength);
4830 wrq->u.data.length = sizeof(NDIS_802_11_SSID);
4831 Status = copy_to_user(wrq->u.data.pointer, &Ssid, wrq->u.data.length);
4832 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_SSID (Len=%d, ssid=%s)\n", Ssid.SsidLength,Ssid.Ssid));
4833 break;
4834 case RT_OID_802_11_QUERY_LINK_STATUS:
4835 pLinkStatus = (RT_802_11_LINK_STATUS *) kmalloc(sizeof(RT_802_11_LINK_STATUS), MEM_ALLOC_FLAG);
4836 if (pLinkStatus)
4837 {
4838 pLinkStatus->CurrTxRate = RateIdTo500Kbps[pAdapter->CommonCfg.TxRate]; // unit : 500 kbps
4839 pLinkStatus->ChannelQuality = pAdapter->Mlme.ChannelQuality;
4840 pLinkStatus->RxByteCount = pAdapter->RalinkCounters.ReceivedByteCount;
4841 pLinkStatus->TxByteCount = pAdapter->RalinkCounters.TransmittedByteCount;
4842 pLinkStatus->CentralChannel = pAdapter->CommonCfg.CentralChannel;
4843 wrq->u.data.length = sizeof(RT_802_11_LINK_STATUS);
4844 Status = copy_to_user(wrq->u.data.pointer, pLinkStatus, wrq->u.data.length);
4845 kfree(pLinkStatus);
4846 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_LINK_STATUS\n"));
4847 }
4848 else
4849 {
4850 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_LINK_STATUS(kmalloc failed)\n"));
4851 Status = -EFAULT;
4852 }
4853 break;
4854 case OID_802_11_CONFIGURATION:
4855 pConfiguration = (NDIS_802_11_CONFIGURATION *) kmalloc(sizeof(NDIS_802_11_CONFIGURATION), MEM_ALLOC_FLAG);
4856 if (pConfiguration)
4857 {
4858 pConfiguration->Length = sizeof(NDIS_802_11_CONFIGURATION);
4859 pConfiguration->BeaconPeriod = pAdapter->CommonCfg.BeaconPeriod;
4860 pConfiguration->ATIMWindow = pAdapter->StaActive.AtimWin;
4861 MAP_CHANNEL_ID_TO_KHZ(pAdapter->CommonCfg.Channel, pConfiguration->DSConfig);
4862 wrq->u.data.length = sizeof(NDIS_802_11_CONFIGURATION);
4863 Status = copy_to_user(wrq->u.data.pointer, pConfiguration, wrq->u.data.length);
4864 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_CONFIGURATION(BeaconPeriod=%ld,AtimW=%ld,Channel=%d) \n",
4865 pConfiguration->BeaconPeriod, pConfiguration->ATIMWindow, pAdapter->CommonCfg.Channel));
4866 kfree(pConfiguration);
4867 }
4868 else
4869 {
4870 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_CONFIGURATION(kmalloc failed)\n"));
4871 Status = -EFAULT;
4872 }
4873 break;
4874 case RT_OID_802_11_SNR_0:
4875 if ((pAdapter->StaCfg.LastSNR0 > 0))
4876 {
4877 ulInfo = ((0xeb - pAdapter->StaCfg.LastSNR0) * 3) / 16 ;
4878 wrq->u.data.length = sizeof(ulInfo);
4879 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
4880 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_SNR_0(0x=%lx)\n", ulInfo));
4881 }
4882 else
4883 Status = -EFAULT;
4884 break;
4885 case RT_OID_802_11_SNR_1:
4886 if ((pAdapter->Antenna.field.RxPath > 1) &&
4887 (pAdapter->StaCfg.LastSNR1 > 0))
4888 {
4889 ulInfo = ((0xeb - pAdapter->StaCfg.LastSNR1) * 3) / 16 ;
4890 wrq->u.data.length = sizeof(ulInfo);
4891 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
4892 DBGPRINT(RT_DEBUG_TRACE,("Query::RT_OID_802_11_SNR_1(0x=%lx)\n",ulInfo));
4893 }
4894 else
4895 Status = -EFAULT;
4896 DBGPRINT(RT_DEBUG_TRACE,("Query::RT_OID_802_11_SNR_1(pAdapter->StaCfg.LastSNR1=%d)\n",pAdapter->StaCfg.LastSNR1));
4897 break;
4898 case OID_802_11_RSSI_TRIGGER:
4899 ulInfo = pAdapter->StaCfg.RssiSample.LastRssi0 - pAdapter->BbpRssiToDbmDelta;
4900 wrq->u.data.length = sizeof(ulInfo);
4901 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
4902 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_RSSI_TRIGGER(=%ld)\n", ulInfo));
4903 break;
4904 case OID_802_11_RSSI:
4905 case RT_OID_802_11_RSSI:
4906 ulInfo = pAdapter->StaCfg.RssiSample.LastRssi0;
4907 wrq->u.data.length = sizeof(ulInfo);
4908 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
4909 break;
4910 case RT_OID_802_11_RSSI_1:
4911 ulInfo = pAdapter->StaCfg.RssiSample.LastRssi1;
4912 wrq->u.data.length = sizeof(ulInfo);
4913 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
4914 break;
4915 case RT_OID_802_11_RSSI_2:
4916 ulInfo = pAdapter->StaCfg.RssiSample.LastRssi2;
4917 wrq->u.data.length = sizeof(ulInfo);
4918 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
4919 break;
4920 case OID_802_11_STATISTICS:
4921 pStatistics = (NDIS_802_11_STATISTICS *) kmalloc(sizeof(NDIS_802_11_STATISTICS), MEM_ALLOC_FLAG);
4922 if (pStatistics)
4923 {
4924 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_STATISTICS \n"));
4925 // add the most up-to-date h/w raw counters into software counters
4926 NICUpdateRawCounters(pAdapter);
4927
4928 // Sanity check for calculation of sucessful count
4929 if (pAdapter->WlanCounters.TransmittedFragmentCount.QuadPart < pAdapter->WlanCounters.RetryCount.QuadPart)
4930 pAdapter->WlanCounters.TransmittedFragmentCount.QuadPart = pAdapter->WlanCounters.RetryCount.QuadPart;
4931
4932 pStatistics->TransmittedFragmentCount.QuadPart = pAdapter->WlanCounters.TransmittedFragmentCount.QuadPart;
4933 pStatistics->MulticastTransmittedFrameCount.QuadPart = pAdapter->WlanCounters.MulticastTransmittedFrameCount.QuadPart;
4934 pStatistics->FailedCount.QuadPart = pAdapter->WlanCounters.FailedCount.QuadPart;
4935 pStatistics->RetryCount.QuadPart = pAdapter->WlanCounters.RetryCount.QuadPart;
4936 pStatistics->MultipleRetryCount.QuadPart = pAdapter->WlanCounters.MultipleRetryCount.QuadPart;
4937 pStatistics->RTSSuccessCount.QuadPart = pAdapter->WlanCounters.RTSSuccessCount.QuadPart;
4938 pStatistics->RTSFailureCount.QuadPart = pAdapter->WlanCounters.RTSFailureCount.QuadPart;
4939 pStatistics->ACKFailureCount.QuadPart = pAdapter->WlanCounters.ACKFailureCount.QuadPart;
4940 pStatistics->FrameDuplicateCount.QuadPart = pAdapter->WlanCounters.FrameDuplicateCount.QuadPart;
4941 pStatistics->ReceivedFragmentCount.QuadPart = pAdapter->WlanCounters.ReceivedFragmentCount.QuadPart;
4942 pStatistics->MulticastReceivedFrameCount.QuadPart = pAdapter->WlanCounters.MulticastReceivedFrameCount.QuadPart;
4943 #ifdef DBG
4944 pStatistics->FCSErrorCount = pAdapter->RalinkCounters.RealFcsErrCount;
4945 #else
4946 pStatistics->FCSErrorCount.QuadPart = pAdapter->WlanCounters.FCSErrorCount.QuadPart;
4947 pStatistics->FrameDuplicateCount.u.LowPart = pAdapter->WlanCounters.FrameDuplicateCount.u.LowPart / 100;
4948 #endif
4949 wrq->u.data.length = sizeof(NDIS_802_11_STATISTICS);
4950 Status = copy_to_user(wrq->u.data.pointer, pStatistics, wrq->u.data.length);
4951 kfree(pStatistics);
4952 }
4953 else
4954 {
4955 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_STATISTICS(kmalloc failed)\n"));
4956 Status = -EFAULT;
4957 }
4958 break;
4959 case OID_GEN_RCV_OK:
4960 ulInfo = pAdapter->Counters8023.GoodReceives;
4961 wrq->u.data.length = sizeof(ulInfo);
4962 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
4963 break;
4964 case OID_GEN_RCV_NO_BUFFER:
4965 ulInfo = pAdapter->Counters8023.RxNoBuffer;
4966 wrq->u.data.length = sizeof(ulInfo);
4967 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
4968 break;
4969 case RT_OID_802_11_PHY_MODE:
4970 ulInfo = (ULONG)pAdapter->CommonCfg.PhyMode;
4971 wrq->u.data.length = sizeof(ulInfo);
4972 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
4973 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_PHY_MODE (=%ld)\n", ulInfo));
4974 break;
4975 case RT_OID_802_11_STA_CONFIG:
4976 pStaConfig = (RT_802_11_STA_CONFIG *) kmalloc(sizeof(RT_802_11_STA_CONFIG), MEM_ALLOC_FLAG);
4977 if (pStaConfig)
4978 {
4979 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_STA_CONFIG\n"));
4980 pStaConfig->EnableTxBurst = pAdapter->CommonCfg.bEnableTxBurst;
4981 pStaConfig->EnableTurboRate = 0;
4982 pStaConfig->UseBGProtection = pAdapter->CommonCfg.UseBGProtection;
4983 pStaConfig->UseShortSlotTime = pAdapter->CommonCfg.bUseShortSlotTime;
4984 //pStaConfig->AdhocMode = pAdapter->StaCfg.AdhocMode;
4985 pStaConfig->HwRadioStatus = (pAdapter->StaCfg.bHwRadio == TRUE) ? 1 : 0;
4986 pStaConfig->Rsv1 = 0;
4987 pStaConfig->SystemErrorBitmap = pAdapter->SystemErrorBitmap;
4988 wrq->u.data.length = sizeof(RT_802_11_STA_CONFIG);
4989 Status = copy_to_user(wrq->u.data.pointer, pStaConfig, wrq->u.data.length);
4990 kfree(pStaConfig);
4991 }
4992 else
4993 {
4994 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_STA_CONFIG(kmalloc failed)\n"));
4995 Status = -EFAULT;
4996 }
4997 break;
4998 case OID_802_11_RTS_THRESHOLD:
4999 RtsThresh = pAdapter->CommonCfg.RtsThreshold;
5000 wrq->u.data.length = sizeof(RtsThresh);
5001 Status = copy_to_user(wrq->u.data.pointer, &RtsThresh, wrq->u.data.length);
5002 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_RTS_THRESHOLD(=%ld)\n", RtsThresh));
5003 break;
5004 case OID_802_11_FRAGMENTATION_THRESHOLD:
5005 FragThresh = pAdapter->CommonCfg.FragmentThreshold;
5006 if (pAdapter->CommonCfg.bUseZeroToDisableFragment == TRUE)
5007 FragThresh = 0;
5008 wrq->u.data.length = sizeof(FragThresh);
5009 Status = copy_to_user(wrq->u.data.pointer, &FragThresh, wrq->u.data.length);
5010 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_FRAGMENTATION_THRESHOLD(=%ld)\n", FragThresh));
5011 break;
5012 case OID_802_11_POWER_MODE:
5013 PowerMode = pAdapter->StaCfg.WindowsPowerMode;
5014 wrq->u.data.length = sizeof(PowerMode);
5015 Status = copy_to_user(wrq->u.data.pointer, &PowerMode, wrq->u.data.length);
5016 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_POWER_MODE(=%d)\n", PowerMode));
5017 break;
5018 case RT_OID_802_11_RADIO:
5019 RadioState = (BOOLEAN) pAdapter->StaCfg.bSwRadio;
5020 wrq->u.data.length = sizeof(RadioState);
5021 Status = copy_to_user(wrq->u.data.pointer, &RadioState, wrq->u.data.length);
5022 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_RADIO (=%d)\n", RadioState));
5023 break;
5024 case OID_802_11_INFRASTRUCTURE_MODE:
5025 if (pAdapter->StaCfg.BssType == BSS_ADHOC)
5026 BssType = Ndis802_11IBSS;
5027 else if (pAdapter->StaCfg.BssType == BSS_INFRA)
5028 BssType = Ndis802_11Infrastructure;
5029 else if (pAdapter->StaCfg.BssType == BSS_MONITOR)
5030 BssType = Ndis802_11Monitor;
5031 else
5032 BssType = Ndis802_11AutoUnknown;
5033
5034 wrq->u.data.length = sizeof(BssType);
5035 Status = copy_to_user(wrq->u.data.pointer, &BssType, wrq->u.data.length);
5036 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_INFRASTRUCTURE_MODE(=%d)\n", BssType));
5037 break;
5038 case RT_OID_802_11_PREAMBLE:
5039 PreamType = pAdapter->CommonCfg.TxPreamble;
5040 wrq->u.data.length = sizeof(PreamType);
5041 Status = copy_to_user(wrq->u.data.pointer, &PreamType, wrq->u.data.length);
5042 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_PREAMBLE(=%d)\n", PreamType));
5043 break;
5044 case OID_802_11_AUTHENTICATION_MODE:
5045 AuthMode = pAdapter->StaCfg.AuthMode;
5046 wrq->u.data.length = sizeof(AuthMode);
5047 Status = copy_to_user(wrq->u.data.pointer, &AuthMode, wrq->u.data.length);
5048 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_AUTHENTICATION_MODE(=%d)\n", AuthMode));
5049 break;
5050 case OID_802_11_WEP_STATUS:
5051 WepStatus = pAdapter->StaCfg.WepStatus;
5052 wrq->u.data.length = sizeof(WepStatus);
5053 Status = copy_to_user(wrq->u.data.pointer, &WepStatus, wrq->u.data.length);
5054 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_WEP_STATUS(=%d)\n", WepStatus));
5055 break;
5056 case OID_802_11_TX_POWER_LEVEL:
5057 wrq->u.data.length = sizeof(ULONG);
5058 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CommonCfg.TxPower, wrq->u.data.length);
5059 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_TX_POWER_LEVEL %x\n",pAdapter->CommonCfg.TxPower));
5060 break;
5061 case RT_OID_802_11_TX_POWER_LEVEL_1:
5062 wrq->u.data.length = sizeof(ULONG);
5063 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CommonCfg.TxPowerPercentage, wrq->u.data.length);
5064 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_TX_POWER_LEVEL_1 (=%ld)\n", pAdapter->CommonCfg.TxPowerPercentage));
5065 break;
5066 case OID_802_11_NETWORK_TYPES_SUPPORTED:
5067 if ((pAdapter->RfIcType == RFIC_2850) || (pAdapter->RfIcType == RFIC_2750))
5068 {
5069 NetworkTypeList[0] = 3; // NumberOfItems = 3
5070 NetworkTypeList[1] = Ndis802_11DS; // NetworkType[1] = 11b
5071 NetworkTypeList[2] = Ndis802_11OFDM24; // NetworkType[2] = 11g
5072 NetworkTypeList[3] = Ndis802_11OFDM5; // NetworkType[3] = 11a
5073 wrq->u.data.length = 16;
5074 Status = copy_to_user(wrq->u.data.pointer, &NetworkTypeList[0], wrq->u.data.length);
5075 }
5076 else
5077 {
5078 NetworkTypeList[0] = 2; // NumberOfItems = 2
5079 NetworkTypeList[1] = Ndis802_11DS; // NetworkType[1] = 11b
5080 NetworkTypeList[2] = Ndis802_11OFDM24; // NetworkType[2] = 11g
5081 wrq->u.data.length = 12;
5082 Status = copy_to_user(wrq->u.data.pointer, &NetworkTypeList[0], wrq->u.data.length);
5083 }
5084 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_NETWORK_TYPES_SUPPORTED\n"));
5085 break;
5086 case OID_802_11_NETWORK_TYPE_IN_USE:
5087 wrq->u.data.length = sizeof(ULONG);
5088 if (pAdapter->CommonCfg.PhyMode == PHY_11A)
5089 ulInfo = Ndis802_11OFDM5;
5090 else if ((pAdapter->CommonCfg.PhyMode == PHY_11BG_MIXED) || (pAdapter->CommonCfg.PhyMode == PHY_11G))
5091 ulInfo = Ndis802_11OFDM24;
5092 else
5093 ulInfo = Ndis802_11DS;
5094 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
5095 break;
5096 case RT_OID_802_11_QUERY_LAST_RX_RATE:
5097 ulInfo = (ULONG)pAdapter->LastRxRate;
5098 wrq->u.data.length = sizeof(ulInfo);
5099 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
5100 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_LAST_RX_RATE (=%ld)\n", ulInfo));
5101 break;
5102 case RT_OID_802_11_QUERY_LAST_TX_RATE:
5103 //ulInfo = (ULONG)pAdapter->LastTxRate;
5104 ulInfo = (ULONG)pAdapter->MacTab.Content[BSSID_WCID].HTPhyMode.word;
5105 wrq->u.data.length = sizeof(ulInfo);
5106 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
5107 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_LAST_TX_RATE (=%lx)\n", ulInfo));
5108 break;
5109 case RT_OID_802_11_QUERY_EEPROM_VERSION:
5110 wrq->u.data.length = sizeof(ULONG);
5111 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->EepromVersion, wrq->u.data.length);
5112 break;
5113 case RT_OID_802_11_QUERY_FIRMWARE_VERSION:
5114 wrq->u.data.length = sizeof(ULONG);
5115 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->FirmwareVersion, wrq->u.data.length);
5116 break;
5117 case RT_OID_802_11_QUERY_NOISE_LEVEL:
5118 wrq->u.data.length = sizeof(UCHAR);
5119 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->BbpWriteLatch[66], wrq->u.data.length);
5120 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_NOISE_LEVEL (=%d)\n", pAdapter->BbpWriteLatch[66]));
5121 break;
5122 case RT_OID_802_11_EXTRA_INFO:
5123 wrq->u.data.length = sizeof(ULONG);
5124 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->ExtraInfo, wrq->u.data.length);
5125 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_EXTRA_INFO (=%ld)\n", pAdapter->ExtraInfo));
5126 break;
5127 case RT_OID_WE_VERSION_COMPILED:
5128 wrq->u.data.length = sizeof(UINT);
5129 we_version_compiled = WIRELESS_EXT;
5130 Status = copy_to_user(wrq->u.data.pointer, &we_version_compiled, wrq->u.data.length);
5131 break;
5132 case RT_OID_802_11_QUERY_APSD_SETTING:
5133 apsd = (pAdapter->CommonCfg.bAPSDCapable | (pAdapter->CommonCfg.bAPSDAC_BE << 1) | (pAdapter->CommonCfg.bAPSDAC_BK << 2)
5134 | (pAdapter->CommonCfg.bAPSDAC_VI << 3) | (pAdapter->CommonCfg.bAPSDAC_VO << 4) | (pAdapter->CommonCfg.MaxSPLength << 5));
5135
5136 wrq->u.data.length = sizeof(ULONG);
5137 Status = copy_to_user(wrq->u.data.pointer, &apsd, wrq->u.data.length);
5138 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_APSD_SETTING (=0x%lx,APSDCap=%d,AC_BE=%d,AC_BK=%d,AC_VI=%d,AC_VO=%d,MAXSPLen=%d)\n",
5139 apsd,pAdapter->CommonCfg.bAPSDCapable,pAdapter->CommonCfg.bAPSDAC_BE,pAdapter->CommonCfg.bAPSDAC_BK,pAdapter->CommonCfg.bAPSDAC_VI,pAdapter->CommonCfg.bAPSDAC_VO,pAdapter->CommonCfg.MaxSPLength));
5140 break;
5141 case RT_OID_802_11_QUERY_APSD_PSM:
5142 wrq->u.data.length = sizeof(ULONG);
5143 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CommonCfg.bAPSDForcePowerSave, wrq->u.data.length);
5144 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_APSD_PSM (=%d)\n", pAdapter->CommonCfg.bAPSDForcePowerSave));
5145 break;
5146 case RT_OID_802_11_QUERY_WMM:
5147 wrq->u.data.length = sizeof(BOOLEAN);
5148 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CommonCfg.bWmmCapable, wrq->u.data.length);
5149 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_WMM (=%d)\n", pAdapter->CommonCfg.bWmmCapable));
5150 break;
5151 #ifdef WPA_SUPPLICANT_SUPPORT
5152 case RT_OID_NEW_DRIVER:
5153 {
5154 UCHAR enabled = 1;
5155 wrq->u.data.length = sizeof(UCHAR);
5156 Status = copy_to_user(wrq->u.data.pointer, &enabled, wrq->u.data.length);
5157 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_NEW_DRIVER (=%d)\n", enabled));
5158 }
5159 break;
5160 case RT_OID_WPA_SUPPLICANT_SUPPORT:
5161 wrq->u.data.length = sizeof(UCHAR);
5162 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->StaCfg.WpaSupplicantUP, wrq->u.data.length);
5163 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_WPA_SUPPLICANT_SUPPORT (=%d)\n", pAdapter->StaCfg.WpaSupplicantUP));
5164 break;
5165 #endif // WPA_SUPPLICANT_SUPPORT //
5166
5167 case RT_OID_DRIVER_DEVICE_NAME:
5168 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_DRIVER_DEVICE_NAME \n"));
5169 wrq->u.data.length = 16;
5170 if (copy_to_user(wrq->u.data.pointer, pAdapter->StaCfg.dev_name, wrq->u.data.length))
5171 {
5172 Status = -EFAULT;
5173 }
5174 break;
5175 case RT_OID_802_11_QUERY_HT_PHYMODE:
5176 pHTPhyMode = (OID_SET_HT_PHYMODE *) kmalloc(sizeof(OID_SET_HT_PHYMODE), MEM_ALLOC_FLAG);
5177 if (pHTPhyMode)
5178 {
5179 pHTPhyMode->PhyMode = pAdapter->CommonCfg.PhyMode;
5180 pHTPhyMode->HtMode = (UCHAR)pAdapter->MacTab.Content[BSSID_WCID].HTPhyMode.field.MODE;
5181 pHTPhyMode->BW = (UCHAR)pAdapter->MacTab.Content[BSSID_WCID].HTPhyMode.field.BW;
5182 pHTPhyMode->MCS= (UCHAR)pAdapter->MacTab.Content[BSSID_WCID].HTPhyMode.field.MCS;
5183 pHTPhyMode->SHORTGI= (UCHAR)pAdapter->MacTab.Content[BSSID_WCID].HTPhyMode.field.ShortGI;
5184 pHTPhyMode->STBC= (UCHAR)pAdapter->MacTab.Content[BSSID_WCID].HTPhyMode.field.STBC;
5185
5186 pHTPhyMode->ExtOffset = ((pAdapter->CommonCfg.CentralChannel < pAdapter->CommonCfg.Channel) ? (EXTCHA_BELOW) : (EXTCHA_ABOVE));
5187 wrq->u.data.length = sizeof(OID_SET_HT_PHYMODE);
5188 if (copy_to_user(wrq->u.data.pointer, pHTPhyMode, wrq->u.data.length))
5189 {
5190 Status = -EFAULT;
5191 }
5192 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_HT_PHYMODE (PhyMode = %d, MCS =%d, BW = %d, STBC = %d, ExtOffset=%d)\n",
5193 pHTPhyMode->HtMode, pHTPhyMode->MCS, pHTPhyMode->BW, pHTPhyMode->STBC, pHTPhyMode->ExtOffset));
5194 DBGPRINT(RT_DEBUG_TRACE, (" MlmeUpdateTxRates (.word = %x )\n", pAdapter->MacTab.Content[BSSID_WCID].HTPhyMode.word));
5195 }
5196 else
5197 {
5198 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_STA_CONFIG(kmalloc failed)\n"));
5199 Status = -EFAULT;
5200 }
5201 break;
5202 case RT_OID_802_11_COUNTRY_REGION:
5203 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_COUNTRY_REGION \n"));
5204 wrq->u.data.length = sizeof(ulInfo);
5205 ulInfo = pAdapter->CommonCfg.CountryRegionForABand;
5206 ulInfo = (ulInfo << 8)|(pAdapter->CommonCfg.CountryRegion);
5207 if (copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length))
5208 {
5209 Status = -EFAULT;
5210 }
5211 break;
5212 case RT_OID_802_11_QUERY_DAT_HT_PHYMODE:
5213 pHTPhyMode = (OID_SET_HT_PHYMODE *) kmalloc(sizeof(OID_SET_HT_PHYMODE), MEM_ALLOC_FLAG);
5214 if (pHTPhyMode)
5215 {
5216 pHTPhyMode->PhyMode = pAdapter->CommonCfg.PhyMode;
5217 pHTPhyMode->HtMode = (UCHAR)pAdapter->CommonCfg.RegTransmitSetting.field.HTMODE;
5218 pHTPhyMode->BW = (UCHAR)pAdapter->CommonCfg.RegTransmitSetting.field.BW;
5219 pHTPhyMode->MCS= (UCHAR)pAdapter->StaCfg.DesiredTransmitSetting.field.MCS;
5220 pHTPhyMode->SHORTGI= (UCHAR)pAdapter->CommonCfg.RegTransmitSetting.field.ShortGI;
5221 pHTPhyMode->STBC= (UCHAR)pAdapter->CommonCfg.RegTransmitSetting.field.STBC;
5222
5223 wrq->u.data.length = sizeof(OID_SET_HT_PHYMODE);
5224 if (copy_to_user(wrq->u.data.pointer, pHTPhyMode, wrq->u.data.length))
5225 {
5226 Status = -EFAULT;
5227 }
5228 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_HT_PHYMODE (PhyMode = %d, MCS =%d, BW = %d, STBC = %d, ExtOffset=%d)\n",
5229 pHTPhyMode->HtMode, pHTPhyMode->MCS, pHTPhyMode->BW, pHTPhyMode->STBC, pHTPhyMode->ExtOffset));
5230 DBGPRINT(RT_DEBUG_TRACE, (" MlmeUpdateTxRates (.word = %x )\n", pAdapter->MacTab.Content[BSSID_WCID].HTPhyMode.word));
5231 }
5232 else
5233 {
5234 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_STA_CONFIG(kmalloc failed)\n"));
5235 Status = -EFAULT;
5236 }
5237 break;
5238 case RT_OID_QUERY_MULTIPLE_CARD_SUPPORT:
5239 wrq->u.data.length = sizeof(UCHAR);
5240 i = 0;
5241 #ifdef MULTIPLE_CARD_SUPPORT
5242 i = 1;
5243 #endif // MULTIPLE_CARD_SUPPORT //
5244 if (copy_to_user(wrq->u.data.pointer, &i, wrq->u.data.length))
5245 {
5246 Status = -EFAULT;
5247 }
5248 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_QUERY_MULTIPLE_CARD_SUPPORT(=%d) \n", i));
5249 break;
5250 #ifdef SNMP_SUPPORT
5251 case RT_OID_802_11_MAC_ADDRESS:
5252 wrq->u.data.length = MAC_ADDR_LEN;
5253 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CurrentAddress, wrq->u.data.length);
5254 break;
5255
5256 case RT_OID_802_11_MANUFACTUREROUI:
5257 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_MANUFACTUREROUI \n"));
5258 wrq->u.data.length = ManufacturerOUI_LEN;
5259 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CurrentAddress, wrq->u.data.length);
5260 break;
5261
5262 case RT_OID_802_11_MANUFACTURERNAME:
5263 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_MANUFACTURERNAME \n"));
5264 wrq->u.data.length = strlen(ManufacturerNAME);
5265 Status = copy_to_user(wrq->u.data.pointer, ManufacturerNAME, wrq->u.data.length);
5266 break;
5267
5268 case RT_OID_802_11_RESOURCETYPEIDNAME:
5269 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_RESOURCETYPEIDNAME \n"));
5270 wrq->u.data.length = strlen(ResourceTypeIdName);
5271 Status = copy_to_user(wrq->u.data.pointer, ResourceTypeIdName, wrq->u.data.length);
5272 break;
5273
5274 case RT_OID_802_11_PRIVACYOPTIONIMPLEMENTED:
5275 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_PRIVACYOPTIONIMPLEMENTED \n"));
5276 ulInfo = 1; // 1 is support wep else 2 is not support.
5277 wrq->u.data.length = sizeof(ulInfo);
5278 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
5279 break;
5280
5281 case RT_OID_802_11_POWERMANAGEMENTMODE:
5282 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_POWERMANAGEMENTMODE \n"));
5283 if (pAdapter->StaCfg.Psm == PSMP_ACTION)
5284 ulInfo = 1; // 1 is power active else 2 is power save.
5285 else
5286 ulInfo = 2;
5287
5288 wrq->u.data.length = sizeof(ulInfo);
5289 Status = copy_to_user(wrq->u.data.pointer, &ulInfo, wrq->u.data.length);
5290 break;
5291
5292 case OID_802_11_WEPDEFAULTKEYVALUE:
5293 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_WEPDEFAULTKEYVALUE \n"));
5294 //KeyIdxValue.KeyIdx = pAd->PortCfg.MBSSID[pAd->IoctlIF].DefaultKeyId;
5295 pKeyIdxValue = wrq->u.data.pointer;
5296 DBGPRINT(RT_DEBUG_TRACE,("KeyIdxValue.KeyIdx = %d, \n",pKeyIdxValue->KeyIdx));
5297 valueLen = pAdapter->SharedKey[BSS0][pAdapter->StaCfg.DefaultKeyId].KeyLen;
5298 NdisMoveMemory(pKeyIdxValue->Value,
5299 &pAdapter->SharedKey[BSS0][pAdapter->StaCfg.DefaultKeyId].Key,
5300 valueLen);
5301 pKeyIdxValue->Value[valueLen]='\0';
5302
5303 wrq->u.data.length = sizeof(DefaultKeyIdxValue);
5304
5305 Status = copy_to_user(wrq->u.data.pointer, pKeyIdxValue, wrq->u.data.length);
5306 DBGPRINT(RT_DEBUG_TRACE,("DefaultKeyId = %d, total len = %d, str len=%d, KeyValue= %02x %02x %02x %02x \n", pAdapter->StaCfg.DefaultKeyId, wrq->u.data.length, pAdapter->SharedKey[BSS0][pAdapter->StaCfg.DefaultKeyId].KeyLen,
5307 pAdapter->SharedKey[BSS0][0].Key[0],
5308 pAdapter->SharedKey[BSS0][1].Key[0],
5309 pAdapter->SharedKey[BSS0][2].Key[0],
5310 pAdapter->SharedKey[BSS0][3].Key[0]));
5311 break;
5312
5313 case OID_802_11_WEPDEFAULTKEYID:
5314 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_WEPDEFAULTKEYID \n"));
5315 wrq->u.data.length = sizeof(UCHAR);
5316 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->StaCfg.DefaultKeyId, wrq->u.data.length);
5317 DBGPRINT(RT_DEBUG_TRACE, ("DefaultKeyId =%d \n", pAdapter->StaCfg.DefaultKeyId));
5318 break;
5319
5320 case RT_OID_802_11_WEPKEYMAPPINGLENGTH:
5321 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_WEPKEYMAPPINGLENGTH \n"));
5322 wrq->u.data.length = sizeof(UCHAR);
5323 Status = copy_to_user(wrq->u.data.pointer,
5324 &pAdapter->SharedKey[BSS0][pAdapter->StaCfg.DefaultKeyId].KeyLen,
5325 wrq->u.data.length);
5326 break;
5327
5328 case OID_802_11_SHORTRETRYLIMIT:
5329 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_SHORTRETRYLIMIT \n"));
5330 wrq->u.data.length = sizeof(ULONG);
5331 RTMP_IO_READ32(pAdapter, TX_RTY_CFG, &tx_rty_cfg.word);
5332 ShortRetryLimit = tx_rty_cfg.field.ShortRtyLimit;
5333 DBGPRINT(RT_DEBUG_TRACE, ("ShortRetryLimit =%ld, tx_rty_cfg.field.ShortRetryLimit=%d\n", ShortRetryLimit, tx_rty_cfg.field.ShortRtyLimit));
5334 Status = copy_to_user(wrq->u.data.pointer, &ShortRetryLimit, wrq->u.data.length);
5335 break;
5336
5337 case OID_802_11_LONGRETRYLIMIT:
5338 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_LONGRETRYLIMIT \n"));
5339 wrq->u.data.length = sizeof(ULONG);
5340 RTMP_IO_READ32(pAdapter, TX_RTY_CFG, &tx_rty_cfg.word);
5341 LongRetryLimit = tx_rty_cfg.field.LongRtyLimit;
5342 DBGPRINT(RT_DEBUG_TRACE, ("LongRetryLimit =%ld, tx_rty_cfg.field.LongRtyLimit=%d\n", LongRetryLimit, tx_rty_cfg.field.LongRtyLimit));
5343 Status = copy_to_user(wrq->u.data.pointer, &LongRetryLimit, wrq->u.data.length);
5344 break;
5345
5346 case RT_OID_802_11_PRODUCTID:
5347 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_PRODUCTID \n"));
5348
5349 #ifdef RT2870
5350 sprintf(tmp, "%04x %04x\n", ((POS_COOKIE)pAdapter->OS_Cookie)->pUsb_Dev->descriptor.idVendor ,((POS_COOKIE)pAdapter->OS_Cookie)->pUsb_Dev->descriptor.idProduct);
5351
5352 #endif // RT2870 //
5353 wrq->u.data.length = strlen(tmp);
5354 Status = copy_to_user(wrq->u.data.pointer, tmp, wrq->u.data.length);
5355 break;
5356
5357 case RT_OID_802_11_MANUFACTUREID:
5358 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_MANUFACTUREID \n"));
5359 wrq->u.data.length = strlen(ManufacturerNAME);
5360 Status = copy_to_user(wrq->u.data.pointer, ManufacturerNAME, wrq->u.data.length);
5361 break;
5362
5363 case OID_802_11_CURRENTCHANNEL:
5364 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_CURRENTCHANNEL \n"));
5365 wrq->u.data.length = sizeof(UCHAR);
5366 DBGPRINT(RT_DEBUG_TRACE, ("sizeof UCHAR=%d, channel=%d \n", sizeof(UCHAR), pAdapter->CommonCfg.Channel));
5367 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CommonCfg.Channel, wrq->u.data.length);
5368 DBGPRINT(RT_DEBUG_TRACE, ("Status=%d\n", Status));
5369 break;
5370 #endif //SNMP_SUPPORT
5371
5372 case OID_802_11_BUILD_CHANNEL_EX:
5373 {
5374 UCHAR value;
5375 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_BUILD_CHANNEL_EX \n"));
5376 wrq->u.data.length = sizeof(UCHAR);
5377 #ifdef EXT_BUILD_CHANNEL_LIST
5378 DBGPRINT(RT_DEBUG_TRACE, ("Support EXT_BUILD_CHANNEL_LIST.\n"));
5379 value = 1;
5380 #else
5381 DBGPRINT(RT_DEBUG_TRACE, ("Doesn't support EXT_BUILD_CHANNEL_LIST.\n"));
5382 value = 0;
5383 #endif // EXT_BUILD_CHANNEL_LIST //
5384 Status = copy_to_user(wrq->u.data.pointer, &value, 1);
5385 DBGPRINT(RT_DEBUG_TRACE, ("Status=%d\n", Status));
5386 }
5387 break;
5388
5389 case OID_802_11_GET_CH_LIST:
5390 {
5391 PRT_CHANNEL_LIST_INFO pChListBuf;
5392
5393 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_GET_CH_LIST \n"));
5394 if (pAdapter->ChannelListNum == 0)
5395 {
5396 wrq->u.data.length = 0;
5397 break;
5398 }
5399
5400 pChListBuf = (RT_CHANNEL_LIST_INFO *) kmalloc(sizeof(RT_CHANNEL_LIST_INFO), MEM_ALLOC_FLAG);
5401 if (pChListBuf == NULL)
5402 {
5403 wrq->u.data.length = 0;
5404 break;
5405 }
5406
5407 pChListBuf->ChannelListNum = pAdapter->ChannelListNum;
5408 for (i = 0; i < pChListBuf->ChannelListNum; i++)
5409 pChListBuf->ChannelList[i] = pAdapter->ChannelList[i].Channel;
5410
5411 wrq->u.data.length = sizeof(RT_CHANNEL_LIST_INFO);
5412 Status = copy_to_user(wrq->u.data.pointer, pChListBuf, sizeof(RT_CHANNEL_LIST_INFO));
5413 DBGPRINT(RT_DEBUG_TRACE, ("Status=%d\n", Status));
5414
5415 if (pChListBuf)
5416 kfree(pChListBuf);
5417 }
5418 break;
5419
5420 case OID_802_11_GET_COUNTRY_CODE:
5421 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_GET_COUNTRY_CODE \n"));
5422 wrq->u.data.length = 2;
5423 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CommonCfg.CountryCode, 2);
5424 DBGPRINT(RT_DEBUG_TRACE, ("Status=%d\n", Status));
5425 break;
5426
5427 case OID_802_11_GET_CHANNEL_GEOGRAPHY:
5428 DBGPRINT(RT_DEBUG_TRACE, ("Query::OID_802_11_GET_CHANNEL_GEOGRAPHY \n"));
5429 wrq->u.data.length = 1;
5430 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CommonCfg.Geography, 1);
5431 DBGPRINT(RT_DEBUG_TRACE, ("Status=%d\n", Status));
5432 break;
5433
5434
5435 #ifdef QOS_DLS_SUPPORT
5436 case RT_OID_802_11_QUERY_DLS:
5437 wrq->u.data.length = sizeof(BOOLEAN);
5438 Status = copy_to_user(wrq->u.data.pointer, &pAdapter->CommonCfg.bDLSCapable, wrq->u.data.length);
5439 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_DLS(=%d)\n", pAdapter->CommonCfg.bDLSCapable));
5440 break;
5441
5442 case RT_OID_802_11_QUERY_DLS_PARAM:
5443 {
5444 PRT_802_11_DLS_INFO pDlsInfo = kmalloc(sizeof(RT_802_11_DLS_INFO), GFP_ATOMIC);
5445 if (pDlsInfo == NULL)
5446 break;
5447
5448 for (i=0; i<MAX_NUM_OF_DLS_ENTRY; i++)
5449 {
5450 RTMPMoveMemory(&pDlsInfo->Entry[i], &pAdapter->StaCfg.DLSEntry[i], sizeof(RT_802_11_DLS_UI));
5451 }
5452
5453 pDlsInfo->num = MAX_NUM_OF_DLS_ENTRY;
5454 wrq->u.data.length = sizeof(RT_802_11_DLS_INFO);
5455 Status = copy_to_user(wrq->u.data.pointer, pDlsInfo, wrq->u.data.length);
5456 DBGPRINT(RT_DEBUG_TRACE, ("Query::RT_OID_802_11_QUERY_DLS_PARAM\n"));
5457
5458 if (pDlsInfo)
5459 kfree(pDlsInfo);
5460 }
5461 break;
5462 #endif // QOS_DLS_SUPPORT //
5463 default:
5464 DBGPRINT(RT_DEBUG_TRACE, ("Query::unknown IOCTL's subcmd = 0x%08x\n", cmd));
5465 Status = -EOPNOTSUPP;
5466 break;
5467 }
5468 return Status;
5469 }
5470
5471 INT rt28xx_sta_ioctl(
5472 IN struct net_device *net_dev,
5473 IN OUT struct ifreq *rq,
5474 IN INT cmd)
5475 {
5476 POS_COOKIE pObj;
5477 VIRTUAL_ADAPTER *pVirtualAd = NULL;
5478 RTMP_ADAPTER *pAd = NULL;
5479 struct iwreq *wrq = (struct iwreq *) rq;
5480 BOOLEAN StateMachineTouched = FALSE;
5481 INT Status = NDIS_STATUS_SUCCESS;
5482 USHORT subcmd;
5483
5484 if (net_dev->priv_flags == INT_MAIN)
5485 {
5486 pAd = net_dev->ml_priv;
5487 }
5488 else
5489 {
5490 pVirtualAd = net_dev->ml_priv;
5491 pAd = pVirtualAd->RtmpDev->ml_priv;
5492 }
5493 pObj = (POS_COOKIE) pAd->OS_Cookie;
5494
5495 if (pAd == NULL)
5496 {
5497 /* if 1st open fail, pAd will be free;
5498 So the net_dev->ml_priv will be NULL in 2rd open */
5499 return -ENETDOWN;
5500 }
5501
5502 //check if the interface is down
5503 if(!RTMP_TEST_FLAG(pAd, fRTMP_ADAPTER_INTERRUPT_IN_USE))
5504 {
5505 #ifdef CONFIG_APSTA_MIXED_SUPPORT
5506 if (wrq->u.data.pointer == NULL)
5507 {
5508 return Status;
5509 }
5510
5511 if (strstr(wrq->u.data.pointer, "OpMode") == NULL)
5512 #endif // CONFIG_APSTA_MIXED_SUPPORT //
5513 {
5514 DBGPRINT(RT_DEBUG_TRACE, ("INFO::Network is down!\n"));
5515 return -ENETDOWN;
5516 }
5517 }
5518
5519 { // determine this ioctl command is comming from which interface.
5520 pObj->ioctl_if_type = INT_MAIN;
5521 pObj->ioctl_if = MAIN_MBSSID;
5522 }
5523
5524 switch(cmd)
5525 {
5526 #ifdef RALINK_ATE
5527 #ifdef RALINK_28xx_QA
5528 case RTPRIV_IOCTL_ATE:
5529 {
5530 RtmpDoAte(pAd, wrq);
5531 }
5532 break;
5533 #endif // RALINK_28xx_QA //
5534 #endif // RALINK_ATE //
5535 case SIOCGIFHWADDR:
5536 DBGPRINT(RT_DEBUG_TRACE, ("IOCTL::SIOCGIFHWADDR\n"));
5537 memcpy(wrq->u.name, pAd->CurrentAddress, ETH_ALEN);
5538 break;
5539 case SIOCGIWNAME:
5540 {
5541 char *name=&wrq->u.name[0];
5542 rt_ioctl_giwname(net_dev, NULL, name, NULL);
5543 break;
5544 }
5545 case SIOCGIWESSID: //Get ESSID
5546 {
5547 struct iw_point *essid=&wrq->u.essid;
5548 rt_ioctl_giwessid(net_dev, NULL, essid, essid->pointer);
5549 break;
5550 }
5551 case SIOCSIWESSID: //Set ESSID
5552 {
5553 struct iw_point *essid=&wrq->u.essid;
5554 rt_ioctl_siwessid(net_dev, NULL, essid, essid->pointer);
5555 break;
5556 }
5557 case SIOCSIWNWID: // set network id (the cell)
5558 case SIOCGIWNWID: // get network id
5559 Status = -EOPNOTSUPP;
5560 break;
5561 case SIOCSIWFREQ: //set channel/frequency (Hz)
5562 {
5563 struct iw_freq *freq=&wrq->u.freq;
5564 rt_ioctl_siwfreq(net_dev, NULL, freq, NULL);
5565 break;
5566 }
5567 case SIOCGIWFREQ: // get channel/frequency (Hz)
5568 {
5569 struct iw_freq *freq=&wrq->u.freq;
5570 rt_ioctl_giwfreq(net_dev, NULL, freq, NULL);
5571 break;
5572 }
5573 case SIOCSIWNICKN: //set node name/nickname
5574 {
5575 struct iw_point *data=&wrq->u.data;
5576 rt_ioctl_siwnickn(net_dev, NULL, data, NULL);
5577 break;
5578 }
5579 case SIOCGIWNICKN: //get node name/nickname
5580 {
5581 struct iw_point *data=&wrq->u.data;
5582 rt_ioctl_giwnickn(net_dev, NULL, data, NULL);
5583 break;
5584 }
5585 case SIOCGIWRATE: //get default bit rate (bps)
5586 rt_ioctl_giwrate(net_dev, NULL, &wrq->u, NULL);
5587 break;
5588 case SIOCSIWRATE: //set default bit rate (bps)
5589 rt_ioctl_siwrate(net_dev, NULL, &wrq->u, NULL);
5590 break;
5591 case SIOCGIWRTS: // get RTS/CTS threshold (bytes)
5592 {
5593 struct iw_param *rts=&wrq->u.rts;
5594 rt_ioctl_giwrts(net_dev, NULL, rts, NULL);
5595 break;
5596 }
5597 case SIOCSIWRTS: //set RTS/CTS threshold (bytes)
5598 {
5599 struct iw_param *rts=&wrq->u.rts;
5600 rt_ioctl_siwrts(net_dev, NULL, rts, NULL);
5601 break;
5602 }
5603 case SIOCGIWFRAG: //get fragmentation thr (bytes)
5604 {
5605 struct iw_param *frag=&wrq->u.frag;
5606 rt_ioctl_giwfrag(net_dev, NULL, frag, NULL);
5607 break;
5608 }
5609 case SIOCSIWFRAG: //set fragmentation thr (bytes)
5610 {
5611 struct iw_param *frag=&wrq->u.frag;
5612 rt_ioctl_siwfrag(net_dev, NULL, frag, NULL);
5613 break;
5614 }
5615 case SIOCGIWENCODE: //get encoding token & mode
5616 {
5617 struct iw_point *erq=&wrq->u.encoding;
5618 if(erq->pointer)
5619 rt_ioctl_giwencode(net_dev, NULL, erq, erq->pointer);
5620 break;
5621 }
5622 case SIOCSIWENCODE: //set encoding token & mode
5623 {
5624 struct iw_point *erq=&wrq->u.encoding;
5625 if(erq->pointer)
5626 rt_ioctl_siwencode(net_dev, NULL, erq, erq->pointer);
5627 break;
5628 }
5629 case SIOCGIWAP: //get access point MAC addresses
5630 {
5631 struct sockaddr *ap_addr=&wrq->u.ap_addr;
5632 rt_ioctl_giwap(net_dev, NULL, ap_addr, ap_addr->sa_data);
5633 break;
5634 }
5635 case SIOCSIWAP: //set access point MAC addresses
5636 {
5637 struct sockaddr *ap_addr=&wrq->u.ap_addr;
5638 rt_ioctl_siwap(net_dev, NULL, ap_addr, ap_addr->sa_data);
5639 break;
5640 }
5641 case SIOCGIWMODE: //get operation mode
5642 {
5643 __u32 *mode=&wrq->u.mode;
5644 rt_ioctl_giwmode(net_dev, NULL, mode, NULL);
5645 break;
5646 }
5647 case SIOCSIWMODE: //set operation mode
5648 {
5649 __u32 *mode=&wrq->u.mode;
5650 rt_ioctl_siwmode(net_dev, NULL, mode, NULL);
5651 break;
5652 }
5653 case SIOCGIWSENS: //get sensitivity (dBm)
5654 case SIOCSIWSENS: //set sensitivity (dBm)
5655 case SIOCGIWPOWER: //get Power Management settings
5656 case SIOCSIWPOWER: //set Power Management settings
5657 case SIOCGIWTXPOW: //get transmit power (dBm)
5658 case SIOCSIWTXPOW: //set transmit power (dBm)
5659 case SIOCGIWRANGE: //Get range of parameters
5660 case SIOCGIWRETRY: //get retry limits and lifetime
5661 case SIOCSIWRETRY: //set retry limits and lifetime
5662 Status = -EOPNOTSUPP;
5663 break;
5664 case RT_PRIV_IOCTL:
5665 subcmd = wrq->u.data.flags;
5666 if( subcmd & OID_GET_SET_TOGGLE)
5667 Status = RTMPSetInformation(pAd, rq, subcmd);
5668 else
5669 Status = RTMPQueryInformation(pAd, rq, subcmd);
5670 break;
5671 case SIOCGIWPRIV:
5672 if (wrq->u.data.pointer)
5673 {
5674 if ( access_ok(VERIFY_WRITE, wrq->u.data.pointer, sizeof(privtab)) != TRUE)
5675 break;
5676 wrq->u.data.length = sizeof(privtab) / sizeof(privtab[0]);
5677 if (copy_to_user(wrq->u.data.pointer, privtab, sizeof(privtab)))
5678 Status = -EFAULT;
5679 }
5680 break;
5681 case RTPRIV_IOCTL_SET:
5682 if(access_ok(VERIFY_READ, wrq->u.data.pointer, wrq->u.data.length) != TRUE)
5683 break;
5684 rt_ioctl_setparam(net_dev, NULL, NULL, wrq->u.data.pointer);
5685 break;
5686 case RTPRIV_IOCTL_GSITESURVEY:
5687 RTMPIoctlGetSiteSurvey(pAd, wrq);
5688 break;
5689 #ifdef DBG
5690 case RTPRIV_IOCTL_MAC:
5691 RTMPIoctlMAC(pAd, wrq);
5692 break;
5693 case RTPRIV_IOCTL_E2P:
5694 RTMPIoctlE2PROM(pAd, wrq);
5695 break;
5696 #endif // DBG //
5697 case SIOCETHTOOL:
5698 break;
5699 default:
5700 DBGPRINT(RT_DEBUG_ERROR, ("IOCTL::unknown IOCTL's cmd = 0x%08x\n", cmd));
5701 Status = -EOPNOTSUPP;
5702 break;
5703 }
5704
5705 if(StateMachineTouched) // Upper layer sent a MLME-related operations
5706 RT28XX_MLME_HANDLER(pAd);
5707
5708 return Status;
5709 }
5710
5711 /*
5712 ==========================================================================
5713 Description:
5714 Set SSID
5715 Return:
5716 TRUE if all parameters are OK, FALSE otherwise
5717 ==========================================================================
5718 */
5719 INT Set_SSID_Proc(
5720 IN PRTMP_ADAPTER pAdapter,
5721 IN PUCHAR arg)
5722 {
5723 NDIS_802_11_SSID Ssid, *pSsid=NULL;
5724 BOOLEAN StateMachineTouched = FALSE;
5725 int success = TRUE;
5726
5727 if( strlen(arg) <= MAX_LEN_OF_SSID)
5728 {
5729 NdisZeroMemory(&Ssid, sizeof(NDIS_802_11_SSID));
5730 if (strlen(arg) != 0)
5731 {
5732 NdisMoveMemory(Ssid.Ssid, arg, strlen(arg));
5733 Ssid.SsidLength = strlen(arg);
5734 }
5735 else //ANY ssid
5736 {
5737 Ssid.SsidLength = 0;
5738 memcpy(Ssid.Ssid, "", 0);
5739 pAdapter->StaCfg.BssType = BSS_INFRA;
5740 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeOpen;
5741 pAdapter->StaCfg.WepStatus = Ndis802_11EncryptionDisabled;
5742 }
5743 pSsid = &Ssid;
5744
5745 if (pAdapter->Mlme.CntlMachine.CurrState != CNTL_IDLE)
5746 {
5747 RT28XX_MLME_RESET_STATE_MACHINE(pAdapter);
5748 DBGPRINT(RT_DEBUG_TRACE, ("!!! MLME busy, reset MLME state machine !!!\n"));
5749 }
5750
5751 pAdapter->MlmeAux.CurrReqIsFromNdis = TRUE;
5752 pAdapter->StaCfg.bScanReqIsFromWebUI = FALSE;
5753 pAdapter->bConfigChanged = TRUE;
5754
5755 MlmeEnqueue(pAdapter,
5756 MLME_CNTL_STATE_MACHINE,
5757 OID_802_11_SSID,
5758 sizeof(NDIS_802_11_SSID),
5759 (VOID *)pSsid);
5760
5761 StateMachineTouched = TRUE;
5762 DBGPRINT(RT_DEBUG_TRACE, ("Set_SSID_Proc::(Len=%d,Ssid=%s)\n", Ssid.SsidLength, Ssid.Ssid));
5763 }
5764 else
5765 success = FALSE;
5766
5767 if (StateMachineTouched) // Upper layer sent a MLME-related operations
5768 RT28XX_MLME_HANDLER(pAdapter);
5769
5770 return success;
5771 }
5772
5773 #ifdef WMM_SUPPORT
5774 /*
5775 ==========================================================================
5776 Description:
5777 Set WmmCapable Enable or Disable
5778 Return:
5779 TRUE if all parameters are OK, FALSE otherwise
5780 ==========================================================================
5781 */
5782 INT Set_WmmCapable_Proc(
5783 IN PRTMP_ADAPTER pAd,
5784 IN PUCHAR arg)
5785 {
5786 BOOLEAN bWmmCapable;
5787
5788 bWmmCapable = simple_strtol(arg, 0, 10);
5789
5790 if ((bWmmCapable == 1)
5791 #ifdef RT2870
5792 && (pAd->NumberOfPipes >= 5)
5793 #endif // RT2870 //
5794 )
5795 pAd->CommonCfg.bWmmCapable = TRUE;
5796 else if (bWmmCapable == 0)
5797 pAd->CommonCfg.bWmmCapable = FALSE;
5798 else
5799 return FALSE; //Invalid argument
5800
5801 DBGPRINT(RT_DEBUG_TRACE, ("Set_WmmCapable_Proc::(bWmmCapable=%d)\n",
5802 pAd->CommonCfg.bWmmCapable));
5803
5804 return TRUE;
5805 }
5806 #endif // WMM_SUPPORT //
5807
5808 /*
5809 ==========================================================================
5810 Description:
5811 Set Network Type(Infrastructure/Adhoc mode)
5812 Return:
5813 TRUE if all parameters are OK, FALSE otherwise
5814 ==========================================================================
5815 */
5816 INT Set_NetworkType_Proc(
5817 IN PRTMP_ADAPTER pAdapter,
5818 IN PUCHAR arg)
5819 {
5820 UINT32 Value = 0;
5821
5822 if (strcmp(arg, "Adhoc") == 0)
5823 {
5824 if (pAdapter->StaCfg.BssType != BSS_ADHOC)
5825 {
5826 // Config has changed
5827 pAdapter->bConfigChanged = TRUE;
5828 if (MONITOR_ON(pAdapter))
5829 {
5830 RTMP_IO_WRITE32(pAdapter, RX_FILTR_CFG, STANORMAL);
5831 RTMP_IO_READ32(pAdapter, MAC_SYS_CTRL, &Value);
5832 Value &= (~0x80);
5833 RTMP_IO_WRITE32(pAdapter, MAC_SYS_CTRL, Value);
5834 OPSTATUS_CLEAR_FLAG(pAdapter, fOP_STATUS_MEDIA_STATE_CONNECTED);
5835 pAdapter->StaCfg.bAutoReconnect = TRUE;
5836 LinkDown(pAdapter, FALSE);
5837 }
5838 if (INFRA_ON(pAdapter))
5839 {
5840 //BOOLEAN Cancelled;
5841 // Set the AutoReconnectSsid to prevent it reconnect to old SSID
5842 // Since calling this indicate user don't want to connect to that SSID anymore.
5843 pAdapter->MlmeAux.AutoReconnectSsidLen= 32;
5844 NdisZeroMemory(pAdapter->MlmeAux.AutoReconnectSsid, pAdapter->MlmeAux.AutoReconnectSsidLen);
5845
5846 LinkDown(pAdapter, FALSE);
5847
5848 DBGPRINT(RT_DEBUG_TRACE, ("NDIS_STATUS_MEDIA_DISCONNECT Event BB!\n"));
5849 }
5850 }
5851 pAdapter->StaCfg.BssType = BSS_ADHOC;
5852 pAdapter->net_dev->type = pAdapter->StaCfg.OriDevType;
5853 DBGPRINT(RT_DEBUG_TRACE, ("===>Set_NetworkType_Proc::(AD-HOC)\n"));
5854 }
5855 else if (strcmp(arg, "Infra") == 0)
5856 {
5857 if (pAdapter->StaCfg.BssType != BSS_INFRA)
5858 {
5859 // Config has changed
5860 pAdapter->bConfigChanged = TRUE;
5861 if (MONITOR_ON(pAdapter))
5862 {
5863 RTMP_IO_WRITE32(pAdapter, RX_FILTR_CFG, STANORMAL);
5864 RTMP_IO_READ32(pAdapter, MAC_SYS_CTRL, &Value);
5865 Value &= (~0x80);
5866 RTMP_IO_WRITE32(pAdapter, MAC_SYS_CTRL, Value);
5867 OPSTATUS_CLEAR_FLAG(pAdapter, fOP_STATUS_MEDIA_STATE_CONNECTED);
5868 pAdapter->StaCfg.bAutoReconnect = TRUE;
5869 LinkDown(pAdapter, FALSE);
5870 }
5871 if (ADHOC_ON(pAdapter))
5872 {
5873 // Set the AutoReconnectSsid to prevent it reconnect to old SSID
5874 // Since calling this indicate user don't want to connect to that SSID anymore.
5875 pAdapter->MlmeAux.AutoReconnectSsidLen= 32;
5876 NdisZeroMemory(pAdapter->MlmeAux.AutoReconnectSsid, pAdapter->MlmeAux.AutoReconnectSsidLen);
5877
5878 LinkDown(pAdapter, FALSE);
5879 }
5880 }
5881 pAdapter->StaCfg.BssType = BSS_INFRA;
5882 pAdapter->net_dev->type = pAdapter->StaCfg.OriDevType;
5883 DBGPRINT(RT_DEBUG_TRACE, ("===>Set_NetworkType_Proc::(INFRA)\n"));
5884
5885 pAdapter->StaCfg.BssType = BSS_INFRA;
5886 }
5887 else if (strcmp(arg, "Monitor") == 0)
5888 {
5889 UCHAR bbpValue = 0;
5890 BCN_TIME_CFG_STRUC csr;
5891 OPSTATUS_CLEAR_FLAG(pAdapter, fOP_STATUS_INFRA_ON);
5892 OPSTATUS_CLEAR_FLAG(pAdapter, fOP_STATUS_ADHOC_ON);
5893 OPSTATUS_SET_FLAG(pAdapter, fOP_STATUS_MEDIA_STATE_CONNECTED);
5894 // disable all periodic state machine
5895 pAdapter->StaCfg.bAutoReconnect = FALSE;
5896 // reset all mlme state machine
5897 RT28XX_MLME_RESET_STATE_MACHINE(pAdapter);
5898 DBGPRINT(RT_DEBUG_TRACE, ("fOP_STATUS_MEDIA_STATE_CONNECTED \n"));
5899 if (pAdapter->CommonCfg.CentralChannel == 0)
5900 {
5901 #ifdef DOT11_N_SUPPORT
5902 if (pAdapter->CommonCfg.PhyMode == PHY_11AN_MIXED)
5903 pAdapter->CommonCfg.CentralChannel = 36;
5904 else
5905 #endif // DOT11_N_SUPPORT //
5906 pAdapter->CommonCfg.CentralChannel = 6;
5907 }
5908 #ifdef DOT11_N_SUPPORT
5909 else
5910 N_ChannelCheck(pAdapter);
5911 #endif // DOT11_N_SUPPORT //
5912
5913 #ifdef DOT11_N_SUPPORT
5914 if (pAdapter->CommonCfg.PhyMode >= PHY_11ABGN_MIXED &&
5915 pAdapter->CommonCfg.RegTransmitSetting.field.BW == BW_40 &&
5916 pAdapter->CommonCfg.RegTransmitSetting.field.EXTCHA == EXTCHA_ABOVE)
5917 {
5918 // 40MHz ,control channel at lower
5919 RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R4, &bbpValue);
5920 bbpValue &= (~0x18);
5921 bbpValue |= 0x10;
5922 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R4, bbpValue);
5923 pAdapter->CommonCfg.BBPCurrentBW = BW_40;
5924 // RX : control channel at lower
5925 RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R3, &bbpValue);
5926 bbpValue &= (~0x20);
5927 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R3, bbpValue);
5928
5929 RTMP_IO_READ32(pAdapter, TX_BAND_CFG, &Value);
5930 Value &= 0xfffffffe;
5931 RTMP_IO_WRITE32(pAdapter, TX_BAND_CFG, Value);
5932 pAdapter->CommonCfg.CentralChannel = pAdapter->CommonCfg.Channel + 2;
5933 AsicSwitchChannel(pAdapter, pAdapter->CommonCfg.CentralChannel, FALSE);
5934 AsicLockChannel(pAdapter, pAdapter->CommonCfg.CentralChannel);
5935 DBGPRINT(RT_DEBUG_TRACE, ("BW_40 ,control_channel(%d), CentralChannel(%d) \n",
5936 pAdapter->CommonCfg.Channel,
5937 pAdapter->CommonCfg.CentralChannel));
5938 }
5939 else if (pAdapter->CommonCfg.PhyMode >= PHY_11ABGN_MIXED &&
5940 pAdapter->CommonCfg.RegTransmitSetting.field.BW == BW_40 &&
5941 pAdapter->CommonCfg.RegTransmitSetting.field.EXTCHA == EXTCHA_BELOW)
5942 {
5943 // 40MHz ,control channel at upper
5944 RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R4, &bbpValue);
5945 bbpValue &= (~0x18);
5946 bbpValue |= 0x10;
5947 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R4, bbpValue);
5948 pAdapter->CommonCfg.BBPCurrentBW = BW_40;
5949 RTMP_IO_READ32(pAdapter, TX_BAND_CFG, &Value);
5950 Value |= 0x1;
5951 RTMP_IO_WRITE32(pAdapter, TX_BAND_CFG, Value);
5952
5953 RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R3, &bbpValue);
5954 bbpValue |= (0x20);
5955 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R3, bbpValue);
5956 pAdapter->CommonCfg.CentralChannel = pAdapter->CommonCfg.Channel - 2;
5957 AsicSwitchChannel(pAdapter, pAdapter->CommonCfg.CentralChannel, FALSE);
5958 AsicLockChannel(pAdapter, pAdapter->CommonCfg.CentralChannel);
5959 DBGPRINT(RT_DEBUG_TRACE, ("BW_40 ,control_channel(%d), CentralChannel(%d) \n",
5960 pAdapter->CommonCfg.Channel,
5961 pAdapter->CommonCfg.CentralChannel));
5962 }
5963 else
5964 #endif // DOT11_N_SUPPORT //
5965 {
5966 // 20MHz
5967 RTMP_BBP_IO_READ8_BY_REG_ID(pAdapter, BBP_R4, &bbpValue);
5968 bbpValue &= (~0x18);
5969 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R4, bbpValue);
5970 pAdapter->CommonCfg.BBPCurrentBW = BW_20;
5971 AsicSwitchChannel(pAdapter, pAdapter->CommonCfg.Channel, FALSE);
5972 AsicLockChannel(pAdapter, pAdapter->CommonCfg.Channel);
5973 DBGPRINT(RT_DEBUG_TRACE, ("BW_20, Channel(%d)\n", pAdapter->CommonCfg.Channel));
5974 }
5975 // Enable Rx with promiscuous reception
5976 RTMP_IO_WRITE32(pAdapter, RX_FILTR_CFG, 0x3);
5977 // ASIC supporsts sniffer function with replacing RSSI with timestamp.
5978 //RTMP_IO_READ32(pAdapter, MAC_SYS_CTRL, &Value);
5979 //Value |= (0x80);
5980 //RTMP_IO_WRITE32(pAdapter, MAC_SYS_CTRL, Value);
5981 // disable sync
5982 RTMP_IO_READ32(pAdapter, BCN_TIME_CFG, &csr.word);
5983 csr.field.bBeaconGen = 0;
5984 csr.field.bTBTTEnable = 0;
5985 csr.field.TsfSyncMode = 0;
5986 RTMP_IO_WRITE32(pAdapter, BCN_TIME_CFG, csr.word);
5987
5988 pAdapter->StaCfg.BssType = BSS_MONITOR;
5989 pAdapter->net_dev->type = ARPHRD_IEEE80211_PRISM; //ARPHRD_IEEE80211; // IEEE80211
5990 DBGPRINT(RT_DEBUG_TRACE, ("===>Set_NetworkType_Proc::(MONITOR)\n"));
5991 }
5992
5993 // Reset Ralink supplicant to not use, it will be set to start when UI set PMK key
5994 pAdapter->StaCfg.WpaState = SS_NOTUSE;
5995
5996 DBGPRINT(RT_DEBUG_TRACE, ("Set_NetworkType_Proc::(NetworkType=%d)\n", pAdapter->StaCfg.BssType));
5997
5998 return TRUE;
5999 }
6000
6001 /*
6002 ==========================================================================
6003 Description:
6004 Set Authentication mode
6005 Return:
6006 TRUE if all parameters are OK, FALSE otherwise
6007 ==========================================================================
6008 */
6009 INT Set_AuthMode_Proc(
6010 IN PRTMP_ADAPTER pAdapter,
6011 IN PUCHAR arg)
6012 {
6013 if ((strcmp(arg, "WEPAUTO") == 0) || (strcmp(arg, "wepauto") == 0))
6014 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeAutoSwitch;
6015 else if ((strcmp(arg, "OPEN") == 0) || (strcmp(arg, "open") == 0))
6016 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeOpen;
6017 else if ((strcmp(arg, "SHARED") == 0) || (strcmp(arg, "shared") == 0))
6018 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeShared;
6019 else if ((strcmp(arg, "WPAPSK") == 0) || (strcmp(arg, "wpapsk") == 0))
6020 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeWPAPSK;
6021 else if ((strcmp(arg, "WPANONE") == 0) || (strcmp(arg, "wpanone") == 0))
6022 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeWPANone;
6023 else if ((strcmp(arg, "WPA2PSK") == 0) || (strcmp(arg, "wpa2psk") == 0))
6024 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeWPA2PSK;
6025 #ifdef WPA_SUPPLICANT_SUPPORT
6026 else if ((strcmp(arg, "WPA") == 0) || (strcmp(arg, "wpa") == 0))
6027 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeWPA;
6028 else if ((strcmp(arg, "WPA2") == 0) || (strcmp(arg, "wpa2") == 0))
6029 pAdapter->StaCfg.AuthMode = Ndis802_11AuthModeWPA2;
6030 #endif // WPA_SUPPLICANT_SUPPORT //
6031 else
6032 return FALSE;
6033
6034 pAdapter->StaCfg.PortSecured = WPA_802_1X_PORT_NOT_SECURED;
6035
6036 DBGPRINT(RT_DEBUG_TRACE, ("Set_AuthMode_Proc::(AuthMode=%d)\n", pAdapter->StaCfg.AuthMode));
6037
6038 return TRUE;
6039 }
6040
6041 /*
6042 ==========================================================================
6043 Description:
6044 Set Encryption Type
6045 Return:
6046 TRUE if all parameters are OK, FALSE otherwise
6047 ==========================================================================
6048 */
6049 INT Set_EncrypType_Proc(
6050 IN PRTMP_ADAPTER pAdapter,
6051 IN PUCHAR arg)
6052 {
6053 if ((strcmp(arg, "NONE") == 0) || (strcmp(arg, "none") == 0))
6054 {
6055 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
6056 return TRUE; // do nothing
6057
6058 pAdapter->StaCfg.WepStatus = Ndis802_11WEPDisabled;
6059 pAdapter->StaCfg.PairCipher = Ndis802_11WEPDisabled;
6060 pAdapter->StaCfg.GroupCipher = Ndis802_11WEPDisabled;
6061 }
6062 else if ((strcmp(arg, "WEP") == 0) || (strcmp(arg, "wep") == 0))
6063 {
6064 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
6065 return TRUE; // do nothing
6066
6067 pAdapter->StaCfg.WepStatus = Ndis802_11WEPEnabled;
6068 pAdapter->StaCfg.PairCipher = Ndis802_11WEPEnabled;
6069 pAdapter->StaCfg.GroupCipher = Ndis802_11WEPEnabled;
6070 }
6071 else if ((strcmp(arg, "TKIP") == 0) || (strcmp(arg, "tkip") == 0))
6072 {
6073 if (pAdapter->StaCfg.AuthMode < Ndis802_11AuthModeWPA)
6074 return TRUE; // do nothing
6075
6076 pAdapter->StaCfg.WepStatus = Ndis802_11Encryption2Enabled;
6077 pAdapter->StaCfg.PairCipher = Ndis802_11Encryption2Enabled;
6078 pAdapter->StaCfg.GroupCipher = Ndis802_11Encryption2Enabled;
6079 }
6080 else if ((strcmp(arg, "AES") == 0) || (strcmp(arg, "aes") == 0))
6081 {
6082 if (pAdapter->StaCfg.AuthMode < Ndis802_11AuthModeWPA)
6083 return TRUE; // do nothing
6084
6085 pAdapter->StaCfg.WepStatus = Ndis802_11Encryption3Enabled;
6086 pAdapter->StaCfg.PairCipher = Ndis802_11Encryption3Enabled;
6087 pAdapter->StaCfg.GroupCipher = Ndis802_11Encryption3Enabled;
6088 }
6089 else
6090 return FALSE;
6091
6092 pAdapter->StaCfg.OrigWepStatus = pAdapter->StaCfg.WepStatus;
6093
6094 DBGPRINT(RT_DEBUG_TRACE, ("Set_EncrypType_Proc::(EncrypType=%d)\n", pAdapter->StaCfg.WepStatus));
6095
6096 return TRUE;
6097 }
6098
6099 /*
6100 ==========================================================================
6101 Description:
6102 Set Default Key ID
6103 Return:
6104 TRUE if all parameters are OK, FALSE otherwise
6105 ==========================================================================
6106 */
6107 INT Set_DefaultKeyID_Proc(
6108 IN PRTMP_ADAPTER pAdapter,
6109 IN PUCHAR arg)
6110 {
6111 ULONG KeyIdx;
6112
6113 KeyIdx = simple_strtol(arg, 0, 10);
6114 if((KeyIdx >= 1 ) && (KeyIdx <= 4))
6115 pAdapter->StaCfg.DefaultKeyId = (UCHAR) (KeyIdx - 1 );
6116 else
6117 return FALSE; //Invalid argument
6118
6119 DBGPRINT(RT_DEBUG_TRACE, ("Set_DefaultKeyID_Proc::(DefaultKeyID=%d)\n", pAdapter->StaCfg.DefaultKeyId));
6120
6121 return TRUE;
6122 }
6123
6124 /*
6125 ==========================================================================
6126 Description:
6127 Set WEP KEY1
6128 Return:
6129 TRUE if all parameters are OK, FALSE otherwise
6130 ==========================================================================
6131 */
6132 INT Set_Key1_Proc(
6133 IN PRTMP_ADAPTER pAdapter,
6134 IN PUCHAR arg)
6135 {
6136 int KeyLen;
6137 int i;
6138 UCHAR CipherAlg=CIPHER_WEP64;
6139
6140 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
6141 return TRUE; // do nothing
6142
6143 KeyLen = strlen(arg);
6144
6145 switch (KeyLen)
6146 {
6147 case 5: //wep 40 Ascii type
6148 pAdapter->SharedKey[BSS0][0].KeyLen = KeyLen;
6149 memcpy(pAdapter->SharedKey[BSS0][0].Key, arg, KeyLen);
6150 CipherAlg = CIPHER_WEP64;
6151 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key1_Proc::(Key1=%s and type=%s)\n", arg, "Ascii"));
6152 break;
6153 case 10: //wep 40 Hex type
6154 for(i=0; i < KeyLen; i++)
6155 {
6156 if( !isxdigit(*(arg+i)) )
6157 return FALSE; //Not Hex value;
6158 }
6159 pAdapter->SharedKey[BSS0][0].KeyLen = KeyLen / 2 ;
6160 AtoH(arg, pAdapter->SharedKey[BSS0][0].Key, KeyLen / 2);
6161 CipherAlg = CIPHER_WEP64;
6162 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key1_Proc::(Key1=%s and type=%s)\n", arg, "Hex"));
6163 break;
6164 case 13: //wep 104 Ascii type
6165 pAdapter->SharedKey[BSS0][0].KeyLen = KeyLen;
6166 memcpy(pAdapter->SharedKey[BSS0][0].Key, arg, KeyLen);
6167 CipherAlg = CIPHER_WEP128;
6168 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key1_Proc::(Key1=%s and type=%s)\n", arg, "Ascii"));
6169 break;
6170 case 26: //wep 104 Hex type
6171 for(i=0; i < KeyLen; i++)
6172 {
6173 if( !isxdigit(*(arg+i)) )
6174 return FALSE; //Not Hex value;
6175 }
6176 pAdapter->SharedKey[BSS0][0].KeyLen = KeyLen / 2 ;
6177 AtoH(arg, pAdapter->SharedKey[BSS0][0].Key, KeyLen / 2);
6178 CipherAlg = CIPHER_WEP128;
6179 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key1_Proc::(Key1=%s and type=%s)\n", arg, "Hex"));
6180 break;
6181 default: //Invalid argument
6182 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key1_Proc::Invalid argument (=%s)\n", arg));
6183 return FALSE;
6184 }
6185
6186 pAdapter->SharedKey[BSS0][0].CipherAlg = CipherAlg;
6187
6188 // Set keys (into ASIC)
6189 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
6190 ; // not support
6191 else // Old WEP stuff
6192 {
6193 AsicAddSharedKeyEntry(pAdapter,
6194 0,
6195 0,
6196 pAdapter->SharedKey[BSS0][0].CipherAlg,
6197 pAdapter->SharedKey[BSS0][0].Key,
6198 NULL,
6199 NULL);
6200 }
6201
6202 return TRUE;
6203 }
6204 /*
6205 ==========================================================================
6206
6207 Description:
6208 Set WEP KEY2
6209 Return:
6210 TRUE if all parameters are OK, FALSE otherwise
6211 ==========================================================================
6212 */
6213 INT Set_Key2_Proc(
6214 IN PRTMP_ADAPTER pAdapter,
6215 IN PUCHAR arg)
6216 {
6217 int KeyLen;
6218 int i;
6219 UCHAR CipherAlg=CIPHER_WEP64;
6220
6221 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
6222 return TRUE; // do nothing
6223
6224 KeyLen = strlen(arg);
6225
6226 switch (KeyLen)
6227 {
6228 case 5: //wep 40 Ascii type
6229 pAdapter->SharedKey[BSS0][1].KeyLen = KeyLen;
6230 memcpy(pAdapter->SharedKey[BSS0][1].Key, arg, KeyLen);
6231 CipherAlg = CIPHER_WEP64;
6232 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key2_Proc::(Key2=%s and type=%s)\n", arg, "Ascii"));
6233 break;
6234 case 10: //wep 40 Hex type
6235 for(i=0; i < KeyLen; i++)
6236 {
6237 if( !isxdigit(*(arg+i)) )
6238 return FALSE; //Not Hex value;
6239 }
6240 pAdapter->SharedKey[BSS0][1].KeyLen = KeyLen / 2 ;
6241 AtoH(arg, pAdapter->SharedKey[BSS0][1].Key, KeyLen / 2);
6242 CipherAlg = CIPHER_WEP64;
6243 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key2_Proc::(Key2=%s and type=%s)\n", arg, "Hex"));
6244 break;
6245 case 13: //wep 104 Ascii type
6246 pAdapter->SharedKey[BSS0][1].KeyLen = KeyLen;
6247 memcpy(pAdapter->SharedKey[BSS0][1].Key, arg, KeyLen);
6248 CipherAlg = CIPHER_WEP128;
6249 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key2_Proc::(Key2=%s and type=%s)\n", arg, "Ascii"));
6250 break;
6251 case 26: //wep 104 Hex type
6252 for(i=0; i < KeyLen; i++)
6253 {
6254 if( !isxdigit(*(arg+i)) )
6255 return FALSE; //Not Hex value;
6256 }
6257 pAdapter->SharedKey[BSS0][1].KeyLen = KeyLen / 2 ;
6258 AtoH(arg, pAdapter->SharedKey[BSS0][1].Key, KeyLen / 2);
6259 CipherAlg = CIPHER_WEP128;
6260 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key2_Proc::(Key2=%s and type=%s)\n", arg, "Hex"));
6261 break;
6262 default: //Invalid argument
6263 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key2_Proc::Invalid argument (=%s)\n", arg));
6264 return FALSE;
6265 }
6266 pAdapter->SharedKey[BSS0][1].CipherAlg = CipherAlg;
6267
6268 // Set keys (into ASIC)
6269 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
6270 ; // not support
6271 else // Old WEP stuff
6272 {
6273 AsicAddSharedKeyEntry(pAdapter,
6274 0,
6275 1,
6276 pAdapter->SharedKey[BSS0][1].CipherAlg,
6277 pAdapter->SharedKey[BSS0][1].Key,
6278 NULL,
6279 NULL);
6280 }
6281
6282 return TRUE;
6283 }
6284 /*
6285 ==========================================================================
6286 Description:
6287 Set WEP KEY3
6288 Return:
6289 TRUE if all parameters are OK, FALSE otherwise
6290 ==========================================================================
6291 */
6292 INT Set_Key3_Proc(
6293 IN PRTMP_ADAPTER pAdapter,
6294 IN PUCHAR arg)
6295 {
6296 int KeyLen;
6297 int i;
6298 UCHAR CipherAlg=CIPHER_WEP64;
6299
6300 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
6301 return TRUE; // do nothing
6302
6303 KeyLen = strlen(arg);
6304
6305 switch (KeyLen)
6306 {
6307 case 5: //wep 40 Ascii type
6308 pAdapter->SharedKey[BSS0][2].KeyLen = KeyLen;
6309 memcpy(pAdapter->SharedKey[BSS0][2].Key, arg, KeyLen);
6310 CipherAlg = CIPHER_WEP64;
6311 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key3_Proc::(Key3=%s and type=Ascii)\n", arg));
6312 break;
6313 case 10: //wep 40 Hex type
6314 for(i=0; i < KeyLen; i++)
6315 {
6316 if( !isxdigit(*(arg+i)) )
6317 return FALSE; //Not Hex value;
6318 }
6319 pAdapter->SharedKey[BSS0][2].KeyLen = KeyLen / 2 ;
6320 AtoH(arg, pAdapter->SharedKey[BSS0][2].Key, KeyLen / 2);
6321 CipherAlg = CIPHER_WEP64;
6322 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key3_Proc::(Key3=%s and type=Hex)\n", arg));
6323 break;
6324 case 13: //wep 104 Ascii type
6325 pAdapter->SharedKey[BSS0][2].KeyLen = KeyLen;
6326 memcpy(pAdapter->SharedKey[BSS0][2].Key, arg, KeyLen);
6327 CipherAlg = CIPHER_WEP128;
6328 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key3_Proc::(Key3=%s and type=Ascii)\n", arg));
6329 break;
6330 case 26: //wep 104 Hex type
6331 for(i=0; i < KeyLen; i++)
6332 {
6333 if( !isxdigit(*(arg+i)) )
6334 return FALSE; //Not Hex value;
6335 }
6336 pAdapter->SharedKey[BSS0][2].KeyLen = KeyLen / 2 ;
6337 AtoH(arg, pAdapter->SharedKey[BSS0][2].Key, KeyLen / 2);
6338 CipherAlg = CIPHER_WEP128;
6339 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key3_Proc::(Key3=%s and type=Hex)\n", arg));
6340 break;
6341 default: //Invalid argument
6342 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key3_Proc::Invalid argument (=%s)\n", arg));
6343 return FALSE;
6344 }
6345 pAdapter->SharedKey[BSS0][2].CipherAlg = CipherAlg;
6346
6347 // Set keys (into ASIC)
6348 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
6349 ; // not support
6350 else // Old WEP stuff
6351 {
6352 AsicAddSharedKeyEntry(pAdapter,
6353 0,
6354 2,
6355 pAdapter->SharedKey[BSS0][2].CipherAlg,
6356 pAdapter->SharedKey[BSS0][2].Key,
6357 NULL,
6358 NULL);
6359 }
6360
6361 return TRUE;
6362 }
6363 /*
6364 ==========================================================================
6365 Description:
6366 Set WEP KEY4
6367 Return:
6368 TRUE if all parameters are OK, FALSE otherwise
6369 ==========================================================================
6370 */
6371 INT Set_Key4_Proc(
6372 IN PRTMP_ADAPTER pAdapter,
6373 IN PUCHAR arg)
6374 {
6375 int KeyLen;
6376 int i;
6377 UCHAR CipherAlg=CIPHER_WEP64;
6378
6379 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
6380 return TRUE; // do nothing
6381
6382 KeyLen = strlen(arg);
6383
6384 switch (KeyLen)
6385 {
6386 case 5: //wep 40 Ascii type
6387 pAdapter->SharedKey[BSS0][3].KeyLen = KeyLen;
6388 memcpy(pAdapter->SharedKey[BSS0][3].Key, arg, KeyLen);
6389 CipherAlg = CIPHER_WEP64;
6390 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key4_Proc::(Key4=%s and type=%s)\n", arg, "Ascii"));
6391 break;
6392 case 10: //wep 40 Hex type
6393 for(i=0; i < KeyLen; i++)
6394 {
6395 if( !isxdigit(*(arg+i)) )
6396 return FALSE; //Not Hex value;
6397 }
6398 pAdapter->SharedKey[BSS0][3].KeyLen = KeyLen / 2 ;
6399 AtoH(arg, pAdapter->SharedKey[BSS0][3].Key, KeyLen / 2);
6400 CipherAlg = CIPHER_WEP64;
6401 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key4_Proc::(Key4=%s and type=%s)\n", arg, "Hex"));
6402 break;
6403 case 13: //wep 104 Ascii type
6404 pAdapter->SharedKey[BSS0][3].KeyLen = KeyLen;
6405 memcpy(pAdapter->SharedKey[BSS0][3].Key, arg, KeyLen);
6406 CipherAlg = CIPHER_WEP128;
6407 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key4_Proc::(Key4=%s and type=%s)\n", arg, "Ascii"));
6408 break;
6409 case 26: //wep 104 Hex type
6410 for(i=0; i < KeyLen; i++)
6411 {
6412 if( !isxdigit(*(arg+i)) )
6413 return FALSE; //Not Hex value;
6414 }
6415 pAdapter->SharedKey[BSS0][3].KeyLen = KeyLen / 2 ;
6416 AtoH(arg, pAdapter->SharedKey[BSS0][3].Key, KeyLen / 2);
6417 CipherAlg = CIPHER_WEP128;
6418 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key4_Proc::(Key4=%s and type=%s)\n", arg, "Hex"));
6419 break;
6420 default: //Invalid argument
6421 DBGPRINT(RT_DEBUG_TRACE, ("Set_Key4_Proc::Invalid argument (=%s)\n", arg));
6422 return FALSE;
6423 }
6424 pAdapter->SharedKey[BSS0][3].CipherAlg = CipherAlg;
6425
6426 // Set keys (into ASIC)
6427 if (pAdapter->StaCfg.AuthMode >= Ndis802_11AuthModeWPA)
6428 ; // not support
6429 else // Old WEP stuff
6430 {
6431 AsicAddSharedKeyEntry(pAdapter,
6432 0,
6433 3,
6434 pAdapter->SharedKey[BSS0][3].CipherAlg,
6435 pAdapter->SharedKey[BSS0][3].Key,
6436 NULL,
6437 NULL);
6438 }
6439
6440 return TRUE;
6441 }
6442
6443 /*
6444 ==========================================================================
6445 Description:
6446 Set WPA PSK key
6447 Return:
6448 TRUE if all parameters are OK, FALSE otherwise
6449 ==========================================================================
6450 */
6451 INT Set_WPAPSK_Proc(
6452 IN PRTMP_ADAPTER pAdapter,
6453 IN PUCHAR arg)
6454 {
6455 UCHAR keyMaterial[40];
6456
6457 if ((pAdapter->StaCfg.AuthMode != Ndis802_11AuthModeWPAPSK) &&
6458 (pAdapter->StaCfg.AuthMode != Ndis802_11AuthModeWPA2PSK) &&
6459 (pAdapter->StaCfg.AuthMode != Ndis802_11AuthModeWPANone)
6460 )
6461 return TRUE; // do nothing
6462
6463 DBGPRINT(RT_DEBUG_TRACE, ("Set_WPAPSK_Proc::(WPAPSK=%s)\n", arg));
6464
6465 NdisZeroMemory(keyMaterial, 40);
6466
6467 if ((strlen(arg) < 8) || (strlen(arg) > 64))
6468 {
6469 DBGPRINT(RT_DEBUG_TRACE, ("Set failed!!(WPAPSK=%s), WPAPSK key-string required 8 ~ 64 characters \n", arg));
6470 return FALSE;
6471 }
6472
6473 if (strlen(arg) == 64)
6474 {
6475 AtoH(arg, keyMaterial, 32);
6476 NdisMoveMemory(pAdapter->StaCfg.PMK, keyMaterial, 32);
6477
6478 }
6479 else
6480 {
6481 PasswordHash((char *)arg, pAdapter->MlmeAux.Ssid, pAdapter->MlmeAux.SsidLen, keyMaterial);
6482 NdisMoveMemory(pAdapter->StaCfg.PMK, keyMaterial, 32);
6483 }
6484
6485
6486
6487 if(pAdapter->StaCfg.BssType == BSS_ADHOC &&
6488 pAdapter->StaCfg.AuthMode == Ndis802_11AuthModeWPANone)
6489 {
6490 pAdapter->StaCfg.WpaState = SS_NOTUSE;
6491 }
6492 else
6493 {
6494 // Start STA supplicant state machine
6495 pAdapter->StaCfg.WpaState = SS_START;
6496 }
6497
6498 return TRUE;
6499 }
6500
6501 /*
6502 ==========================================================================
6503 Description:
6504 Set Power Saving mode
6505 Return:
6506 TRUE if all parameters are OK, FALSE otherwise
6507 ==========================================================================
6508 */
6509 INT Set_PSMode_Proc(
6510 IN PRTMP_ADAPTER pAdapter,
6511 IN PUCHAR arg)
6512 {
6513 if (pAdapter->StaCfg.BssType == BSS_INFRA)
6514 {
6515 if ((strcmp(arg, "Max_PSP") == 0) ||
6516 (strcmp(arg, "max_psp") == 0) ||
6517 (strcmp(arg, "MAX_PSP") == 0))
6518 {
6519 // do NOT turn on PSM bit here, wait until MlmeCheckForPsmChange()
6520 // to exclude certain situations.
6521 if (pAdapter->StaCfg.bWindowsACCAMEnable == FALSE)
6522 pAdapter->StaCfg.WindowsPowerMode = Ndis802_11PowerModeMAX_PSP;
6523 pAdapter->StaCfg.WindowsBatteryPowerMode = Ndis802_11PowerModeMAX_PSP;
6524 OPSTATUS_SET_FLAG(pAdapter, fOP_STATUS_RECEIVE_DTIM);
6525 pAdapter->StaCfg.DefaultListenCount = 5;
6526
6527 }
6528 else if ((strcmp(arg, "Fast_PSP") == 0) ||
6529 (strcmp(arg, "fast_psp") == 0) ||
6530 (strcmp(arg, "FAST_PSP") == 0))
6531 {
6532 // do NOT turn on PSM bit here, wait until MlmeCheckForPsmChange()
6533 // to exclude certain situations.
6534 OPSTATUS_SET_FLAG(pAdapter, fOP_STATUS_RECEIVE_DTIM);
6535 if (pAdapter->StaCfg.bWindowsACCAMEnable == FALSE)
6536 pAdapter->StaCfg.WindowsPowerMode = Ndis802_11PowerModeFast_PSP;
6537 pAdapter->StaCfg.WindowsBatteryPowerMode = Ndis802_11PowerModeFast_PSP;
6538 pAdapter->StaCfg.DefaultListenCount = 3;
6539 }
6540 else if ((strcmp(arg, "Legacy_PSP") == 0) ||
6541 (strcmp(arg, "legacy_psp") == 0) ||
6542 (strcmp(arg, "LEGACY_PSP") == 0))
6543 {
6544 // do NOT turn on PSM bit here, wait until MlmeCheckForPsmChange()
6545 // to exclude certain situations.
6546 OPSTATUS_SET_FLAG(pAdapter, fOP_STATUS_RECEIVE_DTIM);
6547 if (pAdapter->StaCfg.bWindowsACCAMEnable == FALSE)
6548 pAdapter->StaCfg.WindowsPowerMode = Ndis802_11PowerModeLegacy_PSP;
6549 pAdapter->StaCfg.WindowsBatteryPowerMode = Ndis802_11PowerModeLegacy_PSP;
6550 pAdapter->StaCfg.DefaultListenCount = 3;
6551 }
6552 else
6553 {
6554 //Default Ndis802_11PowerModeCAM
6555 // clear PSM bit immediately
6556 MlmeSetPsmBit(pAdapter, PWR_ACTIVE);
6557 OPSTATUS_SET_FLAG(pAdapter, fOP_STATUS_RECEIVE_DTIM);
6558 if (pAdapter->StaCfg.bWindowsACCAMEnable == FALSE)
6559 pAdapter->StaCfg.WindowsPowerMode = Ndis802_11PowerModeCAM;
6560 pAdapter->StaCfg.WindowsBatteryPowerMode = Ndis802_11PowerModeCAM;
6561 }
6562
6563 DBGPRINT(RT_DEBUG_TRACE, ("Set_PSMode_Proc::(PSMode=%ld)\n", pAdapter->StaCfg.WindowsPowerMode));
6564 }
6565 else
6566 return FALSE;
6567
6568
6569 return TRUE;
6570 }
6571
6572 #ifdef WPA_SUPPLICANT_SUPPORT
6573 /*
6574 ==========================================================================
6575 Description:
6576 Set WpaSupport flag.
6577 Value:
6578 0: Driver ignore wpa_supplicant.
6579 1: wpa_supplicant initiates scanning and AP selection.
6580 2: driver takes care of scanning, AP selection, and IEEE 802.11 association parameters.
6581 Return:
6582 TRUE if all parameters are OK, FALSE otherwise
6583 ==========================================================================
6584 */
6585 INT Set_Wpa_Support(
6586 IN PRTMP_ADAPTER pAd,
6587 IN PUCHAR arg)
6588 {
6589
6590 if ( simple_strtol(arg, 0, 10) == 0)
6591 pAd->StaCfg.WpaSupplicantUP = WPA_SUPPLICANT_DISABLE;
6592 else if ( simple_strtol(arg, 0, 10) == 1)
6593 pAd->StaCfg.WpaSupplicantUP = WPA_SUPPLICANT_ENABLE;
6594 else if ( simple_strtol(arg, 0, 10) == 2)
6595 pAd->StaCfg.WpaSupplicantUP = WPA_SUPPLICANT_ENABLE_WITH_WEB_UI;
6596 else
6597 pAd->StaCfg.WpaSupplicantUP = WPA_SUPPLICANT_DISABLE;
6598
6599 DBGPRINT(RT_DEBUG_TRACE, ("Set_Wpa_Support::(WpaSupplicantUP=%d)\n", pAd->StaCfg.WpaSupplicantUP));
6600
6601 return TRUE;
6602 }
6603 #endif // WPA_SUPPLICANT_SUPPORT //
6604
6605 #ifdef DBG
6606 /*
6607 ==========================================================================
6608 Description:
6609 Read / Write MAC
6610 Arguments:
6611 pAdapter Pointer to our adapter
6612 wrq Pointer to the ioctl argument
6613
6614 Return Value:
6615 None
6616
6617 Note:
6618 Usage:
6619 1.) iwpriv ra0 mac 0 ==> read MAC where Addr=0x0
6620 2.) iwpriv ra0 mac 0=12 ==> write MAC where Addr=0x0, value=12
6621 ==========================================================================
6622 */
6623 VOID RTMPIoctlMAC(
6624 IN PRTMP_ADAPTER pAdapter,
6625 IN struct iwreq *wrq)
6626 {
6627 CHAR *this_char;
6628 CHAR *value;
6629 INT j = 0, k = 0;
6630 CHAR msg[1024];
6631 CHAR arg[255];
6632 ULONG macAddr = 0;
6633 UCHAR temp[16], temp2[16];
6634 UINT32 macValue = 0;
6635 INT Status;
6636
6637
6638 memset(msg, 0x00, 1024);
6639 if (wrq->u.data.length > 1) //No parameters.
6640 {
6641 Status = copy_from_user(arg, wrq->u.data.pointer, (wrq->u.data.length > 255) ? 255 : wrq->u.data.length);
6642 sprintf(msg, "\n");
6643
6644 //Parsing Read or Write
6645 this_char = arg;
6646 if (!*this_char)
6647 goto next;
6648
6649 if ((value = rtstrchr(this_char, '=')) != NULL)
6650 *value++ = 0;
6651
6652 if (!value || !*value)
6653 { //Read
6654 // Sanity check
6655 if(strlen(this_char) > 4)
6656 goto next;
6657
6658 j = strlen(this_char);
6659 while(j-- > 0)
6660 {
6661 if(this_char[j] > 'f' || this_char[j] < '0')
6662 return;
6663 }
6664
6665 // Mac Addr
6666 k = j = strlen(this_char);
6667 while(j-- > 0)
6668 {
6669 this_char[4-k+j] = this_char[j];
6670 }
6671
6672 while(k < 4)
6673 this_char[3-k++]='0';
6674 this_char[4]='\0';
6675
6676 if(strlen(this_char) == 4)
6677 {
6678 AtoH(this_char, temp, 2);
6679 macAddr = *temp*256 + temp[1];
6680 if (macAddr < 0xFFFF)
6681 {
6682 RTMP_IO_READ32(pAdapter, macAddr, &macValue);
6683 DBGPRINT(RT_DEBUG_TRACE, ("MacAddr=%lx, MacValue=%x\n", macAddr, macValue));
6684 sprintf(msg+strlen(msg), "[0x%08lX]:%08X ", macAddr , macValue);
6685 }
6686 else
6687 {//Invalid parametes, so default printk all bbp
6688 goto next;
6689 }
6690 }
6691 }
6692 else
6693 { //Write
6694 memcpy(&temp2, value, strlen(value));
6695 temp2[strlen(value)] = '\0';
6696
6697 // Sanity check
6698 if((strlen(this_char) > 4) || strlen(temp2) > 8)
6699 goto next;
6700
6701 j = strlen(this_char);
6702 while(j-- > 0)
6703 {
6704 if(this_char[j] > 'f' || this_char[j] < '0')
6705 return;
6706 }
6707
6708 j = strlen(temp2);
6709 while(j-- > 0)
6710 {
6711 if(temp2[j] > 'f' || temp2[j] < '0')
6712 return;
6713 }
6714
6715 //MAC Addr
6716 k = j = strlen(this_char);
6717 while(j-- > 0)
6718 {
6719 this_char[4-k+j] = this_char[j];
6720 }
6721
6722 while(k < 4)
6723 this_char[3-k++]='0';
6724 this_char[4]='\0';
6725
6726 //MAC value
6727 k = j = strlen(temp2);
6728 while(j-- > 0)
6729 {
6730 temp2[8-k+j] = temp2[j];
6731 }
6732
6733 while(k < 8)
6734 temp2[7-k++]='0';
6735 temp2[8]='\0';
6736
6737 {
6738 AtoH(this_char, temp, 2);
6739 macAddr = *temp*256 + temp[1];
6740
6741 AtoH(temp2, temp, 4);
6742 macValue = *temp*256*256*256 + temp[1]*256*256 + temp[2]*256 + temp[3];
6743
6744 // debug mode
6745 if (macAddr == (HW_DEBUG_SETTING_BASE + 4))
6746 {
6747 // 0x2bf4: byte0 non-zero: enable R17 tuning, 0: disable R17 tuning
6748 if (macValue & 0x000000ff)
6749 {
6750 pAdapter->BbpTuning.bEnable = TRUE;
6751 DBGPRINT(RT_DEBUG_TRACE,("turn on R17 tuning\n"));
6752 }
6753 else
6754 {
6755 UCHAR R66;
6756 pAdapter->BbpTuning.bEnable = FALSE;
6757 R66 = 0x26 + GET_LNA_GAIN(pAdapter);
6758 #ifdef RALINK_ATE
6759 if (ATE_ON(pAdapter))
6760 {
6761 ATE_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R66, (0x26 + GET_LNA_GAIN(pAdapter)));
6762 }
6763 else
6764 #endif // RALINK_ATE //
6765 RTMP_BBP_IO_WRITE8_BY_REG_ID(pAdapter, BBP_R66, (0x26 + GET_LNA_GAIN(pAdapter)));
6766 DBGPRINT(RT_DEBUG_TRACE,("turn off R17 tuning, restore to 0x%02x\n", R66));
6767 }
6768 return;
6769 }
6770
6771 DBGPRINT(RT_DEBUG_TRACE, ("MacAddr=%02lx, MacValue=0x%x\n", macAddr, macValue));
6772
6773 RTMP_IO_WRITE32(pAdapter, macAddr, macValue);
6774 sprintf(msg+strlen(msg), "[0x%08lX]:%08X ", macAddr, macValue);
6775 }
6776 }
6777 }
6778 next:
6779 if(strlen(msg) == 1)
6780 sprintf(msg+strlen(msg), "===>Error command format!");
6781
6782 // Copy the information into the user buffer
6783 wrq->u.data.length = strlen(msg);
6784 Status = copy_to_user(wrq->u.data.pointer, msg, wrq->u.data.length);
6785
6786 DBGPRINT(RT_DEBUG_TRACE, ("<==RTMPIoctlMAC\n\n"));
6787 }
6788
6789 /*
6790 ==========================================================================
6791 Description:
6792 Read / Write E2PROM
6793 Arguments:
6794 pAdapter Pointer to our adapter
6795 wrq Pointer to the ioctl argument
6796
6797 Return Value:
6798 None
6799
6800 Note:
6801 Usage:
6802 1.) iwpriv ra0 e2p 0 ==> read E2PROM where Addr=0x0
6803 2.) iwpriv ra0 e2p 0=1234 ==> write E2PROM where Addr=0x0, value=1234
6804 ==========================================================================
6805 */
6806 VOID RTMPIoctlE2PROM(
6807 IN PRTMP_ADAPTER pAdapter,
6808 IN struct iwreq *wrq)
6809 {
6810 CHAR *this_char;
6811 CHAR *value;
6812 INT j = 0, k = 0;
6813 CHAR msg[1024];
6814 CHAR arg[255];
6815 USHORT eepAddr = 0;
6816 UCHAR temp[16], temp2[16];
6817 USHORT eepValue;
6818 int Status;
6819
6820
6821 memset(msg, 0x00, 1024);
6822 if (wrq->u.data.length > 1) //No parameters.
6823 {
6824 Status = copy_from_user(arg, wrq->u.data.pointer, (wrq->u.data.length > 255) ? 255 : wrq->u.data.length);
6825 sprintf(msg, "\n");
6826
6827 //Parsing Read or Write
6828 this_char = arg;
6829
6830
6831 if (!*this_char)
6832 goto next;
6833
6834 if ((value = rtstrchr(this_char, '=')) != NULL)
6835 *value++ = 0;
6836
6837 if (!value || !*value)
6838 { //Read
6839
6840 // Sanity check
6841 if(strlen(this_char) > 4)
6842 goto next;
6843
6844 j = strlen(this_char);
6845 while(j-- > 0)
6846 {
6847 if(this_char[j] > 'f' || this_char[j] < '0')
6848 return;
6849 }
6850
6851 // E2PROM addr
6852 k = j = strlen(this_char);
6853 while(j-- > 0)
6854 {
6855 this_char[4-k+j] = this_char[j];
6856 }
6857
6858 while(k < 4)
6859 this_char[3-k++]='0';
6860 this_char[4]='\0';
6861
6862 if(strlen(this_char) == 4)
6863 {
6864 AtoH(this_char, temp, 2);
6865 eepAddr = *temp*256 + temp[1];
6866 if (eepAddr < 0xFFFF)
6867 {
6868 RT28xx_EEPROM_READ16(pAdapter, eepAddr, eepValue);
6869 sprintf(msg+strlen(msg), "[0x%04X]:0x%04X ", eepAddr , eepValue);
6870 }
6871 else
6872 {//Invalid parametes, so default printk all bbp
6873 goto next;
6874 }
6875 }
6876 }
6877 else
6878 { //Write
6879 memcpy(&temp2, value, strlen(value));
6880 temp2[strlen(value)] = '\0';
6881
6882 // Sanity check
6883 if((strlen(this_char) > 4) || strlen(temp2) > 8)
6884 goto next;
6885
6886 j = strlen(this_char);
6887 while(j-- > 0)
6888 {
6889 if(this_char[j] > 'f' || this_char[j] < '0')
6890 return;
6891 }
6892 j = strlen(temp2);
6893 while(j-- > 0)
6894 {
6895 if(temp2[j] > 'f' || temp2[j] < '0')
6896 return;
6897 }
6898
6899 //MAC Addr
6900 k = j = strlen(this_char);
6901 while(j-- > 0)
6902 {
6903 this_char[4-k+j] = this_char[j];
6904 }
6905
6906 while(k < 4)
6907 this_char[3-k++]='0';
6908 this_char[4]='\0';
6909
6910 //MAC value
6911 k = j = strlen(temp2);
6912 while(j-- > 0)
6913 {
6914 temp2[4-k+j] = temp2[j];
6915 }
6916
6917 while(k < 4)
6918 temp2[3-k++]='0';
6919 temp2[4]='\0';
6920
6921 AtoH(this_char, temp, 2);
6922 eepAddr = *temp*256 + temp[1];
6923
6924 AtoH(temp2, temp, 2);
6925 eepValue = *temp*256 + temp[1];
6926
6927 RT28xx_EEPROM_WRITE16(pAdapter, eepAddr, eepValue);
6928 sprintf(msg+strlen(msg), "[0x%02X]:%02X ", eepAddr, eepValue);
6929 }
6930 }
6931 next:
6932 if(strlen(msg) == 1)
6933 sprintf(msg+strlen(msg), "===>Error command format!");
6934
6935
6936 // Copy the information into the user buffer
6937 wrq->u.data.length = strlen(msg);
6938 Status = copy_to_user(wrq->u.data.pointer, msg, wrq->u.data.length);
6939
6940 DBGPRINT(RT_DEBUG_TRACE, ("<==RTMPIoctlE2PROM\n"));
6941 }
6942 #endif // DBG //
6943
6944
6945
6946
6947 INT Set_TGnWifiTest_Proc(
6948 IN PRTMP_ADAPTER pAd,
6949 IN PUCHAR arg)
6950 {
6951 if (simple_strtol(arg, 0, 10) == 0)
6952 pAd->StaCfg.bTGnWifiTest = FALSE;
6953 else
6954 pAd->StaCfg.bTGnWifiTest = TRUE;
6955
6956 DBGPRINT(RT_DEBUG_TRACE, ("IF Set_TGnWifiTest_Proc::(bTGnWifiTest=%d)\n", pAd->StaCfg.bTGnWifiTest));
6957 return TRUE;
6958 }
6959
6960 INT Set_LongRetryLimit_Proc(
6961 IN PRTMP_ADAPTER pAdapter,
6962 IN PUCHAR arg)
6963 {
6964 TX_RTY_CFG_STRUC tx_rty_cfg;
6965 UCHAR LongRetryLimit = (UCHAR)simple_strtol(arg, 0, 10);
6966
6967 RTMP_IO_READ32(pAdapter, TX_RTY_CFG, &tx_rty_cfg.word);
6968 tx_rty_cfg.field.LongRtyLimit = LongRetryLimit;
6969 RTMP_IO_WRITE32(pAdapter, TX_RTY_CFG, tx_rty_cfg.word);
6970 DBGPRINT(RT_DEBUG_TRACE, ("IF Set_LongRetryLimit_Proc::(tx_rty_cfg=0x%x)\n", tx_rty_cfg.word));
6971 return TRUE;
6972 }
6973
6974 INT Set_ShortRetryLimit_Proc(
6975 IN PRTMP_ADAPTER pAdapter,
6976 IN PUCHAR arg)
6977 {
6978 TX_RTY_CFG_STRUC tx_rty_cfg;
6979 UCHAR ShortRetryLimit = (UCHAR)simple_strtol(arg, 0, 10);
6980
6981 RTMP_IO_READ32(pAdapter, TX_RTY_CFG, &tx_rty_cfg.word);
6982 tx_rty_cfg.field.ShortRtyLimit = ShortRetryLimit;
6983 RTMP_IO_WRITE32(pAdapter, TX_RTY_CFG, tx_rty_cfg.word);
6984 DBGPRINT(RT_DEBUG_TRACE, ("IF Set_ShortRetryLimit_Proc::(tx_rty_cfg=0x%x)\n", tx_rty_cfg.word));
6985 return TRUE;
6986 }
6987
6988 #ifdef EXT_BUILD_CHANNEL_LIST
6989 INT Set_Ieee80211dClientMode_Proc(
6990 IN PRTMP_ADAPTER pAdapter,
6991 IN PUCHAR arg)
6992 {
6993 if (simple_strtol(arg, 0, 10) == 0)
6994 pAdapter->StaCfg.IEEE80211dClientMode = Rt802_11_D_None;
6995 else if (simple_strtol(arg, 0, 10) == 1)
6996 pAdapter->StaCfg.IEEE80211dClientMode = Rt802_11_D_Flexible;
6997 else if (simple_strtol(arg, 0, 10) == 2)
6998 pAdapter->StaCfg.IEEE80211dClientMode = Rt802_11_D_Strict;
6999 else
7000 return FALSE;
7001
7002 DBGPRINT(RT_DEBUG_TRACE, ("Set_Ieee802dMode_Proc::(IEEEE0211dMode=%d)\n", pAdapter->StaCfg.IEEE80211dClientMode));
7003 return TRUE;
7004 }
7005 #endif // EXT_BUILD_CHANNEL_LIST //
7006
7007 #ifdef CARRIER_DETECTION_SUPPORT
7008 INT Set_CarrierDetect_Proc(
7009 IN PRTMP_ADAPTER pAd,
7010 IN PUCHAR arg)
7011 {
7012 if (simple_strtol(arg, 0, 10) == 0)
7013 pAd->CommonCfg.CarrierDetect.Enable = FALSE;
7014 else
7015 pAd->CommonCfg.CarrierDetect.Enable = TRUE;
7016
7017 DBGPRINT(RT_DEBUG_TRACE, ("IF Set_CarrierDetect_Proc::(CarrierDetect.Enable=%d)\n", pAd->CommonCfg.CarrierDetect.Enable));
7018 return TRUE;
7019 }
7020 #endif // CARRIER_DETECTION_SUPPORT //
7021
7022
7023 INT Show_Adhoc_MacTable_Proc(
7024 IN PRTMP_ADAPTER pAd,
7025 IN PCHAR extra)
7026 {
7027 INT i;
7028
7029 sprintf(extra, "\n");
7030
7031 #ifdef DOT11_N_SUPPORT
7032 sprintf(extra, "%sHT Operating Mode : %d\n", extra, pAd->CommonCfg.AddHTInfo.AddHtInfo2.OperaionMode);
7033 #endif // DOT11_N_SUPPORT //
7034
7035 sprintf(extra, "%s\n%-19s%-4s%-4s%-7s%-7s%-7s%-10s%-6s%-6s%-6s%-6s\n", extra,
7036 "MAC", "AID", "BSS", "RSSI0", "RSSI1", "RSSI2", "PhMd", "BW", "MCS", "SGI", "STBC");
7037
7038 for (i=1; i<MAX_LEN_OF_MAC_TABLE; i++)
7039 {
7040 PMAC_TABLE_ENTRY pEntry = &pAd->MacTab.Content[i];
7041
7042 if (strlen(extra) > (IW_PRIV_SIZE_MASK - 30))
7043 break;
7044 if ((pEntry->ValidAsCLI || pEntry->ValidAsApCli) && (pEntry->Sst == SST_ASSOC))
7045 {
7046 sprintf(extra, "%s%02X:%02X:%02X:%02X:%02X:%02X ", extra,
7047 pEntry->Addr[0], pEntry->Addr[1], pEntry->Addr[2],
7048 pEntry->Addr[3], pEntry->Addr[4], pEntry->Addr[5]);
7049 sprintf(extra, "%s%-4d", extra, (int)pEntry->Aid);
7050 sprintf(extra, "%s%-4d", extra, (int)pEntry->apidx);
7051 sprintf(extra, "%s%-7d", extra, pEntry->RssiSample.AvgRssi0);
7052 sprintf(extra, "%s%-7d", extra, pEntry->RssiSample.AvgRssi1);
7053 sprintf(extra, "%s%-7d", extra, pEntry->RssiSample.AvgRssi2);
7054 sprintf(extra, "%s%-10s", extra, GetPhyMode(pEntry->HTPhyMode.field.MODE));
7055 sprintf(extra, "%s%-6s", extra, GetBW(pEntry->HTPhyMode.field.BW));
7056 sprintf(extra, "%s%-6d", extra, pEntry->HTPhyMode.field.MCS);
7057 sprintf(extra, "%s%-6d", extra, pEntry->HTPhyMode.field.ShortGI);
7058 sprintf(extra, "%s%-6d", extra, pEntry->HTPhyMode.field.STBC);
7059 sprintf(extra, "%s%-10d, %d, %d%%\n", extra, pEntry->DebugFIFOCount, pEntry->DebugTxCount,
7060 (pEntry->DebugTxCount) ? ((pEntry->DebugTxCount-pEntry->DebugFIFOCount)*100/pEntry->DebugTxCount) : 0);
7061 sprintf(extra, "%s\n", extra);
7062 }
7063 }
7064
7065 return TRUE;
7066 }
7067
7068
Linux 2.6 libata-dev (mirror)