drivers/staging/rt3090/sta_ioctl.c

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