drivers/mtk_wcn_combo/drv_wlan/mt6620/wlan/common/wlan_oid.c

   1 /*
   2 ** $Id: //Department/DaVinci/BRANCHES/MT6620_WIFI_DRIVER_V2_3/common/wlan_oid.c#5 $
   3 */
   4
   5 /*! \file wlanoid.c
   6     \brief This file contains the WLAN OID processing routines of Windows driver for
   7            MediaTek Inc. 802.11 Wireless LAN Adapters.
   8 */
   9
  10
  11
  12 /*
  13 ** $Log: wlan_oid.c $
  14 **
  15 ** 07 19 2012 yuche.tsai
  16 ** NULL
  17 ** Code update for JB.
  18  *
  19  * 07 17 2012 yuche.tsai
  20  * NULL
  21  * Let netdev bring up.
  22  *
  23  * 07 17 2012 yuche.tsai
  24  * NULL
  25  * Compile no error before trial run.
  26  *
  27  * 03 02 2012 terry.wu
  28  * NULL
  29  * Sync CFG80211 modification from branch 2,2.
  30  *
  31  * 01 06 2012 wh.su
  32  * [WCXRP00001153] [MT6620 Wi-Fi][Driver] Adding the get_ch_list and set_tx_power proto type function
  33  * using the wlanSendSetQueryCmd to set the tx power control cmd.
  34  *
  35  * 01 06 2012 wh.su
  36  * [WCXRP00001153] [MT6620 Wi-Fi][Driver] Adding the get_ch_list and set_tx_power proto type function
  37  * change the set tx power cmd name.
  38  *
  39  * 01 05 2012 wh.su
  40  * [WCXRP00001153] [MT6620 Wi-Fi][Driver] Adding the get_ch_list and set_tx_power proto type function
  41  * Adding the related ioctl / wlan oid function to set the Tx power cfg.
  42  *
  43  * 12 20 2011 cp.wu
  44  * [WCXRP00001144] [MT6620 Wi-Fi][Driver][Firmware] Add RF_FUNC_ID for exposing device and related version information
  45  * add driver implementations for RF_AT_FUNCID_FW_INFO & RF_AT_FUNCID_DRV_INFO
  46  * to expose version information
  47  *
  48  * 12 05 2011 cp.wu
  49  * [WCXRP00001131] [MT6620 Wi-Fi][Driver][AIS] Implement connect-by-BSSID path
  50  * add CONNECT_BY_BSSID policy
  51  *
  52  * 11 22 2011 cp.wu
  53  * [WCXRP00001120] [MT6620 Wi-Fi][Driver] Modify roaming to AIS state transition from synchronous to asynchronous approach to avoid incomplete state termination
  54  * 1. change RDD related compile option brace position.
  55  * 2. when roaming is triggered, ask AIS to transit immediately only when AIS is in Normal TR state without join timeout timer ticking
  56  * 3. otherwise, insert AIS_REQUEST into pending request queue
  57  *
  58  * 11 21 2011 cp.wu
  59  * [WCXRP00001118] [MT6620 Wi-Fi][Driver] Corner case protections to pass Monkey testing
  60  * 1. wlanoidQueryBssIdList might be passed with a non-zero length but a NULL pointer of buffer
  61  * add more checking for such cases
  62  *
  63  * 2. kalSendComplete() might be invoked with a packet belongs to P2P network right after P2P is unregistered.
  64  * add some tweaking to protect such cases because that net device has become invalid.
  65  *
  66  * 11 15 2011 cm.chang
  67  * NULL
  68  * Fix compiling warning
  69  *
  70  * 11 11 2011 wh.su
  71  * [WCXRP00001078] [MT6620 Wi-Fi][Driver] Adding the mediatek log improment support : XLOG
  72  * modify the xlog related code.
  73  *
  74  * 11 11 2011 tsaiyuan.hsu
  75  * [WCXRP00001083] [MT6620 Wi-Fi][DRV]] dump debug counter or frames when debugging is triggered
  76  * add debug counters of bb and ar for xlog.
  77  *
  78  * 11 10 2011 wh.su
  79  * [WCXRP00001078] [MT6620 Wi-Fi][Driver] Adding the mediatek log improment support : XLOG
  80  * change the debug module level.
  81  *
  82  * 11 09 2011 george.huang
  83  * [WCXRP00000871] [MT6620 Wi-Fi][FW] Include additional wakeup condition, which is by consequent DTIM unicast indication
  84  * add XLOG for Set PS mode entry
  85  *
  86  * 11 08 2011 tsaiyuan.hsu
  87  * [WCXRP00001083] [MT6620 Wi-Fi][DRV]] dump debug counter or frames when debugging is triggered
  88  * check if CFG_SUPPORT_SWCR is defined to aoid compiler error.
  89  *
  90  * 11 07 2011 tsaiyuan.hsu
  91  * [WCXRP00001083] [MT6620 Wi-Fi][DRV]] dump debug counter or frames when debugging is triggered
  92  * add debug counters and periodically dump counters for debugging.
  93  *
  94  * 11 03 2011 wh.su
  95  * [WCXRP00001078] [MT6620 Wi-Fi][Driver] Adding the mediatek log improment support : XLOG
  96  * change the DBGLOG for "\n" and "\r\n". LABEL to LOUD for XLOG
  97  *
  98  * 11 02 2011 chinghwa.yu
  99  * [WCXRP00000612] [MT6620 Wi-Fi] [FW] CSD update SWRDD algorithm
 100  * Add RDD certification features.
 101  *
 102  * 10 21 2011 eddie.chen
 103  * [WCXRP00001051] [MT6620 Wi-Fi][Driver/Fw] Adjust the STA aging timeout
 104  * Add switch to ignore the STA aging timeout.
 105  *
 106  * 10 12 2011 wh.su
 107  * [WCXRP00001036] [MT6620 Wi-Fi][Driver][FW] Adding the 802.11w code for MFP
 108  * adding the 802.11w related function and define .
 109  *
 110  * 09 15 2011 tsaiyuan.hsu
 111  * [WCXRP00000938] [MT6620 Wi-Fi][FW] add system config for CTIA
 112  * correct fifo full control from query to set operation for CTIA.
 113  *
 114  * 08 31 2011 cm.chang
 115  * [WCXRP00000969] [MT6620 Wi-Fi][Driver][FW] Channel list for 5G band based on country code
 116  * .
 117  *
 118  * 08 17 2011 tsaiyuan.hsu
 119  * [WCXRP00000938] [MT6620 Wi-Fi][FW] add system config for CTIA
 120  * add system config for CTIA.
 121  *
 122  * 08 15 2011 george.huang
 123  * [MT6620 Wi-Fi][FW] handle TSF drift for connection detection
 124  * .
 125  *
 126  * 07 28 2011 chinghwa.yu
 127  * [WCXRP00000063] Update BCM CoEx design and settings
 128  * Add BWCS cmd and event.
 129  *
 130  * 07 18 2011 chinghwa.yu
 131  * [WCXRP00000063] Update BCM CoEx design and settings[WCXRP00000612] [MT6620 Wi-Fi] [FW] CSD update SWRDD algorithm
 132  * Add CMD/Event for RDD and BWCS.
 133  *
 134  * 07 11 2011 wh.su
 135  * [WCXRP00000849] [MT6620 Wi-Fi][Driver] Remove some of the WAPI define for make sure the value is initialize, for customer not enable WAPI
 136  * For make sure wapi initial value is set.
 137  *
 138  * 06 23 2011 cp.wu
 139  * [WCXRP00000812] [MT6620 Wi-Fi][Driver] not show NVRAM when there is no valid MAC address in NVRAM content
 140  * check with firmware for valid MAC address.
 141  *
 142  * 05 02 2011 eddie.chen
 143  * [WCXRP00000373] [MT6620 Wi-Fi][FW] SW debug control
 144  * Fix compile warning.
 145  *
 146  * 04 29 2011 george.huang
 147  * [WCXRP00000684] [MT6620 Wi-Fi][Driver] Support P2P setting ARP filter
 148  * .
 149  *
 150  * 04 27 2011 george.huang
 151  * [WCXRP00000684] [MT6620 Wi-Fi][Driver] Support P2P setting ARP filter
 152  * add more debug message
 153  *
 154  * 04 26 2011 eddie.chen
 155  * [WCXRP00000373] [MT6620 Wi-Fi][FW] SW debug control
 156  * Add rx path profiling.
 157  *
 158  * 04 12 2011 eddie.chen
 159  * [WCXRP00000617] [MT6620 Wi-Fi][DRV/FW] Fix for sigma
 160  * Fix the sta index in processing security frame
 161  * Simple flow control for TC4 to avoid mgt frames for PS STA to occupy the TC4
 162  * Add debug message.
 163  *
 164  * 04 08 2011 george.huang
 165  * [WCXRP00000621] [MT6620 Wi-Fi][Driver] Support P2P supplicant to set power mode
 166  * separate settings of P2P and AIS
 167  *
 168  * 03 31 2011 puff.wen
 169  * NULL
 170  * .
 171  *
 172  * 03 29 2011 puff.wen
 173  * NULL
 174  * Add chennel switch for stress test
 175  *
 176  * 03 29 2011 cp.wu
 177  * [WCXRP00000604] [MT6620 Wi-Fi][Driver] Surpress Klockwork Warning
 178  * surpress klock warning with code path rewritten
 179  *
 180  * 03 24 2011 wh.su
 181  * [WCXRP00000595] [MT6620 Wi-Fi][Driver] at CTIA indicate disconnect to make the ps profile can apply
 182  * use disconnect event instead of ais abort for CTIA testing.
 183  *
 184  * 03 23 2011 george.huang
 185  * [WCXRP00000586] [MT6620 Wi-Fi][FW] Modify for blocking absence request right after connected
 186  * revise for CTIA power mode setting
 187  *
 188  * 03 22 2011 george.huang
 189  * [WCXRP00000504] [MT6620 Wi-Fi][FW] Support Sigma CAPI for power saving related command
 190  * link with supplicant commands
 191  *
 192  * 03 17 2011 chinglan.wang
 193  * [WCXRP00000570] [MT6620 Wi-Fi][Driver] Add Wi-Fi Protected Setup v2.0 feature
 194  * .
 195  *
 196  * 03 17 2011 yarco.yang
 197  * [WCXRP00000569] [MT6620 Wi-Fi][F/W][Driver] Set multicast address support current network usage
 198  * .
 199  *
 200  * 03 15 2011 george.huang
 201  * [WCXRP00000557] [MT6620 Wi-Fi] Support current consumption test mode commands
 202  * Support current consumption measurement mode command
 203  *
 204  * 03 15 2011 eddie.chen
 205  * [WCXRP00000554] [MT6620 Wi-Fi][DRV] Add sw control debug counter
 206  * Add sw debug counter for QM.
 207  *
 208  * 03 10 2011 cp.wu
 209  * [WCXRP00000532] [MT6620 Wi-Fi][Driver] Migrate NVRAM configuration procedures from MT6620 E2 to MT6620 E3
 210  * deprecate configuration used by MT6620 E2
 211  *
 212  * 03 07 2011 terry.wu
 213  * [WCXRP00000521] [MT6620 Wi-Fi][Driver] Remove non-standard debug message
 214  * Toggle non-standard debug messages to comments.
 215  *
 216  * 03 04 2011 cp.wu
 217  * [WCXRP00000515] [MT6620 Wi-Fi][Driver] Surpress compiler warning which is identified by GNU compiler collection
 218  * surpress compile warning occured when compiled by GNU compiler collection.
 219  *
 220  * 03 03 2011 wh.su
 221  * [WCXRP00000510] [MT6620 Wi-Fi] [Driver] Fixed the CTIA enter test mode issue
 222  * fixed the enter ctia test mode issue.
 223  *
 224  * 03 02 2011 george.huang
 225  * [WCXRP00000504] [MT6620 Wi-Fi][FW] Support Sigma CAPI for power saving related command
 226  * Update sigma CAPI for U-APSD setting
 227  *
 228  * 03 02 2011 george.huang
 229  * [WCXRP00000504] [MT6620 Wi-Fi][FW] Support Sigma CAPI for power saving related command
 230  * Support UAPSD/OppPS/NoA parameter setting
 231  *
 232  * 03 02 2011 cp.wu
 233  * [WCXRP00000503] [MT6620 Wi-Fi][Driver] Take RCPI brought by association response as initial RSSI right after connection is built.
 234  * use RCPI brought by ASSOC-RESP after connection is built as initial RCPI to avoid using a uninitialized MAC-RX RCPI.
 235  *
 236  * 01 27 2011 george.huang
 237  * [WCXRP00000400] [MT6620 Wi-Fi] support CTIA power mode setting
 238  * Support CTIA power mode setting.
 239  *
 240  * 01 26 2011 wh.su
 241  * [WCXRP00000396] [MT6620 Wi-Fi][Driver] Support Sw Ctrl ioctl at linux
 242  * adding the SW cmd ioctl support, use set/get structure ioctl.
 243  *
 244  * 01 25 2011 cp.wu
 245  * [WCXRP00000394] [MT6620 Wi-Fi][Driver] Count space needed for generating error message in scanning list into buffer size checking
 246  * when doing size prechecking, check illegal MAC address as well
 247  *
 248  * 01 20 2011 eddie.chen
 249  * [WCXRP00000374] [MT6620 Wi-Fi][DRV] SW debug control
 250  * Add Oid for sw control debug command
 251  *
 252  * 01 15 2011 puff.wen
 253  * NULL
 254  * Add Stress test
 255  *
 256  * 01 12 2011 cp.wu
 257  * [WCXRP00000358] [MT6620 Wi-Fi][Driver] Provide concurrent information for each module
 258  * check if allow to switch to IBSS mode via concurrent module before setting to IBSS mode
 259  *
 260  * 01 12 2011 cm.chang
 261  * [WCXRP00000354] [MT6620 Wi-Fi][Driver][FW] Follow NVRAM bandwidth setting
 262  * User-defined bandwidth is for 2.4G and 5G individually
 263  *
 264  * 01 04 2011 cp.wu
 265  * [WCXRP00000342] [MT6620 Wi-Fi][Driver] show error code in scanning list when MAC address is not correctly configured in NVRAM
 266  * show error code 0x10 when MAC address in NVRAM is not configured correctly.
 267  *
 268  * 01 04 2011 cp.wu
 269  * [WCXRP00000338] [MT6620 Wi-Fi][Driver] Separate kalMemAlloc into kmalloc and vmalloc implementations to ease physically continous memory demands
 270  * separate kalMemAlloc() into virtually-continous and physically-continous type to ease slab system pressure
 271  *
 272  * 12 28 2010 george.huang
 273  * [WCXRP00000232] [MT5931 Wi-Fi][FW] Modifications for updated HW power on sequence and related design
 274  * support WMM-PS U-APSD AC assignment.
 275  *
 276  * 12 28 2010 cp.wu
 277  * [WCXRP00000269] [MT6620 Wi-Fi][Driver][Firmware] Prepare for v1.1 branch release
 278  * report EEPROM used flag via NIC_CAPABILITY
 279  *
 280  * 12 28 2010 cp.wu
 281  * [WCXRP00000269] [MT6620 Wi-Fi][Driver][Firmware] Prepare for v1.1 branch release
 282  * integrate with 'EEPROM used' flag for reporting correct capability to Engineer Mode/META and other tools
 283  *
 284  * 12 16 2010 cp.wu
 285  * [WCXRP00000268] [MT6620 Wi-Fi][Driver] correction for WHQL failed items
 286  * correction for OID_802_11_NETWORK_TYPES_SUPPORTED handlers
 287  *
 288  * 12 13 2010 cp.wu
 289  * [WCXRP00000256] [MT6620 Wi-Fi][Driver] Eliminate potential issues which is identified by Klockwork
 290  * suppress warning reported by Klockwork.
 291  *
 292  * 12 07 2010 cm.chang
 293  * [WCXRP00000239] MT6620 Wi-Fi][Driver][FW] Merge concurrent branch back to maintrunk
 294  * 1. BSSINFO include RLM parameter
 295  * 2. free all sta records when network is disconnected
 296  *
 297  * 12 07 2010 cm.chang
 298  * [WCXRP00000238] MT6620 Wi-Fi][Driver][FW] Support regulation domain setting from NVRAM and supplicant
 299  * 1. Country code is from NVRAM or supplicant
 300  * 2. Change band definition in CMD/EVENT.
 301  *
 302  * 11 30 2010 cp.wu
 303  * [WCXRP00000213] [MT6620 Wi-Fi][Driver] Implement scanning with specified SSID for wpa_supplicant with ap_scan=1
 304  * .
 305  *
 306  * 11 26 2010 cp.wu
 307  * [WCXRP00000209] [MT6620 Wi-Fi][Driver] Modify NVRAM checking mechanism to warning only with necessary data field checking
 308  * 1. NVRAM error is now treated as warning only, thus normal operation is still available but extra scan result used to indicate user is attached
 309  * 2. DPD and TX-PWR are needed fields from now on, if these 2 fields are not availble then warning message is shown
 310  *
 311  * 11 25 2010 cp.wu
 312  * [WCXRP00000208] [MT6620 Wi-Fi][Driver] Add scanning with specified SSID to AIS FSM
 313  * add scanning with specified SSID facility to AIS-FSM
 314  *
 315  * 11 21 2010 wh.su
 316  * [WCXRP00000192] [MT6620 Wi-Fi][Driver] Fixed fail trying to build connection with Security AP while enable WAPI message check
 317  * Not set the wapi mode while the wapi assoc info set non-wapi ie.
 318  *
 319  * 11 05 2010 wh.su
 320  * [WCXRP00000165] [MT6620 Wi-Fi] [Pre-authentication] Assoc req rsn ie use wrong pmkid value
 321  * fixed the.pmkid value mismatch issue
 322  *
 323  * 11 01 2010 cp.wu
 324  * [WCXRP00000056] [MT6620 Wi-Fi][Driver] NVRAM implementation with Version Check[WCXRP00000150] [MT6620 Wi-Fi][Driver] Add implementation for querying current TX rate from firmware auto rate module
 325  * 1) Query link speed (TX rate) from firmware directly with buffering mechanism to reduce overhead
 326  * 2) Remove CNM CH-RECOVER event handling
 327  * 3) cfg read/write API renamed with kal prefix for unified naming rules.
 328  *
 329  * 10 26 2010 cp.wu
 330  * [WCXRP00000056] [MT6620 Wi-Fi][Driver] NVRAM implementation with Version Check[WCXRP00000137] [MT6620 Wi-Fi] [FW] Support NIC capability query command
 331  * 1) update NVRAM content template to ver 1.02
 332  * 2) add compile option for querying NIC capability (default: off)
 333  * 3) modify AIS 5GHz support to run-time option, which could be turned on by registry or NVRAM setting
 334  * 4) correct auto-rate compiler error under linux (treat warning as error)
 335  * 5) simplify usage of NVRAM and REG_INFO_T
 336  * 6) add version checking between driver and firmware
 337  *
 338  * 10 22 2010 cp.wu
 339  * [WCXRP00000122] [MT6620 Wi-Fi][Driver] Preparation for YuSu source tree integration
 340  * dos2unix conversion.
 341  *
 342  * 10 20 2010 cp.wu
 343  * [WCXRP00000117] [MT6620 Wi-Fi][Driver] Add logic for suspending driver when MT6620 is not responding anymore
 344  * use OID_CUSTOM_TEST_MODE as indication for driver reset
 345  * by dropping pending TX packets
 346  *
 347  * 10 18 2010 cp.wu
 348  * [WCXRP00000056] [MT6620 Wi-Fi][Driver] NVRAM implementation with Version Check[WCXRP00000086] [MT6620 Wi-Fi][Driver] The mac address is all zero at android
 349  * complete implementation of Android NVRAM access
 350  *
 351  * 10 06 2010 yuche.tsai
 352  * NULL
 353  * Update SLT 5G Test Channel Set.
 354  *
 355  * 10 06 2010 cp.wu
 356  * [WCXRP00000052] [MT6620 Wi-Fi][Driver] Eliminate Linux Compile Warning
 357  * code reorganization to improve isolation between GLUE and CORE layers.
 358  *
 359  * 10 06 2010 yuche.tsai
 360  * NULL
 361  * Update For SLT 5G Test Channel Selection Rule.
 362  *
 363  * 10 05 2010 cp.wu
 364  * [WCXRP00000075] [MT6620 Wi-Fi][Driver] Fill query buffer for OID_802_11_BSSID_LIST in 4-bytes aligned form
 365  * Query buffer size needs to be enlarged due to result is filled in 4-bytes alignment boundary
 366  *
 367  * 10 05 2010 cp.wu
 368  * [WCXRP00000056] [MT6620 Wi-Fi][Driver] NVRAM implementation with Version Check
 369  * 1) add NVRAM access API
 370  * 2) fake scanning result when NVRAM doesn't exist and/or version mismatch. (off by compiler option)
 371  * 3) add OID implementation for NVRAM read/write service
 372  *
 373  * 10 04 2010 cp.wu
 374  * [WCXRP00000077] [MT6620 Wi-Fi][Driver][FW] Eliminate use of ENUM_NETWORK_TYPE_T and replaced by ENUM_NETWORK_TYPE_INDEX_T only
 375  * remove ENUM_NETWORK_TYPE_T definitions
 376  *
 377  * 10 04 2010 cp.wu
 378  * [WCXRP00000075] [MT6620 Wi-Fi][Driver] Fill query buffer for OID_802_11_BSSID_LIST in 4-bytes aligned form
 379  * Extend result length to multiples of 4-bytes
 380  *
 381  * 09 24 2010 cp.wu
 382  * [WCXRP00000052] [MT6620 Wi-Fi][Driver] Eliminate Linux Compile Warning
 383  * eliminate unused variables which lead gcc to argue
 384  *
 385  * 09 24 2010 cp.wu
 386  * [WCXRP00000057] [MT6620 Wi-Fi][Driver] Modify online scan to a run-time switchable feature
 387  * Modify online scan as a run-time adjustable option (for Windows, in registry)
 388  *
 389  * 09 23 2010 cp.wu
 390  * [WCXRP00000051] [MT6620 Wi-Fi][Driver] WHQL test fail in MAC address changed item
 391  * use firmware reported mac address right after wlanAdapterStart() as permanent address
 392  *
 393  * 09 23 2010 cp.wu
 394  * [WCXRP00000056] [MT6620 Wi-Fi][Driver] NVRAM implementation with Version Check
 395  * add skeleton for NVRAM integration
 396  *
 397  * 09 08 2010 cp.wu
 398  * NULL
 399  * use static memory pool for storing IEs of scanning result.
 400  *
 401  * 09 07 2010 yuche.tsai
 402  * NULL
 403  * Update SLT due to API change of SCAN module.
 404  *
 405  * 09 06 2010 cp.wu
 406  * NULL
 407  * Androi/Linux: return current operating channel information
 408  *
 409  * 09 06 2010 cp.wu
 410  * NULL
 411  * 1) initialize for correct parameter even for disassociation.
 412  * 2) AIS-FSM should have a limit on trials to build connection
 413  *
 414  * 09 03 2010 yuche.tsai
 415  * NULL
 416  * Refine SLT IO control handler.
 417  *
 418  * 09 03 2010 kevin.huang
 419  * NULL
 420  * Refine #include sequence and solve recursive/nested #include issue
 421  *
 422  * 09 01 2010 wh.su
 423  * NULL
 424  * adding the wapi support for integration test.
 425  *
 426  * 08 30 2010 chinglan.wang
 427  * NULL
 428  * Modify the rescan condition.
 429  *
 430  * 08 29 2010 yuche.tsai
 431  * NULL
 432  * Finish SLT TX/RX & Rate Changing Support.
 433  *
 434  * 08 27 2010 chinglan.wang
 435  * NULL
 436  * Update configuration for MT6620_E1_PRE_ALPHA_1832_0827_2010
 437  *
 438  * 08 25 2010 george.huang
 439  * NULL
 440  * update OID/ registry control path for PM related settings
 441  *
 442  * 08 24 2010 cp.wu
 443  * NULL
 444  * 1) initialize variable for enabling short premable/short time slot.
 445  * 2) add compile option for disabling online scan
 446  *
 447  * 08 16 2010 george.huang
 448  * NULL
 449  * .
 450  *
 451  * 08 16 2010 george.huang
 452  * NULL
 453  * upate params defined in CMD_SET_NETWORK_ADDRESS_LIST
 454  *
 455  * 08 04 2010 cp.wu
 456  * NULL
 457  * fix for check build WHQL testing:
 458  * 1) do not assert query buffer if indicated buffer length is zero
 459  * 2) sdio.c has bugs which cause freeing same pointer twice
 460  *
 461  * 08 04 2010 cp.wu
 462  * NULL
 463  * revert changelist #15371, efuse read/write access will be done by RF test approach
 464  *
 465  * 08 04 2010 cp.wu
 466  * NULL
 467  * add OID definitions for EFUSE read/write access.
 468  *
 469  * 08 04 2010 george.huang
 470  * NULL
 471  * handle change PS mode OID/ CMD
 472  *
 473  * 08 04 2010 cp.wu
 474  * NULL
 475  * add an extra parameter to rftestQueryATInfo 'cause it's necessary to pass u4FuncData for query request.
 476  *
 477  * 08 04 2010 cp.wu
 478  * NULL
 479  * bypass u4FuncData for RF-Test query request as well.
 480  *
 481  * 08 04 2010 yarco.yang
 482  * NULL
 483  * Add TX_AMPDU and ADDBA_REJECT command
 484  *
 485  * 08 03 2010 cp.wu
 486  * NULL
 487  * surpress compilation warning.
 488  *
 489  * 08 02 2010 george.huang
 490  * NULL
 491  * add WMM-PS test related OID/ CMD handlers
 492  *
 493  * 07 29 2010 cp.wu
 494  * NULL
 495  * eliminate u4FreqInKHz usage, combined into rConnections.ucAdHoc*
 496  *
 497  * 07 28 2010 cp.wu
 498  * NULL
 499  * 1) eliminate redundant variable eOPMode in prAdapter->rWlanInfo
 500  * 2) change nicMediaStateChange() API prototype
 501  *
 502  * 07 26 2010 cp.wu
 503  *
 504  * re-commit code logic being overwriten.
 505  *
 506  * 07 24 2010 wh.su
 507  *
 508  * .support the Wi-Fi RSN
 509  *
 510  * 07 21 2010 cp.wu
 511  *
 512  * 1) change BG_SCAN to ONLINE_SCAN for consistent term
 513  * 2) only clear scanning result when scan is permitted to do
 514  *
 515  * 07 20 2010 cp.wu
 516  *
 517  * 1) [AIS] when new scan is issued, clear currently available scanning result except the connected one
 518  * 2) refine disconnection behaviour when issued during BG-SCAN process
 519  *
 520  * 07 19 2010 wh.su
 521  *
 522  * modify the auth and encry status variable.
 523  *
 524  * 07 16 2010 cp.wu
 525  *
 526  * remove work-around in case SCN is not available.
 527  *
 528  * 07 08 2010 cp.wu
 529  *
 530  * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
 531  *
 532  * 07 05 2010 cp.wu
 533  * [WPD00003833][MT6620 and MT5931] Driver migration
 534  * 1) change fake BSS_DESC from channel 6 to channel 1 due to channel switching is not done yet.
 535  * 2) after MAC address is queried from firmware, all related variables in driver domain should be updated as well
 536  *
 537  * 07 01 2010 cp.wu
 538  * [WPD00003833][MT6620 and MT5931] Driver migration
 539  * AIS-FSM integration with CNM channel request messages
 540  *
 541  * 07 01 2010 cp.wu
 542  * [WPD00003833][MT6620 and MT5931] Driver migration
 543  * implementation of DRV-SCN and related mailbox message handling.
 544  *
 545  * 06 29 2010 cp.wu
 546  * [WPD00003833][MT6620 and MT5931] Driver migration
 547  * 1) sync to. CMD/EVENT document v0.03
 548  * 2) simplify DTIM period parsing in scan.c only, bss.c no longer parses it again.
 549  * 3) send command packet to indicate FW-PM after
 550  *     a) 1st beacon is received after AIS has connected to an AP
 551  *     b) IBSS-ALONE has been created
 552  *     c) IBSS-MERGE has occured
 553  *
 554  * 06 25 2010 cp.wu
 555  * [WPD00003833][MT6620 and MT5931] Driver migration
 556  * add API in que_mgt to retrieve sta-rec index for security frames.
 557  *
 558  * 06 24 2010 cp.wu
 559  * [WPD00003833][MT6620 and MT5931] Driver migration
 560  * 802.1x and bluetooth-over-Wi-Fi security frames are now delievered to firmware via command path instead of data path.
 561  *
 562  * 06 23 2010 cp.wu
 563  * [WPD00003833][MT6620 and MT5931] Driver migration
 564  * 1) add SCN compilation option.
 565  * 2) when SCN is not turned on, BSSID_SCAN will generate a fake entry for 1st connection
 566  *
 567  * 06 23 2010 cp.wu
 568  * [WPD00003833][MT6620 and MT5931] Driver migration
 569  * implement SCAN-REQUEST oid as mailbox message dispatching.
 570  *
 571  * 06 23 2010 cp.wu
 572  * [WPD00003833][MT6620 and MT5931] Driver migration
 573  * integrate .
 574  *
 575  * 06 22 2010 cp.wu
 576  * [WPD00003833][MT6620 and MT5931] Driver migration
 577  * 1) add command warpper for STA-REC/BSS-INFO sync.
 578  * 2) enhance command packet sending procedure for non-oid part
 579  * 3) add command packet definitions for STA-REC/BSS-INFO sync.
 580  *
 581  * 06 21 2010 wh.su
 582  * [WPD00003840][MT6620 5931] Security migration
 583  * remove duplicate variable for migration.
 584  *
 585  * 06 21 2010 wh.su
 586  * [WPD00003840][MT6620 5931] Security migration
 587  * adding the compiling flag for oid pmkid.
 588  *
 589  * 06 21 2010 cp.wu
 590  * [WPD00003833][MT6620 and MT5931] Driver migration
 591  * enable RX management frame handling.
 592  *
 593  * 06 18 2010 wh.su
 594  * [WPD00003840][MT6620 5931] Security migration
 595  * migration the security related function from firmware.
 596  *
 597  * 06 11 2010 cp.wu
 598  * [WPD00003833][MT6620 and MT5931] Driver migration
 599  * 1) migrate assoc.c.
 600  * 2) add ucTxSeqNum for tracking frames which needs TX-DONE awareness
 601  * 3) add configuration options for CNM_MEM and RSN modules
 602  * 4) add data path for management frames
 603  * 5) eliminate rPacketInfo of MSDU_INFO_T
 604  *
 605  * 06 10 2010 cp.wu
 606  * [WPD00003833][MT6620 and MT5931] Driver migration
 607  * 1) eliminate CFG_CMD_EVENT_VERSION_0_9
 608  * 2) when disconnected, indicate nic directly (no event is needed)
 609  *
 610  * 06 07 2010 cp.wu
 611  * [WPD00003833][MT6620 and MT5931] Driver migration
 612  * merge wlan_def.h.
 613  *
 614  * 06 07 2010 cp.wu
 615  * [WPD00003833][MT6620 and MT5931] Driver migration
 616  * merge wifi_var.h, precomp.h, cnm_timer.h (data type only)
 617  *
 618  * 06 06 2010 kevin.huang
 619  * [WPD00003832][MT6620 5931] Create driver base
 620  * [MT6620 5931] Create driver base
 621  *
 622  * 06 03 2010 cp.wu
 623  * [WPD00001943]Create WiFi test driver framework on WinXP
 624  * move timer callback to glue layer.
 625  *
 626  * 05 28 2010 cp.wu
 627  * [WPD00001943]Create WiFi test driver framework on WinXP
 628  * simplify cmd packet sending for RF test and MCR access OIDs
 629  *
 630  * 05 27 2010 cp.wu
 631  * [WPD00001943]Create WiFi test driver framework on WinXP
 632  * disable radio even when STA is not associated.
 633  *
 634  * 05 27 2010 cp.wu
 635  * [WPD00001943]Create WiFi test driver framework on WinXP
 636  * correct 2 OID behaviour to meet WHQL requirement.
 637  *
 638  * 05 26 2010 jeffrey.chang
 639  * [WPD00003826]Initial import for Linux port
 640  * 1) Modify set mac address code
 641  * 2) remove power managment macro
 642  *
 643  * 05 25 2010 cp.wu
 644  * [WPD00001943]Create WiFi test driver framework on WinXP
 645  * correct BSSID_LIST oid when radio if turned off.
 646  *
 647  * 05 24 2010 cp.wu
 648  * [WPD00001943]Create WiFi test driver framework on WinXP
 649  * 1) when acquiring LP-own, write for clr-own with lower frequency compared to read poll
 650  * 2) correct address list parsing
 651  *
 652  * 05 24 2010 cp.wu
 653  * [WPD00001943]Create WiFi test driver framework on WinXP
 654  * disable wlanoidSetNetworkAddress() temporally.
 655  *
 656  * 05 22 2010 cp.wu
 657  * [WPD00001943]Create WiFi test driver framework on WinXP
 658  * some OIDs should be DRIVER_CORE instead of GLUE_EXTENSION
 659  *
 660  * 05 22 2010 cp.wu
 661  * [WPD00001943]Create WiFi test driver framework on WinXP
 662  * 1) disable NETWORK_LAYER_ADDRESSES handling temporally.
 663  * 2) finish statistics OIDs
 664  *
 665  * 05 22 2010 cp.wu
 666  * [WPD00001943]Create WiFi test driver framework on WinXP
 667  * change OID behavior to meet WHQL requirement.
 668  *
 669  * 05 20 2010 cp.wu
 670  * [WPD00001943]Create WiFi test driver framework on WinXP
 671  * 1) integrate OID_GEN_NETWORK_LAYER_ADDRESSES with CMD_ID_SET_IP_ADDRESS
 672  * 2) buffer statistics data for 2 seconds
 673  * 3) use default value for adhoc parameters instead of 0
 674  *
 675  * 05 19 2010 cp.wu
 676  * [WPD00001943]Create WiFi test driver framework on WinXP
 677  * 1) do not take timeout mechanism for power mode oids
 678  * 2) retrieve network type from connection status
 679  * 3) after disassciation, set radio state to off
 680  * 4) TCP option over IPv6 is supported
 681  *
 682  * 05 18 2010 cp.wu
 683  * [WPD00001943]Create WiFi test driver framework on WinXP
 684  * implement Wakeup-on-LAN except firmware integration part
 685  *
 686  * 05 17 2010 cp.wu
 687  * [WPD00001943]Create WiFi test driver framework on WinXP
 688  * correct wlanoidSet802dot11PowerSaveProfile implementation.
 689  *
 690  * 05 17 2010 cp.wu
 691  * [WPD00001943]Create WiFi test driver framework on WinXP
 692  * 1) enable CMD/EVENT ver 0.9 definition.
 693  * 2) abandon use of ENUM_MEDIA_STATE
 694  *
 695  * 05 17 2010 cp.wu
 696  * [WPD00001943]Create WiFi test driver framework on WinXP
 697  * correct OID_802_11_DISASSOCIATE handling.
 698  *
 699  * 05 17 2010 cp.wu
 700  * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 701  * 1) add timeout handler mechanism for pending command packets
 702  * 2) add p2p add/removal key
 703  *
 704  * 05 14 2010 jeffrey.chang
 705  * [WPD00003826]Initial import for Linux port
 706  * Add dissassocation support for wpa supplicant
 707  *
 708  * 05 14 2010 cp.wu
 709  * [WPD00001943]Create WiFi test driver framework on WinXP
 710  * correct return value.
 711  *
 712  * 05 13 2010 cp.wu
 713  * [WPD00001943]Create WiFi test driver framework on WinXP
 714  * add NULL OID implementation for WOL-related OIDs.
 715  *
 716  * 05 06 2010 cp.wu
 717  * [WPD00001943]Create WiFi test driver framework on WinXP
 718  * for disassociation, still use parameter with current setting.
 719  *
 720  * 05 06 2010 cp.wu
 721  * [WPD00001943]Create WiFi test driver framework on WinXP
 722  * for disassociation, generate a WZC-compatible invalid SSID.
 723  *
 724  * 05 06 2010 cp.wu
 725  * [WPD00001943]Create WiFi test driver framework on WinXP
 726  * associate to illegal SSID when handling OID_802_11_DISASSOCIATE
 727  *
 728  * 04 27 2010 cp.wu
 729  * [WPD00001943]Create WiFi test driver framework on WinXP
 730  * reserve field of privacy filter and RTS threshold setting.
 731  *
 732  * 04 23 2010 cp.wu
 733  * [WPD00001943]Create WiFi test driver framework on WinXP
 734  * surpress compiler warning
 735  *
 736  * 04 23 2010 cp.wu
 737  * [WPD00001943]Create WiFi test driver framework on WinXP
 738  * .
 739  *
 740  * 04 22 2010 cp.wu
 741  * [WPD00003830]add OID_802_11_PRIVACY_FILTER support
 742  * enable RX filter OID
 743  *
 744  * 04 19 2010 jeffrey.chang
 745  * [WPD00003826]Initial import for Linux port
 746  * Add ioctl of power management
 747  *
 748  * 04 14 2010 cp.wu
 749  * [WPD00001943]Create WiFi test driver framework on WinXP
 750  * information buffer for query oid/ioctl is now buffered in prCmdInfo
 751  *  * instead of glue-layer variable to improve multiple oid/ioctl capability
 752  *
 753  * 04 13 2010 cp.wu
 754  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 755  * add framework for BT-over-Wi-Fi support.
 756  *  *  *  * 1) prPendingCmdInfo is replaced by queue for multiple handler capability
 757  *  *  *  * 2) command sequence number is now increased atomically
 758  *  *  *  * 3) private data could be hold and taken use for other purpose
 759  *
 760  * 04 12 2010 cp.wu
 761  * [WPD00001943]Create WiFi test driver framework on WinXP
 762  * correct OID_802_11_CONFIGURATION query for infrastructure mode.
 763  *
 764  * 04 09 2010 jeffrey.chang
 765  * [WPD00003826]Initial import for Linux port
 766  * 1) remove unused spin lock declaration
 767  *
 768  * 04 07 2010 cp.wu
 769  * [WPD00001943]Create WiFi test driver framework on WinXP
 770  * finish non-glue layer access to glue variables
 771  *
 772  * 04 07 2010 cp.wu
 773  * [WPD00001943]Create WiFi test driver framework on WinXP
 774  * rWlanInfo should be placed at adapter rather than glue due to most operations
 775  *  * are done in adapter layer.
 776  *
 777  * 04 07 2010 jeffrey.chang
 778  * [WPD00003826]Initial import for Linux port
 779  * (1)improve none-glue code portability
 780  * (2) disable set Multicast address during atomic context
 781  *
 782  * 04 07 2010 cp.wu
 783  * [WPD00001943]Create WiFi test driver framework on WinXP
 784  * eliminate direct access to prGlueInfo->eParamMediaStateIndicated from non-glue layer
 785  *
 786  * 04 06 2010 cp.wu
 787  * [WPD00001943]Create WiFi test driver framework on WinXP
 788  * ePowerCtrl is not necessary as a glue variable.
 789  *
 790  * 04 06 2010 cp.wu
 791  * [WPD00001943]Create WiFi test driver framework on WinXP
 792  * eliminate direct access to prGlueInfo->rWlanInfo.eLinkAttr.ucMediaStreamMode from non-glue layer.
 793  *
 794  * 04 06 2010 jeffrey.chang
 795  * [WPD00003826]Initial import for Linux port
 796  * improve none-glue code portability
 797  *
 798  * 04 06 2010 cp.wu
 799  * [WPD00001943]Create WiFi test driver framework on WinXP
 800  * code refine: fgTestMode should be at adapter rather than glue due to the device/fw is also involved
 801  *
 802  * 04 01 2010 cp.wu
 803  * [WPD00001943]Create WiFi test driver framework on WinXP
 804  * .
 805  *
 806  * 03 31 2010 wh.su
 807  * [WPD00003816][MT6620 Wi-Fi] Adding the security support
 808  * modify the wapi related code for new driver's design.
 809  *
 810  * 03 30 2010 cp.wu
 811  * [WPD00001943]Create WiFi test driver framework on WinXP
 812  * statistics information OIDs are now handled by querying from firmware domain
 813  *
 814  * 03 28 2010 jeffrey.chang
 815  * [WPD00003826]Initial import for Linux port
 816  * improve glue code portability
 817  *
 818  * 03 26 2010 cp.wu
 819  * [WPD00001943]Create WiFi test driver framework on WinXP
 820  * indicate media stream mode after set is done
 821  *
 822  * 03 26 2010 cp.wu
 823  * [WPD00001943]Create WiFi test driver framework on WinXP
 824  * add a temporary flag for integration with CMD/EVENT v0.9.
 825  *
 826  * 03 25 2010 cp.wu
 827  * [WPD00001943]Create WiFi test driver framework on WinXP
 828  * 1) correct OID_802_11_CONFIGURATION with frequency setting behavior.
 829  * the frequency is used for adhoc connection only
 830  * 2) update with SD1 v0.9 CMD/EVENT documentation
 831  *
 832  * 03 24 2010 jeffrey.chang
 833  * [WPD00003826]Initial import for Linux port
 834  * [WPD00003826] Initial import for Linux port
 835  * initial import for Linux port
 836  *
 837  * 03 24 2010 jeffrey.chang
 838  * [WPD00003826]Initial import for Linux port
 839  * initial import for Linux port
 840  *
 841  * 03 24 2010 cp.wu
 842  * [WPD00001943]Create WiFi test driver framework on WinXP
 843  * generate information for OID_GEN_RCV_OK & OID_GEN_XMIT_OK
 844  *
 845  *
 846  * 03 22 2010 cp.wu
 847  * [WPD00003824][MT6620 Wi-Fi][New Feature] Add support of large scan list
 848  * Implement feature needed by CR: WPD00003824: refining association command by pasting scanning result
 849  *
 850  * 03 19 2010 wh.su
 851  * [WPD00003820][MT6620 Wi-Fi] Modify the code for meet the WHQL test
 852  * adding the check for pass WHQL test item.
 853  *
 854  * 03 19 2010 cp.wu
 855  * [WPD00001943]Create WiFi test driver framework on WinXP
 856  * 1) add ACPI D0/D3 state switching support
 857  *  * 2) use more formal way to handle interrupt when the status is retrieved from enhanced RX response
 858  *
 859 * 03 16 2010 wh.su
 860  * [WPD00003820][MT6620 Wi-Fi] Modify the code for meet the WHQL test
 861  * fixed some whql pre-test fail case.
 862  *
 863  * 03 03 2010 cp.wu
 864  * [WPD00001943]Create WiFi test driver framework on WinXP
 865  * implement custom OID: EEPROM read/write access
 866  *
 867  * 03 03 2010 cp.wu
 868  * [WPD00001943]Create WiFi test driver framework on WinXP
 869  * implement OID_802_3_MULTICAST_LIST oid handling
 870  *
 871  * 03 02 2010 cp.wu
 872  * [WPD00001943]Create WiFi test driver framework on WinXP
 873  * 1) the use of prPendingOid revised, all accessing are now protected by spin lock
 874  *  * 2) ensure wlanReleasePendingOid will clear all command queues
 875  *
 876  * 02 25 2010 cp.wu
 877  * [WPD00001943]Create WiFi test driver framework on WinXP
 878  * send CMD_ID_INFRASTRUCTURE when handling OID_802_11_INFRASTRUCTURE_MODE set.
 879  *
 880  * 02 24 2010 wh.su
 881  * [WPD00003820][MT6620 Wi-Fi] Modify the code for meet the WHQL test
 882  * Don't needed to check the auth mode, WHQL testing not specific at auth wpa2.
 883  *
 884  * 02 23 2010 cp.wu
 885  * [WPD00001943]Create WiFi test driver framework on WinXP
 886  * do not check SSID validity anymore.
 887  *
 888  * 02 23 2010 cp.wu
 889  * [WPD00001943]Create WiFi test driver framework on WinXP
 890  * add checksum offloading support.
 891  *
 892  * 02 09 2010 cp.wu
 893  * [WPD00001943]Create WiFi test driver framework on WinXP
 894  * 1. Permanent and current MAC address are now retrieved by CMD/EVENT packets instead of hard-coded address
 895  *  * 2. follow MSDN defined behavior when associates to another AP
 896  *  * 3. for firmware download, packet size could be up to 2048 bytes
 897  *
 898  * 02 09 2010 cp.wu
 899  * [WPD00001943]Create WiFi test driver framework on WinXP
 900  * move ucCmdSeqNum as instance variable
 901  *
 902  * 02 04 2010 cp.wu
 903  * [WPD00001943]Create WiFi test driver framework on WinXP
 904  * when OID_CUSTOM_OID_INTERFACE_VERSION is queried, do modify connection states
 905  *
 906  * 01 27 2010 cp.wu
 907  * [WPD00001943]Create WiFi test driver framework on WinXP
 908  * 1) implement timeout mechanism when OID is pending for longer than 1 second
 909  *  * 2) allow OID_802_11_CONFIGURATION to be executed when RF test mode is turned on
 910  *
 911  * 01 27 2010 wh.su
 912  * [WPD00003816][MT6620 Wi-Fi] Adding the security support
 913  * .
 914  *
 915  * 01 27 2010 cp.wu
 916  * [WPD00001943]Create WiFi test driver framework on WinXP
 917  * 1. eliminate improper variable in rHifInfo
 918  *  * 2. block TX/ordinary OID when RF test mode is engaged
 919  *  * 3. wait until firmware finish operation when entering into and leaving from RF test mode
 920  *  * 4. correct some HAL implementation
 921  *
 922  * 01 22 2010 cp.wu
 923  * [WPD00001943]Create WiFi test driver framework on WinXP
 924  * implement following 802.11 OIDs:
 925  * OID_802_11_RSSI,
 926  * OID_802_11_RSSI_TRIGGER,
 927  * OID_802_11_STATISTICS,
 928  * OID_802_11_DISASSOCIATE,
 929  * OID_802_11_POWER_MODE
 930  *
 931  * 01 21 2010 cp.wu
 932  * [WPD00001943]Create WiFi test driver framework on WinXP
 933  * implement OID_802_11_MEDIA_STREAM_MODE
 934  *
 935  * 01 21 2010 cp.wu
 936  * [WPD00001943]Create WiFi test driver framework on WinXP
 937  * implement OID_802_11_SUPPORTED_RATES / OID_802_11_DESIRED_RATES
 938  *
 939  * 01 21 2010 cp.wu
 940  * [WPD00001943]Create WiFi test driver framework on WinXP
 941  * do not fill ucJoinOnly currently
 942  *
 943  * 01 14 2010 cp.wu
 944  * [WPD00001943]Create WiFi test driver framework on WinXP
 945  * enable to connect to ad-hoc network
 946  *
 947  * 01 07 2010 cp.wu
 948  * [WPD00001943]Create WiFi test driver framework on WinXP
 949  * .implement Set/Query BeaconInterval/AtimWindow
 950  *
 951  * 01 07 2010 cp.wu
 952  * [WPD00001943]Create WiFi test driver framework on WinXP
 953  * .Set/Get AT Info is not blocked even when driver is not in fg test mode
 954  *
 955  * 12 30 2009 cp.wu
 956  * [WPD00001943]Create WiFi test driver framework on WinXP
 957  * 1) According to CMD/EVENT documentation v0.8,
 958  * OID_CUSTOM_TEST_RX_STATUS & OID_CUSTOM_TEST_TX_STATUS is no longer used,
 959  * and result is retrieved by get ATInfo instead
 960  * 2) add 4 counter for recording aggregation statistics
 961  *
 962  * 12 28 2009 cp.wu
 963  * [WPD00001943]Create WiFi test driver framework on WinXP
 964  * eliminate redundant variables for connection_state
 965 **  \main\maintrunk.MT6620WiFiDriver_Prj\32 2009-12-16 22:13:36 GMT mtk02752
 966 **  change hard-coded MAC address to match with FW (temporally)
 967 **  \main\maintrunk.MT6620WiFiDriver_Prj\31 2009-12-10 16:49:50 GMT mtk02752
 968 **  code clean
 969 **  \main\maintrunk.MT6620WiFiDriver_Prj\30 2009-12-08 17:38:49 GMT mtk02752
 970 **  + add OID for RF test
 971 **  * MCR RD/WR are modified to match with cmd/event definition
 972 **  \main\maintrunk.MT6620WiFiDriver_Prj\29 2009-12-08 11:32:20 GMT mtk02752
 973 **  add skeleton for RF test implementation
 974 **  \main\maintrunk.MT6620WiFiDriver_Prj\28 2009-12-03 16:43:24 GMT mtk01461
 975 **  Modify query SCAN list oid by adding prEventScanResult
 976 **
 977 **  \main\maintrunk.MT6620WiFiDriver_Prj\27 2009-12-03 16:39:27 GMT mtk01461
 978 **  Sync CMD data structure in set ssid oid
 979 **  \main\maintrunk.MT6620WiFiDriver_Prj\26 2009-12-03 16:28:22 GMT mtk01461
 980 **  Add invalid check of set SSID oid and fix query scan list oid
 981 **  \main\maintrunk.MT6620WiFiDriver_Prj\25 2009-11-30 17:33:08 GMT mtk02752
 982 **  implement wlanoidSetInfrastructureMode/wlanoidQueryInfrastructureMode
 983 **  \main\maintrunk.MT6620WiFiDriver_Prj\24 2009-11-30 10:53:49 GMT mtk02752
 984 **  1st DW of WIFI_CMD_T is shared with HIF_TX_HEADER_T
 985 **  \main\maintrunk.MT6620WiFiDriver_Prj\23 2009-11-30 09:22:48 GMT mtk02752
 986 **  correct wifi cmd length mismatch
 987 **  \main\maintrunk.MT6620WiFiDriver_Prj\22 2009-11-25 21:34:33 GMT mtk02752
 988 **  sync EVENT_SCAN_RESULT_T with firmware
 989 **  \main\maintrunk.MT6620WiFiDriver_Prj\21 2009-11-25 21:03:27 GMT mtk02752
 990 **  implement wlanoidQueryBssidList()
 991 **  \main\maintrunk.MT6620WiFiDriver_Prj\20 2009-11-25 18:17:17 GMT mtk02752
 992 **  refine GL_WLAN_INFO_T for buffering scan result
 993 **  \main\maintrunk.MT6620WiFiDriver_Prj\19 2009-11-23 20:28:51 GMT mtk02752
 994 **  some OID will be set to WLAN_STATUS_PENDING until it is sent via wlanSendCommand()
 995 **  \main\maintrunk.MT6620WiFiDriver_Prj\18 2009-11-23 17:56:36 GMT mtk02752
 996 **  implement wlanoidSetBssidListScan(), wlanoidSetBssid() and wlanoidSetSsid()
 997 **
 998 **  \main\maintrunk.MT6620WiFiDriver_Prj\17 2009-11-13 17:20:53 GMT mtk02752
 999 **  add Set BSSID/SSID path but disabled temporally due to FW is not ready yet
1000 **  \main\maintrunk.MT6620WiFiDriver_Prj\16 2009-11-13 12:28:58 GMT mtk02752
1001 **  add wlanoidSetBssidListScan -> cmd_info path
1002 **  \main\maintrunk.MT6620WiFiDriver_Prj\15 2009-11-09 22:48:07 GMT mtk01084
1003 **  modify test cases entry
1004 **  \main\maintrunk.MT6620WiFiDriver_Prj\14 2009-11-04 14:10:58 GMT mtk01084
1005 **  add new test interfaces
1006 **  \main\maintrunk.MT6620WiFiDriver_Prj\13 2009-10-30 18:17:10 GMT mtk01084
1007 **  fix compiler warning
1008 **  \main\maintrunk.MT6620WiFiDriver_Prj\12 2009-10-29 19:46:26 GMT mtk01084
1009 **  add test functions
1010 **  \main\maintrunk.MT6620WiFiDriver_Prj\11 2009-10-23 16:07:56 GMT mtk01084
1011 **  include new file
1012 **  \main\maintrunk.MT6620WiFiDriver_Prj\10 2009-10-13 21:58:29 GMT mtk01084
1013 **  modify for new HW architecture
1014 **  \main\maintrunk.MT6620WiFiDriver_Prj\9 2009-10-02 13:48:49 GMT mtk01725
1015 **  \main\maintrunk.MT6620WiFiDriver_Prj\8 2009-09-09 17:26:04 GMT mtk01084
1016 **  \main\maintrunk.MT6620WiFiDriver_Prj\7 2009-04-21 12:09:50 GMT mtk01461
1017 **  Update for MCR Write OID
1018 **  \main\maintrunk.MT6620WiFiDriver_Prj\6 2009-04-21 09:35:18 GMT mtk01461
1019 **  Update wlanoidQueryMcrRead() for composing CMD_INFO_T
1020 **  \main\maintrunk.MT6620WiFiDriver_Prj\5 2009-04-17 18:09:51 GMT mtk01426
1021 **  Remove kalIndicateStatusAndComplete() in wlanoidQueryOidInterfaceVersion()
1022 **  \main\maintrunk.MT6620WiFiDriver_Prj\4 2009-04-14 15:51:50 GMT mtk01426
1023 **  Add MCR read/write support
1024 **  \main\maintrunk.MT6620WiFiDriver_Prj\3 2009-03-19 18:32:40 GMT mtk01084
1025 **  update for basic power management functions
1026 **  \main\maintrunk.MT6620WiFiDriver_Prj\2 2009-03-10 20:06:31 GMT mtk01426
1027 **  Init for develop
1028 **
1029 */
1030
1031 /******************************************************************************
1032 *                         C O M P I L E R   F L A G S
1033 *******************************************************************************
1034 */
1035
1036 /******************************************************************************
1037 *                    E X T E R N A L   R E F E R E N C E S
1038 *******************************************************************************
1039 */
1040 #include "precomp.h"
1041 #include "mgmt/rsn.h"
1042
1043 #include <stddef.h>
1044
1045 /******************************************************************************
1046 *                              C O N S T A N T S
1047 *******************************************************************************
1048 */
1049
1050 /******************************************************************************
1051 *                             D A T A   T Y P E S
1052 *******************************************************************************
1053 */
1054
1055 /******************************************************************************
1056 *                            P U B L I C   D A T A
1057 *******************************************************************************
1058 */
1059 #if DBG
1060 extern UINT_8  aucDebugModule[DBG_MODULE_NUM];
1061 extern UINT_32 u4DebugModule;
1062 UINT_32 u4DebugModuleTemp;
1063 #endif /* DBG */
1064
1065 /******************************************************************************
1066 *                           P R I V A T E   D A T A
1067 *******************************************************************************
1068 */
1069
1070 /******************************************************************************
1071 *                                 M A C R O S
1072 *******************************************************************************
1073 */
1074
1075 /******************************************************************************
1076 *                   F U N C T I O N   D E C L A R A T I O N S
1077 *******************************************************************************
1078 */
1079 extern int sprintf(char * buf, const char * fmt, ...);
1080
1081 /******************************************************************************
1082 *                              F U N C T I O N S
1083 *******************************************************************************
1084 */
1085 #if CFG_ENABLE_STATISTICS_BUFFERING
1086 static BOOLEAN
1087 IsBufferedStatisticsUsable(
1088     P_ADAPTER_T prAdapter)
1089 {
1090     ASSERT(prAdapter);
1091
1092     if(prAdapter->fgIsStatValid == TRUE &&
1093             (kalGetTimeTick() - prAdapter->rStatUpdateTime) <= CFG_STATISTICS_VALID_CYCLE)
1094         return TRUE;
1095     else
1096         return FALSE;
1097 }
1098 #endif
1099
1100
1101 /*----------------------------------------------------------------------------*/
1102 /*!
1103 * \brief This routine is called to query the supported physical layer network
1104 *        type that can be used by the driver.
1105 *
1106 * \param[in] prAdapter Pointer to the Adapter structure.
1107 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
1108 *                           the query.
1109 * \param[in] u4QueryBufferLen The length of the query buffer.
1110 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
1111 *                            bytes written into the query buffer. If the call
1112 *                            failed due to invalid length of the query buffer,
1113 *                            returns the amount of storage needed.
1114 *
1115 * \retval WLAN_STATUS_SUCCESS
1116 * \retval WLAN_STATUS_INVALID_LENGTH
1117 */
1118 /*----------------------------------------------------------------------------*/
1119 WLAN_STATUS
1120 wlanoidQueryNetworkTypesSupported (
1121     IN  P_ADAPTER_T       prAdapter,
1122     OUT PVOID             pvQueryBuffer,
1123     IN  UINT_32           u4QueryBufferLen,
1124     OUT PUINT_32          pu4QueryInfoLen
1125     )
1126 {
1127     UINT_32 u4NumItem = 0;
1128     ENUM_PARAM_NETWORK_TYPE_T eSupportedNetworks[PARAM_NETWORK_TYPE_NUM];
1129     PPARAM_NETWORK_TYPE_LIST prSupported;
1130
1131     /* The array of all physical layer network subtypes that the driver supports. */
1132
1133     DEBUGFUNC("wlanoidQueryNetworkTypesSupported");
1134
1135     ASSERT(prAdapter);
1136     ASSERT(pu4QueryInfoLen);
1137     if (u4QueryBufferLen) {
1138         ASSERT(pvQueryBuffer);
1139     }
1140
1141     /* Init. */
1142     for (u4NumItem = 0; u4NumItem < PARAM_NETWORK_TYPE_NUM ; u4NumItem++) {
1143         eSupportedNetworks[u4NumItem] = 0;
1144     }
1145
1146     u4NumItem = 0;
1147
1148     eSupportedNetworks[u4NumItem] = PARAM_NETWORK_TYPE_DS;
1149     u4NumItem ++;
1150
1151     eSupportedNetworks[u4NumItem] = PARAM_NETWORK_TYPE_OFDM24;
1152     u4NumItem ++;
1153
1154     *pu4QueryInfoLen =
1155         (UINT_32)OFFSET_OF(PARAM_NETWORK_TYPE_LIST, eNetworkType) +
1156         (u4NumItem * sizeof(ENUM_PARAM_NETWORK_TYPE_T));
1157
1158     if (u4QueryBufferLen < *pu4QueryInfoLen) {
1159         return WLAN_STATUS_INVALID_LENGTH;
1160     }
1161
1162     prSupported = (PPARAM_NETWORK_TYPE_LIST)pvQueryBuffer;
1163     prSupported->NumberOfItems = u4NumItem;
1164     kalMemCopy(prSupported->eNetworkType,
1165         eSupportedNetworks,
1166         u4NumItem * sizeof(ENUM_PARAM_NETWORK_TYPE_T));
1167
1168     DBGLOG(REQ, TRACE, ("NDIS supported network type list: %ld\n",
1169         prSupported->NumberOfItems));
1170     DBGLOG_MEM8(REQ, INFO, prSupported, *pu4QueryInfoLen);
1171
1172     return WLAN_STATUS_SUCCESS;
1173 } /* wlanoidQueryNetworkTypesSupported */
1174
1175
1176 /*----------------------------------------------------------------------------*/
1177 /*!
1178 * \brief This routine is called to query the current physical layer network
1179 *        type used by the driver.
1180 *
1181 * \param[in] prAdapter Pointer to the Adapter structure.
1182 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
1183 *             the query.
1184 * \param[in] u4QueryBufferLen The length of the query buffer.
1185 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
1186 *                             bytes written into the query buffer. If the
1187 *                             call failed due to invalid length of the query
1188 *                             buffer, returns the amount of storage needed.
1189 *
1190 * \retval WLAN_STATUS_SUCCESS
1191 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
1192 */
1193 /*----------------------------------------------------------------------------*/
1194 WLAN_STATUS
1195 wlanoidQueryNetworkTypeInUse (
1196     IN  P_ADAPTER_T       prAdapter,
1197     OUT PVOID             pvQueryBuffer,
1198     IN  UINT_32           u4QueryBufferLen,
1199     OUT PUINT_32          pu4QueryInfoLen
1200     )
1201 {
1202     // TODO: need to check the OID handler content again!!
1203
1204     ENUM_PARAM_NETWORK_TYPE_T rCurrentNetworkTypeInUse = PARAM_NETWORK_TYPE_OFDM24;
1205
1206     DEBUGFUNC("wlanoidQueryNetworkTypeInUse");
1207
1208     ASSERT(prAdapter);
1209     ASSERT(pu4QueryInfoLen);
1210     if (u4QueryBufferLen) {
1211         ASSERT(pvQueryBuffer);
1212     }
1213
1214     if (u4QueryBufferLen < sizeof(ENUM_PARAM_NETWORK_TYPE_T)) {
1215         *pu4QueryInfoLen = sizeof(ENUM_PARAM_NETWORK_TYPE_T);
1216         return WLAN_STATUS_BUFFER_TOO_SHORT;
1217     }
1218
1219
1220     if (kalGetMediaStateIndicated(prAdapter->prGlueInfo) == PARAM_MEDIA_STATE_CONNECTED) {
1221         rCurrentNetworkTypeInUse =
1222             (ENUM_PARAM_NETWORK_TYPE_T)(prAdapter->rWlanInfo.ucNetworkType);
1223     }
1224     else {
1225         rCurrentNetworkTypeInUse =
1226             (ENUM_PARAM_NETWORK_TYPE_T)(prAdapter->rWlanInfo.ucNetworkTypeInUse);
1227     }
1228
1229     *(P_ENUM_PARAM_NETWORK_TYPE_T)pvQueryBuffer = rCurrentNetworkTypeInUse;
1230     *pu4QueryInfoLen = sizeof(ENUM_PARAM_NETWORK_TYPE_T);
1231
1232     DBGLOG(REQ, TRACE, ("Network type in use: %d\n", rCurrentNetworkTypeInUse));
1233
1234     return WLAN_STATUS_SUCCESS;
1235 } /* wlanoidQueryNetworkTypeInUse */
1236
1237
1238 /*----------------------------------------------------------------------------*/
1239 /*!
1240 * \brief This routine is called to set the physical layer network type used
1241 *        by the driver.
1242 *
1243 * \param[in] pvAdapter Pointer to the Adapter structure.
1244 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
1245 * \param[in] u4SetBufferLen The length of the set buffer.
1246 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1247 *                          bytes read from the set buffer. If the call failed
1248 *                          due to invalid length of the set buffer, returns the
1249 *                          amount of storage needed.
1250 *
1251 * \retval WLAN_STATUS_SUCCESS The given network type is supported and accepted.
1252 * \retval WLAN_STATUS_INVALID_DATA The given network type is not in the
1253 *                                  supported list.
1254 */
1255 /*----------------------------------------------------------------------------*/
1256 WLAN_STATUS
1257 wlanoidSetNetworkTypeInUse (
1258     IN  P_ADAPTER_T       prAdapter,
1259     IN  PVOID             pvSetBuffer,
1260     IN  UINT_32           u4SetBufferLen,
1261     OUT PUINT_32          pu4SetInfoLen
1262     )
1263 {
1264     // TODO: need to check the OID handler content again!!
1265
1266     ENUM_PARAM_NETWORK_TYPE_T eNewNetworkType;
1267     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
1268     DEBUGFUNC("wlanoidSetNetworkTypeInUse");
1269
1270     ASSERT(prAdapter);
1271     ASSERT(pvSetBuffer);
1272     ASSERT(pu4SetInfoLen);
1273
1274     if (u4SetBufferLen < sizeof(ENUM_PARAM_NETWORK_TYPE_T)) {
1275         *pu4SetInfoLen = sizeof(ENUM_PARAM_NETWORK_TYPE_T);
1276         return WLAN_STATUS_INVALID_LENGTH;
1277     }
1278
1279     eNewNetworkType = *(P_ENUM_PARAM_NETWORK_TYPE_T)pvSetBuffer;
1280     *pu4SetInfoLen = sizeof(ENUM_PARAM_NETWORK_TYPE_T);
1281
1282     DBGLOG(REQ,
1283         INFO,
1284         ("New network type: %d mode\n", eNewNetworkType));
1285
1286     switch (eNewNetworkType) {
1287
1288     case PARAM_NETWORK_TYPE_DS:
1289         prAdapter->rWlanInfo.ucNetworkTypeInUse = (UINT_8) PARAM_NETWORK_TYPE_DS;
1290         break;
1291
1292     case PARAM_NETWORK_TYPE_OFDM5:
1293         prAdapter->rWlanInfo.ucNetworkTypeInUse = (UINT_8) PARAM_NETWORK_TYPE_OFDM5;
1294         break;
1295
1296     case PARAM_NETWORK_TYPE_OFDM24:
1297         prAdapter->rWlanInfo.ucNetworkTypeInUse = (UINT_8) PARAM_NETWORK_TYPE_OFDM24;
1298         break;
1299
1300     case PARAM_NETWORK_TYPE_AUTOMODE:
1301         prAdapter->rWlanInfo.ucNetworkTypeInUse = (UINT_8) PARAM_NETWORK_TYPE_AUTOMODE;
1302         break;
1303
1304     case PARAM_NETWORK_TYPE_FH:
1305         DBGLOG(REQ, INFO, ("Not support network type: %d\n", eNewNetworkType));
1306         rStatus = WLAN_STATUS_NOT_SUPPORTED;
1307         break;
1308
1309     default:
1310         DBGLOG(REQ, INFO, ("Unknown network type: %d\n", eNewNetworkType));
1311         rStatus = WLAN_STATUS_INVALID_DATA;
1312         break;
1313     }
1314
1315     /* Verify if we support the new network type. */
1316     if (rStatus != WLAN_STATUS_SUCCESS) {
1317         DBGLOG(REQ, WARN, ("Unknown network type: %d\n", eNewNetworkType));
1318     }
1319
1320     return rStatus;
1321 } /* wlanoidSetNetworkTypeInUse */
1322
1323
1324 /*----------------------------------------------------------------------------*/
1325 /*!
1326 * \brief This routine is called to query the current BSSID.
1327 *
1328 * \param[in] prAdapter Pointer to the Adapter structure.
1329 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
1330 *                           the query.
1331 * \param[in] u4QueryBufferLen The length of the query buffer.
1332 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
1333 *                             bytes written into the query buffer. If the call
1334 *                             failed due to invalid length of the query buffer,
1335 *                             returns the amount of storage needed.
1336 *
1337 * \retval WLAN_STATUS_SUCCESS
1338 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1339 */
1340 /*----------------------------------------------------------------------------*/
1341 WLAN_STATUS
1342 wlanoidQueryBssid (
1343     IN  P_ADAPTER_T       prAdapter,
1344     OUT PVOID             pvQueryBuffer,
1345     IN  UINT_32           u4QueryBufferLen,
1346     OUT PUINT_32          pu4QueryInfoLen
1347     )
1348 {
1349     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
1350
1351     DEBUGFUNC("wlanoidQueryBssid");
1352
1353     ASSERT(prAdapter);
1354
1355     if (u4QueryBufferLen < MAC_ADDR_LEN) {
1356         ASSERT(pu4QueryInfoLen);
1357         *pu4QueryInfoLen = MAC_ADDR_LEN;
1358         return WLAN_STATUS_BUFFER_TOO_SHORT;
1359     }
1360
1361     ASSERT(u4QueryBufferLen >= MAC_ADDR_LEN);
1362     if (u4QueryBufferLen) {
1363         ASSERT(pvQueryBuffer);
1364     }
1365     ASSERT(pu4QueryInfoLen);
1366
1367     if(kalGetMediaStateIndicated(prAdapter->prGlueInfo) == PARAM_MEDIA_STATE_CONNECTED) {
1368         kalMemCopy(pvQueryBuffer, prAdapter->rWlanInfo.rCurrBssId.arMacAddress, MAC_ADDR_LEN);
1369     }
1370     else if(prAdapter->rWifiVar.rConnSettings.eOPMode == NET_TYPE_IBSS) {
1371         PARAM_MAC_ADDRESS aucTemp;         /*!< BSSID */
1372         COPY_MAC_ADDR(aucTemp, prAdapter->rWlanInfo.rCurrBssId.arMacAddress);
1373         aucTemp[0] &= ~BIT(0);
1374         aucTemp[1] |= BIT(1);
1375         COPY_MAC_ADDR(pvQueryBuffer, aucTemp);
1376     }
1377     else {
1378         rStatus = WLAN_STATUS_ADAPTER_NOT_READY;
1379     }
1380
1381     *pu4QueryInfoLen = MAC_ADDR_LEN;
1382     return rStatus;
1383 } /* wlanoidQueryBssid */
1384
1385
1386
1387 /*----------------------------------------------------------------------------*/
1388 /*!
1389 * \brief This routine is called to query the list of all BSSIDs detected by
1390 *        the driver.
1391 *
1392 * \param[in] prAdapter Pointer to the Adapter structure.
1393 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
1394 *                           the query.
1395 * \param[in] u4QueryBufferLen The length of the query buffer.
1396 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
1397 *                             bytes written into the query buffer. If the call
1398 *                             failed due to invalid length of the query buffer,
1399 *                             returns the amount of storage needed.
1400 *
1401 * \retval WLAN_STATUS_SUCCESS
1402 * \retval WLAN_STATUS_INVALID_LENGTH
1403 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1404 */
1405 /*----------------------------------------------------------------------------*/
1406 WLAN_STATUS
1407 wlanoidQueryBssidList (
1408     IN  P_ADAPTER_T       prAdapter,
1409     OUT PVOID             pvQueryBuffer,
1410     IN  UINT_32           u4QueryBufferLen,
1411     OUT PUINT_32          pu4QueryInfoLen
1412     )
1413 {
1414     P_GLUE_INFO_T prGlueInfo;
1415     UINT_32 i, u4BssidListExLen;
1416     P_PARAM_BSSID_LIST_EX_T prList;
1417     P_PARAM_BSSID_EX_T prBssidEx;
1418     PUINT_8 cp;
1419
1420     DEBUGFUNC("wlanoidQueryBssidList");
1421
1422     ASSERT(prAdapter);
1423     ASSERT(pu4QueryInfoLen);
1424
1425     if (u4QueryBufferLen) {
1426         ASSERT(pvQueryBuffer);
1427
1428         if(!pvQueryBuffer) {
1429             return WLAN_STATUS_INVALID_DATA;
1430         }
1431     }
1432
1433     prGlueInfo = prAdapter->prGlueInfo;
1434
1435     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
1436         DBGLOG(REQ, WARN, ("Fail in qeury BSSID list! (Adapter not ready). ACPI=D%d, Radio=%d\n",
1437                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
1438         return WLAN_STATUS_ADAPTER_NOT_READY;
1439     }
1440
1441     u4BssidListExLen = 0;
1442
1443     if(prAdapter->fgIsRadioOff == FALSE) {
1444         for(i = 0 ; i < prAdapter->rWlanInfo.u4ScanResultNum ; i++) {
1445             u4BssidListExLen += ALIGN_4(prAdapter->rWlanInfo.arScanResult[i].u4Length);
1446         }
1447     }
1448
1449     if(u4BssidListExLen) {
1450         u4BssidListExLen += 4; // u4NumberOfItems.
1451     }
1452     else {
1453         u4BssidListExLen = sizeof(PARAM_BSSID_LIST_EX_T);
1454     }
1455
1456     *pu4QueryInfoLen = u4BssidListExLen;
1457
1458     if (u4QueryBufferLen < *pu4QueryInfoLen) {
1459         return WLAN_STATUS_INVALID_LENGTH;
1460     }
1461
1462     /* Clear the buffer */
1463     kalMemZero(pvQueryBuffer, u4BssidListExLen);
1464
1465     prList = (P_PARAM_BSSID_LIST_EX_T) pvQueryBuffer;
1466     cp = (PUINT_8)&prList->arBssid[0];
1467
1468     if(prAdapter->fgIsRadioOff == FALSE && prAdapter->rWlanInfo.u4ScanResultNum > 0) {
1469         // fill up for each entry
1470         for(i = 0 ; i < prAdapter->rWlanInfo.u4ScanResultNum ; i++) {
1471             prBssidEx = (P_PARAM_BSSID_EX_T)cp;
1472
1473             // copy structure
1474             kalMemCopy(prBssidEx,
1475                     &(prAdapter->rWlanInfo.arScanResult[i]),
1476                     OFFSET_OF(PARAM_BSSID_EX_T, aucIEs));
1477
1478             /*For WHQL test, Rssi should be in range -10 ~ -200 dBm*/
1479             if(prBssidEx->rRssi > PARAM_WHQL_RSSI_MAX_DBM) {
1480                 prBssidEx->rRssi = PARAM_WHQL_RSSI_MAX_DBM;
1481             }
1482
1483             if(prAdapter->rWlanInfo.arScanResult[i].u4IELength > 0) {
1484                 // copy IEs
1485                 kalMemCopy(prBssidEx->aucIEs,
1486                         prAdapter->rWlanInfo.apucScanResultIEs[i],
1487                         prAdapter->rWlanInfo.arScanResult[i].u4IELength);
1488             }
1489
1490             // 4-bytes alignement
1491             prBssidEx->u4Length = ALIGN_4(prBssidEx->u4Length);
1492
1493             cp += prBssidEx->u4Length;
1494             prList->u4NumberOfItems++;
1495         }
1496     }
1497
1498     return WLAN_STATUS_SUCCESS;
1499 } /* wlanoidQueryBssidList */
1500
1501
1502 /*----------------------------------------------------------------------------*/
1503 /*!
1504 * \brief This routine is called to request the driver to perform
1505 *        scanning.
1506 *
1507 * \param[in] prAdapter Pointer to the Adapter structure.
1508 * \param[in] pvSetBuffer Pointer to the buffer that holds the data to be set.
1509 * \param[in] u4SetBufferLen The length of the set buffer.
1510 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1511 *                          bytes read from the set buffer. If the call failed
1512 *                          due to invalid length of the set buffer, returns
1513 *                          the amount of storage needed.
1514 *
1515 * \retval WLAN_STATUS_SUCCESS
1516 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1517 * \retval WLAN_STATUS_FAILURE
1518 */
1519 /*----------------------------------------------------------------------------*/
1520 WLAN_STATUS
1521 wlanoidSetBssidListScan (
1522     IN  P_ADAPTER_T       prAdapter,
1523     IN  PVOID             pvSetBuffer,
1524     IN  UINT_32           u4SetBufferLen,
1525     OUT PUINT_32          pu4SetInfoLen
1526     )
1527 {
1528     P_PARAM_SSID_T prSsid;
1529     PARAM_SSID_T rSsid;
1530
1531     DEBUGFUNC("wlanoidSetBssidListScan()");
1532
1533     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
1534         DBGLOG(REQ, WARN, ("Fail in set BSSID list scan! (Adapter not ready). ACPI=D%d, Radio=%d\n",
1535                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
1536         return WLAN_STATUS_ADAPTER_NOT_READY;
1537     }
1538
1539     ASSERT(pu4SetInfoLen);
1540     *pu4SetInfoLen = 0;
1541
1542     if (prAdapter->fgIsRadioOff) {
1543         DBGLOG(REQ, WARN, ("Return from BSSID list scan! (radio off). ACPI=D%d, Radio=%d\n",
1544                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
1545         return WLAN_STATUS_SUCCESS;
1546     }
1547
1548     if(pvSetBuffer != NULL && u4SetBufferLen != 0) {
1549         COPY_SSID(rSsid.aucSsid,
1550                 rSsid.u4SsidLen,
1551                 pvSetBuffer,
1552                 u4SetBufferLen);
1553         prSsid = &rSsid;
1554     }
1555     else {
1556         prSsid = NULL;
1557     }
1558
1559 #if CFG_SUPPORT_RDD_TEST_MODE
1560     if (prAdapter->prGlueInfo->rRegInfo.u4RddTestMode) {
1561         if((prAdapter->fgEnOnlineScan == TRUE) && (prAdapter->ucRddStatus)){
1562             if (kalGetMediaStateIndicated(prAdapter->prGlueInfo) != PARAM_MEDIA_STATE_CONNECTED){
1563                 aisFsmScanRequest(prAdapter, prSsid, NULL, 0);
1564             }
1565         }
1566     }
1567     else
1568 #endif
1569     {
1570         if(prAdapter->fgEnOnlineScan == TRUE) {
1571             aisFsmScanRequest(prAdapter, prSsid, NULL, 0);
1572         }
1573         else if(kalGetMediaStateIndicated(prAdapter->prGlueInfo) != PARAM_MEDIA_STATE_CONNECTED) {
1574             aisFsmScanRequest(prAdapter, prSsid, NULL, 0);
1575         }
1576     }
1577
1578     return WLAN_STATUS_SUCCESS;
1579 } /* wlanoidSetBssidListScan */
1580
1581
1582 /*----------------------------------------------------------------------------*/
1583 /*!
1584 * \brief This routine is called to request the driver to perform
1585 *        scanning with attaching information elements(IEs) specified from user space
1586 *
1587 * \param[in] prAdapter Pointer to the Adapter structure.
1588 * \param[in] pvSetBuffer Pointer to the buffer that holds the data to be set.
1589 * \param[in] u4SetBufferLen The length of the set buffer.
1590 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1591 *                          bytes read from the set buffer. If the call failed
1592 *                          due to invalid length of the set buffer, returns
1593 *                          the amount of storage needed.
1594 *
1595 * \retval WLAN_STATUS_SUCCESS
1596 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1597 * \retval WLAN_STATUS_FAILURE
1598 */
1599 /*----------------------------------------------------------------------------*/
1600 WLAN_STATUS
1601 wlanoidSetBssidListScanExt (
1602     IN  P_ADAPTER_T       prAdapter,
1603     IN  PVOID             pvSetBuffer,
1604     IN  UINT_32           u4SetBufferLen,
1605     OUT PUINT_32          pu4SetInfoLen
1606     )
1607 {
1608     P_PARAM_SCAN_REQUEST_EXT_T prScanRequest;
1609     P_PARAM_SSID_T prSsid;
1610     PUINT_8 pucIe;
1611     UINT_32 u4IeLength;
1612
1613     DEBUGFUNC("wlanoidSetBssidListScanExt()");
1614
1615     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
1616         DBGLOG(REQ, WARN, ("Fail in set BSSID list scan! (Adapter not ready). ACPI=D%d, Radio=%d\n",
1617                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
1618         return WLAN_STATUS_ADAPTER_NOT_READY;
1619     }
1620
1621     ASSERT(pu4SetInfoLen);
1622     *pu4SetInfoLen = 0;
1623
1624     if(u4SetBufferLen != sizeof(PARAM_SCAN_REQUEST_EXT_T)) {
1625         return WLAN_STATUS_INVALID_LENGTH;
1626     }
1627
1628     if (prAdapter->fgIsRadioOff) {
1629         DBGLOG(REQ, WARN, ("Return from BSSID list scan! (radio off). ACPI=D%d, Radio=%d\n",
1630                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
1631         return WLAN_STATUS_SUCCESS;
1632     }
1633
1634     if(pvSetBuffer != NULL && u4SetBufferLen != 0) {
1635         prScanRequest = (P_PARAM_SCAN_REQUEST_EXT_T)pvSetBuffer;
1636         prSsid = &(prScanRequest->rSsid);
1637         pucIe = prScanRequest->pucIE;
1638         u4IeLength = prScanRequest->u4IELength;
1639     }
1640     else {
1641         prScanRequest = NULL;
1642         prSsid = NULL;
1643         pucIe = NULL;
1644         u4IeLength = 0;
1645     }
1646
1647 #if CFG_SUPPORT_RDD_TEST_MODE
1648     if (prAdapter->prGlueInfo->rRegInfo.u4RddTestMode) {
1649         if((prAdapter->fgEnOnlineScan == TRUE) && (prAdapter->ucRddStatus)){
1650             if (kalGetMediaStateIndicated(prAdapter->prGlueInfo) != PARAM_MEDIA_STATE_CONNECTED){
1651                 aisFsmScanRequest(prAdapter, prSsid, pucIe, u4IeLength);
1652             }
1653         }
1654     }
1655     else
1656 #endif
1657     {
1658         if(prAdapter->fgEnOnlineScan == TRUE) {
1659             aisFsmScanRequest(prAdapter, prSsid, pucIe, u4IeLength);
1660         }
1661         else if(kalGetMediaStateIndicated(prAdapter->prGlueInfo) != PARAM_MEDIA_STATE_CONNECTED) {
1662             aisFsmScanRequest(prAdapter, prSsid, pucIe, u4IeLength);
1663         }
1664     }
1665
1666     return WLAN_STATUS_SUCCESS;
1667 } /* wlanoidSetBssidListScanWithIE */
1668
1669
1670
1671 /*----------------------------------------------------------------------------*/
1672 /*!
1673 * \brief This routine will initiate the join procedure to attempt to associate
1674 *        with the specified BSSID.
1675 *
1676 * \param[in] pvAdapter Pointer to the Adapter structure.
1677 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
1678 * \param[in] u4SetBufferLen The length of the set buffer.
1679 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1680 *                          bytes read from the set buffer. If the call failed
1681 *                          due to invalid length of the set buffer, returns
1682 *                          the amount of storage needed.
1683 *
1684 * \retval WLAN_STATUS_SUCCESS
1685 * \retval WLAN_STATUS_INVALID_LENGTH
1686 * \retval WLAN_STATUS_INVALID_DATA
1687 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1688 */
1689 /*----------------------------------------------------------------------------*/
1690 WLAN_STATUS
1691 wlanoidSetBssid (
1692     IN  P_ADAPTER_T       prAdapter,
1693     IN  PVOID             pvSetBuffer,
1694     IN  UINT_32           u4SetBufferLen,
1695     OUT PUINT_32          pu4SetInfoLen
1696     )
1697 {
1698     P_GLUE_INFO_T prGlueInfo;
1699     P_UINT_8 pAddr;
1700     UINT_32 i;
1701     INT_32 i4Idx = -1;
1702     P_MSG_AIS_ABORT_T prAisAbortMsg;
1703
1704     ASSERT(prAdapter);
1705     ASSERT(pu4SetInfoLen);
1706
1707     *pu4SetInfoLen = MAC_ADDR_LEN;;
1708     if (u4SetBufferLen != MAC_ADDR_LEN){
1709     *pu4SetInfoLen = MAC_ADDR_LEN;
1710     return WLAN_STATUS_INVALID_LENGTH;
1711     }
1712     else if (prAdapter->rAcpiState == ACPI_STATE_D3) {
1713         DBGLOG(REQ, WARN, ("Fail in set ssid! (Adapter not ready). ACPI=D%d, Radio=%d\n",
1714                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
1715         return WLAN_STATUS_ADAPTER_NOT_READY;
1716     }
1717
1718     prGlueInfo = prAdapter->prGlueInfo;
1719     pAddr = (P_UINT_8)pvSetBuffer;
1720
1721     // re-association check
1722     if(kalGetMediaStateIndicated(prGlueInfo) == PARAM_MEDIA_STATE_CONNECTED) {
1723         if(EQUAL_MAC_ADDR(prAdapter->rWlanInfo.rCurrBssId.arMacAddress, pAddr)) {
1724             kalSetMediaStateIndicated(prGlueInfo, PARAM_MEDIA_STATE_TO_BE_INDICATED);
1725         }
1726         else {
1727             kalIndicateStatusAndComplete(prGlueInfo,
1728                     WLAN_STATUS_MEDIA_DISCONNECT,
1729                     NULL,
1730                     0);
1731         }
1732     }
1733
1734     // check if any scanned result matchs with the BSSID
1735     for(i = 0 ; i < prAdapter->rWlanInfo.u4ScanResultNum ; i++) {
1736         if(EQUAL_MAC_ADDR(prAdapter->rWlanInfo.arScanResult[i].arMacAddress, pAddr)) {
1737             i4Idx = (INT_32)i;
1738             break;
1739         }
1740     }
1741
1742     /* prepare message to AIS */
1743     if (prAdapter->rWifiVar.rConnSettings.eOPMode == NET_TYPE_IBSS
1744             || prAdapter->rWifiVar.rConnSettings.eOPMode == NET_TYPE_DEDICATED_IBSS) {
1745         /* IBSS */ /* beacon period */
1746         prAdapter->rWifiVar.rConnSettings.u2BeaconPeriod    = prAdapter->rWlanInfo.u2BeaconPeriod;
1747         prAdapter->rWifiVar.rConnSettings.u2AtimWindow      = prAdapter->rWlanInfo.u2AtimWindow;
1748     }
1749
1750     /* Set Connection Request Issued Flag */
1751     prAdapter->rWifiVar.rConnSettings.fgIsConnReqIssued = TRUE;
1752     prAdapter->rWifiVar.rConnSettings.eConnectionPolicy = CONNECT_BY_BSSID;
1753
1754     /* Send AIS Abort Message */
1755     prAisAbortMsg = (P_MSG_AIS_ABORT_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_AIS_ABORT_T));
1756     if (!prAisAbortMsg) {
1757         ASSERT(0);
1758         return WLAN_STATUS_FAILURE;
1759     }
1760
1761     prAisAbortMsg->rMsgHdr.eMsgId = MID_OID_AIS_FSM_JOIN_REQ;
1762     prAisAbortMsg->ucReasonOfDisconnect = DISCONNECT_REASON_CODE_NEW_CONNECTION;
1763
1764     if (EQUAL_MAC_ADDR(prAdapter->rWifiVar.rConnSettings.aucBSSID, pAddr)) {
1765         prAisAbortMsg->fgDelayIndication = TRUE;
1766     }
1767     else {
1768         /* Update the information to CONNECTION_SETTINGS_T */
1769         prAdapter->rWifiVar.rConnSettings.ucSSIDLen = 0;
1770         prAdapter->rWifiVar.rConnSettings.aucSSID[0] = '\0';
1771
1772         COPY_MAC_ADDR(prAdapter->rWifiVar.rConnSettings.aucBSSID, pAddr);
1773         prAisAbortMsg->fgDelayIndication = FALSE;
1774     }
1775
1776     mboxSendMsg(prAdapter,
1777             MBOX_ID_0,
1778             (P_MSG_HDR_T) prAisAbortMsg,
1779             MSG_SEND_METHOD_BUF);
1780
1781     return WLAN_STATUS_SUCCESS;
1782 } /* end of wlanoidSetBssid() */
1783
1784
1785 /*----------------------------------------------------------------------------*/
1786 /*!
1787 * \brief This routine will initiate the join procedure to attempt
1788 *        to associate with the new SSID. If the previous scanning
1789 *        result is aged, we will scan the channels at first.
1790 *
1791 * \param[in] prAdapter Pointer to the Adapter structure.
1792 * \param[in] pvSetBuffer Pointer to the buffer that holds the data to be set.
1793 * \param[in] u4SetBufferLen The length of the set buffer.
1794 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
1795 *                           bytes read from the set buffer. If the call failed
1796 *                           due to invalid length of the set buffer, returns
1797 *                           the amount of storage needed.
1798 *
1799 * \retval WLAN_STATUS_SUCCESS
1800 * \retval WLAN_STATUS_INVALID_DATA
1801 * \retval WLAN_STATUS_ADAPTER_NOT_READY
1802 * \retval WLAN_STATUS_INVALID_LENGTH
1803 */
1804 /*----------------------------------------------------------------------------*/
1805 WLAN_STATUS
1806 wlanoidSetSsid (
1807     IN  P_ADAPTER_T       prAdapter,
1808     IN  PVOID             pvSetBuffer,
1809     IN  UINT_32           u4SetBufferLen,
1810     OUT PUINT_32          pu4SetInfoLen
1811     )
1812 {
1813     P_GLUE_INFO_T prGlueInfo;
1814     P_PARAM_SSID_T pParamSsid;
1815     UINT_32 i;
1816     INT_32 i4Idx = -1, i4MaxRSSI = INT_MIN;
1817     P_MSG_AIS_ABORT_T prAisAbortMsg;
1818     BOOLEAN fgIsValidSsid = TRUE;
1819
1820     ASSERT(prAdapter);
1821     ASSERT(pu4SetInfoLen);
1822
1823     /* MSDN:
1824      * Powering on the radio if the radio is powered off through a setting of OID_802_11_DISASSOCIATE
1825      */
1826     if(prAdapter->fgIsRadioOff == TRUE) {
1827         prAdapter->fgIsRadioOff = FALSE;
1828     }
1829
1830     if(u4SetBufferLen < sizeof(PARAM_SSID_T) || u4SetBufferLen > sizeof(PARAM_SSID_T)) {
1831         return WLAN_STATUS_INVALID_LENGTH;
1832     }
1833     else if (prAdapter->rAcpiState == ACPI_STATE_D3) {
1834         DBGLOG(REQ, WARN, ("Fail in set ssid! (Adapter not ready). ACPI=D%d, Radio=%d\n",
1835                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
1836         return WLAN_STATUS_ADAPTER_NOT_READY;
1837     }
1838
1839     pParamSsid = (P_PARAM_SSID_T) pvSetBuffer;
1840
1841     if (pParamSsid->u4SsidLen > 32) {
1842         return WLAN_STATUS_INVALID_LENGTH;
1843     }
1844
1845     prGlueInfo = prAdapter->prGlueInfo;
1846
1847     // prepare for CMD_BUILD_CONNECTION & CMD_GET_CONNECTION_STATUS
1848     // re-association check
1849     if(kalGetMediaStateIndicated(prGlueInfo) == PARAM_MEDIA_STATE_CONNECTED) {
1850         if(EQUAL_SSID(prAdapter->rWlanInfo.rCurrBssId.rSsid.aucSsid,
1851                     prAdapter->rWlanInfo.rCurrBssId.rSsid.u4SsidLen,
1852                     pParamSsid->aucSsid,
1853                     pParamSsid->u4SsidLen)) {
1854             kalSetMediaStateIndicated(prGlueInfo, PARAM_MEDIA_STATE_TO_BE_INDICATED);
1855         }
1856         else {
1857             kalIndicateStatusAndComplete(prGlueInfo,
1858                     WLAN_STATUS_MEDIA_DISCONNECT,
1859                     NULL,
1860                     0);
1861         }
1862     }
1863
1864     // check if any scanned result matchs with the SSID
1865     for(i = 0 ; i < prAdapter->rWlanInfo.u4ScanResultNum ; i++) {
1866         PUINT_8 aucSsid = prAdapter->rWlanInfo.arScanResult[i].rSsid.aucSsid;
1867         UINT_8 ucSsidLength = (UINT_8) prAdapter->rWlanInfo.arScanResult[i].rSsid.u4SsidLen;
1868         INT_32 i4RSSI = prAdapter->rWlanInfo.arScanResult[i].rRssi;
1869
1870         if(EQUAL_SSID(aucSsid, ucSsidLength, pParamSsid->aucSsid, pParamSsid->u4SsidLen) &&
1871                 i4RSSI >= i4MaxRSSI) {
1872             i4Idx = (INT_32)i;
1873             i4MaxRSSI = i4RSSI;
1874         }
1875     }
1876
1877     /* prepare message to AIS */
1878     if (prAdapter->rWifiVar.rConnSettings.eOPMode == NET_TYPE_IBSS
1879             || prAdapter->rWifiVar.rConnSettings.eOPMode == NET_TYPE_DEDICATED_IBSS) {
1880         /* IBSS */ /* beacon period */
1881         prAdapter->rWifiVar.rConnSettings.u2BeaconPeriod    = prAdapter->rWlanInfo.u2BeaconPeriod;
1882         prAdapter->rWifiVar.rConnSettings.u2AtimWindow      = prAdapter->rWlanInfo.u2AtimWindow;
1883     }
1884
1885     if (prAdapter->rWifiVar.fgSupportWZCDisassociation) {
1886         if (pParamSsid->u4SsidLen == ELEM_MAX_LEN_SSID) {
1887             fgIsValidSsid = FALSE;
1888
1889             for (i = 0; i < ELEM_MAX_LEN_SSID; i++) {
1890                 if ( !((0 < pParamSsid->aucSsid[i]) && (pParamSsid->aucSsid[i] <= 0x1F)) ) {
1891                     fgIsValidSsid = TRUE;
1892                     break;
1893                 }
1894             }
1895         }
1896     }
1897
1898     /* Set Connection Request Issued Flag */
1899     if (fgIsValidSsid) {
1900         prAdapter->rWifiVar.rConnSettings.fgIsConnReqIssued = TRUE;
1901
1902         if(pParamSsid->u4SsidLen) {
1903             prAdapter->rWifiVar.rConnSettings.eConnectionPolicy = CONNECT_BY_SSID_BEST_RSSI;
1904         }
1905         else {
1906             // wildcard SSID
1907             prAdapter->rWifiVar.rConnSettings.eConnectionPolicy = CONNECT_BY_SSID_ANY;
1908         }
1909     }
1910     else {
1911         prAdapter->rWifiVar.rConnSettings.fgIsConnReqIssued = FALSE;
1912     }
1913
1914     /* Send AIS Abort Message */
1915     prAisAbortMsg = (P_MSG_AIS_ABORT_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_AIS_ABORT_T));
1916     if (!prAisAbortMsg) {
1917         ASSERT(0);
1918         return WLAN_STATUS_FAILURE;
1919     }
1920
1921     prAisAbortMsg->rMsgHdr.eMsgId = MID_OID_AIS_FSM_JOIN_REQ;
1922     prAisAbortMsg->ucReasonOfDisconnect = DISCONNECT_REASON_CODE_NEW_CONNECTION;
1923
1924     if (EQUAL_SSID(prAdapter->rWifiVar.rConnSettings.aucSSID,
1925                 prAdapter->rWifiVar.rConnSettings.ucSSIDLen,
1926                 pParamSsid->aucSsid,
1927                 pParamSsid->u4SsidLen)) {
1928         prAisAbortMsg->fgDelayIndication = TRUE;
1929     }
1930     else {
1931         /* Update the information to CONNECTION_SETTINGS_T */
1932         COPY_SSID(prAdapter->rWifiVar.rConnSettings.aucSSID,
1933                 prAdapter->rWifiVar.rConnSettings.ucSSIDLen,
1934                 pParamSsid->aucSsid,
1935                 (UINT_8)pParamSsid->u4SsidLen);
1936
1937         prAisAbortMsg->fgDelayIndication = FALSE;
1938     }
1939     DBGLOG(SCN, INFO, ("SSID %s\n", prAdapter->rWifiVar.rConnSettings.aucSSID));
1940
1941     mboxSendMsg(prAdapter,
1942             MBOX_ID_0,
1943             (P_MSG_HDR_T) prAisAbortMsg,
1944             MSG_SEND_METHOD_BUF);
1945
1946     return WLAN_STATUS_SUCCESS;
1947
1948 } /* end of wlanoidSetSsid() */
1949
1950
1951 /*----------------------------------------------------------------------------*/
1952 /*!
1953 * \brief This routine is called to query the currently associated SSID.
1954 *
1955 * \param[in] prAdapter Pointer to the Adapter structure.
1956 * \param[in] pvQueryBuffer Pointer to the buffer that holds the result of
1957 *                           the query.
1958 * \param[in] u4QueryBufferLen The length of the query buffer.
1959 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
1960 *                             bytes written into the query buffer. If the call
1961 *                             failed due to invalid length of the query buffer,
1962 *                             returns the amount of storage needed.
1963 *
1964 * \retval WLAN_STATUS_SUCCESS
1965 * \retval WLAN_STATUS_INVALID_LENGTH
1966 */
1967 /*----------------------------------------------------------------------------*/
1968 WLAN_STATUS
1969 wlanoidQuerySsid (
1970     IN  P_ADAPTER_T       prAdapter,
1971     OUT PVOID             pvQueryBuffer,
1972     IN  UINT_32           u4QueryBufferLen,
1973     OUT PUINT_32          pu4QueryInfoLen
1974     )
1975 {
1976     P_PARAM_SSID_T prAssociatedSsid;
1977
1978     DEBUGFUNC("wlanoidQuerySsid");
1979
1980     ASSERT(prAdapter);
1981     ASSERT(pu4QueryInfoLen);
1982
1983     if (u4QueryBufferLen) {
1984         ASSERT(pvQueryBuffer);
1985     }
1986
1987     *pu4QueryInfoLen = sizeof(PARAM_SSID_T);
1988
1989     /* Check for query buffer length */
1990     if (u4QueryBufferLen < *pu4QueryInfoLen) {
1991         DBGLOG(REQ, WARN, ("Invalid length %lu\n", u4QueryBufferLen));
1992         return WLAN_STATUS_INVALID_LENGTH;
1993     }
1994
1995     prAssociatedSsid = (P_PARAM_SSID_T)pvQueryBuffer;
1996
1997     kalMemZero(prAssociatedSsid->aucSsid, sizeof(prAssociatedSsid->aucSsid));
1998
1999     if (kalGetMediaStateIndicated(prAdapter->prGlueInfo) == PARAM_MEDIA_STATE_CONNECTED) {
2000         prAssociatedSsid->u4SsidLen = prAdapter->rWlanInfo.rCurrBssId.rSsid.u4SsidLen;
2001
2002         if (prAssociatedSsid->u4SsidLen) {
2003             kalMemCopy(prAssociatedSsid->aucSsid,
2004                 prAdapter->rWlanInfo.rCurrBssId.rSsid.aucSsid,
2005                 prAssociatedSsid->u4SsidLen);
2006         }
2007     }
2008     else {
2009         prAssociatedSsid->u4SsidLen = 0;
2010
2011         DBGLOG(REQ, TRACE, ("Null SSID\n"));
2012     }
2013
2014     return WLAN_STATUS_SUCCESS;
2015 } /* wlanoidQuerySsid */
2016
2017
2018 /*----------------------------------------------------------------------------*/
2019 /*!
2020 * \brief This routine is called to query the current 802.11 network type.
2021 *
2022 * \param[in] prAdapter Pointer to the Adapter structure.
2023 * \param[in] pvQueryBuffer Pointer to the buffer that holds the result of
2024 *                           the query.
2025 * \param[in] u4QueryBufferLen The length of the query buffer.
2026 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
2027 *                             bytes written into the query buffer. If the call
2028 *                             failed due to invalid length of the query buffer,
2029 *                             returns the amount of storage needed.
2030 *
2031 * \retval WLAN_STATUS_SUCCESS
2032 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
2033 */
2034 /*----------------------------------------------------------------------------*/
2035 WLAN_STATUS
2036 wlanoidQueryInfrastructureMode (
2037     IN  P_ADAPTER_T       prAdapter,
2038     OUT PVOID             pvQueryBuffer,
2039     IN  UINT_32           u4QueryBufferLen,
2040     OUT PUINT_32          pu4QueryInfoLen
2041     )
2042 {
2043     DEBUGFUNC("wlanoidQueryInfrastructureMode");
2044
2045     ASSERT(prAdapter);
2046     ASSERT(pu4QueryInfoLen);
2047
2048     *pu4QueryInfoLen = sizeof(ENUM_PARAM_OP_MODE_T);
2049
2050     if (u4QueryBufferLen < sizeof(ENUM_PARAM_OP_MODE_T)) {
2051         return WLAN_STATUS_BUFFER_TOO_SHORT;
2052     }
2053
2054     if (u4QueryBufferLen) {
2055         ASSERT(pvQueryBuffer);
2056     }
2057
2058     *(P_ENUM_PARAM_OP_MODE_T)pvQueryBuffer = prAdapter->rWifiVar.rConnSettings.eOPMode;
2059
2060     /*
2061     ** According to OID_802_11_INFRASTRUCTURE_MODE
2062     ** If there is no prior OID_802_11_INFRASTRUCTURE_MODE,
2063     ** NDIS_STATUS_ADAPTER_NOT_READY shall be returned.
2064     */
2065 #if DBG
2066     switch (*(P_ENUM_PARAM_OP_MODE_T)pvQueryBuffer) {
2067         case NET_TYPE_IBSS:
2068              DBGLOG(REQ, INFO, ("IBSS mode\n"));
2069              break;
2070         case NET_TYPE_INFRA:
2071              DBGLOG(REQ, INFO, ("Infrastructure mode\n"));
2072              break;
2073         default:
2074              DBGLOG(REQ, INFO, ("Automatic mode\n"));
2075     }
2076 #endif
2077
2078     return WLAN_STATUS_SUCCESS;
2079 }   /* wlanoidQueryInfrastructureMode */
2080
2081
2082 /*----------------------------------------------------------------------------*/
2083 /*!
2084 * \brief This routine is called to set mode to infrastructure or
2085 *        IBSS, or automatic switch between the two.
2086 *
2087 * \param[in] prAdapter Pointer to the Adapter structure.
2088 * \param[in] pvSetBuffer Pointer to the buffer that holds the data to be set.
2089 * \param[in] u4SetBufferLen The length of the set buffer.
2090 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
2091 *             bytes read from the set buffer. If the call failed due to invalid
2092 *             length of the set buffer, returns the amount of storage needed.
2093 *
2094 * \retval WLAN_STATUS_SUCCESS
2095 * \retval WLAN_STATUS_INVALID_DATA
2096 * \retval WLAN_STATUS_ADAPTER_NOT_READY
2097 * \retval WLAN_STATUS_INVALID_LENGTH
2098 */
2099 /*----------------------------------------------------------------------------*/
2100 WLAN_STATUS
2101 wlanoidSetInfrastructureMode (
2102     IN  P_ADAPTER_T       prAdapter,
2103     IN  PVOID             pvSetBuffer,
2104     IN  UINT_32           u4SetBufferLen,
2105     OUT PUINT_32          pu4SetInfoLen
2106     )
2107 {
2108     P_GLUE_INFO_T prGlueInfo;
2109     ENUM_PARAM_OP_MODE_T eOpMode;
2110
2111     DEBUGFUNC("wlanoidSetInfrastructureMode");
2112
2113     ASSERT(prAdapter);
2114     ASSERT(pvSetBuffer);
2115     ASSERT(pu4SetInfoLen);
2116
2117     prGlueInfo = prAdapter->prGlueInfo;
2118
2119     if (u4SetBufferLen < sizeof(ENUM_PARAM_OP_MODE_T))
2120         return WLAN_STATUS_BUFFER_TOO_SHORT;
2121
2122     *pu4SetInfoLen = sizeof(ENUM_PARAM_OP_MODE_T);
2123
2124
2125     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
2126         DBGLOG(REQ, WARN, ("Fail in set infrastructure mode! (Adapter not ready). ACPI=D%d, Radio=%d\n",
2127                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
2128         return WLAN_STATUS_ADAPTER_NOT_READY;
2129     }
2130
2131     eOpMode = *(P_ENUM_PARAM_OP_MODE_T)pvSetBuffer;
2132     /* Verify the new infrastructure mode. */
2133     if (eOpMode >= NET_TYPE_NUM) {
2134         DBGLOG(REQ, TRACE, ("Invalid mode value %d\n", eOpMode));
2135         return WLAN_STATUS_INVALID_DATA;
2136     }
2137
2138     /* check if possible to switch to AdHoc mode */
2139     if(eOpMode == NET_TYPE_IBSS || eOpMode == NET_TYPE_DEDICATED_IBSS) {
2140         if(cnmAisIbssIsPermitted(prAdapter) == FALSE) {
2141             DBGLOG(REQ, TRACE, ("Mode value %d unallowed\n", eOpMode));
2142             return WLAN_STATUS_FAILURE;
2143         }
2144     }
2145
2146     /* Save the new infrastructure mode setting. */
2147     prAdapter->rWifiVar.rConnSettings.eOPMode = eOpMode;
2148
2149     /* Clean up the Tx key flag */
2150     prAdapter->rWifiVar.rAisSpecificBssInfo.fgTransmitKeyExist = FALSE;
2151
2152     prAdapter->rWifiVar.rConnSettings.fgWapiMode = FALSE;
2153 #if CFG_SUPPORT_WAPI
2154     prAdapter->prGlueInfo->u2WapiAssocInfoIESz = 0;
2155     kalMemZero(&prAdapter->prGlueInfo->aucWapiAssocInfoIEs, 42);
2156 #endif
2157
2158 #if CFG_SUPPORT_802_11W
2159     prAdapter->rWifiVar.rAisSpecificBssInfo.fgMgmtProtection = FALSE;
2160     prAdapter->rWifiVar.rAisSpecificBssInfo.fgBipKeyInstalled = FALSE;
2161 #endif
2162
2163 #if CFG_SUPPORT_WPS2
2164     kalMemZero(&prAdapter->prGlueInfo->aucWSCAssocInfoIE, 200);
2165     prAdapter->prGlueInfo->u2WSCAssocInfoIELen = 0;
2166 #endif
2167
2168     return wlanSendSetQueryCmd(prAdapter,
2169             CMD_ID_INFRASTRUCTURE,
2170             TRUE,
2171             FALSE,
2172             TRUE,
2173             nicCmdEventSetCommon,
2174             nicOidCmdTimeoutCommon,
2175             0,
2176             NULL,
2177             pvSetBuffer,
2178             u4SetBufferLen
2179             );
2180
2181 }   /* wlanoidSetInfrastructureMode */
2182
2183
2184 /*----------------------------------------------------------------------------*/
2185 /*!
2186 * \brief This routine is called to query the current 802.11 authentication
2187 *        mode.
2188 *
2189 * \param[in] prAdapter Pointer to the Adapter structure.
2190 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
2191 *                           the query.
2192 * \param[in] u4QueryBufferLen The length of the query buffer.
2193 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
2194 *                            bytes written into the query buffer. If the call
2195 *                            failed due to invalid length of the query buffer,
2196 *                            returns the amount of storage needed.
2197 *
2198 * \retval WLAN_STATUS_SUCCESS
2199 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
2200 */
2201 /*----------------------------------------------------------------------------*/
2202 WLAN_STATUS
2203 wlanoidQueryAuthMode (
2204     IN  P_ADAPTER_T       prAdapter,
2205     OUT PVOID             pvQueryBuffer,
2206     IN  UINT_32           u4QueryBufferLen,
2207     OUT PUINT_32          pu4QueryInfoLen
2208     )
2209 {
2210     DEBUGFUNC("wlanoidQueryAuthMode");
2211
2212     ASSERT(prAdapter);
2213     if (u4QueryBufferLen) {
2214         ASSERT(pvQueryBuffer);
2215     }
2216     ASSERT(pu4QueryInfoLen);
2217
2218     *pu4QueryInfoLen = sizeof(ENUM_PARAM_AUTH_MODE_T);
2219
2220     if (u4QueryBufferLen < sizeof(ENUM_PARAM_AUTH_MODE_T)) {
2221         return WLAN_STATUS_BUFFER_TOO_SHORT;
2222     }
2223
2224     *(P_ENUM_PARAM_AUTH_MODE_T)pvQueryBuffer = prAdapter->rWifiVar.rConnSettings.eAuthMode;
2225
2226 #if DBG
2227     switch (*(P_ENUM_PARAM_AUTH_MODE_T)pvQueryBuffer) {
2228     case AUTH_MODE_OPEN:
2229         DBGLOG(REQ, INFO, ("Current auth mode: Open\n"));
2230         break;
2231
2232     case AUTH_MODE_SHARED:
2233         DBGLOG(REQ, INFO, ("Current auth mode: Shared\n"));
2234         break;
2235
2236     case AUTH_MODE_AUTO_SWITCH:
2237         DBGLOG(REQ, INFO, ("Current auth mode: Auto-switch\n"));
2238         break;
2239
2240     case AUTH_MODE_WPA:
2241         DBGLOG(REQ, INFO, ("Current auth mode: WPA\n"));
2242         break;
2243
2244     case AUTH_MODE_WPA_PSK:
2245         DBGLOG(REQ, INFO, ("Current auth mode: WPA PSK\n"));
2246         break;
2247
2248     case AUTH_MODE_WPA_NONE:
2249         DBGLOG(REQ, INFO, ("Current auth mode: WPA None\n"));
2250         break;
2251
2252     case AUTH_MODE_WPA2:
2253         DBGLOG(REQ, INFO, ("Current auth mode: WPA2\n"));
2254         break;
2255
2256     case AUTH_MODE_WPA2_PSK:
2257         DBGLOG(REQ, INFO, ("Current auth mode: WPA2 PSK\n"));
2258         break;
2259
2260     default:
2261         DBGLOG(REQ, INFO, ("Current auth mode: %d\n",
2262             *(P_ENUM_PARAM_AUTH_MODE_T)pvQueryBuffer));
2263     }
2264 #endif
2265     return WLAN_STATUS_SUCCESS;
2266 } /* wlanoidQueryAuthMode */
2267
2268
2269 /*----------------------------------------------------------------------------*/
2270 /*!
2271 * \brief This routine is called to set the IEEE 802.11 authentication mode
2272 *        to the driver.
2273 *
2274 * \param[in] prAdapter Pointer to the Adapter structure.
2275 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
2276 * \param[in] u4SetBufferLen The length of the set buffer.
2277 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
2278 *                          bytes read from the set buffer. If the call failed
2279 *                          due to invalid length of the set buffer, returns
2280 *                          the amount of storage needed.
2281 *
2282 * \retval WLAN_STATUS_SUCCESS
2283 * \retval WLAN_STATUS_INVALID_DATA
2284 * \retval WLAN_STATUS_INVALID_LENGTH
2285 * \retval WLAN_STATUS_ADAPTER_NOT_READY
2286 * \retval WLAN_STATUS_NOT_ACCEPTED
2287 */
2288 /*----------------------------------------------------------------------------*/
2289 WLAN_STATUS
2290 wlanoidSetAuthMode (
2291     IN  P_ADAPTER_T       prAdapter,
2292     IN  PVOID             pvSetBuffer,
2293     IN  UINT_32           u4SetBufferLen,
2294     OUT PUINT_32          pu4SetInfoLen
2295     )
2296 {
2297     P_GLUE_INFO_T prGlueInfo;
2298     UINT_32       i, u4AkmSuite;
2299     P_DOT11_RSNA_CONFIG_AUTHENTICATION_SUITES_ENTRY prEntry;
2300
2301     DEBUGFUNC("wlanoidSetAuthMode");
2302
2303     ASSERT(prAdapter);
2304     ASSERT(pu4SetInfoLen);
2305     ASSERT(pvSetBuffer);
2306
2307     prGlueInfo = prAdapter->prGlueInfo;
2308
2309     *pu4SetInfoLen = sizeof(ENUM_PARAM_AUTH_MODE_T);
2310
2311     if (u4SetBufferLen < sizeof(ENUM_PARAM_AUTH_MODE_T)) {
2312         return WLAN_STATUS_INVALID_LENGTH;
2313     }
2314
2315     /* RF Test */
2316     //if (IS_ARB_IN_RFTEST_STATE(prAdapter)) {
2317     //  return WLAN_STATUS_SUCCESS;
2318     //}
2319
2320     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
2321         DBGLOG(REQ, WARN, ("Fail in set Authentication mode! (Adapter not ready). ACPI=D%d, Radio=%d\n",
2322                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
2323         return WLAN_STATUS_ADAPTER_NOT_READY;
2324     }
2325
2326     /* Check if the new authentication mode is valid. */
2327     if (*(P_ENUM_PARAM_AUTH_MODE_T)pvSetBuffer >= AUTH_MODE_NUM) {
2328         DBGLOG(REQ, TRACE, ("Invalid auth mode %d\n",
2329             *(P_ENUM_PARAM_AUTH_MODE_T)pvSetBuffer));
2330         return WLAN_STATUS_INVALID_DATA;
2331     }
2332
2333     switch (*(P_ENUM_PARAM_AUTH_MODE_T)pvSetBuffer) {
2334     case AUTH_MODE_WPA:
2335     case AUTH_MODE_WPA_PSK:
2336     case AUTH_MODE_WPA2:
2337     case AUTH_MODE_WPA2_PSK:
2338         /* infrastructure mode only */
2339         if (prAdapter->rWifiVar.rConnSettings.eOPMode != NET_TYPE_INFRA) {
2340             return WLAN_STATUS_NOT_ACCEPTED;
2341         }
2342         break;
2343
2344     case AUTH_MODE_WPA_NONE:
2345         /* ad hoc mode only */
2346         if (prAdapter->rWifiVar.rConnSettings.eOPMode != NET_TYPE_IBSS) {
2347             return WLAN_STATUS_NOT_ACCEPTED;
2348         }
2349         break;
2350
2351     default:
2352         ;
2353     }
2354
2355     /* Save the new authentication mode. */
2356     prAdapter->rWifiVar.rConnSettings.eAuthMode = *(P_ENUM_PARAM_AUTH_MODE_T)pvSetBuffer;
2357
2358 #if DBG
2359     switch (prAdapter->rWifiVar.rConnSettings.eAuthMode) {
2360     case AUTH_MODE_OPEN:
2361         DBGLOG(RSN, TRACE, ("New auth mode: open\n"));
2362         break;
2363
2364     case AUTH_MODE_SHARED:
2365         DBGLOG(RSN, TRACE, ("New auth mode: shared\n"));
2366         break;
2367
2368     case AUTH_MODE_AUTO_SWITCH:
2369         DBGLOG(RSN, TRACE, ("New auth mode: auto-switch\n"));
2370         break;
2371
2372     case AUTH_MODE_WPA:
2373         DBGLOG(RSN, TRACE, ("New auth mode: WPA\n"));
2374         break;
2375
2376     case AUTH_MODE_WPA_PSK:
2377         DBGLOG(RSN, TRACE, ("New auth mode: WPA PSK\n"));
2378         break;
2379
2380     case AUTH_MODE_WPA_NONE:
2381         DBGLOG(RSN, TRACE, ("New auth mode: WPA None\n"));
2382         break;
2383
2384     case AUTH_MODE_WPA2:
2385         DBGLOG(RSN, TRACE, ("New auth mode: WPA2\n"));
2386         break;
2387
2388     case AUTH_MODE_WPA2_PSK:
2389         DBGLOG(RSN, TRACE, ("New auth mode: WPA2 PSK\n"));
2390         break;
2391
2392     default:
2393         DBGLOG(RSN, TRACE, ("New auth mode: unknown (%d)\n",
2394             prAdapter->rWifiVar.rConnSettings.eAuthMode));
2395     }
2396 #endif
2397
2398     if (prAdapter->rWifiVar.rConnSettings.eAuthMode >= AUTH_MODE_WPA) {
2399         switch(prAdapter->rWifiVar.rConnSettings.eAuthMode) {
2400         case AUTH_MODE_WPA:
2401             u4AkmSuite = WPA_AKM_SUITE_802_1X;
2402             break;
2403
2404         case AUTH_MODE_WPA_PSK:
2405             u4AkmSuite = WPA_AKM_SUITE_PSK;
2406             break;
2407
2408         case AUTH_MODE_WPA_NONE:
2409             u4AkmSuite = WPA_AKM_SUITE_NONE;
2410             break;
2411
2412         case AUTH_MODE_WPA2:
2413             u4AkmSuite = RSN_AKM_SUITE_802_1X;
2414             break;
2415
2416         case AUTH_MODE_WPA2_PSK:
2417             u4AkmSuite = RSN_AKM_SUITE_PSK;
2418             break;
2419
2420         default:
2421             u4AkmSuite = 0;
2422         }
2423     }
2424     else {
2425         u4AkmSuite = 0;
2426     }
2427
2428     /* Enable the specific AKM suite only. */
2429     for (i = 0; i < MAX_NUM_SUPPORTED_AKM_SUITES; i++) {
2430         prEntry = &prAdapter->rMib.dot11RSNAConfigAuthenticationSuitesTable[i];
2431
2432         if (prEntry->dot11RSNAConfigAuthenticationSuite == u4AkmSuite) {
2433             prEntry->dot11RSNAConfigAuthenticationSuiteEnabled = TRUE;
2434         }
2435         else {
2436             prEntry->dot11RSNAConfigAuthenticationSuiteEnabled = FALSE;
2437         }
2438 #if CFG_SUPPORT_802_11W
2439         if (kalGetMfpSetting(prAdapter->prGlueInfo) != RSN_AUTH_MFP_DISABLED) {
2440             if ((u4AkmSuite == RSN_AKM_SUITE_PSK) &&
2441                 prEntry->dot11RSNAConfigAuthenticationSuite == RSN_AKM_SUITE_PSK_SHA256) {
2442                 DBGLOG(RSN, TRACE, ("Enable RSN_AKM_SUITE_PSK_SHA256 AKM support\n"));
2443                 prEntry->dot11RSNAConfigAuthenticationSuiteEnabled = TRUE;
2444
2445             }
2446             if ((u4AkmSuite == RSN_AKM_SUITE_802_1X) &&
2447                 prEntry->dot11RSNAConfigAuthenticationSuite == RSN_AKM_SUITE_802_1X_SHA256) {
2448                 DBGLOG(RSN, TRACE, ("Enable RSN_AKM_SUITE_802_1X_SHA256 AKM support\n"));
2449                 prEntry->dot11RSNAConfigAuthenticationSuiteEnabled = TRUE;
2450             }
2451         }
2452 #endif
2453     }
2454
2455
2456     return WLAN_STATUS_SUCCESS;
2457
2458 } /* wlanoidSetAuthMode */
2459
2460
2461 #if 0
2462 /*----------------------------------------------------------------------------*/
2463 /*!
2464 * \brief This routine is called to query the current 802.11 privacy filter
2465 *
2466 * \param[in] prAdapter Pointer to the Adapter structure.
2467 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
2468 *                           the query.
2469 * \param[in] u4QueryBufferLen The length of the query buffer.
2470 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
2471 *                            bytes written into the query buffer. If the call
2472 *                            failed due to invalid length of the query buffer,
2473 *                            returns the amount of storage needed.
2474 *
2475 * \retval WLAN_STATUS_SUCCESS
2476 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
2477 */
2478 /*----------------------------------------------------------------------------*/
2479 WLAN_STATUS
2480 wlanoidQueryPrivacyFilter (
2481     IN  P_ADAPTER_T       prAdapter,
2482     OUT PVOID             pvQueryBuffer,
2483     IN  UINT_32           u4QueryBufferLen,
2484     OUT PUINT_32          pu4QueryInfoLen
2485     )
2486 {
2487     DEBUGFUNC("wlanoidQueryPrivacyFilter");
2488
2489     ASSERT(prAdapter);
2490
2491     ASSERT(pvQueryBuffer);
2492     ASSERT(pu4QueryInfoLen);
2493
2494     *pu4QueryInfoLen = sizeof(ENUM_PARAM_PRIVACY_FILTER_T);
2495
2496     if (u4QueryBufferLen < sizeof(ENUM_PARAM_PRIVACY_FILTER_T)) {
2497         return WLAN_STATUS_BUFFER_TOO_SHORT;
2498     }
2499
2500     *(P_ENUM_PARAM_PRIVACY_FILTER_T)pvQueryBuffer = prAdapter->rWlanInfo.ePrivacyFilter;
2501
2502 #if DBG
2503     switch (*(P_ENUM_PARAM_PRIVACY_FILTER_T)pvQueryBuffer) {
2504     case PRIVACY_FILTER_ACCEPT_ALL:
2505         DBGLOG(REQ, INFO, ("Current privacy mode: open mode\n"));
2506         break;
2507
2508     case PRIVACY_FILTER_8021xWEP:
2509         DBGLOG(REQ, INFO, ("Current privacy mode: filtering mode\n"));
2510         break;
2511
2512     default:
2513         DBGLOG(REQ, INFO, ("Current auth mode: %d\n",
2514             *(P_ENUM_PARAM_AUTH_MODE_T)pvQueryBuffer));
2515     }
2516 #endif
2517     return WLAN_STATUS_SUCCESS;
2518 } /* wlanoidQueryPrivacyFilter */
2519
2520
2521 /*----------------------------------------------------------------------------*/
2522 /*!
2523 * \brief This routine is called to set the IEEE 802.11 privacy filter
2524 *        to the driver.
2525 *
2526 * \param[in] prAdapter Pointer to the Adapter structure.
2527 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
2528 * \param[in] u4SetBufferLen The length of the set buffer.
2529 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
2530 *                          bytes read from the set buffer. If the call failed
2531 *                          due to invalid length of the set buffer, returns
2532 *                          the amount of storage needed.
2533 *
2534 * \retval WLAN_STATUS_SUCCESS
2535 * \retval WLAN_STATUS_INVALID_DATA
2536 * \retval WLAN_STATUS_INVALID_LENGTH
2537 * \retval WLAN_STATUS_ADAPTER_NOT_READY
2538 * \retval WLAN_STATUS_NOT_ACCEPTED
2539 */
2540 /*----------------------------------------------------------------------------*/
2541 WLAN_STATUS
2542 wlanoidSetPrivacyFilter (
2543     IN  P_ADAPTER_T       prAdapter,
2544     IN  PVOID             pvSetBuffer,
2545     IN  UINT_32           u4SetBufferLen,
2546     OUT PUINT_32          pu4SetInfoLen
2547     )
2548 {
2549     P_GLUE_INFO_T prGlueInfo;
2550
2551     DEBUGFUNC("wlanoidSetPrivacyFilter");
2552
2553     ASSERT(prAdapter);
2554     ASSERT(pu4SetInfoLen);
2555     ASSERT(pvSetBuffer);
2556
2557     prGlueInfo = prAdapter->prGlueInfo;
2558
2559     *pu4SetInfoLen = sizeof(ENUM_PARAM_PRIVACY_FILTER_T);
2560
2561     if (u4SetBufferLen < sizeof(ENUM_PARAM_PRIVACY_FILTER_T)) {
2562         return WLAN_STATUS_INVALID_LENGTH;
2563     }
2564
2565     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
2566         DBGLOG(REQ, WARN, ("Fail in set Authentication mode! (Adapter not ready). ACPI=D%d, Radio=%d\n",
2567                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
2568         return WLAN_STATUS_ADAPTER_NOT_READY;
2569     }
2570
2571     /* Check if the new authentication mode is valid. */
2572     if (*(P_ENUM_PARAM_PRIVACY_FILTER_T)pvSetBuffer >= PRIVACY_FILTER_NUM) {
2573         DBGLOG(REQ, TRACE, ("Invalid privacy filter %d\n",
2574             *(P_ENUM_PARAM_PRIVACY_FILTER_T)pvSetBuffer));
2575         return WLAN_STATUS_INVALID_DATA;
2576     }
2577
2578     switch (*(P_ENUM_PARAM_PRIVACY_FILTER_T)pvSetBuffer) {
2579     default:
2580         break;
2581     }
2582
2583     /* Save the new authentication mode. */
2584     prAdapter->rWlanInfo.ePrivacyFilter = *(ENUM_PARAM_PRIVACY_FILTER_T)pvSetBuffer;
2585
2586     return WLAN_STATUS_SUCCESS;
2587
2588 } /* wlanoidSetPrivacyFilter */
2589 #endif
2590
2591
2592 /*----------------------------------------------------------------------------*/
2593 /*!
2594 * \brief This routine is called to reload the available default settings for
2595 *        the specified type field.
2596 *
2597 * \param[in] prAdapter Pointer to the Adapter structure.
2598 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
2599 * \param[in] u4SetBufferLen The length of the set buffer.
2600 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
2601 *                          bytes read from the set buffer. If the call failed
2602 *                          due to invalid length of the set buffer, returns
2603 *                          the amount of storage needed.
2604 *
2605 * \retval WLAN_STATUS_SUCCESS
2606 * \retval WLAN_STATUS_ADAPTER_NOT_READY
2607 * \retval WLAN_STATUS_INVALID_DATA
2608 */
2609 /*----------------------------------------------------------------------------*/
2610 WLAN_STATUS
2611 wlanoidSetReloadDefaults (
2612     IN  P_ADAPTER_T       prAdapter,
2613     IN  PVOID             pvSetBuffer,
2614     IN  UINT_32           u4SetBufferLen,
2615     OUT PUINT_32          pu4SetInfoLen
2616     )
2617 {
2618     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
2619     ENUM_PARAM_NETWORK_TYPE_T eNetworkType;
2620     UINT_32 u4Len;
2621     UINT_8 ucCmdSeqNum;
2622
2623
2624     DEBUGFUNC("wlanoidSetReloadDefaults");
2625
2626     ASSERT(prAdapter);
2627
2628     ASSERT(pu4SetInfoLen);
2629     *pu4SetInfoLen = sizeof(PARAM_RELOAD_DEFAULTS);
2630
2631     //if (IS_ARB_IN_RFTEST_STATE(prAdapter)) {
2632     //  return WLAN_STATUS_SUCCESS;
2633     //}
2634
2635     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
2636         DBGLOG(REQ, WARN, ("Fail in set Reload default! (Adapter not ready). ACPI=D%d, Radio=%d\n",
2637                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
2638         return WLAN_STATUS_ADAPTER_NOT_READY;
2639     }
2640
2641     ASSERT(pvSetBuffer);
2642     /* Verify the available reload options and reload the settings. */
2643     switch (*(P_PARAM_RELOAD_DEFAULTS)pvSetBuffer) {
2644     case ENUM_RELOAD_WEP_KEYS:
2645         /* Reload available default WEP keys from the permanent
2646             storage. */
2647         prAdapter->rWifiVar.rConnSettings.eAuthMode = AUTH_MODE_OPEN;
2648         prAdapter->rWifiVar.rConnSettings.eEncStatus = ENUM_ENCRYPTION1_KEY_ABSENT;//ENUM_ENCRYPTION_DISABLED;
2649         {
2650             P_GLUE_INFO_T         prGlueInfo;
2651             P_CMD_INFO_T          prCmdInfo;
2652             P_WIFI_CMD_T          prWifiCmd;
2653             P_CMD_802_11_KEY      prCmdKey;
2654             UINT_8                aucBCAddr[] = BC_MAC_ADDR;
2655
2656             prGlueInfo = prAdapter->prGlueInfo;
2657             prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + sizeof(CMD_802_11_KEY)));
2658
2659             if (!prCmdInfo) {
2660                 DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
2661                 return WLAN_STATUS_FAILURE;
2662             }
2663             // increase command sequence number
2664             ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
2665
2666             // compose CMD_802_11_KEY cmd pkt
2667             prCmdInfo->eCmdType = COMMAND_TYPE_NETWORK_IOCTL;
2668             prCmdInfo->eNetworkType = NETWORK_TYPE_AIS_INDEX;
2669             prCmdInfo->u2InfoBufLen = CMD_HDR_SIZE + sizeof(CMD_802_11_KEY);
2670             prCmdInfo->pfCmdDoneHandler = nicCmdEventSetCommon;
2671             prCmdInfo->pfCmdTimeoutHandler = nicOidCmdTimeoutCommon;
2672             prCmdInfo->fgIsOid = TRUE;
2673             prCmdInfo->ucCID = CMD_ID_ADD_REMOVE_KEY;
2674             prCmdInfo->fgSetQuery = TRUE;
2675             prCmdInfo->fgNeedResp = FALSE;
2676             prCmdInfo->fgDriverDomainMCR = FALSE;
2677             prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
2678             prCmdInfo->u4SetInfoLen = sizeof(PARAM_REMOVE_KEY_T);
2679             prCmdInfo->pvInformationBuffer = pvSetBuffer;
2680             prCmdInfo->u4InformationBufferLength = u4SetBufferLen;
2681
2682             // Setup WIFI_CMD_T
2683             prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
2684             prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
2685             prWifiCmd->ucCID = prCmdInfo->ucCID;
2686             prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
2687             prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
2688
2689             prCmdKey = (P_CMD_802_11_KEY)(prWifiCmd->aucBuffer);
2690
2691             kalMemZero((PUINT_8)prCmdKey, sizeof(CMD_802_11_KEY));
2692
2693             prCmdKey->ucAddRemove = 0; /* Remove */
2694             prCmdKey->ucKeyId = 0;//(UINT_8)(prRemovedKey->u4KeyIndex & 0x000000ff);
2695             kalMemCopy(prCmdKey->aucPeerAddr, aucBCAddr, MAC_ADDR_LEN);
2696
2697             ASSERT(prCmdKey->ucKeyId < MAX_KEY_NUM);
2698
2699             prCmdKey->ucKeyType = 0;
2700
2701             // insert into prCmdQueue
2702             kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
2703
2704             // wakeup txServiceThread later
2705             GLUE_SET_EVENT(prGlueInfo);
2706
2707             return WLAN_STATUS_PENDING;
2708         }
2709
2710         break;
2711
2712     default:
2713         DBGLOG(REQ, TRACE, ("Invalid reload option %d\n",
2714             *(P_PARAM_RELOAD_DEFAULTS)pvSetBuffer));
2715         rStatus = WLAN_STATUS_INVALID_DATA;
2716     }
2717
2718     /* OID_802_11_RELOAD_DEFAULTS requiest to reset to auto mode */
2719     eNetworkType = PARAM_NETWORK_TYPE_AUTOMODE;
2720     wlanoidSetNetworkTypeInUse(prAdapter, &eNetworkType, sizeof(eNetworkType), &u4Len);
2721
2722     return rStatus;
2723 } /* wlanoidSetReloadDefaults */
2724
2725
2726 /*----------------------------------------------------------------------------*/
2727 /*!
2728 * \brief This routine is called to set a WEP key to the driver.
2729 *
2730 * \param[in]  prAdapter Pointer to the Adapter structure.
2731 * \param[in]  pvSetBuffer A pointer to the buffer that holds the data to be set.
2732 * \param[in]  u4SetBufferLen The length of the set buffer.
2733 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
2734 *                          bytes read from the set buffer. If the call failed
2735 *                          due to invalid length of the set buffer, returns
2736 *                          the amount of storage needed.
2737 *
2738 * \retval WLAN_STATUS_SUCCESS
2739 * \retval WLAN_STATUS_INVALID_LENGTH
2740 * \retval WLAN_STATUS_INVALID_DATA
2741 * \retval WLAN_STATUS_ADAPTER_NOT_READY
2742 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
2743 */
2744 /*----------------------------------------------------------------------------*/
2745 #ifdef LINUX
2746 UINT_8        keyBuffer[sizeof(PARAM_KEY_T) + 16 /* LEGACY_KEY_MAX_LEN*/];
2747 UINT_8        aucBCAddr[] = BC_MAC_ADDR;
2748 #endif
2749 WLAN_STATUS
2750 wlanoidSetAddWep (
2751     IN  P_ADAPTER_T       prAdapter,
2752     IN  PVOID    pvSetBuffer,
2753     IN  UINT_32  u4SetBufferLen,
2754     OUT PUINT_32 pu4SetInfoLen
2755     )
2756 {
2757     #ifndef LINUX
2758     UINT_8        keyBuffer[sizeof(PARAM_KEY_T) + 16 /* LEGACY_KEY_MAX_LEN*/];
2759     UINT_8        aucBCAddr[] = BC_MAC_ADDR;
2760     #endif
2761     P_PARAM_WEP_T prNewWepKey;
2762     P_PARAM_KEY_T prParamKey = (P_PARAM_KEY_T)keyBuffer;
2763     UINT_32       u4KeyId, u4SetLen;
2764
2765     DEBUGFUNC("wlanoidSetAddWep");
2766
2767     ASSERT(prAdapter);
2768
2769     *pu4SetInfoLen = OFFSET_OF(PARAM_WEP_T, aucKeyMaterial);
2770
2771     if (u4SetBufferLen < OFFSET_OF(PARAM_WEP_T, aucKeyMaterial)) {
2772         ASSERT(pu4SetInfoLen);
2773         return WLAN_STATUS_BUFFER_TOO_SHORT;
2774     }
2775
2776     ASSERT(pvSetBuffer);
2777     ASSERT(pu4SetInfoLen);
2778
2779     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
2780         DBGLOG(REQ, WARN, ("Fail in set add WEP! (Adapter not ready). ACPI=D%d, Radio=%d\n",
2781                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
2782         return WLAN_STATUS_ADAPTER_NOT_READY;
2783     }
2784
2785     prNewWepKey = (P_PARAM_WEP_T)pvSetBuffer;
2786
2787     /* Verify the total buffer for minimum length. */
2788     if (u4SetBufferLen < OFFSET_OF(PARAM_WEP_T, aucKeyMaterial) + prNewWepKey->u4KeyLength) {
2789         DBGLOG(REQ, WARN, ("Invalid total buffer length (%d) than minimum length (%d)\n",
2790                           (UINT_8)u4SetBufferLen,
2791                           (UINT_8)OFFSET_OF(PARAM_WEP_T, aucKeyMaterial)));
2792
2793         *pu4SetInfoLen = OFFSET_OF(PARAM_WEP_T, aucKeyMaterial);
2794         return WLAN_STATUS_INVALID_DATA;
2795     }
2796
2797     /* Verify the key structure length. */
2798     if (prNewWepKey->u4Length > u4SetBufferLen) {
2799         DBGLOG(REQ, WARN, ("Invalid key structure length (%d) greater than total buffer length (%d)\n",
2800                           (UINT_8)prNewWepKey->u4Length,
2801                           (UINT_8)u4SetBufferLen));
2802
2803         *pu4SetInfoLen = u4SetBufferLen;
2804         return WLAN_STATUS_INVALID_DATA;
2805     }
2806
2807     /* Verify the key material length for maximum key material length:16 */
2808     if (prNewWepKey->u4KeyLength > 16 /* LEGACY_KEY_MAX_LEN */) {
2809         DBGLOG(REQ, WARN, ("Invalid key material length (%d) greater than maximum key material length (16)\n",
2810             (UINT_8)prNewWepKey->u4KeyLength));
2811
2812         *pu4SetInfoLen = u4SetBufferLen;
2813         return WLAN_STATUS_INVALID_DATA;
2814     }
2815
2816     *pu4SetInfoLen = u4SetBufferLen;
2817
2818     u4KeyId = prNewWepKey->u4KeyIndex & BITS(0,29) /* WEP_KEY_ID_FIELD */;
2819
2820     /* Verify whether key index is valid or not, current version
2821        driver support only 4 global WEP keys setting by this OID */
2822     if (u4KeyId > MAX_KEY_NUM - 1) {
2823         DBGLOG(REQ, ERROR, ("Error, invalid WEP key ID: %d\n", (UINT_8)u4KeyId));
2824         return WLAN_STATUS_INVALID_DATA;
2825     }
2826
2827     prParamKey->u4KeyIndex = u4KeyId;
2828
2829     /* Transmit key */
2830     if (prNewWepKey->u4KeyIndex & IS_TRANSMIT_KEY) {
2831         prParamKey->u4KeyIndex |= IS_TRANSMIT_KEY;
2832     }
2833
2834     /* Per client key */
2835     if (prNewWepKey->u4KeyIndex & IS_UNICAST_KEY) {
2836         prParamKey->u4KeyIndex |= IS_UNICAST_KEY;
2837     }
2838
2839     prParamKey->u4KeyLength = prNewWepKey->u4KeyLength;
2840
2841     kalMemCopy(prParamKey->arBSSID, aucBCAddr, MAC_ADDR_LEN);
2842
2843     kalMemCopy(prParamKey->aucKeyMaterial,
2844         prNewWepKey->aucKeyMaterial,
2845         prNewWepKey->u4KeyLength);
2846
2847     prParamKey->u4Length = OFFSET_OF(PARAM_KEY_T, aucKeyMaterial) + prNewWepKey->u4KeyLength;
2848
2849     wlanoidSetAddKey(prAdapter,
2850         (PVOID)prParamKey,
2851         prParamKey->u4Length,
2852         &u4SetLen);
2853
2854     return WLAN_STATUS_PENDING;
2855 } /* wlanoidSetAddWep */
2856
2857
2858 /*----------------------------------------------------------------------------*/
2859 /*!
2860 * \brief This routine is called to request the driver to remove the WEP key
2861 *          at the specified key index.
2862 *
2863 * \param[in] prAdapter Pointer to the Adapter structure.
2864 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
2865 * \param[in] u4SetBufferLen The length of the set buffer.
2866 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
2867 *                          bytes read from the set buffer. If the call failed
2868 *                          due to invalid length of the set buffer, returns
2869 *                          the amount of storage needed.
2870 *
2871 * \retval WLAN_STATUS_SUCCESS
2872 * \retval WLAN_STATUS_INVALID_DATA
2873 * \retval WLAN_STATUS_INVALID_LENGTH
2874 * \retval WLAN_STATUS_ADAPTER_NOT_READY
2875 */
2876 /*----------------------------------------------------------------------------*/
2877 WLAN_STATUS
2878 wlanoidSetRemoveWep (
2879     IN  P_ADAPTER_T       prAdapter,
2880     IN  PVOID             pvSetBuffer,
2881     IN  UINT_32           u4SetBufferLen,
2882     OUT PUINT_32          pu4SetInfoLen
2883     )
2884 {
2885     UINT_32               u4KeyId, u4SetLen;
2886     PARAM_REMOVE_KEY_T    rRemoveKey;
2887     UINT_8                aucBCAddr[] = BC_MAC_ADDR;
2888
2889     DEBUGFUNC("wlanoidSetRemoveWep");
2890
2891     ASSERT(prAdapter);
2892     ASSERT(pu4SetInfoLen);
2893
2894     *pu4SetInfoLen = sizeof(PARAM_KEY_INDEX);
2895
2896     if (u4SetBufferLen < sizeof(PARAM_KEY_INDEX)) {
2897         return WLAN_STATUS_INVALID_LENGTH;
2898     }
2899
2900     ASSERT(pvSetBuffer);
2901     u4KeyId = *(PUINT_32)pvSetBuffer;
2902
2903     /* Dump PARAM_WEP content. */
2904     DBGLOG(REQ, INFO, ("Set: Dump PARAM_KEY_INDEX content\n"));
2905     DBGLOG(REQ, INFO, ("Index : 0x%08lx\n", u4KeyId));
2906
2907     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
2908         DBGLOG(REQ, WARN, ("Fail in set remove WEP! (Adapter not ready). ACPI=D%d, Radio=%d\n",
2909                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
2910         return WLAN_STATUS_ADAPTER_NOT_READY;
2911     }
2912
2913     if (u4KeyId & IS_TRANSMIT_KEY) {
2914         /* Bit 31 should not be set */
2915         DBGLOG(REQ, ERROR, ("Invalid WEP key index: 0x%08lx\n", u4KeyId));
2916         return WLAN_STATUS_INVALID_DATA;
2917     }
2918
2919     u4KeyId &= BITS(0,7);
2920
2921     /* Verify whether key index is valid or not. Current version
2922         driver support only 4 global WEP keys. */
2923     if (u4KeyId > MAX_KEY_NUM - 1) {
2924         DBGLOG(REQ, ERROR, ("invalid WEP key ID %lu\n", u4KeyId));
2925         return WLAN_STATUS_INVALID_DATA;
2926     }
2927
2928     rRemoveKey.u4Length = sizeof(PARAM_REMOVE_KEY_T);
2929     rRemoveKey.u4KeyIndex = *(PUINT_32)pvSetBuffer;
2930
2931     kalMemCopy(rRemoveKey.arBSSID, aucBCAddr, MAC_ADDR_LEN);
2932
2933     wlanoidSetRemoveKey(prAdapter,
2934         (PVOID)&rRemoveKey,
2935         sizeof(PARAM_REMOVE_KEY_T),
2936         &u4SetLen);
2937
2938     return WLAN_STATUS_PENDING;
2939 } /* wlanoidSetRemoveWep */
2940
2941
2942 /*----------------------------------------------------------------------------*/
2943 /*!
2944 * \brief This routine is called to set a key to the driver.
2945 *
2946 * \param[in] prAdapter Pointer to the Adapter structure.
2947 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
2948 * \param[in] u4SetBufferLen The length of the set buffer.
2949 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
2950 *                          bytes read from the set buffer. If the call failed
2951 *                          due to invalid length of the set buffer, returns
2952 *                          the amount of storage needed.
2953 *
2954 * \retval WLAN_STATUS_SUCCESS
2955 * \retval WLAN_STATUS_ADAPTER_NOT_READY
2956 * \retval WLAN_STATUS_INVALID_LENGTH
2957 * \retval WLAN_STATUS_INVALID_DATA
2958 *
2959 * \note The setting buffer PARAM_KEY_T, which is set by NDIS, is unpacked.
2960 */
2961 /*----------------------------------------------------------------------------*/
2962 WLAN_STATUS
2963 wlanoidSetAddKey (
2964     IN  P_ADAPTER_T       prAdapter,
2965     IN  PVOID    pvSetBuffer,
2966     IN  UINT_32  u4SetBufferLen,
2967     OUT PUINT_32 pu4SetInfoLen
2968     )
2969 {
2970     P_GLUE_INFO_T         prGlueInfo;
2971     P_CMD_INFO_T          prCmdInfo;
2972     P_WIFI_CMD_T          prWifiCmd;
2973     P_PARAM_KEY_T         prNewKey;
2974     P_CMD_802_11_KEY      prCmdKey;
2975     UINT_8 ucCmdSeqNum;
2976
2977     DEBUGFUNC("wlanoidSetAddKey");
2978     DBGLOG(REQ, LOUD, ("\n"));
2979
2980     ASSERT(prAdapter);
2981     ASSERT(pvSetBuffer);
2982     ASSERT(pu4SetInfoLen);
2983
2984     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
2985         DBGLOG(REQ, WARN, ("Fail in set add key! (Adapter not ready). ACPI=D%d, Radio=%d\n",
2986                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
2987         return WLAN_STATUS_ADAPTER_NOT_READY;
2988     }
2989
2990     prNewKey = (P_PARAM_KEY_T) pvSetBuffer;
2991
2992     /* Verify the key structure length. */
2993     if (prNewKey->u4Length > u4SetBufferLen) {
2994         DBGLOG(REQ, WARN, ("Invalid key structure length (%d) greater than total buffer length (%d)\n",
2995                           (UINT_8)prNewKey->u4Length,
2996                           (UINT_8)u4SetBufferLen));
2997
2998         *pu4SetInfoLen = u4SetBufferLen;
2999         return WLAN_STATUS_INVALID_LENGTH;
3000     }
3001
3002     /* Verify the key material length for key material buffer */
3003     if (prNewKey->u4KeyLength > prNewKey->u4Length - OFFSET_OF(PARAM_KEY_T, aucKeyMaterial)) {
3004         DBGLOG(REQ, WARN, ("Invalid key material length (%d)\n", (UINT_8)prNewKey->u4KeyLength));
3005         *pu4SetInfoLen = u4SetBufferLen;
3006         return WLAN_STATUS_INVALID_DATA;
3007     }
3008
3009     /* Exception check */
3010     if (prNewKey->u4KeyIndex & 0x0fffff00) {
3011         return WLAN_STATUS_INVALID_DATA;
3012     }
3013
3014    /* Exception check, pairwise key must with transmit bit enabled */
3015     if ((prNewKey->u4KeyIndex & BITS(30,31)) == IS_UNICAST_KEY) {
3016         return WLAN_STATUS_INVALID_DATA;
3017     }
3018
3019     if (!(prNewKey->u4KeyLength == WEP_40_LEN || prNewKey->u4KeyLength == WEP_104_LEN ||
3020           prNewKey->u4KeyLength == CCMP_KEY_LEN || prNewKey->u4KeyLength == TKIP_KEY_LEN))
3021     {
3022         return WLAN_STATUS_INVALID_DATA;
3023     }
3024
3025     /* Exception check, pairwise key must with transmit bit enabled */
3026     if ((prNewKey->u4KeyIndex & BITS(30,31)) == BITS(30,31)) {
3027         if (((prNewKey->u4KeyIndex & 0xff) != 0) ||
3028             ((prNewKey->arBSSID[0] == 0xff) && (prNewKey->arBSSID[1] == 0xff) && (prNewKey->arBSSID[2] == 0xff) &&
3029              (prNewKey->arBSSID[3] == 0xff) && (prNewKey->arBSSID[4] == 0xff) && (prNewKey->arBSSID[5] == 0xff))) {
3030             return WLAN_STATUS_INVALID_DATA;
3031         }
3032     }
3033
3034     *pu4SetInfoLen = u4SetBufferLen;
3035
3036     /* Dump PARAM_KEY content. */
3037     DBGLOG(REQ, TRACE, ("Set: Dump PARAM_KEY content\n"));
3038     DBGLOG(REQ, TRACE, ("Length    : 0x%08lx\n", prNewKey->u4Length));
3039     DBGLOG(REQ, TRACE, ("Key Index : 0x%08lx\n", prNewKey->u4KeyIndex));
3040     DBGLOG(REQ, TRACE, ("Key Length: 0x%08lx\n", prNewKey->u4KeyLength));
3041     DBGLOG(REQ, TRACE, ("BSSID:\n"));
3042     DBGLOG_MEM8(REQ, TRACE, prNewKey->arBSSID, sizeof(PARAM_MAC_ADDRESS));
3043     DBGLOG(REQ, TRACE, ("Key RSC:\n"));
3044     DBGLOG_MEM8(REQ, TRACE, &prNewKey->rKeyRSC, sizeof(PARAM_KEY_RSC));
3045     DBGLOG(REQ, TRACE, ("Key Material:\n"));
3046     DBGLOG_MEM8(REQ, TRACE, prNewKey->aucKeyMaterial, prNewKey->u4KeyLength);
3047
3048     if (prAdapter->rWifiVar.rConnSettings.eAuthMode < AUTH_MODE_WPA) {
3049         /* Todo:: Store the legacy wep key for OID_802_11_RELOAD_DEFAULTS */
3050     }
3051
3052     if (prNewKey->u4KeyIndex & IS_TRANSMIT_KEY)
3053         prAdapter->rWifiVar.rAisSpecificBssInfo.fgTransmitKeyExist = TRUE;
3054
3055     prGlueInfo = prAdapter->prGlueInfo;
3056     prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + sizeof(CMD_802_11_KEY)));
3057
3058     if (!prCmdInfo) {
3059         DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
3060         return WLAN_STATUS_FAILURE;
3061     }
3062
3063     // increase command sequence number
3064     ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
3065     DBGLOG(REQ, INFO, ("ucCmdSeqNum = %d\n", ucCmdSeqNum));
3066
3067     // compose CMD_802_11_KEY cmd pkt
3068     prCmdInfo->eCmdType = COMMAND_TYPE_NETWORK_IOCTL;
3069     prCmdInfo->eNetworkType = NETWORK_TYPE_AIS_INDEX;
3070     prCmdInfo->u2InfoBufLen = CMD_HDR_SIZE + sizeof(CMD_802_11_KEY);
3071     prCmdInfo->pfCmdDoneHandler = nicCmdEventSetCommon;
3072     prCmdInfo->pfCmdTimeoutHandler = nicOidCmdTimeoutCommon;
3073     prCmdInfo->fgIsOid = TRUE;
3074     prCmdInfo->ucCID = CMD_ID_ADD_REMOVE_KEY;
3075     prCmdInfo->fgSetQuery = TRUE;
3076     prCmdInfo->fgNeedResp = FALSE;
3077     prCmdInfo->fgDriverDomainMCR = FALSE;
3078     prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
3079     prCmdInfo->u4SetInfoLen = u4SetBufferLen;
3080     prCmdInfo->pvInformationBuffer = pvSetBuffer;
3081     prCmdInfo->u4InformationBufferLength = u4SetBufferLen;
3082
3083     // Setup WIFI_CMD_T
3084     prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
3085     prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
3086     prWifiCmd->ucCID = prCmdInfo->ucCID;
3087     prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
3088     prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
3089
3090     prCmdKey = (P_CMD_802_11_KEY)(prWifiCmd->aucBuffer);
3091
3092     kalMemZero(prCmdKey, sizeof(CMD_802_11_KEY));
3093
3094     prCmdKey->ucAddRemove = 1; /* Add */
3095
3096     prCmdKey->ucTxKey = ((prNewKey->u4KeyIndex & IS_TRANSMIT_KEY) == IS_TRANSMIT_KEY) ? 1 : 0;
3097     prCmdKey->ucKeyType = ((prNewKey->u4KeyIndex & IS_UNICAST_KEY) == IS_UNICAST_KEY) ? 1 : 0;
3098     prCmdKey->ucIsAuthenticator = ((prNewKey->u4KeyIndex & IS_AUTHENTICATOR) == IS_AUTHENTICATOR) ? 1 : 0;
3099
3100     kalMemCopy(prCmdKey->aucPeerAddr, (PUINT_8)prNewKey->arBSSID, MAC_ADDR_LEN);
3101
3102     prCmdKey->ucNetType = 0; /* AIS */
3103
3104     prCmdKey->ucKeyId = (UINT_8)(prNewKey->u4KeyIndex & 0xff);
3105
3106     /* Note: adjust the key length for WPA-None */
3107     prCmdKey->ucKeyLen = (UINT_8)prNewKey->u4KeyLength;
3108
3109     kalMemCopy(prCmdKey->aucKeyMaterial, (PUINT_8)prNewKey->aucKeyMaterial, prCmdKey->ucKeyLen);
3110
3111     if (prNewKey->u4KeyLength == 5) {
3112         prCmdKey->ucAlgorithmId = CIPHER_SUITE_WEP40;
3113     }
3114     else if (prNewKey->u4KeyLength == 13) {
3115         prCmdKey->ucAlgorithmId = CIPHER_SUITE_WEP104;
3116     }
3117     else if (prNewKey->u4KeyLength == 16) {
3118         if (prAdapter->rWifiVar.rConnSettings.eAuthMode < AUTH_MODE_WPA)
3119             prCmdKey->ucAlgorithmId = CIPHER_SUITE_WEP128;
3120         else {
3121 #if CFG_SUPPORT_802_11W
3122             if (prCmdKey->ucKeyId >= 4) {
3123                 prCmdKey->ucAlgorithmId = CIPHER_SUITE_BIP;
3124                 P_AIS_SPECIFIC_BSS_INFO_T  prAisSpecBssInfo;
3125
3126                 prAisSpecBssInfo = &prAdapter->rWifiVar.rAisSpecificBssInfo;
3127                 prAisSpecBssInfo->fgBipKeyInstalled = TRUE;
3128             }
3129         else
3130 #endif
3131             prCmdKey->ucAlgorithmId = CIPHER_SUITE_CCMP;
3132         }
3133     }
3134     else if (prNewKey->u4KeyLength == 32) {
3135         if (prAdapter->rWifiVar.rConnSettings.eAuthMode == AUTH_MODE_WPA_NONE) {
3136             if (prAdapter->rWifiVar.rConnSettings.eEncStatus == ENUM_ENCRYPTION2_ENABLED) {
3137                 prCmdKey->ucAlgorithmId = CIPHER_SUITE_TKIP;
3138             }
3139             else if (prAdapter->rWifiVar.rConnSettings.eEncStatus == ENUM_ENCRYPTION3_ENABLED) {
3140                 prCmdKey->ucAlgorithmId = CIPHER_SUITE_CCMP;
3141                 prCmdKey->ucKeyLen = CCMP_KEY_LEN;
3142             }
3143         }
3144         else {
3145             if (rsnCheckPmkidCandicate(prAdapter)) {
3146                 P_AIS_SPECIFIC_BSS_INFO_T  prAisSpecBssInfo;
3147
3148                 prAisSpecBssInfo = &prAdapter->rWifiVar.rAisSpecificBssInfo;
3149                 DBGLOG(RSN, TRACE, ("Add key: Prepare a timer to indicate candidate PMKID Candidate\n"));
3150                 cnmTimerStopTimer(prAdapter, &prAisSpecBssInfo->rPreauthenticationTimer);
3151                 cnmTimerStartTimer(prAdapter, &prAisSpecBssInfo->rPreauthenticationTimer,
3152                         SEC_TO_MSEC(WAIT_TIME_IND_PMKID_CANDICATE_SEC));
3153             }
3154             prCmdKey->ucAlgorithmId = CIPHER_SUITE_TKIP;
3155         }
3156     }
3157
3158     // insert into prCmdQueue
3159     kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
3160
3161     // wakeup txServiceThread later
3162     GLUE_SET_EVENT(prGlueInfo);
3163
3164     return WLAN_STATUS_PENDING;
3165 } /* wlanoidSetAddKey */
3166
3167
3168 /*----------------------------------------------------------------------------*/
3169 /*!
3170 * \brief This routine is called to request the driver to remove the key at
3171 *        the specified key index.
3172 *
3173 * \param[in] prAdapter Pointer to the Adapter structure.
3174 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
3175 * \param[in] u4SetBufferLen The length of the set buffer.
3176 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
3177 *                          bytes read from the set buffer. If the call failed
3178 *                          due to invalid length of the set buffer, returns
3179 *                          the amount of storage needed.
3180 *
3181 * \retval WLAN_STATUS_SUCCESS
3182 * \retval WLAN_STATUS_INVALID_DATA
3183 * \retval WLAN_STATUS_INVALID_LENGTH
3184 * \retval WLAN_STATUS_ADAPTER_NOT_READY
3185 */
3186 /*----------------------------------------------------------------------------*/
3187 WLAN_STATUS
3188 wlanoidSetRemoveKey (
3189     IN  P_ADAPTER_T       prAdapter,
3190     IN  PVOID             pvSetBuffer,
3191     IN  UINT_32           u4SetBufferLen,
3192     OUT PUINT_32          pu4SetInfoLen
3193     )
3194 {
3195     P_GLUE_INFO_T         prGlueInfo;
3196     P_CMD_INFO_T          prCmdInfo;
3197     P_WIFI_CMD_T          prWifiCmd;
3198     P_PARAM_REMOVE_KEY_T  prRemovedKey;
3199     P_CMD_802_11_KEY      prCmdKey;
3200     UINT_8                ucCmdSeqNum;
3201
3202     DEBUGFUNC("wlanoidSetRemoveKey");
3203
3204     ASSERT(prAdapter);
3205     ASSERT(pu4SetInfoLen);
3206
3207     *pu4SetInfoLen = sizeof(PARAM_REMOVE_KEY_T);
3208
3209     if (u4SetBufferLen < sizeof(PARAM_REMOVE_KEY_T)) {
3210         return WLAN_STATUS_INVALID_LENGTH;
3211     }
3212
3213     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
3214         DBGLOG(REQ, WARN, ("Fail in set remove key! (Adapter not ready). ACPI=D%d, Radio=%d\n",
3215                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
3216         return WLAN_STATUS_ADAPTER_NOT_READY;
3217     }
3218
3219     ASSERT(pvSetBuffer);
3220     prRemovedKey = (P_PARAM_REMOVE_KEY_T)pvSetBuffer;
3221
3222     /* Dump PARAM_REMOVE_KEY content. */
3223     DBGLOG(REQ, INFO, ("Set: Dump PARAM_REMOVE_KEY content\n"));
3224     DBGLOG(REQ, INFO, ("Length    : 0x%08lx\n", prRemovedKey->u4Length));
3225     DBGLOG(REQ, INFO, ("Key Index : 0x%08lx\n", prRemovedKey->u4KeyIndex));
3226     DBGLOG(REQ, INFO, ("BSSID:\n"));
3227     DBGLOG_MEM8(REQ, INFO, prRemovedKey->arBSSID, MAC_ADDR_LEN);
3228
3229     /* Check bit 31: this bit should always 0 */
3230     if (prRemovedKey->u4KeyIndex & IS_TRANSMIT_KEY) {
3231         /* Bit 31 should not be set */
3232         DBGLOG(REQ, ERROR, ("invalid key index: 0x%08lx\n",
3233             prRemovedKey->u4KeyIndex));
3234         return WLAN_STATUS_INVALID_DATA;
3235     }
3236
3237     /* Check bits 8 ~ 29 should always be 0 */
3238     if (prRemovedKey->u4KeyIndex & BITS(8, 29)) {
3239         /* Bit 31 should not be set */
3240         DBGLOG(REQ, ERROR, ("invalid key index: 0x%08lx\n",
3241             prRemovedKey->u4KeyIndex));
3242         return WLAN_STATUS_INVALID_DATA;
3243     }
3244
3245     /* Clean up the Tx key flag */
3246     if (prRemovedKey->u4KeyIndex & IS_UNICAST_KEY) {
3247         prAdapter->rWifiVar.rAisSpecificBssInfo.fgTransmitKeyExist = FALSE;
3248     }
3249
3250     prGlueInfo = prAdapter->prGlueInfo;
3251     prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + sizeof(CMD_802_11_KEY)));
3252
3253     if (!prCmdInfo) {
3254         DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
3255         return WLAN_STATUS_FAILURE;
3256     }
3257
3258     // increase command sequence number
3259     ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
3260
3261     // compose CMD_802_11_KEY cmd pkt
3262     prCmdInfo->eCmdType = COMMAND_TYPE_NETWORK_IOCTL;
3263     prCmdInfo->eNetworkType = NETWORK_TYPE_AIS_INDEX;
3264     prCmdInfo->u2InfoBufLen = CMD_HDR_SIZE + sizeof(CMD_802_11_KEY);
3265     prCmdInfo->pfCmdDoneHandler = nicCmdEventSetCommon;
3266     prCmdInfo->pfCmdTimeoutHandler = nicOidCmdTimeoutCommon;
3267     prCmdInfo->fgIsOid = TRUE;
3268     prCmdInfo->ucCID = CMD_ID_ADD_REMOVE_KEY;
3269     prCmdInfo->fgSetQuery = TRUE;
3270     prCmdInfo->fgNeedResp = FALSE;
3271     prCmdInfo->fgDriverDomainMCR = FALSE;
3272     prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
3273     prCmdInfo->u4SetInfoLen = sizeof(PARAM_REMOVE_KEY_T);
3274     prCmdInfo->pvInformationBuffer = pvSetBuffer;
3275     prCmdInfo->u4InformationBufferLength = u4SetBufferLen;
3276
3277     // Setup WIFI_CMD_T
3278     prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
3279     prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
3280     prWifiCmd->ucCID = prCmdInfo->ucCID;
3281     prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
3282     prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
3283
3284     prCmdKey = (P_CMD_802_11_KEY)(prWifiCmd->aucBuffer);
3285
3286     kalMemZero((PUINT_8)prCmdKey, sizeof(CMD_802_11_KEY));
3287
3288     prCmdKey->ucAddRemove = 0; /* Remove */
3289     prCmdKey->ucKeyId = (UINT_8)(prRemovedKey->u4KeyIndex & 0x000000ff);
3290     kalMemCopy(prCmdKey->aucPeerAddr, (PUINT_8)prRemovedKey->arBSSID, MAC_ADDR_LEN);
3291
3292 #if CFG_SUPPORT_802_11W
3293     ASSERT(prCmdKey->ucKeyId < MAX_KEY_NUM + 2);
3294 #else
3295     //ASSERT(prCmdKey->ucKeyId < MAX_KEY_NUM);
3296 #endif
3297
3298     if (prRemovedKey->u4KeyIndex & IS_UNICAST_KEY) {
3299         prCmdKey->ucKeyType = 1;
3300     }
3301
3302     // insert into prCmdQueue
3303     kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
3304
3305     // wakeup txServiceThread later
3306     GLUE_SET_EVENT(prGlueInfo);
3307
3308     return WLAN_STATUS_PENDING;
3309 } /* wlanoidSetRemoveKey */
3310
3311
3312 /*----------------------------------------------------------------------------*/
3313 /*!
3314 * \brief This routine is called to query the current encryption status.
3315 *
3316 * \param[in] prAdapter Pointer to the Adapter structure.
3317 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
3318 *                           the query.
3319 * \param[in] u4QueryBufferLen The length of the query buffer.
3320 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
3321 *                            bytes written into the query buffer. If the call
3322 *                            failed due to invalid length of the query buffer,
3323 *                            returns the amount of storage needed.
3324 *
3325 * \retval WLAN_STATUS_SUCCESS
3326 */
3327 /*----------------------------------------------------------------------------*/
3328 WLAN_STATUS
3329 wlanoidQueryEncryptionStatus (
3330     IN  P_ADAPTER_T       prAdapter,
3331     IN  PVOID             pvQueryBuffer,
3332     IN  UINT_32           u4QueryBufferLen,
3333     OUT PUINT_32          pu4QueryInfoLen
3334     )
3335 {
3336     BOOLEAN               fgTransmitKeyAvailable = TRUE;
3337     ENUM_PARAM_ENCRYPTION_STATUS_T eEncStatus = 0;
3338
3339     DEBUGFUNC("wlanoidQueryEncryptionStatus");
3340
3341     ASSERT(prAdapter);
3342     ASSERT(pu4QueryInfoLen);
3343     if (u4QueryBufferLen) {
3344         ASSERT(pvQueryBuffer);
3345     }
3346
3347     *pu4QueryInfoLen = sizeof(ENUM_PARAM_ENCRYPTION_STATUS_T);
3348
3349     fgTransmitKeyAvailable = prAdapter->rWifiVar.rAisSpecificBssInfo.fgTransmitKeyExist;
3350
3351     switch (prAdapter->rWifiVar.rConnSettings.eEncStatus) {
3352     case ENUM_ENCRYPTION3_ENABLED:
3353         if (fgTransmitKeyAvailable) {
3354             eEncStatus = ENUM_ENCRYPTION3_ENABLED;
3355         }
3356         else {
3357             eEncStatus = ENUM_ENCRYPTION3_KEY_ABSENT;
3358         }
3359         break;
3360
3361     case ENUM_ENCRYPTION2_ENABLED:
3362         if (fgTransmitKeyAvailable) {
3363             eEncStatus = ENUM_ENCRYPTION2_ENABLED;
3364             break;
3365         }
3366         else {
3367             eEncStatus = ENUM_ENCRYPTION2_KEY_ABSENT;
3368         }
3369         break;
3370
3371     case ENUM_ENCRYPTION1_ENABLED:
3372         if (fgTransmitKeyAvailable) {
3373             eEncStatus = ENUM_ENCRYPTION1_ENABLED;
3374         }
3375         else {
3376             eEncStatus = ENUM_ENCRYPTION1_KEY_ABSENT;
3377         }
3378         break;
3379
3380     case ENUM_ENCRYPTION_DISABLED:
3381         eEncStatus = ENUM_ENCRYPTION_DISABLED;
3382         break;
3383
3384     default:
3385         DBGLOG(REQ, ERROR, ("Unknown Encryption Status Setting:%d\n",
3386             prAdapter->rWifiVar.rConnSettings.eEncStatus));
3387     }
3388
3389 #if DBG
3390     DBGLOG(REQ, INFO,
3391         ("Encryption status: %d Return:%d\n",
3392         prAdapter->rWifiVar.rConnSettings.eEncStatus,
3393         eEncStatus));
3394 #endif
3395
3396     *(P_ENUM_PARAM_ENCRYPTION_STATUS_T)pvQueryBuffer = eEncStatus;
3397
3398     return WLAN_STATUS_SUCCESS;
3399 } /* wlanoidQueryEncryptionStatus */
3400
3401
3402 /*----------------------------------------------------------------------------*/
3403 /*!
3404 * \brief This routine is called to set the encryption status to the driver.
3405 *
3406 * \param[in] prAdapter Pointer to the Adapter structure.
3407 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
3408 * \param[in] u4SetBufferLen The length of the set buffer.
3409 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
3410 *                          bytes read from the set buffer. If the call failed
3411 *                          due to invalid length of the set buffer, returns
3412 *                          the amount of storage needed.
3413 *
3414 * \retval WLAN_STATUS_SUCCESS
3415 * \retval WLAN_STATUS_ADAPTER_NOT_READY
3416 * \retval WLAN_STATUS_NOT_SUPPORTED
3417 */
3418 /*----------------------------------------------------------------------------*/
3419 WLAN_STATUS
3420 wlanoidSetEncryptionStatus (
3421     IN  P_ADAPTER_T       prAdapter,
3422     IN  PVOID             pvSetBuffer,
3423     IN  UINT_32           u4SetBufferLen,
3424     OUT PUINT_32          pu4SetInfoLen
3425     )
3426 {
3427     P_GLUE_INFO_T         prGlueInfo;
3428     WLAN_STATUS           rStatus = WLAN_STATUS_SUCCESS;
3429     ENUM_PARAM_ENCRYPTION_STATUS_T eEewEncrypt;
3430
3431     DEBUGFUNC("wlanoidSetEncryptionStatus");
3432
3433     ASSERT(prAdapter);
3434     ASSERT(pvSetBuffer);
3435     ASSERT(pu4SetInfoLen);
3436
3437     prGlueInfo = prAdapter->prGlueInfo;
3438
3439     *pu4SetInfoLen = sizeof(ENUM_PARAM_ENCRYPTION_STATUS_T);
3440
3441     //if (IS_ARB_IN_RFTEST_STATE(prAdapter)) {
3442     //  return WLAN_STATUS_SUCCESS;
3443     //}
3444
3445     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
3446         DBGLOG(REQ, WARN, ("Fail in set encryption status! (Adapter not ready). ACPI=D%d, Radio=%d\n",
3447                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
3448         return WLAN_STATUS_ADAPTER_NOT_READY;
3449     }
3450
3451     eEewEncrypt = *(P_ENUM_PARAM_ENCRYPTION_STATUS_T)pvSetBuffer;
3452     DBGLOG(REQ, TRACE, ("ENCRYPTION_STATUS %d\n", eEewEncrypt));
3453
3454     switch (eEewEncrypt) {
3455     case ENUM_ENCRYPTION_DISABLED: /* Disable WEP, TKIP, AES */
3456         DBGLOG(RSN, TRACE, ("Disable Encryption\n"));
3457         secSetCipherSuite(prAdapter,
3458             CIPHER_FLAG_WEP40  |
3459             CIPHER_FLAG_WEP104 |
3460             CIPHER_FLAG_WEP128);
3461         break;
3462
3463     case ENUM_ENCRYPTION1_ENABLED: /* Enable WEP. Disable TKIP, AES */
3464         DBGLOG(RSN, TRACE, ("Enable Encryption1\n"));
3465         secSetCipherSuite(prAdapter,
3466             CIPHER_FLAG_WEP40  |
3467             CIPHER_FLAG_WEP104 |
3468             CIPHER_FLAG_WEP128);
3469         break;
3470
3471     case ENUM_ENCRYPTION2_ENABLED: /* Enable WEP, TKIP. Disable AES */
3472         secSetCipherSuite(prAdapter,
3473             CIPHER_FLAG_WEP40  |
3474             CIPHER_FLAG_WEP104 |
3475             CIPHER_FLAG_WEP128 |
3476             CIPHER_FLAG_TKIP);
3477         DBGLOG(RSN, TRACE, ("Enable Encryption2\n"));
3478         break;
3479
3480     case ENUM_ENCRYPTION3_ENABLED: /* Enable WEP, TKIP, AES */
3481         secSetCipherSuite(prAdapter,
3482             CIPHER_FLAG_WEP40  |
3483             CIPHER_FLAG_WEP104 |
3484             CIPHER_FLAG_WEP128 |
3485             CIPHER_FLAG_TKIP |
3486             CIPHER_FLAG_CCMP);
3487         DBGLOG(RSN, TRACE, ("Enable Encryption3\n"));
3488         break;
3489
3490     default:
3491         DBGLOG(RSN, WARN, ("Unacceptible encryption status: %d\n",
3492             *(P_ENUM_PARAM_ENCRYPTION_STATUS_T)pvSetBuffer));
3493
3494         rStatus = WLAN_STATUS_NOT_SUPPORTED;
3495     }
3496
3497     if (rStatus == WLAN_STATUS_SUCCESS) {
3498         /* Save the new encryption status. */
3499         prAdapter->rWifiVar.rConnSettings.eEncStatus =
3500             *(P_ENUM_PARAM_ENCRYPTION_STATUS_T)pvSetBuffer;
3501     }
3502
3503     return rStatus;
3504 } /* wlanoidSetEncryptionStatus */
3505
3506
3507 /*----------------------------------------------------------------------------*/
3508 /*!
3509 * \brief This routine is called to test the driver.
3510 *
3511 * \param[in] prAdapter Pointer to the Adapter structure.
3512 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
3513 * \param[in] u4SetBufferLen The length of the set buffer.
3514 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
3515 *                          bytes read from the set buffer. If the call failed
3516 *                          due to invalid length of the set buffer, returns
3517 *                          the amount of storage needed.
3518 *
3519 * \retval WLAN_STATUS_SUCCESS
3520 * \retval WLAN_STATUS_INVALID_LENGTH
3521 * \retval WLAN_STATUS_INVALID_DATA
3522 */
3523 /*----------------------------------------------------------------------------*/
3524 WLAN_STATUS
3525 wlanoidSetTest (
3526     IN  P_ADAPTER_T       prAdapter,
3527     IN  PVOID             pvSetBuffer,
3528     IN  UINT_32           u4SetBufferLen,
3529     OUT PUINT_32          pu4SetInfoLen
3530     )
3531 {
3532     P_PARAM_802_11_TEST_T prTest;
3533     PVOID                 pvTestData;
3534     PVOID                 pvStatusBuffer;
3535     UINT_32               u4StatusBufferSize;
3536
3537     DEBUGFUNC("wlanoidSetTest");
3538
3539     ASSERT(prAdapter);
3540
3541     ASSERT(pu4SetInfoLen);
3542     ASSERT(pvSetBuffer);
3543
3544     *pu4SetInfoLen = u4SetBufferLen;
3545
3546     prTest = (P_PARAM_802_11_TEST_T)pvSetBuffer;
3547
3548     DBGLOG(REQ, TRACE, ("Test - Type %ld\n", prTest->u4Type));
3549
3550     switch (prTest->u4Type) {
3551     case 1:     /* Type 1: generate an authentication event */
3552         pvTestData = (PVOID)&prTest->u.AuthenticationEvent;
3553         pvStatusBuffer = (PVOID)prAdapter->aucIndicationEventBuffer;
3554         u4StatusBufferSize = prTest->u4Length - 8;
3555         break;
3556
3557     case 2:     /* Type 2: generate an RSSI status indication */
3558         pvTestData = (PVOID)&prTest->u.RssiTrigger;
3559         pvStatusBuffer = (PVOID)&prAdapter->rWlanInfo.rCurrBssId.rRssi;
3560         u4StatusBufferSize = sizeof(PARAM_RSSI);
3561         break;
3562
3563     default:
3564         return WLAN_STATUS_INVALID_DATA;
3565     }
3566
3567     ASSERT(u4StatusBufferSize <= 180);
3568     if (u4StatusBufferSize > 180) {
3569         return WLAN_STATUS_INVALID_LENGTH;
3570     }
3571
3572     /* Get the contents of the StatusBuffer from the test structure. */
3573     kalMemCopy(pvStatusBuffer, pvTestData, u4StatusBufferSize);
3574
3575     kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
3576         WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
3577         pvStatusBuffer,
3578         u4StatusBufferSize);
3579
3580     return WLAN_STATUS_SUCCESS;
3581 } /* wlanoidSetTest */
3582
3583
3584 /*----------------------------------------------------------------------------*/
3585 /*!
3586 * \brief This routine is called to query the driver's WPA2 status.
3587 *
3588 * \param[in] prAdapter Pointer to the Adapter structure.
3589 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
3590 *                           the query.
3591 * \param[in] u4QueryBufferLen The length of the query buffer.
3592 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
3593 *                            bytes written into the query buffer. If the call
3594 *                            failed due to invalid length of the query buffer,
3595 *                            returns the amount of storage needed.
3596 *
3597 * \retval WLAN_STATUS_SUCCESS
3598 * \retval WLAN_STATUS_INVALID_LENGTH
3599 */
3600 /*----------------------------------------------------------------------------*/
3601 WLAN_STATUS
3602 wlanoidQueryCapability (
3603     IN  P_ADAPTER_T       prAdapter,
3604     OUT PVOID             pvQueryBuffer,
3605     IN  UINT_32           u4QueryBufferLen,
3606     OUT PUINT_32          pu4QueryInfoLen
3607     )
3608 {
3609     P_PARAM_CAPABILITY_T  prCap;
3610     P_PARAM_AUTH_ENCRYPTION_T prAuthenticationEncryptionSupported;
3611
3612     DEBUGFUNC("wlanoidQueryCapability");
3613
3614     ASSERT(prAdapter);
3615     ASSERT(pu4QueryInfoLen);
3616     if (u4QueryBufferLen) {
3617         ASSERT(pvQueryBuffer);
3618     }
3619
3620     *pu4QueryInfoLen = 4 * sizeof(UINT_32) + 14 * sizeof(PARAM_AUTH_ENCRYPTION_T);
3621
3622     if (u4QueryBufferLen < *pu4QueryInfoLen) {
3623         return WLAN_STATUS_INVALID_LENGTH;
3624     }
3625
3626     prCap = (P_PARAM_CAPABILITY_T)pvQueryBuffer;
3627
3628     prCap->u4Length = *pu4QueryInfoLen;
3629     prCap->u4Version = 2; /* WPA2 */
3630     prCap->u4NoOfPMKIDs = CFG_MAX_PMKID_CACHE;
3631     prCap->u4NoOfAuthEncryptPairsSupported = 14;
3632
3633     prAuthenticationEncryptionSupported =
3634         &prCap->arAuthenticationEncryptionSupported[0];
3635
3636     // fill 14 entries of supported settings
3637     prAuthenticationEncryptionSupported[0].eAuthModeSupported =
3638         AUTH_MODE_OPEN;
3639
3640     prAuthenticationEncryptionSupported[0].eEncryptStatusSupported =
3641         ENUM_ENCRYPTION_DISABLED;
3642
3643     prAuthenticationEncryptionSupported[1].eAuthModeSupported =
3644         AUTH_MODE_OPEN;
3645     prAuthenticationEncryptionSupported[1].eEncryptStatusSupported =
3646         ENUM_ENCRYPTION1_ENABLED;
3647
3648     prAuthenticationEncryptionSupported[2].eAuthModeSupported =
3649         AUTH_MODE_SHARED;
3650     prAuthenticationEncryptionSupported[2].eEncryptStatusSupported =
3651         ENUM_ENCRYPTION_DISABLED;
3652
3653     prAuthenticationEncryptionSupported[3].eAuthModeSupported =
3654         AUTH_MODE_SHARED;
3655     prAuthenticationEncryptionSupported[3].eEncryptStatusSupported =
3656         ENUM_ENCRYPTION1_ENABLED;
3657
3658     prAuthenticationEncryptionSupported[4].eAuthModeSupported =
3659         AUTH_MODE_WPA;
3660     prAuthenticationEncryptionSupported[4].eEncryptStatusSupported =
3661         ENUM_ENCRYPTION2_ENABLED;
3662
3663     prAuthenticationEncryptionSupported[5].eAuthModeSupported =
3664         AUTH_MODE_WPA;
3665     prAuthenticationEncryptionSupported[5].eEncryptStatusSupported =
3666         ENUM_ENCRYPTION3_ENABLED;
3667
3668     prAuthenticationEncryptionSupported[6].eAuthModeSupported =
3669         AUTH_MODE_WPA_PSK;
3670     prAuthenticationEncryptionSupported[6].eEncryptStatusSupported =
3671         ENUM_ENCRYPTION2_ENABLED;
3672
3673     prAuthenticationEncryptionSupported[7].eAuthModeSupported =
3674         AUTH_MODE_WPA_PSK;
3675     prAuthenticationEncryptionSupported[7].eEncryptStatusSupported =
3676         ENUM_ENCRYPTION3_ENABLED;
3677
3678     prAuthenticationEncryptionSupported[8].eAuthModeSupported =
3679         AUTH_MODE_WPA_NONE;
3680     prAuthenticationEncryptionSupported[8].eEncryptStatusSupported =
3681         ENUM_ENCRYPTION2_ENABLED;
3682
3683     prAuthenticationEncryptionSupported[9].eAuthModeSupported =
3684         AUTH_MODE_WPA_NONE;
3685     prAuthenticationEncryptionSupported[9].eEncryptStatusSupported =
3686         ENUM_ENCRYPTION3_ENABLED;
3687
3688     prAuthenticationEncryptionSupported[10].eAuthModeSupported =
3689         AUTH_MODE_WPA2;
3690     prAuthenticationEncryptionSupported[10].eEncryptStatusSupported =
3691         ENUM_ENCRYPTION2_ENABLED;
3692
3693     prAuthenticationEncryptionSupported[11].eAuthModeSupported =
3694         AUTH_MODE_WPA2;
3695     prAuthenticationEncryptionSupported[11].eEncryptStatusSupported =
3696         ENUM_ENCRYPTION3_ENABLED;
3697
3698     prAuthenticationEncryptionSupported[12].eAuthModeSupported =
3699         AUTH_MODE_WPA2_PSK;
3700     prAuthenticationEncryptionSupported[12].eEncryptStatusSupported =
3701         ENUM_ENCRYPTION2_ENABLED;
3702
3703     prAuthenticationEncryptionSupported[13].eAuthModeSupported =
3704         AUTH_MODE_WPA2_PSK;
3705     prAuthenticationEncryptionSupported[13].eEncryptStatusSupported =
3706         ENUM_ENCRYPTION3_ENABLED;
3707
3708     return WLAN_STATUS_SUCCESS;
3709
3710 } /* wlanoidQueryCapability */
3711
3712
3713 /*----------------------------------------------------------------------------*/
3714 /*!
3715 * \brief This routine is called to query the PMKID in the PMK cache.
3716 *
3717 * \param[in] prAdapter Pointer to the Adapter structure.
3718 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
3719 *                           the query.
3720 * \param[in] u4QueryBufferLen The length of the query buffer.
3721 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
3722 *                             bytes written into the query buffer. If the call
3723 *                             failed due to invalid length of the query buffer,
3724 *                             returns the amount of storage needed.
3725 *
3726 * \retval WLAN_STATUS_SUCCESS
3727 * \retval WLAN_STATUS_INVALID_LENGTH
3728 */
3729 /*----------------------------------------------------------------------------*/
3730 WLAN_STATUS
3731 wlanoidQueryPmkid (
3732     IN  P_ADAPTER_T       prAdapter,
3733     OUT PVOID             pvQueryBuffer,
3734     IN  UINT_32           u4QueryBufferLen,
3735     OUT PUINT_32          pu4QueryInfoLen
3736     )
3737 {
3738     UINT_32               i;
3739     P_PARAM_PMKID_T       prPmkid;
3740     P_AIS_SPECIFIC_BSS_INFO_T prAisSpecBssInfo;
3741
3742     DEBUGFUNC("wlanoidQueryPmkid");
3743
3744     ASSERT(prAdapter);
3745     ASSERT(pu4QueryInfoLen);
3746     if (u4QueryBufferLen) {
3747         ASSERT(pvQueryBuffer);
3748     }
3749
3750     prAisSpecBssInfo = &prAdapter->rWifiVar.rAisSpecificBssInfo;
3751
3752     *pu4QueryInfoLen = OFFSET_OF(PARAM_PMKID_T, arBSSIDInfo) +
3753         prAisSpecBssInfo->u4PmkidCacheCount * sizeof(PARAM_BSSID_INFO_T);
3754
3755     if (u4QueryBufferLen < *pu4QueryInfoLen) {
3756         return WLAN_STATUS_INVALID_LENGTH;
3757     }
3758
3759     prPmkid = (P_PARAM_PMKID_T)pvQueryBuffer;
3760
3761     prPmkid->u4Length = *pu4QueryInfoLen;
3762     prPmkid->u4BSSIDInfoCount = prAisSpecBssInfo->u4PmkidCacheCount;
3763
3764     for (i = 0; i < prAisSpecBssInfo->u4PmkidCacheCount; i++) {
3765         kalMemCopy(prPmkid->arBSSIDInfo[i].arBSSID,
3766             prAisSpecBssInfo->arPmkidCache[i].rBssidInfo.arBSSID,
3767             sizeof(PARAM_MAC_ADDRESS));
3768         kalMemCopy(prPmkid->arBSSIDInfo[i].arPMKID,
3769             prAisSpecBssInfo->arPmkidCache[i].rBssidInfo.arPMKID,
3770             sizeof(PARAM_PMKID_VALUE));
3771     }
3772
3773     return WLAN_STATUS_SUCCESS;
3774
3775 } /* wlanoidQueryPmkid */
3776
3777
3778 /*----------------------------------------------------------------------------*/
3779 /*!
3780 * \brief This routine is called to set the PMKID to the PMK cache in the driver.
3781 *
3782 * \param[in] prAdapter Pointer to the Adapter structure.
3783 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
3784 * \param[in] u4SetBufferLen The length of the set buffer.
3785 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
3786 *                           bytes read from the set buffer. If the call failed
3787 *                           due to invalid length of the set buffer, returns
3788 *                           the amount of storage needed.
3789 *
3790 * \retval WLAN_STATUS_SUCCESS
3791 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
3792 * \retval WLAN_STATUS_INVALID_DATA
3793 */
3794 /*----------------------------------------------------------------------------*/
3795 WLAN_STATUS
3796 wlanoidSetPmkid (
3797     IN  P_ADAPTER_T       prAdapter,
3798     IN  PVOID             pvSetBuffer,
3799     IN  UINT_32           u4SetBufferLen,
3800     OUT PUINT_32          pu4SetInfoLen
3801     )
3802 {
3803     UINT_32               i, j;
3804     P_PARAM_PMKID_T       prPmkid;
3805     P_AIS_SPECIFIC_BSS_INFO_T prAisSpecBssInfo;
3806
3807     DEBUGFUNC("wlanoidSetPmkid");
3808
3809     ASSERT(prAdapter);
3810     ASSERT(pu4SetInfoLen);
3811
3812     *pu4SetInfoLen = u4SetBufferLen;
3813
3814     /* It's possibble BSSIDInfoCount is zero, because OS wishes to clean PMKID */
3815     if (u4SetBufferLen < OFFSET_OF(PARAM_PMKID_T, arBSSIDInfo)) {
3816         return WLAN_STATUS_BUFFER_TOO_SHORT;
3817     }
3818
3819     ASSERT(pvSetBuffer);
3820     prPmkid = (P_PARAM_PMKID_T)pvSetBuffer;
3821
3822     if (u4SetBufferLen <
3823             ((prPmkid->u4BSSIDInfoCount * sizeof(PARAM_BSSID_INFO_T)) +
3824             OFFSET_OF(PARAM_PMKID_T, arBSSIDInfo))) {
3825         return WLAN_STATUS_INVALID_DATA;
3826     }
3827
3828     if (prPmkid->u4BSSIDInfoCount > CFG_MAX_PMKID_CACHE) {
3829         return WLAN_STATUS_INVALID_DATA;
3830     }
3831
3832     DBGLOG(REQ, INFO, ("Count %lu\n", prPmkid->u4BSSIDInfoCount));
3833
3834     prAisSpecBssInfo = &prAdapter->rWifiVar.rAisSpecificBssInfo;
3835
3836     /* This OID replace everything in the PMKID cache. */
3837     if (prPmkid->u4BSSIDInfoCount == 0) {
3838         prAisSpecBssInfo->u4PmkidCacheCount = 0;
3839         kalMemZero(prAisSpecBssInfo->arPmkidCache, sizeof(PMKID_ENTRY_T) * CFG_MAX_PMKID_CACHE);
3840     }
3841     if ((prAisSpecBssInfo->u4PmkidCacheCount + prPmkid->u4BSSIDInfoCount > CFG_MAX_PMKID_CACHE)) {
3842         prAisSpecBssInfo->u4PmkidCacheCount = 0;
3843         kalMemZero(prAisSpecBssInfo->arPmkidCache, sizeof(PMKID_ENTRY_T) * CFG_MAX_PMKID_CACHE);
3844     }
3845
3846     /*
3847     The driver can only clear its PMKID cache whenever it make a media disconnect
3848     indication. Otherwise, it must change the PMKID cache only when set through this OID.
3849     */
3850 #if CFG_RSN_MIGRATION
3851     for (i = 0; i < prPmkid->u4BSSIDInfoCount; i++) {
3852         /* Search for desired BSSID. If desired BSSID is found,
3853             then set the PMKID */
3854         if (!rsnSearchPmkidEntry(prAdapter,
3855                 (PUINT_8)prPmkid->arBSSIDInfo[i].arBSSID,
3856                 &j)) {
3857             /* No entry found for the specified BSSID, so add one entry */
3858             if (prAisSpecBssInfo->u4PmkidCacheCount < CFG_MAX_PMKID_CACHE - 1) {
3859                 j = prAisSpecBssInfo->u4PmkidCacheCount;
3860                 kalMemCopy(prAisSpecBssInfo->arPmkidCache[j].rBssidInfo.arBSSID,
3861                     prPmkid->arBSSIDInfo[i].arBSSID,
3862                     sizeof(PARAM_MAC_ADDRESS));
3863                 prAisSpecBssInfo->u4PmkidCacheCount++;
3864             }
3865             else {
3866                 j = CFG_MAX_PMKID_CACHE;
3867             }
3868         }
3869
3870         if (j < CFG_MAX_PMKID_CACHE) {
3871             kalMemCopy(prAisSpecBssInfo->arPmkidCache[j].rBssidInfo.arPMKID,
3872                 prPmkid->arBSSIDInfo[i].arPMKID,
3873                 sizeof(PARAM_PMKID_VALUE));
3874             DBGLOG(RSN, TRACE, ("Add BSSID "MACSTR" idx=%d PMKID value "MACSTR"\n",
3875                 MAC2STR(prAisSpecBssInfo->arPmkidCache[j].rBssidInfo.arBSSID),j,  MAC2STR(prAisSpecBssInfo->arPmkidCache[j].rBssidInfo.arPMKID)));
3876             prAisSpecBssInfo->arPmkidCache[j].fgPmkidExist = TRUE;
3877         }
3878     }
3879 #endif
3880     return WLAN_STATUS_SUCCESS;
3881
3882 } /* wlanoidSetPmkid */
3883
3884
3885 /*----------------------------------------------------------------------------*/
3886 /*!
3887 * \brief This routine is called to query the set of supported data rates that
3888 *          the radio is capable of running
3889 *
3890 * \param[in] prAdapter Pointer to the Adapter structure
3891 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
3892 *                           the query
3893 * \param[in] u4QueryBufferLen The length of the query buffer
3894 * \param[out] pu4QueryInfoLen If the call is successful, returns the number
3895 *                             of bytes written into the query buffer. If the
3896 *                             call failed due to invalid length of the query
3897 *                             buffer, returns the amount of storage needed.
3898 *
3899 * \retval WLAN_STATUS_SUCCESS
3900 * \retval WLAN_STATUS_INVALID_LENGTH
3901 */
3902 /*----------------------------------------------------------------------------*/
3903 WLAN_STATUS
3904 wlanoidQuerySupportedRates (
3905     IN  P_ADAPTER_T       prAdapter,
3906     OUT PVOID             pvQueryBuffer,
3907     IN  UINT_32           u4QueryBufferLen,
3908     OUT PUINT_32          pu4QueryInfoLen
3909     )
3910 {
3911     PARAM_RATES eRate = {
3912         // BSSBasicRateSet for 802.11n Non-HT rates
3913         0x8C, // 6M
3914         0x92, // 9M
3915         0x98, // 12M
3916         0xA4, // 18M
3917         0xB0, // 24M
3918         0xC8, // 36M
3919         0xE0, // 48M
3920         0xEC  // 54M
3921     };
3922
3923     DEBUGFUNC("wlanoidQuerySupportedRates");
3924
3925     ASSERT(prAdapter);
3926     ASSERT(pu4QueryInfoLen);
3927     if (u4QueryBufferLen) {
3928         ASSERT(pvQueryBuffer);
3929     }
3930
3931     *pu4QueryInfoLen = sizeof(PARAM_RATES_EX);
3932
3933     if (u4QueryBufferLen < *pu4QueryInfoLen ) {
3934         DBGLOG(REQ, WARN, ("Invalid length %ld\n", u4QueryBufferLen));
3935         return WLAN_STATUS_INVALID_LENGTH;
3936     }
3937
3938     kalMemCopy(pvQueryBuffer,
3939             (PVOID)&eRate,
3940             sizeof(PARAM_RATES));
3941
3942     return WLAN_STATUS_SUCCESS;
3943 } /* end of wlanoidQuerySupportedRates() */
3944
3945
3946 /*----------------------------------------------------------------------------*/
3947 /*!
3948 * \brief This routine is called to query current desired rates.
3949 *
3950 * \param[in] prAdapter          Pointer to the Adapter structure.
3951 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
3952 *                               the query.
3953 * \param[in] u4QueryBufferLen   The length of the query buffer.
3954 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
3955 *                               bytes written into the query buffer. If the call
3956 *                               failed due to invalid length of the query buffer,
3957 *                               returns the amount of storage needed.
3958 *
3959 * \retval WLAN_STATUS_SUCCESS
3960 * \retval WLAN_STATUS_INVALID_LENGTH
3961 */
3962 /*----------------------------------------------------------------------------*/
3963 WLAN_STATUS
3964 wlanoidQueryDesiredRates (
3965     IN  P_ADAPTER_T prAdapter,
3966     OUT PVOID       pvQueryBuffer,
3967     IN  UINT_32     u4QueryBufferLen,
3968     OUT PUINT_32    pu4QueryInfoLen
3969     )
3970 {
3971     DEBUGFUNC("wlanoidQueryDesiredRates");
3972
3973     ASSERT(prAdapter);
3974     ASSERT(pu4QueryInfoLen);
3975     if (u4QueryBufferLen) {
3976         ASSERT(pvQueryBuffer);
3977     }
3978
3979     *pu4QueryInfoLen = sizeof(PARAM_RATES_EX);
3980
3981     if (u4QueryBufferLen < *pu4QueryInfoLen ) {
3982         DBGLOG(REQ, WARN, ("Invalid length %ld\n", u4QueryBufferLen));
3983         return WLAN_STATUS_INVALID_LENGTH;
3984     }
3985
3986     kalMemCopy(pvQueryBuffer,
3987             (PVOID)&(prAdapter->rWlanInfo.eDesiredRates),
3988             sizeof(PARAM_RATES));
3989
3990     return WLAN_STATUS_SUCCESS;
3991
3992 } /* end of wlanoidQueryDesiredRates() */
3993
3994
3995 /*----------------------------------------------------------------------------*/
3996 /*!
3997 * \brief This routine is called to Set the desired rates.
3998 *
3999 * \param[in] prAdapter      Pointer to the Adapter structure.
4000 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
4001 * \param[in] u4SetBufferLen The length of the set buffer.
4002 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
4003 *                           bytes read from the set buffer. If the call failed
4004 *                           due to invalid length of the set buffer, returns
4005 *                           the amount of storage needed.
4006 *
4007 *
4008 * \retval WLAN_STATUS_SUCCESS
4009 * \retval WLAN_STATUS_INVALID_LENGTH
4010 * \retval WLAN_STATUS_INVALID_DATA
4011 * \retval WLAN_STATUS_ADAPTER_NOT_READY
4012 */
4013 /*----------------------------------------------------------------------------*/
4014 WLAN_STATUS
4015 wlanoidSetDesiredRates (
4016     IN  P_ADAPTER_T       prAdapter,
4017     IN  PVOID             pvSetBuffer,
4018     IN  UINT_32           u4SetBufferLen,
4019     OUT PUINT_32          pu4SetInfoLen
4020     )
4021 {
4022     UINT_32 i;
4023     DEBUGFUNC("wlanoidSetDesiredRates");
4024
4025     ASSERT(prAdapter);
4026     ASSERT(pvSetBuffer);
4027     ASSERT(pu4SetInfoLen);
4028
4029     if (u4SetBufferLen < sizeof(PARAM_RATES)) {
4030         DBGLOG(REQ, WARN, ("Invalid length %ld\n", u4SetBufferLen));
4031         return WLAN_STATUS_INVALID_LENGTH;
4032     }
4033
4034     *pu4SetInfoLen = sizeof(PARAM_RATES);
4035
4036     if (u4SetBufferLen < sizeof(PARAM_RATES)) {
4037         return WLAN_STATUS_INVALID_LENGTH;
4038     }
4039
4040     kalMemCopy((PVOID)&(prAdapter->rWlanInfo.eDesiredRates),
4041             pvSetBuffer,
4042             sizeof(PARAM_RATES));
4043
4044     prAdapter->rWlanInfo.eLinkAttr.ucDesiredRateLen = PARAM_MAX_LEN_RATES;
4045     for (i = 0 ; i < PARAM_MAX_LEN_RATES ; i++) {
4046         prAdapter->rWlanInfo.eLinkAttr.u2DesiredRate[i] =
4047             (UINT_16) (prAdapter->rWlanInfo.eDesiredRates[i]);
4048     }
4049
4050     return wlanSendSetQueryCmd(prAdapter,
4051             CMD_ID_LINK_ATTRIB,
4052             TRUE,
4053             FALSE,
4054             TRUE,
4055             nicCmdEventSetCommon,
4056             nicOidCmdTimeoutCommon,
4057             sizeof(CMD_LINK_ATTRIB),
4058             (PUINT_8)&(prAdapter->rWlanInfo.eLinkAttr),
4059             pvSetBuffer,
4060             u4SetBufferLen
4061             );
4062
4063 } /* end of wlanoidSetDesiredRates() */
4064
4065
4066 /*----------------------------------------------------------------------------*/
4067 /*!
4068 * \brief This routine is called to query the maximum frame size in bytes,
4069 *        not including the header.
4070 *
4071 * \param[in] prAdapter Pointer to the Adapter structure.
4072 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
4073 *                           the query.
4074 * \param[in] u4QueryBufferLen The length of the query buffer.
4075 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4076 *                               bytes written into the query buffer. If the
4077 *                               call failed due to invalid length of the query
4078 *                               buffer, returns the amount of storage needed.
4079 *
4080 * \retval WLAN_STATUS_SUCCESS
4081 * \retval WLAN_STATUS_INVALID_LENGTH
4082 */
4083 /*----------------------------------------------------------------------------*/
4084 WLAN_STATUS
4085 wlanoidQueryMaxFrameSize (
4086     IN  P_ADAPTER_T       prAdapter,
4087     OUT PVOID             pvQueryBuffer,
4088     IN  UINT_32           u4QueryBufferLen,
4089     OUT PUINT_32          pu4QueryInfoLen
4090     )
4091 {
4092     DEBUGFUNC("wlanoidQueryMaxFrameSize");
4093
4094
4095     ASSERT(prAdapter);
4096     ASSERT(pu4QueryInfoLen);
4097     if (u4QueryBufferLen) {
4098         ASSERT(pvQueryBuffer);
4099     }
4100
4101
4102     if (u4QueryBufferLen < sizeof(UINT_32)) {
4103         *pu4QueryInfoLen = sizeof(UINT_32);
4104         return WLAN_STATUS_INVALID_LENGTH;
4105     }
4106
4107     *(PUINT_32)pvQueryBuffer = ETHERNET_MAX_PKT_SZ - ETHERNET_HEADER_SZ;
4108     *pu4QueryInfoLen = sizeof(UINT_32);
4109
4110     return WLAN_STATUS_SUCCESS;
4111 } /* wlanoidQueryMaxFrameSize */
4112
4113
4114 /*----------------------------------------------------------------------------*/
4115 /*!
4116 * \brief This routine is called to query the maximum total packet length
4117 *        in bytes.
4118 *
4119 * \param[in] prAdapter Pointer to the Adapter structure.
4120 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
4121 *                           the query.
4122 * \param[in] u4QueryBufferLen The length of the query buffer.
4123 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4124 *                            bytes written into the query buffer. If the call
4125 *                            failed due to invalid length of the query buffer,
4126 *                            returns the amount of storage needed.
4127 *
4128 * \retval WLAN_STATUS_SUCCESS
4129 * \retval WLAN_STATUS_INVALID_LENGTH
4130 */
4131 /*----------------------------------------------------------------------------*/
4132 WLAN_STATUS
4133 wlanoidQueryMaxTotalSize (
4134     IN  P_ADAPTER_T       prAdapter,
4135     OUT PVOID             pvQueryBuffer,
4136     IN  UINT_32           u4QueryBufferLen,
4137     OUT PUINT_32          pu4QueryInfoLen
4138     )
4139 {
4140     DEBUGFUNC("wlanoidQueryMaxTotalSize");
4141
4142     ASSERT(prAdapter);
4143     ASSERT(pu4QueryInfoLen);
4144     if (u4QueryBufferLen) {
4145         ASSERT(pvQueryBuffer);
4146     }
4147
4148     if (u4QueryBufferLen < sizeof(UINT_32)) {
4149         *pu4QueryInfoLen = sizeof(UINT_32);
4150         return WLAN_STATUS_INVALID_LENGTH;
4151     }
4152
4153     *(PUINT_32)pvQueryBuffer = ETHERNET_MAX_PKT_SZ;
4154     *pu4QueryInfoLen = sizeof(UINT_32);
4155
4156     return WLAN_STATUS_SUCCESS;
4157 } /* wlanoidQueryMaxTotalSize */
4158
4159
4160 /*----------------------------------------------------------------------------*/
4161 /*!
4162 * \brief This routine is called to query the vendor ID of the NIC.
4163 *
4164 * \param[in] prAdapter Pointer to the Adapter structure.
4165 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
4166 *                           the query.
4167 * \param[in] u4QueryBufferLen The length of the query buffer.
4168 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4169 *                            bytes written into the query buffer. If the call
4170 *                            failed due to invalid length of the query buffer,
4171 *                            returns the amount of storage needed.
4172 *
4173 * \retval WLAN_STATUS_SUCCESS
4174 * \retval WLAN_STATUS_INVALID_LENGTH
4175 */
4176 /*----------------------------------------------------------------------------*/
4177 WLAN_STATUS
4178 wlanoidQueryVendorId (
4179     IN  P_ADAPTER_T       prAdapter,
4180     OUT PVOID             pvQueryBuffer,
4181     IN  UINT_32           u4QueryBufferLen,
4182     OUT PUINT_32          pu4QueryInfoLen
4183     )
4184 {
4185 #if DBG
4186     PUINT_8               cp;
4187 #endif
4188     DEBUGFUNC("wlanoidQueryVendorId");
4189
4190     ASSERT(prAdapter);
4191     ASSERT(pu4QueryInfoLen);
4192     if (u4QueryBufferLen) {
4193         ASSERT(pvQueryBuffer);
4194     }
4195
4196     if (u4QueryBufferLen < sizeof(UINT_32)) {
4197         *pu4QueryInfoLen = sizeof(UINT_32);
4198         return WLAN_STATUS_INVALID_LENGTH;
4199     }
4200
4201     kalMemCopy(pvQueryBuffer, prAdapter->aucMacAddress, 3);
4202     *((PUINT_8)pvQueryBuffer + 3) = 1;
4203     *pu4QueryInfoLen = sizeof(UINT_32);
4204
4205 #if DBG
4206     cp = (PUINT_8)pvQueryBuffer;
4207     DBGLOG(REQ, LOUD, ("Vendor ID=%02x-%02x-%02x-%02x\n", cp[0], cp[1], cp[2], cp[3]));
4208 #endif
4209
4210     return WLAN_STATUS_SUCCESS;
4211 } /* wlanoidQueryVendorId */
4212
4213
4214 /*----------------------------------------------------------------------------*/
4215 /*!
4216 * \brief This routine is called to query the current RSSI value.
4217 *
4218 * \param[in] prAdapter Pointer to the Adapter structure.
4219 * \param[in] pvQueryBuffer Pointer to the buffer that holds the result of the query.
4220 * \param[in] u4QueryBufferLen The length of the query buffer.
4221 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4222 *   bytes written into the query buffer. If the call failed due to invalid length of
4223 *   the query buffer, returns the amount of storage needed.
4224 *
4225 * \retval WLAN_STATUS_SUCCESS
4226 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
4227 * \retval WLAN_STATUS_ADAPTER_NOT_READY
4228 */
4229 /*----------------------------------------------------------------------------*/
4230 WLAN_STATUS
4231 wlanoidQueryRssi (
4232     IN  P_ADAPTER_T       prAdapter,
4233     OUT PVOID             pvQueryBuffer,
4234     IN  UINT_32           u4QueryBufferLen,
4235     OUT PUINT_32          pu4QueryInfoLen
4236     )
4237 {
4238     DEBUGFUNC("wlanoidQueryRssi");
4239
4240     ASSERT(prAdapter);
4241     ASSERT(pu4QueryInfoLen);
4242     if (u4QueryBufferLen) {
4243         ASSERT(pvQueryBuffer);
4244     }
4245
4246     *pu4QueryInfoLen = sizeof(PARAM_RSSI);
4247
4248     /* Check for query buffer length */
4249     if (u4QueryBufferLen < *pu4QueryInfoLen) {
4250         DBGLOG(REQ, WARN, ("Too short length %ld\n", u4QueryBufferLen));
4251         return WLAN_STATUS_BUFFER_TOO_SHORT;
4252     }
4253
4254     if (kalGetMediaStateIndicated(prAdapter->prGlueInfo) == PARAM_MEDIA_STATE_DISCONNECTED) {
4255         return WLAN_STATUS_ADAPTER_NOT_READY;
4256     }
4257     else if (prAdapter->fgIsLinkQualityValid == TRUE &&
4258             (kalGetTimeTick() - prAdapter->rLinkQualityUpdateTime) <= CFG_LINK_QUALITY_VALID_PERIOD) {
4259         PARAM_RSSI rRssi;
4260
4261         rRssi = (PARAM_RSSI)prAdapter->rLinkQuality.cRssi; // ranged from (-128 ~ 30) in unit of dBm
4262
4263         if(rRssi > PARAM_WHQL_RSSI_MAX_DBM)
4264             rRssi = PARAM_WHQL_RSSI_MAX_DBM;
4265         else if(rRssi < PARAM_WHQL_RSSI_MIN_DBM)
4266             rRssi = PARAM_WHQL_RSSI_MIN_DBM;
4267
4268         kalMemCopy(pvQueryBuffer, &rRssi, sizeof(PARAM_RSSI));
4269         return WLAN_STATUS_SUCCESS;
4270     }
4271
4272     #ifdef LINUX
4273     return wlanSendSetQueryCmd(prAdapter,
4274             CMD_ID_GET_LINK_QUALITY,
4275             FALSE,
4276             TRUE,
4277             TRUE,
4278             nicCmdEventQueryLinkQuality,
4279             nicOidCmdTimeoutCommon,
4280             *pu4QueryInfoLen,
4281             pvQueryBuffer,
4282             pvQueryBuffer,
4283             u4QueryBufferLen
4284             );
4285     #else
4286     return wlanSendSetQueryCmd(prAdapter,
4287             CMD_ID_GET_LINK_QUALITY,
4288             FALSE,
4289             TRUE,
4290             TRUE,
4291             nicCmdEventQueryLinkQuality,
4292             nicOidCmdTimeoutCommon,
4293             0,
4294             NULL,
4295             pvQueryBuffer,
4296             u4QueryBufferLen
4297             );
4298
4299     #endif
4300 } /* end of wlanoidQueryRssi() */
4301
4302
4303 /*----------------------------------------------------------------------------*/
4304 /*!
4305 * \brief This routine is called to query the current RSSI trigger value.
4306 *
4307 * \param[in] prAdapter Pointer to the Adapter structure.
4308 * \param[in] pvQueryBuffer Pointer to the buffer that holds the result of the query.
4309 * \param[in] u4QueryBufferLen The length of the query buffer.
4310 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4311 *   bytes written into the query buffer. If the call failed due to invalid length of
4312 *   the query buffer, returns the amount of storage needed.
4313 *
4314 * \retval WLAN_STATUS_SUCCESS
4315 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
4316 */
4317 /*----------------------------------------------------------------------------*/
4318 WLAN_STATUS
4319 wlanoidQueryRssiTrigger (
4320     IN  P_ADAPTER_T       prAdapter,
4321     OUT PVOID             pvQueryBuffer,
4322     IN  UINT_32           u4QueryBufferLen,
4323     OUT PUINT_32          pu4QueryInfoLen
4324     )
4325 {
4326     DEBUGFUNC("wlanoidQueryRssiTrigger");
4327
4328     ASSERT(prAdapter);
4329     ASSERT(pu4QueryInfoLen);
4330     if (u4QueryBufferLen) {
4331         ASSERT(pvQueryBuffer);
4332     }
4333
4334
4335     if(prAdapter->rWlanInfo.eRssiTriggerType == ENUM_RSSI_TRIGGER_NONE)
4336         return WLAN_STATUS_ADAPTER_NOT_READY;
4337
4338     *pu4QueryInfoLen = sizeof(PARAM_RSSI);
4339
4340     /* Check for query buffer length */
4341     if (u4QueryBufferLen < *pu4QueryInfoLen) {
4342         DBGLOG(REQ, WARN, ("Too short length %ld\n", u4QueryBufferLen));
4343         return WLAN_STATUS_BUFFER_TOO_SHORT;
4344     }
4345
4346     *(PARAM_RSSI *) pvQueryBuffer = prAdapter->rWlanInfo.rRssiTriggerValue;
4347     DBGLOG(REQ, INFO, ("RSSI trigger: %ld dBm\n", *(PARAM_RSSI *) pvQueryBuffer));
4348
4349     return WLAN_STATUS_SUCCESS;
4350 }   /* wlanoidQueryRssiTrigger */
4351
4352
4353 /*----------------------------------------------------------------------------*/
4354 /*!
4355 * \brief This routine is called to set a trigger value of the RSSI event.
4356 *
4357 * \param[in] prAdapter Pointer to the Adapter structure
4358 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
4359 * \param[in] u4SetBufferLen The length of the set buffer.
4360 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
4361 *                          bytes read from the set buffer. If the call failed
4362 *                          due to invalid length of the set buffer, returns the
4363 *                          amount of storage needed.
4364 *
4365 * \retval WLAN_STATUS_SUCCESS
4366 *
4367 */
4368 /*----------------------------------------------------------------------------*/
4369 WLAN_STATUS
4370 wlanoidSetRssiTrigger (
4371     IN  P_ADAPTER_T       prAdapter,
4372     IN  PVOID             pvSetBuffer,
4373     IN  UINT_32           u4SetBufferLen,
4374     OUT PUINT_32          pu4SetInfoLen
4375     )
4376 {
4377     PARAM_RSSI rRssiTriggerValue;
4378     DEBUGFUNC("wlanoidSetRssiTrigger");
4379
4380     ASSERT(prAdapter);
4381     ASSERT(pvSetBuffer);
4382     ASSERT(pu4SetInfoLen);
4383
4384
4385     *pu4SetInfoLen = sizeof(PARAM_RSSI);
4386     rRssiTriggerValue = *(PARAM_RSSI *) pvSetBuffer;
4387
4388     if(rRssiTriggerValue > PARAM_WHQL_RSSI_MAX_DBM
4389             || rRssiTriggerValue < PARAM_WHQL_RSSI_MIN_DBM)
4390         return
4391
4392     /* Save the RSSI trigger value to the Adapter structure */
4393     prAdapter->rWlanInfo.rRssiTriggerValue = rRssiTriggerValue;
4394
4395     /* If the RSSI trigger value is equal to the current RSSI value, the
4396      * indication triggers immediately. We need to indicate the protocol
4397      * that an RSSI status indication event triggers. */
4398     if (rRssiTriggerValue == (PARAM_RSSI)(prAdapter->rLinkQuality.cRssi)) {
4399         prAdapter->rWlanInfo.eRssiTriggerType = ENUM_RSSI_TRIGGER_TRIGGERED;
4400
4401         kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
4402                 WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
4403                 (PVOID) &prAdapter->rWlanInfo.rRssiTriggerValue, sizeof(PARAM_RSSI));
4404     }
4405     else if(rRssiTriggerValue < (PARAM_RSSI)(prAdapter->rLinkQuality.cRssi))
4406         prAdapter->rWlanInfo.eRssiTriggerType = ENUM_RSSI_TRIGGER_GREATER;
4407     else if(rRssiTriggerValue > (PARAM_RSSI)(prAdapter->rLinkQuality.cRssi))
4408         prAdapter->rWlanInfo.eRssiTriggerType = ENUM_RSSI_TRIGGER_LESS;
4409
4410     return WLAN_STATUS_SUCCESS;
4411 }   /* wlanoidSetRssiTrigger */
4412
4413
4414 /*----------------------------------------------------------------------------*/
4415 /*!
4416 * \brief This routine is called to set a suggested value for the number of
4417 *        bytes of received packet data that will be indicated to the protocol
4418 *        driver. We just accept the set and ignore this value.
4419 *
4420 * \param[in] prAdapter Pointer to the Adapter structure.
4421 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
4422 * \param[in] u4SetBufferLen The length of the set buffer.
4423 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
4424 *                          bytes read from the set buffer. If the call failed
4425 *                          due to invalid length of the set buffer, returns
4426 *                          the amount of storage needed.
4427 *
4428 * \retval WLAN_STATUS_SUCCESS
4429 * \retval WLAN_STATUS_INVALID_LENGTH
4430 */
4431 /*----------------------------------------------------------------------------*/
4432 WLAN_STATUS
4433 wlanoidSetCurrentLookahead (
4434     IN  P_ADAPTER_T       prAdapter,
4435     IN  PVOID             pvSetBuffer,
4436     IN  UINT_32           u4SetBufferLen,
4437     OUT PUINT_32          pu4SetInfoLen
4438     )
4439 {
4440     DEBUGFUNC("wlanoidSetCurrentLookahead");
4441
4442     ASSERT(prAdapter);
4443     ASSERT(pvSetBuffer);
4444     ASSERT(pu4SetInfoLen);
4445
4446     if (u4SetBufferLen < sizeof(UINT_32)) {
4447         *pu4SetInfoLen = sizeof(UINT_32);
4448         return WLAN_STATUS_INVALID_LENGTH;
4449     }
4450
4451     *pu4SetInfoLen = sizeof(UINT_32);
4452     return WLAN_STATUS_SUCCESS;
4453 } /* wlanoidSetCurrentLookahead */
4454
4455
4456 /*----------------------------------------------------------------------------*/
4457 /*!
4458 * \brief This routine is called to query the number of frames that the driver
4459 *        receives but does not indicate to the protocols due to errors.
4460 *
4461 * \param[in] pvAdapter Pointer to the Adapter structure.
4462 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
4463 *                           the query.
4464 * \param[in] u4QueryBufLen The length of the query buffer.
4465 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4466 *                            bytes written into the query buffer. If the call
4467 *                            failed due to invalid length of the query buffer,
4468 *                            returns the amount of storage needed.
4469 *
4470 * \retval WLAN_STATUS_SUCCESS
4471 * \retval WLAN_STATUS_INVALID_LENGTH
4472 * \retval WLAN_STATUS_ADAPTER_NOT_READY
4473 */
4474 /*----------------------------------------------------------------------------*/
4475 WLAN_STATUS
4476 wlanoidQueryRcvError (
4477     IN  P_ADAPTER_T         prAdapter,
4478     IN  PVOID               pvQueryBuffer,
4479     IN  UINT_32             u4QueryBufferLen,
4480     OUT PUINT_32            pu4QueryInfoLen
4481     )
4482 {
4483     DEBUGFUNC("wlanoidQueryRcvError");
4484     DBGLOG(REQ, LOUD, ("\n"));
4485
4486     ASSERT(prAdapter);
4487     if (u4QueryBufferLen) {
4488         ASSERT(pvQueryBuffer);
4489     }
4490     ASSERT(pu4QueryInfoLen);
4491
4492     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
4493         DBGLOG(REQ, WARN, ("Fail in query receive error! (Adapter not ready). ACPI=D%d, Radio=%d\n",
4494                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
4495         *pu4QueryInfoLen = sizeof(UINT_32);
4496         return WLAN_STATUS_ADAPTER_NOT_READY;
4497     }
4498     else if (u4QueryBufferLen < sizeof(UINT_32)
4499             || (u4QueryBufferLen > sizeof(UINT_32) && u4QueryBufferLen < sizeof(UINT_64))) {
4500         *pu4QueryInfoLen = sizeof(UINT_64);
4501         return WLAN_STATUS_INVALID_LENGTH;
4502     }
4503
4504 #if CFG_ENABLE_STATISTICS_BUFFERING
4505     if(IsBufferedStatisticsUsable(prAdapter) == TRUE) {
4506         // @FIXME, RX_ERROR_DROP_COUNT/RX_FIFO_FULL_DROP_COUNT is not calculated
4507         if(u4QueryBufferLen == sizeof(UINT_32)) {
4508             *pu4QueryInfoLen = sizeof(UINT_32);
4509             *(PUINT_32) pvQueryBuffer = (UINT_32) prAdapter->rStatStruct.rFCSErrorCount.QuadPart;
4510         }
4511         else {
4512             *pu4QueryInfoLen = sizeof(UINT_64);
4513             *(PUINT_64) pvQueryBuffer = (UINT_64) prAdapter->rStatStruct.rFCSErrorCount.QuadPart;
4514         }
4515
4516         return WLAN_STATUS_SUCCESS;
4517     }
4518     else
4519 #endif
4520     {
4521     return wlanSendSetQueryCmd(prAdapter,
4522             CMD_ID_GET_STATISTICS,
4523             FALSE,
4524             TRUE,
4525             TRUE,
4526             nicCmdEventQueryRecvError,
4527             nicOidCmdTimeoutCommon,
4528             0,
4529             NULL,
4530             pvQueryBuffer,
4531             u4QueryBufferLen
4532             );
4533     }
4534 } /* wlanoidQueryRcvError */
4535
4536
4537 /*----------------------------------------------------------------------------*/
4538 /*! \brief This routine is called to query the number of frames that the NIC
4539 *          cannot receive due to lack of NIC receive buffer space.
4540 *
4541 * \param[in] pvAdapter Pointer to the Adapter structure
4542 * \param[in] pvQueryBuf A pointer to the buffer that holds the result of the
4543 *                          query buffer
4544 * \param[in] u4QueryBufLen The length of the query buffer
4545 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4546 *                            bytes written into the query buffer. If the call
4547 *                            failed due to invalid length of the query buffer,
4548 *                            returns the amount of storage needed.
4549 *
4550 * \retval WLAN_STATUS_SUCCESS If success;
4551 * \retval WLAN_STATUS_INVALID_LENGTH
4552 * \retval WLAN_STATUS_ADAPTER_NOT_READY
4553 */
4554 /*----------------------------------------------------------------------------*/
4555 WLAN_STATUS
4556 wlanoidQueryRcvNoBuffer (
4557     IN  P_ADAPTER_T       prAdapter,
4558     IN  PVOID             pvQueryBuffer,
4559     IN  UINT_32           u4QueryBufferLen,
4560     OUT PUINT_32          pu4QueryInfoLen
4561     )
4562 {
4563     DEBUGFUNC("wlanoidQueryRcvNoBuffer");
4564     DBGLOG(REQ, LOUD, ("\n"));
4565
4566     ASSERT(prAdapter);
4567     if (u4QueryBufferLen) {
4568         ASSERT(pvQueryBuffer);
4569     }
4570     ASSERT(pu4QueryInfoLen);
4571
4572     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
4573         DBGLOG(REQ, WARN, ("Fail in query receive error! (Adapter not ready). ACPI=D%d, Radio=%d\n",
4574                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
4575         *pu4QueryInfoLen = sizeof(UINT_32);
4576         return WLAN_STATUS_ADAPTER_NOT_READY;
4577     }
4578     else if (u4QueryBufferLen < sizeof(UINT_32)
4579             || (u4QueryBufferLen > sizeof(UINT_32) && u4QueryBufferLen < sizeof(UINT_64))) {
4580         *pu4QueryInfoLen = sizeof(UINT_64);
4581         return WLAN_STATUS_INVALID_LENGTH;
4582     }
4583
4584 #if CFG_ENABLE_STATISTICS_BUFFERING
4585     if(IsBufferedStatisticsUsable(prAdapter) == TRUE) {
4586         if(u4QueryBufferLen == sizeof(UINT_32)) {
4587             *pu4QueryInfoLen = sizeof(UINT_32);
4588             *(PUINT_32) pvQueryBuffer = (UINT_32) 0; //@FIXME
4589         }
4590         else {
4591             *pu4QueryInfoLen = sizeof(UINT_64);
4592             *(PUINT_64) pvQueryBuffer = (UINT_64) 0; //@FIXME
4593         }
4594
4595         return WLAN_STATUS_SUCCESS;
4596     }
4597     else
4598 #endif
4599     {
4600     return wlanSendSetQueryCmd(prAdapter,
4601             CMD_ID_GET_STATISTICS,
4602             FALSE,
4603             TRUE,
4604             TRUE,
4605             nicCmdEventQueryRecvNoBuffer,
4606             nicOidCmdTimeoutCommon,
4607             0,
4608             NULL,
4609             pvQueryBuffer,
4610             u4QueryBufferLen
4611             );
4612     }
4613 }   /* wlanoidQueryRcvNoBuffer */
4614
4615
4616 /*----------------------------------------------------------------------------*/
4617 /*! \brief This routine is called to query the number of frames that the NIC
4618 *          received and it is CRC error.
4619 *
4620 * \param[in] pvAdapter Pointer to the Adapter structure
4621 * \param[in] pvQueryBuf A pointer to the buffer that holds the result of the
4622 *                          query buffer
4623 * \param[in] u4QueryBufLen The length of the query buffer
4624 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4625 *                            bytes written into the query buffer. If the call
4626 *                            failed due to invalid length of the query buffer,
4627 *                            returns the amount of storage needed.
4628 *
4629 * \retval WLAN_STATUS_SUCCESS If success;
4630 * \retval WLAN_STATUS_INVALID_LENGTH
4631 * \retval WLAN_STATUS_ADAPTER_NOT_READY
4632 */
4633 /*----------------------------------------------------------------------------*/
4634 WLAN_STATUS
4635 wlanoidQueryRcvCrcError (
4636     IN  P_ADAPTER_T       prAdapter,
4637     IN  PVOID             pvQueryBuffer,
4638     IN  UINT_32           u4QueryBufferLen,
4639     OUT PUINT_32          pu4QueryInfoLen
4640     )
4641 {
4642     DEBUGFUNC("wlanoidQueryRcvCrcError");
4643     DBGLOG(REQ, LOUD, ("\n"));
4644
4645     ASSERT(prAdapter);
4646     if (u4QueryBufferLen) {
4647         ASSERT(pvQueryBuffer);
4648     }
4649     ASSERT(pu4QueryInfoLen);
4650
4651     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
4652         DBGLOG(REQ, WARN, ("Fail in query receive error! (Adapter not ready). ACPI=D%d, Radio=%d\n",
4653                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
4654         *pu4QueryInfoLen = sizeof(UINT_32);
4655         return WLAN_STATUS_ADAPTER_NOT_READY;
4656     }
4657     else if (u4QueryBufferLen < sizeof(UINT_32)
4658             || (u4QueryBufferLen > sizeof(UINT_32) && u4QueryBufferLen < sizeof(UINT_64))) {
4659         *pu4QueryInfoLen = sizeof(UINT_64);
4660         return WLAN_STATUS_INVALID_LENGTH;
4661     }
4662 #if CFG_ENABLE_STATISTICS_BUFFERING
4663     if(IsBufferedStatisticsUsable(prAdapter) == TRUE) {
4664         if(u4QueryBufferLen == sizeof(UINT_32)) {
4665             *pu4QueryInfoLen = sizeof(UINT_32);
4666             *(PUINT_32) pvQueryBuffer = (UINT_32) prAdapter->rStatStruct.rFCSErrorCount.QuadPart;
4667         }
4668         else {
4669             *pu4QueryInfoLen = sizeof(UINT_64);
4670             *(PUINT_64) pvQueryBuffer = (UINT_64) prAdapter->rStatStruct.rFCSErrorCount.QuadPart;
4671         }
4672
4673         return WLAN_STATUS_SUCCESS;
4674     }
4675     else
4676 #endif
4677     {
4678     return wlanSendSetQueryCmd(prAdapter,
4679             CMD_ID_GET_STATISTICS,
4680             FALSE,
4681             TRUE,
4682             TRUE,
4683             nicCmdEventQueryRecvCrcError,
4684             nicOidCmdTimeoutCommon,
4685             0,
4686             NULL,
4687             pvQueryBuffer,
4688             u4QueryBufferLen
4689             );
4690     }
4691 }   /* wlanoidQueryRcvCrcError */
4692
4693
4694 /*----------------------------------------------------------------------------*/
4695 /*! \brief  This routine is called to query the current 802.11 statistics.
4696 *
4697 * \param[in] pvAdapter Pointer to the Adapter structure
4698 * \param[in] pvQueryBuf A pointer to the buffer that holds the result of the
4699 *                          query buffer
4700 * \param[in] u4QueryBufLen The length of the query buffer
4701 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4702 *                            bytes written into the query buffer. If the call
4703 *                            failed due to invalid length of the query buffer,
4704 *                            returns the amount of storage needed.
4705 *
4706 * \retval WLAN_STATUS_SUCCESS
4707 * \retval WLAN_STATUS_INVALID_LENGTH
4708 */
4709 /*----------------------------------------------------------------------------*/
4710 WLAN_STATUS
4711 wlanoidQueryStatistics (
4712     IN  P_ADAPTER_T       prAdapter,
4713     IN  PVOID             pvQueryBuffer,
4714     IN  UINT_32           u4QueryBufferLen,
4715     OUT PUINT_32          pu4QueryInfoLen
4716     )
4717 {
4718     DEBUGFUNC("wlanoidQueryStatistics");
4719     DBGLOG(REQ, LOUD, ("\n"));
4720
4721     ASSERT(prAdapter);
4722     if (u4QueryBufferLen) {
4723         ASSERT(pvQueryBuffer);
4724     }
4725     ASSERT(pu4QueryInfoLen);
4726
4727     *pu4QueryInfoLen = sizeof(PARAM_802_11_STATISTICS_STRUCT_T);
4728
4729     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
4730         DBGLOG(REQ, WARN, ("Fail in query receive error! (Adapter not ready). ACPI=D%d, Radio=%d\n",
4731                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
4732         *pu4QueryInfoLen = sizeof(UINT_32);
4733         return WLAN_STATUS_ADAPTER_NOT_READY;
4734     }
4735     else if (u4QueryBufferLen < sizeof(PARAM_802_11_STATISTICS_STRUCT_T)) {
4736         DBGLOG(REQ, WARN, ("Too short length %ld\n", u4QueryBufferLen));
4737         return WLAN_STATUS_INVALID_LENGTH;
4738     }
4739
4740 #if CFG_ENABLE_STATISTICS_BUFFERING
4741     if(IsBufferedStatisticsUsable(prAdapter) == TRUE) {
4742         P_PARAM_802_11_STATISTICS_STRUCT_T prStatistics;
4743
4744         *pu4QueryInfoLen = sizeof(PARAM_802_11_STATISTICS_STRUCT_T);
4745         prStatistics = (P_PARAM_802_11_STATISTICS_STRUCT_T) pvQueryBuffer;
4746
4747         prStatistics->u4Length = sizeof(PARAM_802_11_STATISTICS_STRUCT_T);
4748         prStatistics->rTransmittedFragmentCount
4749             = prAdapter->rStatStruct.rTransmittedFragmentCount;
4750         prStatistics->rMulticastTransmittedFrameCount
4751             = prAdapter->rStatStruct.rMulticastTransmittedFrameCount;
4752         prStatistics->rFailedCount
4753             = prAdapter->rStatStruct.rFailedCount;
4754         prStatistics->rRetryCount
4755             = prAdapter->rStatStruct.rRetryCount;
4756         prStatistics->rMultipleRetryCount
4757             = prAdapter->rStatStruct.rMultipleRetryCount;
4758         prStatistics->rRTSSuccessCount
4759             = prAdapter->rStatStruct.rRTSSuccessCount;
4760         prStatistics->rRTSFailureCount
4761             = prAdapter->rStatStruct.rRTSFailureCount;
4762         prStatistics->rACKFailureCount
4763             = prAdapter->rStatStruct.rACKFailureCount;
4764         prStatistics->rFrameDuplicateCount
4765             = prAdapter->rStatStruct.rFrameDuplicateCount;
4766         prStatistics->rReceivedFragmentCount
4767             = prAdapter->rStatStruct.rReceivedFragmentCount;
4768         prStatistics->rMulticastReceivedFrameCount
4769             = prAdapter->rStatStruct.rMulticastReceivedFrameCount;
4770         prStatistics->rFCSErrorCount
4771             = prAdapter->rStatStruct.rFCSErrorCount;
4772         prStatistics->rTKIPLocalMICFailures.QuadPart
4773             = 0;
4774         prStatistics->rTKIPICVErrors.QuadPart
4775             = 0;
4776         prStatistics->rTKIPCounterMeasuresInvoked.QuadPart
4777             = 0;
4778         prStatistics->rTKIPReplays.QuadPart
4779             = 0;
4780         prStatistics->rCCMPFormatErrors.QuadPart
4781             = 0;
4782         prStatistics->rCCMPReplays.QuadPart
4783             = 0;
4784         prStatistics->rCCMPDecryptErrors.QuadPart
4785             = 0;
4786         prStatistics->rFourWayHandshakeFailures.QuadPart
4787             = 0;
4788         prStatistics->rWEPUndecryptableCount.QuadPart
4789             = 0;
4790         prStatistics->rWEPICVErrorCount.QuadPart
4791             = 0;
4792         prStatistics->rDecryptSuccessCount.QuadPart
4793             = 0;
4794         prStatistics->rDecryptFailureCount.QuadPart
4795             = 0;
4796
4797         return WLAN_STATUS_SUCCESS;
4798     }
4799     else
4800 #endif
4801     {
4802     return wlanSendSetQueryCmd(prAdapter,
4803             CMD_ID_GET_STATISTICS,
4804             FALSE,
4805             TRUE,
4806             TRUE,
4807             nicCmdEventQueryStatistics,
4808             nicOidCmdTimeoutCommon,
4809             0,
4810             NULL,
4811             pvQueryBuffer,
4812             u4QueryBufferLen
4813             );
4814     }
4815 }   /* wlanoidQueryStatistics */
4816
4817
4818 /*----------------------------------------------------------------------------*/
4819 /*! \brief  This routine is called to query current media streaming status.
4820 *
4821 * \param[in] pvAdapter Pointer to the Adapter structure
4822 * \param[in] pvQueryBuf A pointer to the buffer that holds the result of the
4823 *                          query buffer
4824 * \param[in] u4QueryBufLen The length of the query buffer
4825 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4826 *                            bytes written into the query buffer. If the call
4827 *                            failed due to invalid length of the query buffer,
4828 *                            returns the amount of storage needed.
4829 *
4830 * \retval WLAN_STATUS_SUCCESS
4831 */
4832 /*----------------------------------------------------------------------------*/
4833 WLAN_STATUS
4834 wlanoidQueryMediaStreamMode(
4835     IN  P_ADAPTER_T     prAdapter,
4836     IN  PVOID           pvQueryBuffer,
4837     IN  UINT_32         u4QueryBufferLen,
4838     OUT PUINT_32        pu4QueryInfoLen
4839     )
4840 {
4841     DEBUGFUNC("wlanoidQueryMediaStreamMode");
4842
4843     ASSERT(prAdapter);
4844     ASSERT(pu4QueryInfoLen);
4845     if (u4QueryBufferLen) {
4846         ASSERT(pvQueryBuffer);
4847     }
4848
4849     *pu4QueryInfoLen = sizeof(ENUM_MEDIA_STREAM_MODE);
4850
4851     if (u4QueryBufferLen < *pu4QueryInfoLen ) {
4852         DBGLOG(REQ, WARN, ("Invalid length %ld\n", u4QueryBufferLen));
4853         return WLAN_STATUS_INVALID_LENGTH;
4854     }
4855
4856     *(P_ENUM_MEDIA_STREAM_MODE)pvQueryBuffer =
4857         prAdapter->rWlanInfo.eLinkAttr.ucMediaStreamMode == 0 ?
4858         ENUM_MEDIA_STREAM_OFF : ENUM_MEDIA_STREAM_ON;
4859
4860     return WLAN_STATUS_SUCCESS;
4861
4862 }   /* wlanoidQueryMediaStreamMode */
4863
4864 /*----------------------------------------------------------------------------*/
4865 /*! \brief  This routine is called to enter media streaming mode or exit media streaming mode
4866 *
4867 * \param[in] pvAdapter Pointer to the Adapter structure
4868 * \param[in] pvQueryBuf A pointer to the buffer that holds the result of the
4869 *                          query buffer
4870 * \param[in] u4QueryBufLen The length of the query buffer
4871 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4872 *                            bytes written into the query buffer. If the call
4873 *                            failed due to invalid length of the query buffer,
4874 *                            returns the amount of storage needed.
4875 *
4876 * \retval WLAN_STATUS_SUCCESS
4877 */
4878 /*----------------------------------------------------------------------------*/
4879 WLAN_STATUS
4880 wlanoidSetMediaStreamMode(
4881     IN  P_ADAPTER_T prAdapter,
4882     IN  PVOID       pvSetBuffer,
4883     IN  UINT_32     u4SetBufferLen,
4884     OUT PUINT_32    pu4SetInfoLen
4885     )
4886 {
4887     ENUM_MEDIA_STREAM_MODE eStreamMode;
4888
4889     DEBUGFUNC("wlanoidSetMediaStreamMode");
4890
4891     ASSERT(prAdapter);
4892     ASSERT(pvSetBuffer);
4893     ASSERT(pu4SetInfoLen);
4894
4895     if (u4SetBufferLen < sizeof(ENUM_MEDIA_STREAM_MODE)) {
4896         DBGLOG(REQ, WARN, ("Invalid length %ld\n", u4SetBufferLen));
4897         return WLAN_STATUS_INVALID_LENGTH;
4898     }
4899
4900     *pu4SetInfoLen = sizeof(ENUM_MEDIA_STREAM_MODE);
4901
4902     eStreamMode = *(P_ENUM_MEDIA_STREAM_MODE)pvSetBuffer;
4903
4904     if(eStreamMode == ENUM_MEDIA_STREAM_OFF)
4905         prAdapter->rWlanInfo.eLinkAttr.ucMediaStreamMode = 0;
4906     else
4907         prAdapter->rWlanInfo.eLinkAttr.ucMediaStreamMode = 1;
4908
4909     return wlanSendSetQueryCmd(prAdapter,
4910             CMD_ID_LINK_ATTRIB,
4911             TRUE,
4912             FALSE,
4913             TRUE,
4914             nicCmdEventSetMediaStreamMode,
4915             nicOidCmdTimeoutCommon,
4916             sizeof(CMD_LINK_ATTRIB),
4917             (PUINT_8)&(prAdapter->rWlanInfo.eLinkAttr),
4918             pvSetBuffer,
4919             u4SetBufferLen
4920             );
4921 }   /* wlanoidSetMediaStreamMode */
4922
4923 /*----------------------------------------------------------------------------*/
4924 /*! \brief  This routine is called to query the permanent MAC address of the NIC.
4925 *
4926 * \param[in] pvAdapter Pointer to the Adapter structure
4927 * \param[in] pvQueryBuf A pointer to the buffer that holds the result of the
4928 *                          query buffer
4929 * \param[in] u4QueryBufLen The length of the query buffer
4930 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4931 *                            bytes written into the query buffer. If the call
4932 *                            failed due to invalid length of the query buffer,
4933 *                            returns the amount of storage needed.
4934 *
4935 * \retval WLAN_STATUS_SUCCESS
4936 */
4937 /*----------------------------------------------------------------------------*/
4938 WLAN_STATUS
4939 wlanoidQueryPermanentAddr (
4940     IN P_ADAPTER_T  prAdapter,
4941     IN  PVOID    pvQueryBuffer,
4942     IN  UINT_32  u4QueryBufferLen,
4943     OUT PUINT_32 pu4QueryInfoLen
4944     )
4945 {
4946     DEBUGFUNC("wlanoidQueryPermanentAddr");
4947     DBGLOG(INIT, LOUD, ("\n"));
4948
4949     ASSERT(prAdapter);
4950     ASSERT(pu4QueryInfoLen);
4951     if (u4QueryBufferLen) {
4952         ASSERT(pvQueryBuffer);
4953     }
4954
4955     if (u4QueryBufferLen < MAC_ADDR_LEN) {
4956         return WLAN_STATUS_BUFFER_TOO_SHORT;
4957     }
4958
4959     COPY_MAC_ADDR(pvQueryBuffer, prAdapter->rWifiVar.aucPermanentAddress);
4960     *pu4QueryInfoLen = MAC_ADDR_LEN;
4961
4962     return WLAN_STATUS_SUCCESS;
4963 }   /* wlanoidQueryPermanentAddr */
4964
4965
4966 /*----------------------------------------------------------------------------*/
4967 /*! \brief  This routine is called to query the MAC address the NIC is currently using.
4968 *
4969 * \param[in] pvAdapter Pointer to the Adapter structure
4970 * \param[in] pvQueryBuf A pointer to the buffer that holds the result of the
4971 *                          query buffer
4972 * \param[in] u4QueryBufLen The length of the query buffer
4973 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
4974 *                            bytes written into the query buffer. If the call
4975 *                            failed due to invalid length of the query buffer,
4976 *                            returns the amount of storage needed.
4977 *
4978 * \retval WLAN_STATUS_SUCCESS
4979 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
4980 */
4981 /*----------------------------------------------------------------------------*/
4982 WLAN_STATUS
4983 wlanoidQueryCurrentAddr (
4984     IN P_ADAPTER_T  prAdapter,
4985     IN  PVOID    pvQueryBuffer,
4986     IN  UINT_32  u4QueryBufferLen,
4987     OUT PUINT_32 pu4QueryInfoLen
4988     )
4989 {
4990     CMD_BASIC_CONFIG rCmdBasicConfig;
4991
4992     DEBUGFUNC("wlanoidQueryCurrentAddr");
4993     DBGLOG(INIT, LOUD, ("\n"));
4994
4995     ASSERT(prAdapter);
4996     ASSERT(pu4QueryInfoLen);
4997     if (u4QueryBufferLen) {
4998         ASSERT(pvQueryBuffer);
4999     }
5000
5001     if (u4QueryBufferLen < MAC_ADDR_LEN) {
5002         return WLAN_STATUS_BUFFER_TOO_SHORT;
5003     }
5004
5005     kalMemZero(&rCmdBasicConfig, sizeof(CMD_BASIC_CONFIG));
5006
5007     return wlanSendSetQueryCmd(prAdapter,
5008             CMD_ID_BASIC_CONFIG,
5009             FALSE,
5010             TRUE,
5011             TRUE,
5012             nicCmdEventQueryAddress,
5013             nicOidCmdTimeoutCommon,
5014             sizeof(CMD_BASIC_CONFIG),
5015             (PUINT_8)&rCmdBasicConfig,
5016             pvQueryBuffer,
5017             u4QueryBufferLen
5018             );
5019
5020 }   /* wlanoidQueryCurrentAddr */
5021
5022
5023 /*----------------------------------------------------------------------------*/
5024 /*! \brief  This routine is called to query NIC link speed.
5025 *
5026 * \param[in] pvAdapter Pointer to the Adapter structure
5027 * \param[in] pvQueryBuf A pointer to the buffer that holds the result of the
5028 *                          query buffer
5029 * \param[in] u4QueryBufLen The length of the query buffer
5030 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
5031 *                            bytes written into the query buffer. If the call
5032 *                            failed due to invalid length of the query buffer,
5033 *                            returns the amount of storage needed.
5034 *
5035 * \retval WLAN_STATUS_SUCCESS
5036 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
5037 *
5038 */
5039 /*----------------------------------------------------------------------------*/
5040 WLAN_STATUS
5041 wlanoidQueryLinkSpeed(
5042     IN P_ADAPTER_T  prAdapter,
5043     IN  PVOID    pvQueryBuffer,
5044     IN  UINT_32  u4QueryBufferLen,
5045     OUT PUINT_32 pu4QueryInfoLen
5046     )
5047 {
5048     DEBUGFUNC("wlanoidQueryLinkSpeed");
5049
5050
5051     ASSERT(prAdapter);
5052     ASSERT(pu4QueryInfoLen);
5053     if (u4QueryBufferLen) {
5054         ASSERT(pvQueryBuffer);
5055     }
5056
5057     *pu4QueryInfoLen = sizeof(UINT_32);
5058
5059     if (u4QueryBufferLen < sizeof(UINT_32)) {
5060         return WLAN_STATUS_BUFFER_TOO_SHORT;
5061     }
5062
5063     if (kalGetMediaStateIndicated(prAdapter->prGlueInfo) != PARAM_MEDIA_STATE_CONNECTED) {
5064         *(PUINT_32)pvQueryBuffer = 10000; // change to unit of 100bps
5065         return WLAN_STATUS_SUCCESS;
5066     }
5067     else if (prAdapter->fgIsLinkRateValid == TRUE &&
5068             (kalGetTimeTick() - prAdapter->rLinkRateUpdateTime) <= CFG_LINK_QUALITY_VALID_PERIOD) {
5069         *(PUINT_32)pvQueryBuffer = prAdapter->rLinkQuality.u2LinkSpeed * 5000; // change to unit of 100bps
5070         return WLAN_STATUS_SUCCESS;
5071     }
5072     else {
5073         return wlanSendSetQueryCmd(prAdapter,
5074                 CMD_ID_GET_LINK_QUALITY,
5075                 FALSE,
5076                 TRUE,
5077                 TRUE,
5078                 nicCmdEventQueryLinkSpeed,
5079                 nicOidCmdTimeoutCommon,
5080                 0,
5081                 NULL,
5082                 pvQueryBuffer,
5083                 u4QueryBufferLen
5084                 );
5085     }
5086 } /* end of wlanoidQueryLinkSpeed() */
5087
5088
5089 /*----------------------------------------------------------------------------*/
5090 /*!
5091 * \brief This routine is called to query MCR value.
5092 *
5093 * \param[in] pvAdapter Pointer to the Adapter structure.
5094 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
5095 *                           the query.
5096 * \param[in] u4QueryBufLen The length of the query buffer.
5097 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
5098 *                            bytes written into the query buffer. If the call
5099 *                            failed due to invalid length of the query buffer,
5100 *                            returns the amount of storage needed.
5101 *
5102 * \retval WLAN_STATUS_SUCCESS
5103 * \retval WLAN_STATUS_INVALID_LENGTH
5104 */
5105 /*----------------------------------------------------------------------------*/
5106 WLAN_STATUS
5107 wlanoidQueryMcrRead (
5108     IN P_ADAPTER_T  prAdapter,
5109     IN PVOID        pvQueryBuffer,
5110     IN UINT_32      u4QueryBufferLen,
5111     OUT PUINT_32    pu4QueryInfoLen
5112     )
5113 {
5114     P_PARAM_CUSTOM_MCR_RW_STRUC_T prMcrRdInfo;
5115     CMD_ACCESS_REG rCmdAccessReg;
5116
5117     DEBUGFUNC("wlanoidQueryMcrRead");
5118     DBGLOG(INIT, LOUD,("\n"));
5119
5120     ASSERT(prAdapter);
5121     ASSERT(pu4QueryInfoLen);
5122     if (u4QueryBufferLen) {
5123         ASSERT(pvQueryBuffer);
5124     }
5125
5126     *pu4QueryInfoLen = sizeof(PARAM_CUSTOM_MCR_RW_STRUC_T);
5127
5128     if (u4QueryBufferLen < sizeof(PARAM_CUSTOM_MCR_RW_STRUC_T)) {
5129         return WLAN_STATUS_INVALID_LENGTH;
5130     }
5131
5132     prMcrRdInfo = (P_PARAM_CUSTOM_MCR_RW_STRUC_T)pvQueryBuffer;
5133
5134     /* 0x9000 - 0x9EFF reserved for FW */
5135 #if CFG_SUPPORT_SWCR
5136     if((prMcrRdInfo->u4McrOffset >>16) == 0x9F00) {
5137            swCrReadWriteCmd(prAdapter,
5138                     SWCR_READ,
5139                     (UINT_16) (prMcrRdInfo->u4McrOffset & BITS(0,15)),
5140                     &prMcrRdInfo->u4McrData);
5141             return WLAN_STATUS_SUCCESS;
5142     }
5143 #endif /* CFG_SUPPORT_SWCR */
5144
5145     /* Check if access F/W Domain MCR (due to WiFiSYS is placed from 0x6000-0000*/
5146     if (prMcrRdInfo->u4McrOffset & 0xFFFF0000){
5147         // fill command
5148         rCmdAccessReg.u4Address = prMcrRdInfo->u4McrOffset;
5149         rCmdAccessReg.u4Data = 0;
5150
5151         return wlanSendSetQueryCmd(prAdapter,
5152                 CMD_ID_ACCESS_REG,
5153                 FALSE,
5154                 TRUE,
5155                 TRUE,
5156                 nicCmdEventQueryMcrRead,
5157                 nicOidCmdTimeoutCommon,
5158                 sizeof(CMD_ACCESS_REG),
5159                 (PUINT_8)&rCmdAccessReg,
5160                 pvQueryBuffer,
5161                 u4QueryBufferLen
5162                 );
5163     }
5164     else {
5165         HAL_MCR_RD(prAdapter,
5166                prMcrRdInfo->u4McrOffset & BITS(2,31), //address is in DWORD unit
5167                &prMcrRdInfo->u4McrData);
5168
5169         DBGLOG(INIT, TRACE, ("MCR Read: Offset = %#08lx, Data = %#08lx\n",
5170                     prMcrRdInfo->u4McrOffset, prMcrRdInfo->u4McrData));
5171         return WLAN_STATUS_SUCCESS;
5172     }
5173 } /* end of wlanoidQueryMcrRead() */
5174
5175
5176 /*----------------------------------------------------------------------------*/
5177 /*!
5178 * \brief This routine is called to write MCR and enable specific function.
5179 *
5180 * \param[in] prAdapter Pointer to the Adapter structure.
5181 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
5182 * \param[in] u4SetBufferLen The length of the set buffer.
5183 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
5184 *                           bytes read from the set buffer. If the call failed
5185 *                           due to invalid length of the set buffer, returns
5186 *                           the amount of storage needed.
5187 *
5188 * \retval WLAN_STATUS_SUCCESS
5189 * \retval WLAN_STATUS_INVALID_LENGTH
5190 */
5191 /*----------------------------------------------------------------------------*/
5192 WLAN_STATUS
5193 wlanoidSetMcrWrite (
5194     IN P_ADAPTER_T  prAdapter,
5195     IN  PVOID    pvSetBuffer,
5196     IN  UINT_32  u4SetBufferLen,
5197     OUT PUINT_32 pu4SetInfoLen
5198     )
5199 {
5200     P_PARAM_CUSTOM_MCR_RW_STRUC_T prMcrWrInfo;
5201     CMD_ACCESS_REG rCmdAccessReg;
5202
5203 #if CFG_STRESS_TEST_SUPPORT
5204     P_AIS_FSM_INFO_T prAisFsmInfo;
5205     P_BSS_INFO_T prBssInfo = &(prAdapter->rWifiVar.arBssInfo[(NETWORK_TYPE_AIS_INDEX)]);
5206     P_STA_RECORD_T prStaRec = prBssInfo->prStaRecOfAP;
5207     UINT_32 u4McrOffset, u4McrData;
5208 #endif
5209
5210     DEBUGFUNC("wlanoidSetMcrWrite");
5211     DBGLOG(INIT, LOUD,("\n"));
5212
5213     ASSERT(prAdapter);
5214     ASSERT(pu4SetInfoLen);
5215
5216     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_MCR_RW_STRUC_T);
5217
5218     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_MCR_RW_STRUC_T)) {
5219         return WLAN_STATUS_INVALID_LENGTH;
5220     }
5221
5222     ASSERT(pvSetBuffer);
5223
5224     prMcrWrInfo = (P_PARAM_CUSTOM_MCR_RW_STRUC_T)pvSetBuffer;
5225
5226     /* 0x9000 - 0x9EFF reserved for FW */
5227     /* 0xFFFE          reserved for FW */
5228
5229     // -- Puff Stress Test Begin
5230 #if CFG_STRESS_TEST_SUPPORT
5231
5232     // 0xFFFFFFFE for Control Rate
5233     if (prMcrWrInfo->u4McrOffset == 0xFFFFFFFE){
5234         if(prMcrWrInfo->u4McrData < FIXED_RATE_NUM && prMcrWrInfo->u4McrData > 0){
5235             prAdapter->rWifiVar.eRateSetting = (ENUM_REGISTRY_FIXED_RATE_T)(prMcrWrInfo->u4McrData);
5236         }
5237         cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
5238         cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_3);
5239         DEBUGFUNC("[Stress Test]Complete Rate is Changed...\n");
5240         DBGLOG(INIT, TRACE, ("[Stress Test] Rate is Changed to index %d...\n", prAdapter->rWifiVar.eRateSetting));
5241     }
5242
5243     // 0xFFFFFFFD for Switch Channel
5244     else if (prMcrWrInfo->u4McrOffset == 0xFFFFFFFD){
5245         if(prMcrWrInfo->u4McrData <= 11 && prMcrWrInfo->u4McrData >= 1){
5246             prBssInfo->ucPrimaryChannel = prMcrWrInfo->u4McrData;
5247         }
5248         nicUpdateBss(prAdapter, prBssInfo->ucNetTypeIndex);
5249         DBGLOG(INIT, TRACE, ("[Stress Test] Channel is switched to %d ...\n", prBssInfo->ucPrimaryChannel));
5250
5251         return WLAN_STATUS_SUCCESS;
5252     }
5253
5254     // 0xFFFFFFFFC for Control RF Band and SCO
5255     else if(prMcrWrInfo->u4McrOffset == 0xFFFFFFFC){
5256         // Band
5257         if(prMcrWrInfo->u4McrData & 0x80000000){
5258             //prBssInfo->eBand = BAND_5G;
5259             //prBssInfo->ucPrimaryChannel = 52;  // Bond to Channel 52
5260         } else {
5261             prBssInfo->eBand = BAND_2G4;
5262             prBssInfo->ucPrimaryChannel = 8;   // Bond to Channel 6
5263         }
5264
5265         // Bandwidth
5266         if(prMcrWrInfo->u4McrData & 0x00010000){
5267             prStaRec->u2HtCapInfo |= HT_CAP_INFO_SUP_CHNL_WIDTH;
5268             prStaRec->ucDesiredPhyTypeSet = PHY_TYPE_BIT_HT;
5269
5270             if(prMcrWrInfo->u4McrData == 0x00010002){
5271                 prBssInfo->eBssSCO = CHNL_EXT_SCB; // U20
5272                 prBssInfo->ucPrimaryChannel += 2;
5273             } else if (prMcrWrInfo->u4McrData == 0x00010001){
5274                 prBssInfo->eBssSCO = CHNL_EXT_SCA; // L20
5275                 prBssInfo->ucPrimaryChannel -= 2;
5276             } else {
5277                 prBssInfo->eBssSCO = CHNL_EXT_SCA; // 40
5278             }
5279         }
5280
5281         if(prMcrWrInfo->u4McrData & 0x00000000){
5282             prStaRec->u2HtCapInfo &= ~HT_CAP_INFO_SUP_CHNL_WIDTH;
5283             prBssInfo->eBssSCO = CHNL_EXT_SCN;
5284         }
5285         rlmBssInitForAPandIbss(prAdapter, prBssInfo);
5286     }
5287
5288     // 0xFFFFFFFB for HT Capability
5289     else if (prMcrWrInfo->u4McrOffset == 0xFFFFFFFB){
5290         /* Enable HT Capability */
5291         if(prMcrWrInfo->u4McrData & 0x00000001){
5292             prStaRec->u2HtCapInfo |= HT_CAP_INFO_HT_GF;
5293             DEBUGFUNC("[Stress Test]Enable HT capability...\n");
5294         }else{
5295             prStaRec->u2HtCapInfo &= (~HT_CAP_INFO_HT_GF);
5296             DEBUGFUNC("[Stress Test]Disable HT capability...\n");
5297         }
5298         cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
5299         cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_3);
5300     }
5301
5302     // 0xFFFFFFFA for Enable Random Rx Reset
5303     else if (prMcrWrInfo->u4McrOffset == 0xFFFFFFFA){
5304         rCmdAccessReg.u4Address = prMcrWrInfo->u4McrOffset;
5305         rCmdAccessReg.u4Data = prMcrWrInfo->u4McrData;
5306
5307         return wlanSendSetQueryCmd(
5308                 prAdapter,
5309                 CMD_ID_RANDOM_RX_RESET_EN,
5310                 TRUE,
5311                 FALSE,
5312                 TRUE,
5313                 nicCmdEventSetCommon,
5314                 nicOidCmdTimeoutCommon,
5315                 sizeof(CMD_ACCESS_REG),
5316                 (PUINT_8)&rCmdAccessReg,
5317                 pvSetBuffer,
5318                 u4SetBufferLen
5319                 );
5320     }
5321
5322     // 0xFFFFFFF9 for Disable Random Rx Reset
5323     else if (prMcrWrInfo->u4McrOffset == 0xFFFFFFF9){
5324         rCmdAccessReg.u4Address = prMcrWrInfo->u4McrOffset;
5325         rCmdAccessReg.u4Data = prMcrWrInfo->u4McrData;
5326
5327         return wlanSendSetQueryCmd(
5328                 prAdapter,
5329                 CMD_ID_RANDOM_RX_RESET_DE,
5330                 TRUE,
5331                 FALSE,
5332                 TRUE,
5333                 nicCmdEventSetCommon,
5334                 nicOidCmdTimeoutCommon,
5335                 sizeof(CMD_ACCESS_REG),
5336                 (PUINT_8)&rCmdAccessReg,
5337                 pvSetBuffer,
5338                 u4SetBufferLen
5339                 );
5340     }
5341
5342     // 0xFFFFFFF8 for Enable SAPP
5343     else if (prMcrWrInfo->u4McrOffset == 0xFFFFFFF8){
5344         rCmdAccessReg.u4Address = prMcrWrInfo->u4McrOffset;
5345         rCmdAccessReg.u4Data = prMcrWrInfo->u4McrData;
5346
5347         return wlanSendSetQueryCmd(
5348                 prAdapter,
5349                 CMD_ID_SAPP_EN,
5350                 TRUE,
5351                 FALSE,
5352                 TRUE,
5353                 nicCmdEventSetCommon,
5354                 nicOidCmdTimeoutCommon,
5355                 sizeof(CMD_ACCESS_REG),
5356                 (PUINT_8)&rCmdAccessReg,
5357                 pvSetBuffer,
5358                 u4SetBufferLen
5359                 );
5360     }
5361
5362     // 0xFFFFFFF7 for Disable SAPP
5363     else if (prMcrWrInfo->u4McrOffset == 0xFFFFFFF7){
5364         rCmdAccessReg.u4Address = prMcrWrInfo->u4McrOffset;
5365         rCmdAccessReg.u4Data = prMcrWrInfo->u4McrData;
5366
5367         return wlanSendSetQueryCmd(
5368                 prAdapter,
5369                 CMD_ID_SAPP_DE,
5370                 TRUE,
5371                 FALSE,
5372                 TRUE,
5373                 nicCmdEventSetCommon,
5374                 nicOidCmdTimeoutCommon,
5375                 sizeof(CMD_ACCESS_REG),
5376                 (PUINT_8)&rCmdAccessReg,
5377                 pvSetBuffer,
5378                 u4SetBufferLen
5379                 );
5380     }
5381
5382     else
5383 #endif
5384     // -- Puff Stress Test End
5385
5386
5387     /* Check if access F/W Domain MCR */
5388     if (prMcrWrInfo->u4McrOffset & 0xFFFF0000){
5389
5390     /* 0x9000 - 0x9EFF reserved for FW */
5391 #if CFG_SUPPORT_SWCR
5392         if((prMcrWrInfo->u4McrOffset >> 16) == 0x9F00) {
5393            swCrReadWriteCmd(prAdapter,
5394                     SWCR_WRITE,
5395                     (UINT_16) (prMcrWrInfo->u4McrOffset & BITS(0,15)),
5396                     &prMcrWrInfo->u4McrData);
5397             return WLAN_STATUS_SUCCESS;
5398         }
5399 #endif /* CFG_SUPPORT_SWCR */
5400
5401
5402  #if 1
5403         // low power test special command
5404         if (prMcrWrInfo->u4McrOffset == 0x11111110){
5405             WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
5406             //DbgPrint("Enter test mode\n");
5407             prAdapter->fgTestMode = TRUE;
5408             return rStatus;
5409         }
5410         if (prMcrWrInfo->u4McrOffset == 0x11111111){
5411             //DbgPrint("nicpmSetAcpiPowerD3\n");
5412
5413             nicpmSetAcpiPowerD3(prAdapter);
5414             kalDevSetPowerState(prAdapter->prGlueInfo, (UINT_32)ParamDeviceStateD3);
5415             return WLAN_STATUS_SUCCESS;
5416         }
5417         if (prMcrWrInfo->u4McrOffset == 0x11111112){
5418
5419             //DbgPrint("LP enter sleep\n");
5420
5421            // fill command
5422             rCmdAccessReg.u4Address = prMcrWrInfo->u4McrOffset;
5423             rCmdAccessReg.u4Data = prMcrWrInfo->u4McrData;
5424
5425             return wlanSendSetQueryCmd(prAdapter,
5426                     CMD_ID_ACCESS_REG,
5427                     TRUE,
5428                     FALSE,
5429                     TRUE,
5430                     nicCmdEventSetCommon,
5431                     nicOidCmdTimeoutCommon,
5432                     sizeof(CMD_ACCESS_REG),
5433                     (PUINT_8)&rCmdAccessReg,
5434                     pvSetBuffer,
5435                     u4SetBufferLen
5436                     );
5437         }
5438 #endif
5439
5440  #if 1
5441         // low power test special command
5442         if (prMcrWrInfo->u4McrOffset == 0x11111110){
5443             WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
5444             //DbgPrint("Enter test mode\n");
5445             prAdapter->fgTestMode = TRUE;
5446             return rStatus;
5447         }
5448         if (prMcrWrInfo->u4McrOffset == 0x11111111){
5449             //DbgPrint("nicpmSetAcpiPowerD3\n");
5450
5451             nicpmSetAcpiPowerD3(prAdapter);
5452             kalDevSetPowerState(prAdapter->prGlueInfo, (UINT_32)ParamDeviceStateD3);
5453             return WLAN_STATUS_SUCCESS;
5454         }
5455         if (prMcrWrInfo->u4McrOffset == 0x11111112){
5456
5457             //DbgPrint("LP enter sleep\n");
5458
5459            // fill command
5460             rCmdAccessReg.u4Address = prMcrWrInfo->u4McrOffset;
5461             rCmdAccessReg.u4Data = prMcrWrInfo->u4McrData;
5462
5463             return wlanSendSetQueryCmd(prAdapter,
5464                     CMD_ID_ACCESS_REG,
5465                     TRUE,
5466                     FALSE,
5467                     TRUE,
5468                     nicCmdEventSetCommon,
5469                     nicOidCmdTimeoutCommon,
5470                     sizeof(CMD_ACCESS_REG),
5471                     (PUINT_8)&rCmdAccessReg,
5472                     pvSetBuffer,
5473                     u4SetBufferLen
5474                     );
5475         }
5476
5477 #endif
5478         // fill command
5479         rCmdAccessReg.u4Address = prMcrWrInfo->u4McrOffset;
5480         rCmdAccessReg.u4Data = prMcrWrInfo->u4McrData;
5481
5482         return wlanSendSetQueryCmd(prAdapter,
5483                 CMD_ID_ACCESS_REG,
5484                 TRUE,
5485                 FALSE,
5486                 TRUE,
5487                 nicCmdEventSetCommon,
5488                 nicOidCmdTimeoutCommon,
5489                 sizeof(CMD_ACCESS_REG),
5490                 (PUINT_8)&rCmdAccessReg,
5491                 pvSetBuffer,
5492                 u4SetBufferLen
5493                 );
5494     }
5495     else {
5496         HAL_MCR_WR(prAdapter,
5497                (prMcrWrInfo->u4McrOffset & BITS(2,31)), //address is in DWORD unit
5498                prMcrWrInfo->u4McrData);
5499
5500         DBGLOG(INIT, TRACE, ("MCR Write: Offset = %#08lx, Data = %#08lx\n",
5501                     prMcrWrInfo->u4McrOffset, prMcrWrInfo->u4McrData));
5502
5503         return WLAN_STATUS_SUCCESS;
5504     }
5505 }   /* wlanoidSetMcrWrite */
5506
5507 /*----------------------------------------------------------------------------*/
5508 /*!
5509 * \brief This routine is called to query SW CTRL
5510 *
5511 * \param[in] pvAdapter Pointer to the Adapter structure.
5512 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
5513 *                           the query.
5514 * \param[in] u4QueryBufLen The length of the query buffer.
5515 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
5516 *                            bytes written into the query buffer. If the call
5517 *                            failed due to invalid length of the query buffer,
5518 *                            returns the amount of storage needed.
5519 *
5520 * \retval WLAN_STATUS_SUCCESS
5521 * \retval WLAN_STATUS_INVALID_LENGTH
5522 */
5523 /*----------------------------------------------------------------------------*/
5524 WLAN_STATUS
5525 wlanoidQuerySwCtrlRead (
5526     IN P_ADAPTER_T  prAdapter,
5527     IN PVOID        pvQueryBuffer,
5528     IN UINT_32      u4QueryBufferLen,
5529     OUT PUINT_32    pu4QueryInfoLen
5530     )
5531 {
5532     P_PARAM_CUSTOM_SW_CTRL_STRUC_T prSwCtrlInfo;
5533     WLAN_STATUS rWlanStatus;
5534     UINT_16 u2Id, u2SubId;
5535     UINT_32 u4Data;
5536
5537     CMD_SW_DBG_CTRL_T rCmdSwCtrl;
5538
5539     DEBUGFUNC("wlanoidQuerySwCtrlRead");
5540     DBGLOG(INIT, LOUD,("\n"));
5541
5542     ASSERT(prAdapter);
5543     ASSERT(pu4QueryInfoLen);
5544     if (u4QueryBufferLen) {
5545         ASSERT(pvQueryBuffer);
5546     }
5547
5548     *pu4QueryInfoLen = sizeof(PARAM_CUSTOM_SW_CTRL_STRUC_T);
5549
5550     if (u4QueryBufferLen < sizeof(PARAM_CUSTOM_SW_CTRL_STRUC_T)) {
5551         return WLAN_STATUS_INVALID_LENGTH;
5552     }
5553
5554     prSwCtrlInfo = (P_PARAM_CUSTOM_SW_CTRL_STRUC_T)pvQueryBuffer;
5555
5556     u2Id = (UINT_16)(prSwCtrlInfo->u4Id >> 16);
5557     u2SubId = (UINT_16)(prSwCtrlInfo->u4Id & BITS(0,15));
5558     u4Data = 0;
5559     rWlanStatus = WLAN_STATUS_SUCCESS;
5560
5561     switch(u2Id) {
5562     /* 0x9000 - 0x9EFF reserved for FW */
5563     /* 0xFFFE          reserved for FW */
5564
5565 #if CFG_SUPPORT_SWCR
5566         case 0x9F00:
5567            swCrReadWriteCmd(prAdapter,
5568                     SWCR_READ/* Read */,
5569                     (UINT_16) u2SubId ,
5570                     &u4Data);
5571             break;
5572 #endif /* CFG_SUPPORT_SWCR */
5573
5574         case 0xFFFF:
5575             {
5576                 u4Data = 0x5AA56620;
5577             }
5578             break;
5579
5580         case 0x9000:
5581         default:
5582             {
5583                 rCmdSwCtrl.u4Id = prSwCtrlInfo->u4Id;
5584                 rCmdSwCtrl.u4Data = 0;
5585                 rWlanStatus = wlanSendSetQueryCmd(prAdapter,
5586                 CMD_ID_SW_DBG_CTRL,
5587                 FALSE,
5588                 TRUE,
5589                 TRUE,
5590                 nicCmdEventQuerySwCtrlRead,
5591                 nicOidCmdTimeoutCommon,
5592                 sizeof(CMD_SW_DBG_CTRL_T),
5593                 (PUINT_8)&rCmdSwCtrl,
5594                 pvQueryBuffer,
5595                 u4QueryBufferLen
5596                 );
5597             }
5598     } /* switch(u2Id)*/
5599
5600     prSwCtrlInfo->u4Data = u4Data;
5601
5602     return rWlanStatus;
5603
5604 }
5605  /* end of wlanoidQuerySwCtrlRead() */
5606
5607
5608 /*----------------------------------------------------------------------------*/
5609 /*!
5610 * \brief This routine is called to write SW CTRL
5611 *
5612 * \param[in] prAdapter Pointer to the Adapter structure.
5613 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
5614 * \param[in] u4SetBufferLen The length of the set buffer.
5615 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
5616 *                           bytes read from the set buffer. If the call failed
5617 *                           due to invalid length of the set buffer, returns
5618 *                           the amount of storage needed.
5619 *
5620 * \retval WLAN_STATUS_SUCCESS
5621 * \retval WLAN_STATUS_INVALID_LENGTH
5622 */
5623 /*----------------------------------------------------------------------------*/
5624 WLAN_STATUS
5625 wlanoidSetSwCtrlWrite (
5626     IN P_ADAPTER_T  prAdapter,
5627     IN  PVOID    pvSetBuffer,
5628     IN  UINT_32  u4SetBufferLen,
5629     OUT PUINT_32 pu4SetInfoLen
5630     )
5631 {
5632     P_PARAM_CUSTOM_SW_CTRL_STRUC_T prSwCtrlInfo;
5633     CMD_SW_DBG_CTRL_T rCmdSwCtrl;
5634     WLAN_STATUS rWlanStatus;
5635     UINT_16 u2Id, u2SubId;
5636     UINT_32 u4Data;
5637
5638     DEBUGFUNC("wlanoidSetSwCtrlWrite");
5639     DBGLOG(INIT, LOUD,("\n"));
5640
5641     ASSERT(prAdapter);
5642     ASSERT(pu4SetInfoLen);
5643
5644     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_SW_CTRL_STRUC_T);
5645
5646     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_SW_CTRL_STRUC_T)) {
5647         return WLAN_STATUS_INVALID_LENGTH;
5648     }
5649
5650     ASSERT(pvSetBuffer);
5651
5652     prSwCtrlInfo = (P_PARAM_CUSTOM_SW_CTRL_STRUC_T)pvSetBuffer;
5653
5654     u2Id = (UINT_16)(prSwCtrlInfo->u4Id >> 16);
5655     u2SubId = (UINT_16)(prSwCtrlInfo->u4Id & BITS(0,15));
5656     u4Data = prSwCtrlInfo->u4Data;
5657     rWlanStatus = WLAN_STATUS_SUCCESS;
5658
5659     switch(u2Id) {
5660
5661     /* 0x9000 - 0x9EFF reserved for FW */
5662     /* 0xFFFE          reserved for FW */
5663
5664 #if CFG_SUPPORT_SWCR
5665         case 0x9F00:
5666            swCrReadWriteCmd(prAdapter,
5667                     SWCR_WRITE,
5668                     (UINT_16) u2SubId,
5669                     &u4Data);
5670                 break;
5671 #endif /* CFG_SUPPORT_SWCR */
5672
5673         case 0x1000:
5674             if (u2SubId == 0x8000) {
5675                 // CTIA power save mode setting (code: 0x10008000)
5676                 prAdapter->u4CtiaPowerMode = u4Data;
5677                 prAdapter->fgEnCtiaPowerMode = TRUE;
5678
5679                 //
5680                 {
5681                 PARAM_POWER_MODE ePowerMode;
5682
5683                 if (prAdapter->u4CtiaPowerMode == 0) {
5684                     // force to keep in CAM mode
5685                     ePowerMode = Param_PowerModeCAM;
5686                 } else if (prAdapter->u4CtiaPowerMode == 1) {
5687                     ePowerMode = Param_PowerModeMAX_PSP;
5688                 } else {
5689                     ePowerMode = Param_PowerModeFast_PSP;
5690                 }
5691
5692                 nicConfigPowerSaveProfile(
5693                     prAdapter,
5694                     NETWORK_TYPE_AIS_INDEX,
5695                     ePowerMode,
5696                     TRUE);
5697                 }
5698             }
5699             break;
5700         case 0x1001:
5701             if(u2SubId == 0x0) {
5702                 prAdapter->fgEnOnlineScan = (BOOLEAN)u4Data;
5703             }
5704             else if(u2SubId == 0x1) {
5705                 prAdapter->fgDisBcnLostDetection = (BOOLEAN)u4Data;
5706             }
5707             else if(u2SubId == 0x2) {
5708                 prAdapter->rWifiVar.fgSupportUAPSD =  (BOOLEAN)u4Data;
5709             }
5710             else if(u2SubId == 0x3) {
5711                 prAdapter->u4UapsdAcBmp = u4Data & BITS(0,15);
5712                 prAdapter->rWifiVar.arBssInfo[u4Data>>16].rPmProfSetupInfo.ucBmpDeliveryAC = (UINT_8)prAdapter->u4UapsdAcBmp;
5713                 prAdapter->rWifiVar.arBssInfo[u4Data>>16].rPmProfSetupInfo.ucBmpTriggerAC = (UINT_8)prAdapter->u4UapsdAcBmp;
5714             }
5715             else if(u2SubId == 0x4) {
5716                 prAdapter->fgDisStaAgingTimeoutDetection = (BOOLEAN)u4Data;
5717             }
5718             else if(u2SubId == 0x5) {
5719                 prAdapter->rWifiVar.rConnSettings.uc2G4BandwidthMode = (UINT_8)u4Data;
5720             }
5721
5722
5723             break;
5724
5725 #if CFG_SUPPORT_SWCR
5726         case 0x1002:
5727             if(u2SubId == 0x0) {
5728                 if (u4Data) {
5729                     u4Data = BIT(HIF_RX_PKT_TYPE_MANAGEMENT);
5730                 }
5731                 swCrFrameCheckEnable(prAdapter, u4Data);
5732             }
5733             else if(u2SubId == 0x1) {
5734                 BOOLEAN fgIsEnable;
5735                 UINT_8 ucType;
5736                 UINT_32 u4Timeout;
5737
5738                 fgIsEnable = (BOOLEAN)(u4Data & 0xff);
5739                 ucType = 0;//((u4Data>>4) & 0xf);
5740                 u4Timeout = ((u4Data>>8) & 0xff);
5741                 swCrDebugCheckEnable(prAdapter, fgIsEnable, ucType, u4Timeout);
5742             }
5743             break;
5744 #endif
5745
5746 #if CFG_SUPPORT_802_11W
5747         case 0x2000:
5748             DBGLOG(RSN, INFO, ("802.11w test 0x%x\n", u2SubId));
5749             if (u2SubId == 0x0) {
5750                 rsnStartSaQuery(prAdapter);
5751             }
5752             if (u2SubId == 0x1) {
5753                 rsnStopSaQuery(prAdapter);
5754             }
5755             if (u2SubId == 0x2) {
5756                 rsnSaQueryRequest(prAdapter, NULL);
5757             }
5758             if (u2SubId == 0x3) {
5759                 P_BSS_INFO_T prBssInfo = &(prAdapter->rWifiVar.arBssInfo[(NETWORK_TYPE_AIS_INDEX)]);
5760                 authSendDeauthFrame(prAdapter, prBssInfo->prStaRecOfAP , NULL, 7, NULL);
5761             }
5762             /* wext_set_mode */
5763             /*
5764             if (u2SubId == 0x3) {
5765                 prAdapter->prGlueInfo->rWpaInfo.u4Mfp = RSN_AUTH_MFP_DISABLED;
5766             }
5767             if (u2SubId == 0x4) {
5768                 //prAdapter->rWifiVar.rAisSpecificBssInfo.fgMgmtProtection = TRUE;
5769                 prAdapter->prGlueInfo->rWpaInfo.u4Mfp = RSN_AUTH_MFP_OPTIONAL;
5770             }
5771             if (u2SubId == 0x5) {
5772                 //prAdapter->rWifiVar.rAisSpecificBssInfo.fgMgmtProtection = TRUE;
5773                 prAdapter->prGlueInfo->rWpaInfo.u4Mfp = RSN_AUTH_MFP_REQUIRED;
5774             }
5775             */
5776             break;
5777 #endif
5778         case 0xFFFF:
5779             {
5780             CMD_ACCESS_REG rCmdAccessReg;
5781 #if 1 //CFG_MT6573_SMT_TEST
5782             if (u2SubId == 0x0123) {
5783
5784                 DBGLOG(HAL, INFO, ("set smt fixed rate: %d \n", u4Data));
5785
5786                 if((ENUM_REGISTRY_FIXED_RATE_T)(u4Data) < FIXED_RATE_NUM) {
5787                     prAdapter->rWifiVar.eRateSetting = (ENUM_REGISTRY_FIXED_RATE_T)(u4Data);
5788                 }
5789                 else {
5790                     prAdapter->rWifiVar.eRateSetting = FIXED_RATE_NONE;
5791                 }
5792
5793                 if(prAdapter->rWifiVar.eRateSetting == FIXED_RATE_NONE) {
5794                     /* Enable Auto (Long/Short) Preamble */
5795                     prAdapter->rWifiVar.ePreambleType = PREAMBLE_TYPE_AUTO;
5796                 }
5797                 else if((prAdapter->rWifiVar.eRateSetting >= FIXED_RATE_MCS0_20M_400NS &&
5798                             prAdapter->rWifiVar.eRateSetting <= FIXED_RATE_MCS7_20M_400NS)
5799                         || (prAdapter->rWifiVar.eRateSetting >= FIXED_RATE_MCS0_40M_400NS &&
5800                                 prAdapter->rWifiVar.eRateSetting <= FIXED_RATE_MCS32_400NS)) {
5801                     /* Force Short Preamble */
5802                     prAdapter->rWifiVar.ePreambleType = PREAMBLE_TYPE_SHORT;
5803                 }
5804                 else {
5805                     /* Force Long Preamble */
5806                     prAdapter->rWifiVar.ePreambleType = PREAMBLE_TYPE_LONG;
5807                 }
5808
5809                 /* abort to re-connect */
5810 #if 1
5811                 kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
5812                         WLAN_STATUS_MEDIA_DISCONNECT,
5813                         NULL,
5814                         0);
5815 #else
5816                 aisBssBeaconTimeout(prAdapter);
5817 #endif
5818
5819                 return WLAN_STATUS_SUCCESS;
5820
5821             }
5822             else if (u2SubId == 0x1234) {
5823                 // 1. Disable On-Lin Scan
5824                 prAdapter->fgEnOnlineScan = FALSE;
5825
5826                 // 3. Disable FIFO FULL no ack
5827                 rCmdAccessReg.u4Address = 0x60140028;
5828                 rCmdAccessReg.u4Data = 0x904;
5829                 wlanSendSetQueryCmd(prAdapter,
5830                         CMD_ID_ACCESS_REG,
5831                         TRUE, //FALSE,
5832                         FALSE, //TRUE,
5833                         FALSE,
5834                         nicCmdEventSetCommon,
5835                         nicOidCmdTimeoutCommon,
5836                         sizeof(CMD_ACCESS_REG),
5837                         (PUINT_8)&rCmdAccessReg,
5838                         pvSetBuffer,
5839                         0
5840                         );
5841
5842                 // 4. Disable Roaming
5843                 rCmdSwCtrl.u4Id = 0x90000204;
5844                 rCmdSwCtrl.u4Data = 0x0;
5845                 wlanSendSetQueryCmd(prAdapter,
5846                         CMD_ID_SW_DBG_CTRL,
5847                         TRUE,
5848                         FALSE,
5849                         FALSE,
5850                         nicCmdEventSetCommon,
5851                         nicOidCmdTimeoutCommon,
5852                         sizeof(CMD_SW_DBG_CTRL_T),
5853                         (PUINT_8)&rCmdSwCtrl,
5854                         pvSetBuffer,
5855                         u4SetBufferLen
5856                         );
5857
5858                 rCmdSwCtrl.u4Id = 0x90000200;
5859                 rCmdSwCtrl.u4Data = 0x820000;
5860                 wlanSendSetQueryCmd(prAdapter,
5861                         CMD_ID_SW_DBG_CTRL,
5862                         TRUE,
5863                         FALSE,
5864                         FALSE,
5865                         nicCmdEventSetCommon,
5866                         nicOidCmdTimeoutCommon,
5867                         sizeof(CMD_SW_DBG_CTRL_T),
5868                         (PUINT_8)&rCmdSwCtrl,
5869                         pvSetBuffer,
5870                         u4SetBufferLen
5871                         );
5872
5873                 // Disalbe auto tx power
5874                 //
5875                 rCmdSwCtrl.u4Id = 0xa0100003;
5876                 rCmdSwCtrl.u4Data = 0x0;
5877                 wlanSendSetQueryCmd(prAdapter,
5878                         CMD_ID_SW_DBG_CTRL,
5879                         TRUE,
5880                         FALSE,
5881                         FALSE,
5882                         nicCmdEventSetCommon,
5883                         nicOidCmdTimeoutCommon,
5884                         sizeof(CMD_SW_DBG_CTRL_T),
5885                         (PUINT_8)&rCmdSwCtrl,
5886                         pvSetBuffer,
5887                         u4SetBufferLen
5888                         );
5889
5890
5891
5892                 // 2. Keep at CAM mode
5893                 {
5894                     PARAM_POWER_MODE ePowerMode;
5895
5896                     prAdapter->u4CtiaPowerMode = 0;
5897                     prAdapter->fgEnCtiaPowerMode = TRUE;
5898
5899                     ePowerMode = Param_PowerModeCAM;
5900                     rWlanStatus = nicConfigPowerSaveProfile(
5901                         prAdapter,
5902                         NETWORK_TYPE_AIS_INDEX,
5903                         ePowerMode,
5904                         TRUE);
5905                 }
5906
5907                 // 5. Disable Beacon Timeout Detection
5908                 prAdapter->fgDisBcnLostDetection = TRUE;
5909             }
5910             else if (u2SubId == 0x1235) {
5911
5912                 // 1. Enaable On-Lin Scan
5913                 prAdapter->fgEnOnlineScan = TRUE;
5914
5915                 // 3. Enable FIFO FULL no ack
5916                 rCmdAccessReg.u4Address = 0x60140028;
5917                 rCmdAccessReg.u4Data = 0x905;
5918                 wlanSendSetQueryCmd(prAdapter,
5919                         CMD_ID_ACCESS_REG,
5920                         TRUE, //FALSE,
5921                         FALSE, //TRUE,
5922                         FALSE,
5923                         nicCmdEventSetCommon,
5924                         nicOidCmdTimeoutCommon,
5925                         sizeof(CMD_ACCESS_REG),
5926                         (PUINT_8)&rCmdAccessReg,
5927                         pvSetBuffer,
5928                         0
5929                         );
5930
5931                 // 4. Enable Roaming
5932                 rCmdSwCtrl.u4Id = 0x90000204;
5933                 rCmdSwCtrl.u4Data = 0x1;
5934                 wlanSendSetQueryCmd(prAdapter,
5935                         CMD_ID_SW_DBG_CTRL,
5936                         TRUE,
5937                         FALSE,
5938                         FALSE,
5939                         nicCmdEventSetCommon,
5940                         nicOidCmdTimeoutCommon,
5941                         sizeof(CMD_SW_DBG_CTRL_T),
5942                         (PUINT_8)&rCmdSwCtrl,
5943                         pvSetBuffer,
5944                         u4SetBufferLen
5945                         );
5946
5947                 rCmdSwCtrl.u4Id = 0x90000200;
5948                 rCmdSwCtrl.u4Data = 0x820000;
5949                 wlanSendSetQueryCmd(prAdapter,
5950                         CMD_ID_SW_DBG_CTRL,
5951                         TRUE,
5952                         FALSE,
5953                         FALSE,
5954                         nicCmdEventSetCommon,
5955                         nicOidCmdTimeoutCommon,
5956                         sizeof(CMD_SW_DBG_CTRL_T),
5957                         (PUINT_8)&rCmdSwCtrl,
5958                         pvSetBuffer,
5959                         u4SetBufferLen
5960                         );
5961
5962                 // Enable auto tx power
5963                 //
5964
5965                 rCmdSwCtrl.u4Id = 0xa0100003;
5966                 rCmdSwCtrl.u4Data = 0x1;
5967                 wlanSendSetQueryCmd(prAdapter,
5968                         CMD_ID_SW_DBG_CTRL,
5969                         TRUE,
5970                         FALSE,
5971                         FALSE,
5972                         nicCmdEventSetCommon,
5973                         nicOidCmdTimeoutCommon,
5974                         sizeof(CMD_SW_DBG_CTRL_T),
5975                         (PUINT_8)&rCmdSwCtrl,
5976                         pvSetBuffer,
5977                         u4SetBufferLen
5978                         );
5979
5980
5981                 // 2. Keep at Fast PS
5982                 {
5983                     PARAM_POWER_MODE ePowerMode;
5984
5985                     prAdapter->u4CtiaPowerMode = 2;
5986                     prAdapter->fgEnCtiaPowerMode = TRUE;
5987
5988                     ePowerMode = Param_PowerModeFast_PSP;
5989                     rWlanStatus = nicConfigPowerSaveProfile(
5990                         prAdapter,
5991                         NETWORK_TYPE_AIS_INDEX,
5992                         ePowerMode,
5993                         TRUE);
5994                 }
5995
5996                 // 5. Enable Beacon Timeout Detection
5997                 prAdapter->fgDisBcnLostDetection = FALSE;
5998             }
5999 #endif
6000             }
6001             break;
6002
6003         case 0x9000:
6004         default:
6005             {
6006                 rCmdSwCtrl.u4Id = prSwCtrlInfo->u4Id;
6007                 rCmdSwCtrl.u4Data = prSwCtrlInfo->u4Data;
6008                 rWlanStatus =  wlanSendSetQueryCmd(prAdapter,
6009                         CMD_ID_SW_DBG_CTRL,
6010                         TRUE,
6011                         FALSE,
6012                         TRUE,
6013                         nicCmdEventSetCommon,
6014                         nicOidCmdTimeoutCommon,
6015                         sizeof(CMD_SW_DBG_CTRL_T),
6016                         (PUINT_8)&rCmdSwCtrl,
6017                         pvSetBuffer,
6018                         u4SetBufferLen
6019                         );
6020             }
6021     } /* switch(u2Id)  */
6022
6023     return rWlanStatus;
6024 }
6025    /* wlanoidSetSwCtrlWrite */
6026
6027
6028 /*----------------------------------------------------------------------------*/
6029 /*!
6030 * \brief This routine is called to query EEPROM value.
6031 *
6032 * \param[in] pvAdapter Pointer to the Adapter structure.
6033 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
6034 *                           the query.
6035 * \param[in] u4QueryBufLen The length of the query buffer.
6036 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
6037 *                            bytes written into the query buffer. If the call
6038 *                            failed due to invalid length of the query buffer,
6039 *                            returns the amount of storage needed.
6040 *
6041 * \retval WLAN_STATUS_SUCCESS
6042 * \retval WLAN_STATUS_FAILURE
6043 */
6044 /*----------------------------------------------------------------------------*/
6045 WLAN_STATUS
6046 wlanoidQueryEepromRead (
6047     IN  P_ADAPTER_T  prAdapter,
6048     IN  PVOID        pvQueryBuffer,
6049     IN  UINT_32      u4QueryBufferLen,
6050     OUT PUINT_32     pu4QueryInfoLen
6051     )
6052 {
6053     P_PARAM_CUSTOM_EEPROM_RW_STRUC_T prEepromRwInfo;
6054     CMD_ACCESS_EEPROM rCmdAccessEeprom;
6055
6056     DEBUGFUNC("wlanoidQueryEepromRead");
6057
6058     ASSERT(prAdapter);
6059     ASSERT(pu4QueryInfoLen);
6060     if (u4QueryBufferLen) {
6061         ASSERT(pvQueryBuffer);
6062     }
6063
6064     *pu4QueryInfoLen = sizeof(PARAM_CUSTOM_EEPROM_RW_STRUC_T);
6065
6066     if (u4QueryBufferLen < sizeof(PARAM_CUSTOM_EEPROM_RW_STRUC_T)) {
6067         return WLAN_STATUS_INVALID_LENGTH;
6068     }
6069
6070     prEepromRwInfo = (P_PARAM_CUSTOM_EEPROM_RW_STRUC_T)pvQueryBuffer;
6071
6072     kalMemZero(&rCmdAccessEeprom, sizeof(CMD_ACCESS_EEPROM));
6073     rCmdAccessEeprom.u2Offset = prEepromRwInfo->ucEepromIndex;
6074
6075     return wlanSendSetQueryCmd(prAdapter,
6076             CMD_ID_ACCESS_EEPROM,
6077             FALSE,
6078             TRUE,
6079             TRUE,
6080             nicCmdEventQueryEepromRead,
6081             nicOidCmdTimeoutCommon,
6082             sizeof(CMD_ACCESS_EEPROM),
6083             (PUINT_8)&rCmdAccessEeprom,
6084             pvQueryBuffer,
6085             u4QueryBufferLen
6086             );
6087
6088 }   /* wlanoidQueryEepromRead */
6089
6090
6091 /*----------------------------------------------------------------------------*/
6092 /*!
6093 * \brief This routine is called to write EEPROM value.
6094 *
6095 * \param[in] prAdapter Pointer to the Adapter structure.
6096 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
6097 * \param[in] u4SetBufferLen The length of the set buffer.
6098 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
6099 *                           bytes read from the set buffer. If the call failed
6100 *                           due to invalid length of the set buffer, returns
6101 *                           the amount of storage needed.
6102 *
6103 * \retval WLAN_STATUS_SUCCESS
6104 * \retval WLAN_STATUS_FAILURE
6105 */
6106 /*----------------------------------------------------------------------------*/
6107 WLAN_STATUS
6108 wlanoidSetEepromWrite (
6109     IN P_ADAPTER_T  prAdapter,
6110     IN  PVOID       pvSetBuffer,
6111     IN  UINT_32     u4SetBufferLen,
6112     OUT PUINT_32    pu4SetInfoLen
6113     )
6114 {
6115     P_PARAM_CUSTOM_EEPROM_RW_STRUC_T prEepromRwInfo;
6116     CMD_ACCESS_EEPROM rCmdAccessEeprom;
6117
6118     DEBUGFUNC("wlanoidSetEepromWrite");
6119     DBGLOG(INIT, LOUD,("\n"));
6120
6121     ASSERT(prAdapter);
6122     ASSERT(pu4SetInfoLen);
6123
6124     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_EEPROM_RW_STRUC_T);
6125
6126     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_EEPROM_RW_STRUC_T)) {
6127         return WLAN_STATUS_INVALID_LENGTH;
6128     }
6129
6130     ASSERT(pvSetBuffer);
6131
6132     prEepromRwInfo = (P_PARAM_CUSTOM_EEPROM_RW_STRUC_T)pvSetBuffer;
6133
6134     kalMemZero(&rCmdAccessEeprom, sizeof(CMD_ACCESS_EEPROM));
6135     rCmdAccessEeprom.u2Offset = prEepromRwInfo->ucEepromIndex;
6136     rCmdAccessEeprom.u2Data = prEepromRwInfo->u2EepromData;
6137
6138     return wlanSendSetQueryCmd(prAdapter,
6139             CMD_ID_ACCESS_EEPROM,
6140             TRUE,
6141             FALSE,
6142             TRUE,
6143             nicCmdEventSetCommon,
6144             nicOidCmdTimeoutCommon,
6145             sizeof(CMD_ACCESS_EEPROM),
6146             (PUINT_8)&rCmdAccessEeprom,
6147             pvSetBuffer,
6148             u4SetBufferLen
6149             );
6150
6151 }   /* wlanoidSetEepromWrite */
6152
6153
6154 /*----------------------------------------------------------------------------*/
6155 /*!
6156 * \brief This routine is called to query the number of the successfully transmitted
6157 *        packets.
6158 *
6159 * \param[in] pvAdapter Pointer to the Adapter structure.
6160 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
6161 *                           the query.
6162 * \param[in] u4QueryBufLen The length of the query buffer.
6163 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
6164 *                            bytes written into the query buffer. If the call
6165 *                            failed due to invalid length of the query buffer,
6166 *                            returns the amount of storage needed.
6167 *
6168 * \retval WLAN_STATUS_SUCCESS
6169 * \retval WLAN_STATUS_INVALID_LENGTH
6170 */
6171 /*----------------------------------------------------------------------------*/
6172 WLAN_STATUS
6173 wlanoidQueryXmitOk (
6174     IN  P_ADAPTER_T prAdapter,
6175     IN  PVOID       pvQueryBuffer,
6176     IN  UINT_32     u4QueryBufferLen,
6177     OUT PUINT_32    pu4QueryInfoLen
6178     )
6179 {
6180     DEBUGFUNC("wlanoidQueryXmitOk");
6181     DBGLOG(REQ, LOUD, ("\n"));
6182
6183     ASSERT(prAdapter);
6184     if (u4QueryBufferLen) {
6185         ASSERT(pvQueryBuffer);
6186     }
6187     ASSERT(pu4QueryInfoLen);
6188
6189     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
6190         DBGLOG(REQ, WARN, ("Fail in query receive error! (Adapter not ready). ACPI=D%d, Radio=%d\n",
6191                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
6192         *pu4QueryInfoLen = sizeof(UINT_32);
6193         return WLAN_STATUS_ADAPTER_NOT_READY;
6194     }
6195     else if (u4QueryBufferLen < sizeof(UINT_32)
6196             || (u4QueryBufferLen > sizeof(UINT_32) && u4QueryBufferLen < sizeof(UINT_64))) {
6197         *pu4QueryInfoLen = sizeof(UINT_64);
6198         return WLAN_STATUS_INVALID_LENGTH;
6199     }
6200
6201 #if CFG_ENABLE_STATISTICS_BUFFERING
6202     if(IsBufferedStatisticsUsable(prAdapter) == TRUE) {
6203         if(u4QueryBufferLen == sizeof(UINT_32)) {
6204             *pu4QueryInfoLen = sizeof(UINT_32);
6205             *(PUINT_32) pvQueryBuffer = (UINT_32) prAdapter->rStatStruct.rTransmittedFragmentCount.QuadPart;
6206         }
6207         else {
6208             *pu4QueryInfoLen = sizeof(UINT_64);
6209             *(PUINT_64) pvQueryBuffer = (UINT_64) prAdapter->rStatStruct.rTransmittedFragmentCount.QuadPart;
6210         }
6211
6212         return WLAN_STATUS_SUCCESS;
6213     }
6214     else
6215 #endif
6216     {
6217     return wlanSendSetQueryCmd(prAdapter,
6218             CMD_ID_GET_STATISTICS,
6219             FALSE,
6220             TRUE,
6221             TRUE,
6222             nicCmdEventQueryXmitOk,
6223             nicOidCmdTimeoutCommon,
6224             0,
6225             NULL,
6226             pvQueryBuffer,
6227             u4QueryBufferLen
6228             );
6229     }
6230 }   /* wlanoidQueryXmitOk */
6231
6232
6233 /*----------------------------------------------------------------------------*/
6234 /*!
6235 * \brief This routine is called to query the number of the successfully received
6236 *        packets.
6237 *
6238 * \param[in] pvAdapter Pointer to the Adapter structure.
6239 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
6240 *                           the query.
6241 * \param[in] u4QueryBufLen The length of the query buffer.
6242 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
6243 *                            bytes written into the query buffer. If the call
6244 *                            failed due to invalid length of the query buffer,
6245 *                            returns the amount of storage needed.
6246 *
6247 * \retval WLAN_STATUS_SUCCESS
6248 * \retval WLAN_STATUS_INVALID_LENGTH
6249 */
6250 /*----------------------------------------------------------------------------*/
6251 WLAN_STATUS
6252 wlanoidQueryRcvOk (
6253     IN  P_ADAPTER_T     prAdapter,
6254     IN  PVOID           pvQueryBuffer,
6255     IN  UINT_32         u4QueryBufferLen,
6256     OUT PUINT_32        pu4QueryInfoLen
6257     )
6258 {
6259     DEBUGFUNC("wlanoidQueryRcvOk");
6260     DBGLOG(REQ, LOUD, ("\n"));
6261
6262     ASSERT(prAdapter);
6263     if (u4QueryBufferLen) {
6264         ASSERT(pvQueryBuffer);
6265     }
6266     ASSERT(pu4QueryInfoLen);
6267
6268     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
6269         DBGLOG(REQ, WARN, ("Fail in query receive error! (Adapter not ready). ACPI=D%d, Radio=%d\n",
6270                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
6271         *pu4QueryInfoLen = sizeof(UINT_32);
6272         return WLAN_STATUS_ADAPTER_NOT_READY;
6273     }
6274     else if (u4QueryBufferLen < sizeof(UINT_32)
6275             || (u4QueryBufferLen > sizeof(UINT_32) && u4QueryBufferLen < sizeof(UINT_64))) {
6276         *pu4QueryInfoLen = sizeof(UINT_64);
6277         return WLAN_STATUS_INVALID_LENGTH;
6278     }
6279
6280 #if CFG_ENABLE_STATISTICS_BUFFERING
6281     if(IsBufferedStatisticsUsable(prAdapter) == TRUE) {
6282         if(u4QueryBufferLen == sizeof(UINT_32)) {
6283             *pu4QueryInfoLen = sizeof(UINT_32);
6284             *(PUINT_32) pvQueryBuffer = (UINT_32) prAdapter->rStatStruct.rReceivedFragmentCount.QuadPart;
6285         }
6286         else {
6287             *pu4QueryInfoLen = sizeof(UINT_64);
6288             *(PUINT_64) pvQueryBuffer = (UINT_64) prAdapter->rStatStruct.rReceivedFragmentCount.QuadPart;
6289         }
6290
6291         return WLAN_STATUS_SUCCESS;
6292     }
6293     else
6294 #endif
6295     {
6296     return wlanSendSetQueryCmd(prAdapter,
6297             CMD_ID_GET_STATISTICS,
6298             FALSE,
6299             TRUE,
6300             TRUE,
6301             nicCmdEventQueryRecvOk,
6302             nicOidCmdTimeoutCommon,
6303             0,
6304             NULL,
6305             pvQueryBuffer,
6306             u4QueryBufferLen
6307             );
6308     }
6309 }   /* wlanoidQueryRcvOk */
6310
6311
6312 /*----------------------------------------------------------------------------*/
6313 /*!
6314 * \brief This routine is called to query the number of frames that the driver
6315 *        fails to transmit.
6316 *
6317 * \param[in] pvAdapter Pointer to the Adapter structure.
6318 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
6319 *                           the query.
6320 * \param[in] u4QueryBufLen The length of the query buffer.
6321 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
6322 *                            bytes written into the query buffer. If the call
6323 *                            failed due to invalid length of the query buffer,
6324 *                            returns the amount of storage needed.
6325 *
6326 * \retval WLAN_STATUS_SUCCESS
6327 * \retval WLAN_STATUS_INVALID_LENGTH
6328 */
6329 /*----------------------------------------------------------------------------*/
6330 WLAN_STATUS
6331 wlanoidQueryXmitError (
6332     IN  P_ADAPTER_T     prAdapter,
6333     IN  PVOID           pvQueryBuffer,
6334     IN  UINT_32         u4QueryBufferLen,
6335     OUT PUINT_32        pu4QueryInfoLen
6336     )
6337 {
6338     DEBUGFUNC("wlanoidQueryXmitError");
6339     DBGLOG(REQ, LOUD, ("\n"));
6340
6341     ASSERT(prAdapter);
6342     if (u4QueryBufferLen) {
6343         ASSERT(pvQueryBuffer);
6344     }
6345     ASSERT(pu4QueryInfoLen);
6346
6347     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
6348         DBGLOG(REQ, WARN, ("Fail in query receive error! (Adapter not ready). ACPI=D%d, Radio=%d\n",
6349                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
6350         *pu4QueryInfoLen = sizeof(UINT_32);
6351         return WLAN_STATUS_ADAPTER_NOT_READY;
6352     }
6353     else if (u4QueryBufferLen < sizeof(UINT_32)
6354             || (u4QueryBufferLen > sizeof(UINT_32) && u4QueryBufferLen < sizeof(UINT_64))) {
6355         *pu4QueryInfoLen = sizeof(UINT_64);
6356         return WLAN_STATUS_INVALID_LENGTH;
6357     }
6358
6359 #if CFG_ENABLE_STATISTICS_BUFFERING
6360     if(IsBufferedStatisticsUsable(prAdapter) == TRUE) {
6361         if(u4QueryBufferLen == sizeof(UINT_32)) {
6362             *pu4QueryInfoLen = sizeof(UINT_32);
6363             *(PUINT_32) pvQueryBuffer = (UINT_32) prAdapter->rStatStruct.rFailedCount.QuadPart;
6364         }
6365         else {
6366             *pu4QueryInfoLen = sizeof(UINT_64);
6367             *(PUINT_64) pvQueryBuffer = (UINT_64) prAdapter->rStatStruct.rFailedCount.QuadPart;
6368         }
6369
6370         return WLAN_STATUS_SUCCESS;
6371     }
6372     else
6373 #endif
6374     {
6375     return wlanSendSetQueryCmd(prAdapter,
6376             CMD_ID_GET_STATISTICS,
6377             FALSE,
6378             TRUE,
6379             TRUE,
6380             nicCmdEventQueryXmitError,
6381             nicOidCmdTimeoutCommon,
6382             0,
6383             NULL,
6384             pvQueryBuffer,
6385             u4QueryBufferLen
6386             );
6387     }
6388 } /* wlanoidQueryXmitError */
6389
6390
6391 /*----------------------------------------------------------------------------*/
6392 /*!
6393 * \brief This routine is called to query the number of frames successfully
6394 *        transmitted after exactly one collision.
6395 *
6396 * \param[in] prAdapter Pointer to the Adapter structure.
6397 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
6398 *                           the query.
6399 * \param[in] u4QueryBufLen The length of the query buffer.
6400 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
6401 *                            bytes written into the query buffer. If the call
6402 *                            failed due to invalid length of the query buffer,
6403 *                            returns the amount of storage needed.
6404 *
6405 * \retval WLAN_STATUS_SUCCESS
6406 * \retval WLAN_STATUS_INVALID_LENGTH
6407 */
6408 /*----------------------------------------------------------------------------*/
6409 WLAN_STATUS
6410 wlanoidQueryXmitOneCollision (
6411     IN  P_ADAPTER_T     prAdapter,
6412     IN  PVOID           pvQueryBuffer,
6413     IN  UINT_32         u4QueryBufferLen,
6414     OUT PUINT_32        pu4QueryInfoLen
6415     )
6416 {
6417     DEBUGFUNC("wlanoidQueryXmitOneCollision");
6418     DBGLOG(REQ, LOUD, ("\n"));
6419
6420     ASSERT(prAdapter);
6421     if (u4QueryBufferLen) {
6422         ASSERT(pvQueryBuffer);
6423     }
6424     ASSERT(pu4QueryInfoLen);
6425
6426     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
6427         DBGLOG(REQ, WARN, ("Fail in query receive error! (Adapter not ready). ACPI=D%d, Radio=%d\n",
6428                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
6429         *pu4QueryInfoLen = sizeof(UINT_32);
6430         return WLAN_STATUS_ADAPTER_NOT_READY;
6431     }
6432     else if (u4QueryBufferLen < sizeof(UINT_32)
6433             || (u4QueryBufferLen > sizeof(UINT_32) && u4QueryBufferLen < sizeof(UINT_64))) {
6434         *pu4QueryInfoLen = sizeof(UINT_64);
6435         return WLAN_STATUS_INVALID_LENGTH;
6436     }
6437
6438 #if CFG_ENABLE_STATISTICS_BUFFERING
6439     if(IsBufferedStatisticsUsable(prAdapter) == TRUE) {
6440         if(u4QueryBufferLen == sizeof(UINT_32)) {
6441             *pu4QueryInfoLen = sizeof(UINT_32);
6442             *(PUINT_32) pvQueryBuffer = (UINT_32)
6443                 (prAdapter->rStatStruct.rMultipleRetryCount.QuadPart - prAdapter->rStatStruct.rRetryCount.QuadPart);
6444         }
6445         else {
6446             *pu4QueryInfoLen = sizeof(UINT_64);
6447             *(PUINT_64) pvQueryBuffer = (UINT_64)
6448                 (prAdapter->rStatStruct.rMultipleRetryCount.QuadPart - prAdapter->rStatStruct.rRetryCount.QuadPart);
6449         }
6450
6451         return WLAN_STATUS_SUCCESS;
6452     }
6453     else
6454 #endif
6455     {
6456     return wlanSendSetQueryCmd(prAdapter,
6457             CMD_ID_GET_STATISTICS,
6458             FALSE,
6459             TRUE,
6460             TRUE,
6461             nicCmdEventQueryXmitOneCollision,
6462             nicOidCmdTimeoutCommon,
6463             0,
6464             NULL,
6465             pvQueryBuffer,
6466             u4QueryBufferLen
6467             );
6468     }
6469 } /* wlanoidQueryXmitOneCollision */
6470
6471
6472 /*----------------------------------------------------------------------------*/
6473 /*!
6474 * \brief This routine is called to query the number of frames successfully
6475 *        transmitted after more than one collision.
6476 *
6477 * \param[in] prAdapter Pointer to the Adapter structure.
6478 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
6479 *                           the query.
6480 * \param[in] u4QueryBufLen The length of the query buffer.
6481 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
6482 *                            bytes written into the query buffer. If the call
6483 *                            failed due to invalid length of the query buffer,
6484 *                            returns the amount of storage needed.
6485 *
6486 * \retval WLAN_STATUS_SUCCESS
6487 * \retval WLAN_STATUS_INVALID_LENGTH
6488 */
6489 /*----------------------------------------------------------------------------*/
6490 WLAN_STATUS
6491 wlanoidQueryXmitMoreCollisions (
6492     IN  P_ADAPTER_T     prAdapter,
6493     IN  PVOID           pvQueryBuffer,
6494     IN  UINT_32         u4QueryBufferLen,
6495     OUT PUINT_32        pu4QueryInfoLen
6496     )
6497 {
6498     DEBUGFUNC("wlanoidQueryXmitMoreCollisions");
6499     DBGLOG(REQ, LOUD, ("\n"));
6500
6501     ASSERT(prAdapter);
6502     if (u4QueryBufferLen) {
6503         ASSERT(pvQueryBuffer);
6504     }
6505     ASSERT(pu4QueryInfoLen);
6506
6507     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
6508         DBGLOG(REQ, WARN, ("Fail in query receive error! (Adapter not ready). ACPI=D%d, Radio=%d\n",
6509                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
6510         *pu4QueryInfoLen = sizeof(UINT_32);
6511         return WLAN_STATUS_ADAPTER_NOT_READY;
6512     }
6513     else if (u4QueryBufferLen < sizeof(UINT_32)
6514             || (u4QueryBufferLen > sizeof(UINT_32) && u4QueryBufferLen < sizeof(UINT_64))) {
6515         *pu4QueryInfoLen = sizeof(UINT_64);
6516         return WLAN_STATUS_INVALID_LENGTH;
6517     }
6518
6519 #if CFG_ENABLE_STATISTICS_BUFFERING
6520     if(IsBufferedStatisticsUsable(prAdapter) == TRUE) {
6521         if(u4QueryBufferLen == sizeof(UINT_32)) {
6522             *pu4QueryInfoLen = sizeof(UINT_32);
6523             *(PUINT_32) pvQueryBuffer = (UINT_32) (prAdapter->rStatStruct.rMultipleRetryCount.QuadPart);
6524         }
6525         else {
6526             *pu4QueryInfoLen = sizeof(UINT_64);
6527             *(PUINT_64) pvQueryBuffer = (UINT_64) (prAdapter->rStatStruct.rMultipleRetryCount.QuadPart);
6528         }
6529
6530         return WLAN_STATUS_SUCCESS;
6531     }
6532     else
6533 #endif
6534     {
6535     return wlanSendSetQueryCmd(prAdapter,
6536             CMD_ID_GET_STATISTICS,
6537             FALSE,
6538             TRUE,
6539             TRUE,
6540             nicCmdEventQueryXmitMoreCollisions,
6541             nicOidCmdTimeoutCommon,
6542             0,
6543             NULL,
6544             pvQueryBuffer,
6545             u4QueryBufferLen
6546             );
6547     }
6548 } /* wlanoidQueryXmitMoreCollisions */
6549
6550
6551 /*----------------------------------------------------------------------------*/
6552 /*!
6553 * \brief This routine is called to query the number of frames
6554 *                not transmitted due to excessive collisions.
6555 *
6556 * \param[in] prAdapter          Pointer to the Adapter structure.
6557 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
6558 *                               the query.
6559 * \param[in] u4QueryBufferLen   The length of the query buffer.
6560 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
6561 *                               bytes written into the query buffer. If the call
6562 *                               failed due to invalid length of the query buffer,
6563 *                               returns the amount of storage needed.
6564 *
6565 * \retval WLAN_STATUS_SUCCESS
6566 * \retval WLAN_STATUS_INVALID_LENGTH
6567 */
6568 /*----------------------------------------------------------------------------*/
6569 WLAN_STATUS
6570 wlanoidQueryXmitMaxCollisions (
6571     IN   P_ADAPTER_T     prAdapter,
6572     IN   PVOID           pvQueryBuffer,
6573     IN   UINT_32         u4QueryBufferLen,
6574     OUT  PUINT_32        pu4QueryInfoLen
6575     )
6576 {
6577     DEBUGFUNC("wlanoidQueryXmitMaxCollisions");
6578     DBGLOG(REQ, LOUD, ("\n"));
6579
6580     ASSERT(prAdapter);
6581     if (u4QueryBufferLen) {
6582         ASSERT(pvQueryBuffer);
6583     }
6584     ASSERT(pu4QueryInfoLen);
6585
6586     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
6587         DBGLOG(REQ, WARN, ("Fail in query receive error! (Adapter not ready). ACPI=D%d, Radio=%d\n",
6588                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
6589         *pu4QueryInfoLen = sizeof(UINT_32);
6590         return WLAN_STATUS_ADAPTER_NOT_READY;
6591     }
6592     else if (u4QueryBufferLen < sizeof(UINT_32)
6593             || (u4QueryBufferLen > sizeof(UINT_32) && u4QueryBufferLen < sizeof(UINT_64))) {
6594         *pu4QueryInfoLen = sizeof(UINT_64);
6595         return WLAN_STATUS_INVALID_LENGTH;
6596     }
6597
6598 #if CFG_ENABLE_STATISTICS_BUFFERING
6599     if(IsBufferedStatisticsUsable(prAdapter) == TRUE) {
6600         if(u4QueryBufferLen == sizeof(UINT_32)) {
6601             *pu4QueryInfoLen = sizeof(UINT_32);
6602             *(PUINT_32) pvQueryBuffer = (UINT_32) prAdapter->rStatStruct.rFailedCount.QuadPart;
6603         }
6604         else {
6605             *pu4QueryInfoLen = sizeof(UINT_64);
6606             *(PUINT_64) pvQueryBuffer = (UINT_64) prAdapter->rStatStruct.rFailedCount.QuadPart;
6607         }
6608
6609         return WLAN_STATUS_SUCCESS;
6610     }
6611     else
6612 #endif
6613     {
6614     return wlanSendSetQueryCmd(prAdapter,
6615             CMD_ID_GET_STATISTICS,
6616             FALSE,
6617             TRUE,
6618             TRUE,
6619             nicCmdEventQueryXmitMaxCollisions,
6620             nicOidCmdTimeoutCommon,
6621             0,
6622             NULL,
6623             pvQueryBuffer,
6624             u4QueryBufferLen
6625             );
6626     }
6627 }   /* wlanoidQueryXmitMaxCollisions */
6628
6629
6630 #define MTK_CUSTOM_OID_INTERFACE_VERSION     0x00006620    // for WPDWifi DLL
6631 /*----------------------------------------------------------------------------*/
6632 /*!
6633 * \brief This routine is called to query current the OID interface version,
6634 *        which is the interface between the application and driver.
6635 *
6636 * \param[in] prAdapter          Pointer to the Adapter structure.
6637 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
6638 *                               the query.
6639 * \param[in] u4QueryBufferLen   The length of the query buffer.
6640 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
6641 *                               bytes written into the query buffer. If the call
6642 *                               failed due to invalid length of the query buffer,
6643 *                               returns the amount of storage needed.
6644 *
6645 * \retval WLAN_STATUS_SUCCESS
6646 */
6647 /*----------------------------------------------------------------------------*/
6648 WLAN_STATUS
6649 wlanoidQueryOidInterfaceVersion (
6650     IN P_ADAPTER_T  prAdapter,
6651     IN  PVOID    pvQueryBuffer,
6652     IN  UINT_32  u4QueryBufferLen,
6653     OUT PUINT_32 pu4QueryInfoLen)
6654 {
6655     DEBUGFUNC("wlanoidQueryOidInterfaceVersion");
6656
6657     ASSERT(prAdapter);
6658     if (u4QueryBufferLen) {
6659         ASSERT(pvQueryBuffer);
6660     }
6661     ASSERT(pu4QueryInfoLen);
6662
6663     *(PUINT_32) pvQueryBuffer = MTK_CUSTOM_OID_INTERFACE_VERSION ;
6664     *pu4QueryInfoLen = sizeof(UINT_32);
6665
6666     DBGLOG(REQ, WARN, ("Custom OID interface version: %#08lX\n",
6667         *(PUINT_32) pvQueryBuffer));
6668
6669     return WLAN_STATUS_SUCCESS;
6670 }   /* wlanoidQueryOidInterfaceVersion */
6671
6672
6673 /*----------------------------------------------------------------------------*/
6674 /*!
6675 * \brief This routine is called to query current Multicast Address List.
6676 *
6677 * \param[in] prAdapter          Pointer to the Adapter structure.
6678 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
6679 *                               the query.
6680 * \param[in] u4QueryBufferLen   The length of the query buffer.
6681 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
6682 *                               bytes written into the query buffer. If the call
6683 *                               failed due to invalid length of the query buffer,
6684 *                               returns the amount of storage needed.
6685 *
6686 * \retval WLAN_STATUS_SUCCESS
6687 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
6688 */
6689 /*----------------------------------------------------------------------------*/
6690 WLAN_STATUS
6691 wlanoidQueryMulticastList(
6692     IN  P_ADAPTER_T prAdapter,
6693     OUT PVOID       pvQueryBuffer,
6694     IN  UINT_32     u4QueryBufferLen,
6695     OUT PUINT_32    pu4QueryInfoLen
6696     )
6697 {
6698 #ifndef LINUX
6699     ASSERT(prAdapter);
6700     ASSERT(pu4QueryInfoLen);
6701     if (u4QueryBufferLen) {
6702         ASSERT(pvQueryBuffer);
6703     }
6704
6705     return wlanSendSetQueryCmd(prAdapter,
6706             CMD_ID_MAC_MCAST_ADDR,
6707             FALSE,
6708             TRUE,
6709             TRUE,
6710             nicCmdEventQueryMcastAddr,
6711             nicOidCmdTimeoutCommon,
6712             0,
6713             NULL,
6714             pvQueryBuffer,
6715             u4QueryBufferLen
6716             );
6717 #else
6718      return WLAN_STATUS_SUCCESS;
6719 #endif
6720 } /* end of wlanoidQueryMulticastList() */
6721
6722
6723 /*----------------------------------------------------------------------------*/
6724 /*!
6725 * \brief This routine is called to set Multicast Address List.
6726 *
6727 * \param[in] prAdapter      Pointer to the Adapter structure.
6728 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
6729 * \param[in] u4SetBufferLen The length of the set buffer.
6730 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
6731 *                           bytes read from the set buffer. If the call failed
6732 *                           due to invalid length of the set buffer, returns
6733 *                           the amount of storage needed.
6734 *
6735 * \retval WLAN_STATUS_SUCCESS
6736 * \retval WLAN_STATUS_INVALID_LENGTH
6737 * \retval WLAN_STATUS_ADAPTER_NOT_READY
6738 * \retval WLAN_STATUS_MULTICAST_FULL
6739 */
6740 /*----------------------------------------------------------------------------*/
6741  WLAN_STATUS
6742  wlanoidSetMulticastList(
6743      IN  P_ADAPTER_T prAdapter,
6744      IN  PVOID       pvSetBuffer,
6745      IN  UINT_32     u4SetBufferLen,
6746      OUT PUINT_32    pu4SetInfoLen
6747      )
6748  {
6749      UINT_8 ucNetTypeIndex = NETWORK_TYPE_AIS_INDEX; /* Caller should provide this information */
6750      CMD_MAC_MCAST_ADDR  rCmdMacMcastAddr;
6751      ASSERT(prAdapter);
6752      ASSERT(pu4SetInfoLen);
6753
6754      /* The data must be a multiple of the Ethernet address size. */
6755      if ((u4SetBufferLen % MAC_ADDR_LEN)) {
6756          DBGLOG(REQ, WARN, ("Invalid MC list length %ld\n", u4SetBufferLen));
6757
6758          *pu4SetInfoLen = (((u4SetBufferLen + MAC_ADDR_LEN) - 1) /
6759              MAC_ADDR_LEN) * MAC_ADDR_LEN;
6760
6761          return WLAN_STATUS_INVALID_LENGTH;
6762      }
6763
6764      *pu4SetInfoLen = u4SetBufferLen;
6765
6766      /* Verify if we can support so many multicast addresses. */
6767      if ((u4SetBufferLen / MAC_ADDR_LEN) > MAX_NUM_GROUP_ADDR) {
6768          DBGLOG(REQ, WARN, ("Too many MC addresses\n"));
6769
6770          return WLAN_STATUS_MULTICAST_FULL;
6771      }
6772
6773      /* NOTE(Kevin): Windows may set u4SetBufferLen == 0 &&
6774       * pvSetBuffer == NULL to clear exist Multicast List.
6775       */
6776      if (u4SetBufferLen) {
6777          ASSERT(pvSetBuffer);
6778      }
6779
6780      if (prAdapter->rAcpiState == ACPI_STATE_D3) {
6781          DBGLOG(REQ, WARN, ("Fail in set multicast list! (Adapter not ready). ACPI=D%d, Radio=%d\n",
6782                      prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
6783          return WLAN_STATUS_ADAPTER_NOT_READY;
6784      }
6785
6786      rCmdMacMcastAddr.u4NumOfGroupAddr = u4SetBufferLen / MAC_ADDR_LEN;
6787      rCmdMacMcastAddr.ucNetTypeIndex = ucNetTypeIndex;
6788      kalMemCopy(rCmdMacMcastAddr.arAddress, pvSetBuffer, u4SetBufferLen);
6789
6790      return wlanSendSetQueryCmd(prAdapter,
6791             CMD_ID_MAC_MCAST_ADDR,
6792             TRUE,
6793             FALSE,
6794             TRUE,
6795             nicCmdEventSetCommon,
6796             nicOidCmdTimeoutCommon,
6797             sizeof(CMD_MAC_MCAST_ADDR),
6798             (PUINT_8)&rCmdMacMcastAddr,
6799             pvSetBuffer,
6800             u4SetBufferLen
6801             );
6802 } /* end of wlanoidSetMulticastList() */
6803
6804
6805
6806 /*----------------------------------------------------------------------------*/
6807 /*!
6808 * \brief This routine is called to set Packet Filter.
6809 *
6810 * \param[in] prAdapter      Pointer to the Adapter structure.
6811 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
6812 * \param[in] u4SetBufferLen The length of the set buffer.
6813 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
6814 *                           bytes read from the set buffer. If the call failed
6815 *                           due to invalid length of the set buffer, returns
6816 *                           the amount of storage needed.
6817 *
6818 * \retval WLAN_STATUS_SUCCESS
6819 * \retval WLAN_STATUS_INVALID_LENGTH
6820 * \retval WLAN_STATUS_NOT_SUPPORTED
6821 * \retval WLAN_STATUS_ADAPTER_NOT_READY
6822 */
6823 /*----------------------------------------------------------------------------*/
6824 WLAN_STATUS
6825 wlanoidSetCurrentPacketFilter (
6826     IN P_ADAPTER_T  prAdapter,
6827     IN  PVOID    pvSetBuffer,
6828     IN  UINT_32  u4SetBufferLen,
6829     OUT PUINT_32 pu4SetInfoLen
6830     )
6831 {
6832     UINT_32 u4NewPacketFilter;
6833     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
6834
6835     DEBUGFUNC("wlanoidSetCurrentPacketFilter");
6836
6837     ASSERT(prAdapter);
6838     ASSERT(pu4SetInfoLen);
6839
6840     if (u4SetBufferLen < sizeof(UINT_32)) {
6841         *pu4SetInfoLen = sizeof(UINT_32);
6842         return WLAN_STATUS_INVALID_LENGTH;
6843     }
6844     ASSERT(pvSetBuffer);
6845
6846     /* Set the new packet filter. */
6847     u4NewPacketFilter = *(PUINT_32) pvSetBuffer;
6848
6849     DBGLOG(REQ, INFO, ("New packet filter: %#08lx\n", u4NewPacketFilter));
6850
6851     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
6852         DBGLOG(REQ, WARN, ("Fail in set current packet filter! (Adapter not ready). ACPI=D%d, Radio=%d\n",
6853                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
6854         return WLAN_STATUS_ADAPTER_NOT_READY;
6855     }
6856
6857     do {
6858         /* Verify the bits of the new packet filter. If any bits are set that
6859            we don't support, leave. */
6860         if (u4NewPacketFilter & ~(PARAM_PACKET_FILTER_SUPPORTED)) {
6861             rStatus = WLAN_STATUS_NOT_SUPPORTED;
6862             break;
6863         }
6864
6865 #if DBG
6866         /* Need to enable or disable promiscuous support depending on the new
6867            filter. */
6868         if (u4NewPacketFilter & PARAM_PACKET_FILTER_PROMISCUOUS) {
6869             DBGLOG(REQ, INFO, ("Enable promiscuous mode\n"));
6870         }
6871         else {
6872             DBGLOG(REQ, INFO, ("Disable promiscuous mode\n"));
6873         }
6874
6875         if (u4NewPacketFilter & PARAM_PACKET_FILTER_ALL_MULTICAST) {
6876             DBGLOG(REQ, INFO, ("Enable all-multicast mode\n"));
6877         }
6878         else if (u4NewPacketFilter & PARAM_PACKET_FILTER_MULTICAST) {
6879             DBGLOG(REQ, INFO, ("Enable multicast\n"));
6880         }
6881         else {
6882             DBGLOG(REQ, INFO, ("Disable multicast\n"));
6883         }
6884
6885         if (u4NewPacketFilter & PARAM_PACKET_FILTER_BROADCAST) {
6886             DBGLOG(REQ, INFO, ("Enable Broadcast\n"));
6887         }
6888         else {
6889             DBGLOG(REQ, INFO, ("Disable Broadcast\n"));
6890         }
6891 #endif
6892     } while (FALSE);
6893
6894     if(rStatus == WLAN_STATUS_SUCCESS) {
6895         // Store the packet filter
6896
6897         prAdapter->u4OsPacketFilter &= PARAM_PACKET_FILTER_P2P_MASK;
6898         prAdapter->u4OsPacketFilter |= u4NewPacketFilter;
6899
6900         return wlanSendSetQueryCmd(prAdapter,
6901                 CMD_ID_SET_RX_FILTER,
6902                 TRUE,
6903                 FALSE,
6904                 TRUE,
6905                 nicCmdEventSetCommon,
6906                 nicOidCmdTimeoutCommon,
6907                 sizeof(UINT_32),
6908                 (PUINT_8)&prAdapter->u4OsPacketFilter,
6909                 pvSetBuffer,
6910                 u4SetBufferLen
6911                 );
6912     }
6913     else {
6914         return rStatus;
6915     }
6916 }   /* wlanoidSetCurrentPacketFilter */
6917
6918
6919 /*----------------------------------------------------------------------------*/
6920 /*!
6921 * \brief This routine is called to query current packet filter.
6922 *
6923 * \param[in] prAdapter          Pointer to the Adapter structure.
6924 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
6925 *                               the query.
6926 * \param[in] u4QueryBufferLen   The length of the query buffer.
6927 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
6928 *                               bytes written into the query buffer. If the call
6929 *                               failed due to invalid length of the query buffer,
6930 *                               returns the amount of storage needed.
6931 *
6932 * \retval WLAN_STATUS_SUCCESS
6933 */
6934 /*----------------------------------------------------------------------------*/
6935 WLAN_STATUS
6936 wlanoidQueryCurrentPacketFilter (
6937     IN P_ADAPTER_T  prAdapter,
6938     OUT PVOID       pvQueryBuffer,
6939     IN  UINT_32     u4QueryBufferLen,
6940     OUT PUINT_32    pu4QueryInfoLen
6941     )
6942 {
6943     DEBUGFUNC("wlanoidQueryCurrentPacketFilter");
6944     ASSERT(prAdapter);
6945     ASSERT(pu4QueryInfoLen);
6946
6947     *pu4QueryInfoLen = sizeof(UINT_32);
6948
6949     if (u4QueryBufferLen >= sizeof(UINT_32)) {
6950         ASSERT(pvQueryBuffer);
6951         *(PUINT_32) pvQueryBuffer = prAdapter->u4OsPacketFilter;
6952     }
6953
6954     return WLAN_STATUS_SUCCESS;
6955 }   /* wlanoidQueryCurrentPacketFilter */
6956
6957 /*----------------------------------------------------------------------------*/
6958 /*!
6959 * \brief This routine is called to query ACPI device power state.
6960 *
6961 * \param[in] prAdapter          Pointer to the Adapter structure.
6962 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
6963 *                               the query.
6964 * \param[in] u4QueryBufferLen   The length of the query buffer.
6965 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
6966 *                               bytes written into the query buffer. If the call
6967 *                               failed due to invalid length of the query buffer,
6968 *                               returns the amount of storage needed.
6969 *
6970 * \retval WLAN_STATUS_SUCCESS
6971 */
6972 /*----------------------------------------------------------------------------*/
6973 WLAN_STATUS
6974 wlanoidQueryAcpiDevicePowerState (
6975     IN P_ADAPTER_T prAdapter,
6976     IN  PVOID       pvQueryBuffer,
6977     IN  UINT_32     u4QueryBufferLen,
6978     OUT PUINT_32    pu4QueryInfoLen
6979     )
6980 {
6981 #if DBG
6982     PPARAM_DEVICE_POWER_STATE prPowerState;
6983 #endif
6984
6985     DEBUGFUNC("wlanoidQueryAcpiDevicePowerState");
6986     ASSERT(prAdapter);
6987     ASSERT(pu4QueryInfoLen);
6988     if (u4QueryBufferLen) {
6989         ASSERT(pvQueryBuffer);
6990     }
6991
6992     *pu4QueryInfoLen = sizeof(PARAM_DEVICE_POWER_STATE);
6993
6994 #if DBG
6995     prPowerState = (PPARAM_DEVICE_POWER_STATE) pvQueryBuffer;
6996     switch (*prPowerState) {
6997     case ParamDeviceStateD0:
6998         DBGLOG(REQ, INFO, ("Query Power State: D0\n"));
6999         break;
7000     case ParamDeviceStateD1:
7001         DBGLOG(REQ, INFO, ("Query Power State: D1\n"));
7002         break;
7003     case ParamDeviceStateD2:
7004         DBGLOG(REQ, INFO, ("Query Power State: D2\n"));
7005         break;
7006     case ParamDeviceStateD3:
7007         DBGLOG(REQ, INFO, ("Query Power State: D3\n"));
7008         break;
7009     default:
7010         break;
7011     }
7012 #endif
7013
7014     /* Since we will disconnect the newwork, therefore we do not
7015        need to check queue empty */
7016     *(PPARAM_DEVICE_POWER_STATE) pvQueryBuffer = ParamDeviceStateD3;
7017     //WARNLOG(("Ready to transition to D3\n"));
7018     return WLAN_STATUS_SUCCESS;
7019
7020 }   /* pwrmgtQueryPower */
7021
7022
7023 /*----------------------------------------------------------------------------*/
7024 /*!
7025 * \brief This routine is called to set ACPI device power state.
7026 *
7027 * \param[in] pvAdapter Pointer to the Adapter structure.
7028 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
7029 * \param[in] u4SetBufferLen The length of the set buffer.
7030 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7031 *                          bytes read from the set buffer. If the call failed
7032 *                          due to invalid length of the set buffer, returns
7033 *                          the amount of storage needed.
7034 *
7035 * \retval WLAN_STATUS_SUCCESS
7036 */
7037 /*----------------------------------------------------------------------------*/
7038 WLAN_STATUS
7039 wlanoidSetAcpiDevicePowerState (
7040     IN P_ADAPTER_T prAdapter,
7041     IN  PVOID    pvSetBuffer,
7042     IN  UINT_32  u4SetBufferLen,
7043     OUT PUINT_32 pu4SetInfoLen
7044     )
7045 {
7046     PPARAM_DEVICE_POWER_STATE prPowerState;
7047     BOOLEAN fgRetValue = TRUE;
7048
7049     DEBUGFUNC("wlanoidSetAcpiDevicePowerState");
7050     ASSERT(prAdapter);
7051     ASSERT(pu4SetInfoLen);
7052
7053     *pu4SetInfoLen = sizeof(PARAM_DEVICE_POWER_STATE);
7054
7055     ASSERT(pvSetBuffer);
7056     prPowerState = (PPARAM_DEVICE_POWER_STATE) pvSetBuffer;
7057     switch (*prPowerState) {
7058     case ParamDeviceStateD0:
7059         DBGLOG(REQ, INFO, ("Set Power State: D0\n"));
7060         kalDevSetPowerState(prAdapter->prGlueInfo, (UINT_32)ParamDeviceStateD0);
7061         fgRetValue = nicpmSetAcpiPowerD0(prAdapter);
7062         break;
7063     case ParamDeviceStateD1:
7064         DBGLOG(REQ, INFO, ("Set Power State: D1\n"));
7065         /* no break here */
7066     case ParamDeviceStateD2:
7067         DBGLOG(REQ, INFO, ("Set Power State: D2\n"));
7068         /* no break here */
7069     case ParamDeviceStateD3:
7070         DBGLOG(REQ, INFO, ("Set Power State: D3\n"));
7071         fgRetValue = nicpmSetAcpiPowerD3(prAdapter);
7072         kalDevSetPowerState(prAdapter->prGlueInfo, (UINT_32)ParamDeviceStateD3);
7073         break;
7074     default:
7075         break;
7076     }
7077
7078     if(fgRetValue == TRUE)
7079         return WLAN_STATUS_SUCCESS;
7080     else
7081         return WLAN_STATUS_FAILURE;
7082 } /* end of wlanoidSetAcpiDevicePowerState() */
7083
7084 /*----------------------------------------------------------------------------*/
7085 /*!
7086 * \brief This routine is called to query the current fragmentation threshold.
7087 *
7088 * \param[in] pvAdapter Pointer to the Adapter structure.
7089 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
7090 *                           the query.
7091 * \param[in] u4QueryBufferLen The length of the query buffer.
7092 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
7093 *                            bytes written into the query buffer. If the call
7094 *                            failed due to invalid length of the query buffer,
7095 *                            returns the amount of storage needed.
7096 *
7097 * \retval WLAN_STATUS_SUCCESS
7098 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
7099 */
7100 /*----------------------------------------------------------------------------*/
7101 WLAN_STATUS
7102 wlanoidQueryFragThreshold (
7103     IN  P_ADAPTER_T prAdapter,
7104     OUT PVOID       pvQueryBuffer,
7105     IN  UINT_32     u4QueryBufferLen,
7106     OUT PUINT_32    pu4QueryInfoLen
7107     )
7108 {
7109     DEBUGFUNC("wlanoidQueryFragThreshold");
7110
7111     ASSERT(prAdapter);
7112     if (u4QueryBufferLen) {
7113         ASSERT(pvQueryBuffer);
7114     }
7115     ASSERT(pu4QueryInfoLen);
7116
7117     DBGLOG(REQ, LOUD, ("\n"));
7118
7119 #if CFG_TX_FRAGMENT
7120
7121     return WLAN_STATUS_SUCCESS;
7122
7123 #else
7124
7125     return WLAN_STATUS_NOT_SUPPORTED;
7126 #endif /* CFG_TX_FRAGMENT */
7127
7128 } /* end of wlanoidQueryFragThreshold() */
7129
7130
7131 /*----------------------------------------------------------------------------*/
7132 /*!
7133 * \brief This routine is called to set a new fragmentation threshold to the
7134 *        driver.
7135 *
7136 * \param[in] pvAdapter Pointer to the Adapter structure.
7137 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
7138 * \param[in] u4SetBufferLen The length of the set buffer.
7139 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7140 *                          bytes read from the set buffer. If the call failed
7141 *                          due to invalid length of the set buffer, returns
7142 *                          the amount of storage needed.
7143 *
7144 * \retval WLAN_STATUS_SUCCESS
7145 * \retval WLAN_STATUS_INVALID_DATA
7146 * \retval WLAN_STATUS_INVALID_LENGTH
7147 */
7148 /*----------------------------------------------------------------------------*/
7149 WLAN_STATUS
7150 wlanoidSetFragThreshold (
7151     IN  P_ADAPTER_T prAdapter,
7152     IN  PVOID       pvSetBuffer,
7153     IN  UINT_32     u4SetBufferLen,
7154     OUT PUINT_32    pu4SetInfoLen
7155     )
7156 {
7157 #if CFG_TX_FRAGMENT
7158
7159     return WLAN_STATUS_SUCCESS;
7160
7161 #else
7162
7163     return WLAN_STATUS_NOT_SUPPORTED;
7164 #endif /* CFG_TX_FRAGMENT */
7165
7166 } /* end of wlanoidSetFragThreshold() */
7167
7168
7169 /*----------------------------------------------------------------------------*/
7170 /*!
7171 * \brief This routine is called to query the current RTS threshold.
7172 *
7173 * \param[in] pvAdapter Pointer to the Adapter structure.
7174 * \param[out] pvQueryBuffer A pointer to the buffer that holds the result of
7175 *                           the query.
7176 * \param[in] u4QueryBufferLen The length of the query buffer.
7177 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
7178 *                            bytes written into the query buffer. If the call
7179 *                            failed due to invalid length of the query buffer,
7180 *                            returns the amount of storage needed.
7181 *
7182 * \retval WLAN_STATUS_SUCCESS
7183 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
7184 */
7185 /*----------------------------------------------------------------------------*/
7186 WLAN_STATUS
7187 wlanoidQueryRtsThreshold (
7188     IN  P_ADAPTER_T prAdapter,
7189     OUT PVOID       pvQueryBuffer,
7190     IN  UINT_32     u4QueryBufferLen,
7191     OUT PUINT_32    pu4QueryInfoLen
7192     )
7193 {
7194     DEBUGFUNC("wlanoidQueryRtsThreshold");
7195
7196     ASSERT(prAdapter);
7197     if (u4QueryBufferLen) {
7198         ASSERT(pvQueryBuffer);
7199     }
7200     ASSERT(pu4QueryInfoLen);
7201
7202     DBGLOG(REQ, LOUD, ("\n"));
7203
7204     if (u4QueryBufferLen < sizeof(PARAM_RTS_THRESHOLD)) {
7205         *pu4QueryInfoLen = sizeof(PARAM_RTS_THRESHOLD);
7206         return WLAN_STATUS_BUFFER_TOO_SHORT;
7207     }
7208
7209     *((PARAM_RTS_THRESHOLD *)pvQueryBuffer) = prAdapter->rWlanInfo.eRtsThreshold;
7210
7211     return WLAN_STATUS_SUCCESS;
7212
7213 } /* wlanoidQueryRtsThreshold */
7214
7215
7216 /*----------------------------------------------------------------------------*/
7217 /*!
7218 * \brief This routine is called to set a new RTS threshold to the driver.
7219 *
7220 * \param[in] pvAdapter Pointer to the Adapter structure.
7221 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
7222 * \param[in] u4SetBufferLen The length of the set buffer.
7223 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7224 *                          bytes read from the set buffer. If the call failed
7225 *                          due to invalid length of the set buffer, returns
7226 *                          the amount of storage needed.
7227 *
7228 * \retval WLAN_STATUS_SUCCESS
7229 * \retval WLAN_STATUS_INVALID_DATA
7230 * \retval WLAN_STATUS_INVALID_LENGTH
7231 */
7232 /*----------------------------------------------------------------------------*/
7233 WLAN_STATUS
7234 wlanoidSetRtsThreshold (
7235     IN  P_ADAPTER_T prAdapter,
7236     IN  PVOID       pvSetBuffer,
7237     IN  UINT_32     u4SetBufferLen,
7238     OUT PUINT_32    pu4SetInfoLen
7239     )
7240 {
7241     PARAM_RTS_THRESHOLD   *prRtsThreshold;
7242
7243     ASSERT(prAdapter);
7244     ASSERT(pu4SetInfoLen);
7245
7246     *pu4SetInfoLen = sizeof(PARAM_RTS_THRESHOLD);
7247     if (u4SetBufferLen < sizeof(PARAM_RTS_THRESHOLD)) {
7248         DBGLOG(REQ, WARN, ("Invalid length %ld\n", u4SetBufferLen));
7249         return WLAN_STATUS_INVALID_LENGTH;
7250     }
7251
7252     prRtsThreshold = (PARAM_RTS_THRESHOLD *)pvSetBuffer;
7253     *prRtsThreshold = prAdapter->rWlanInfo.eRtsThreshold;
7254
7255     return WLAN_STATUS_SUCCESS;
7256
7257 } /* wlanoidSetRtsThreshold */
7258
7259 /*----------------------------------------------------------------------------*/
7260 /*!
7261 * \brief This routine is used to turn radio off.
7262 *
7263 * \param[in] pvAdapter Pointer to the Adapter structure.
7264 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
7265 * \param[in] u4SetBufferLen The length of the set buffer.
7266 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7267 *                          bytes read from the set buffer. If the call failed
7268 *                          due to invalid length of the set buffer, returns
7269 *                          the amount of storage needed.
7270 *
7271 * \retval WLAN_STATUS_SUCCESS
7272 * \retval WLAN_STATUS_ADAPTER_NOT_READY
7273 */
7274 /*----------------------------------------------------------------------------*/
7275 WLAN_STATUS
7276 wlanoidSetDisassociate (
7277     IN P_ADAPTER_T        prAdapter,
7278     IN  PVOID             pvSetBuffer,
7279     IN  UINT_32           u4SetBufferLen,
7280     OUT PUINT_32          pu4SetInfoLen
7281     )
7282 {
7283     P_MSG_AIS_ABORT_T prAisAbortMsg;
7284
7285     DEBUGFUNC("wlanoidSetDisassociate");
7286
7287     ASSERT(prAdapter);
7288     ASSERT(pu4SetInfoLen);
7289
7290     *pu4SetInfoLen = 0;
7291
7292     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
7293         DBGLOG(REQ, WARN, ("Fail in set disassociate! (Adapter not ready). ACPI=D%d, Radio=%d\n",
7294                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
7295         return WLAN_STATUS_ADAPTER_NOT_READY;
7296     }
7297
7298     /* prepare message to AIS */
7299     prAdapter->rWifiVar.rConnSettings.fgIsConnReqIssued = FALSE;
7300
7301     /* Send AIS Abort Message */
7302     prAisAbortMsg = (P_MSG_AIS_ABORT_T)cnmMemAlloc(prAdapter, RAM_TYPE_MSG, sizeof(MSG_AIS_ABORT_T));
7303     if (!prAisAbortMsg) {
7304         ASSERT(0);
7305         return WLAN_STATUS_FAILURE;
7306     }
7307
7308     prAisAbortMsg->rMsgHdr.eMsgId = MID_OID_AIS_FSM_JOIN_REQ;
7309     prAisAbortMsg->ucReasonOfDisconnect = DISCONNECT_REASON_CODE_NEW_CONNECTION;
7310     prAisAbortMsg->fgDelayIndication = FALSE;
7311
7312     mboxSendMsg(prAdapter,
7313             MBOX_ID_0,
7314             (P_MSG_HDR_T) prAisAbortMsg,
7315             MSG_SEND_METHOD_BUF);
7316
7317     /* indicate for disconnection */
7318     if (kalGetMediaStateIndicated(prAdapter->prGlueInfo) == PARAM_MEDIA_STATE_CONNECTED) {
7319         kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
7320                 WLAN_STATUS_MEDIA_DISCONNECT,
7321                 NULL,
7322                 0);
7323     }
7324
7325 #if !defined(LINUX)
7326     prAdapter->fgIsRadioOff = TRUE;
7327 #endif
7328
7329     return WLAN_STATUS_SUCCESS;
7330 } /* wlanoidSetDisassociate */
7331
7332
7333
7334 /*----------------------------------------------------------------------------*/
7335 /*!
7336 * \brief This routine is used to query the power save profile.
7337 *
7338 * \param[in] prAdapter Pointer to the Adapter structure.
7339 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
7340 *                           the query.
7341 * \param[in] u4QueryBufLen The length of the query buffer.
7342 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
7343 *                            bytes written into the query buffer. If the call
7344 *                            failed due to invalid length of the query buffer,
7345 *                            returns the amount of storage needed.
7346 *
7347 * \return WLAN_STATUS_SUCCESS
7348 */
7349 /*----------------------------------------------------------------------------*/
7350 WLAN_STATUS
7351 wlanoidQuery802dot11PowerSaveProfile (
7352     IN  P_ADAPTER_T prAdapter,
7353     IN  PVOID       pvQueryBuffer,
7354     IN  UINT_32     u4QueryBufferLen,
7355     OUT PUINT_32    pu4QueryInfoLen
7356     )
7357 {
7358     DEBUGFUNC("wlanoidQuery802dot11PowerSaveProfile");
7359
7360     ASSERT(prAdapter);
7361     ASSERT(pu4QueryInfoLen);
7362
7363     if (u4QueryBufferLen!=0) {
7364         ASSERT(pvQueryBuffer);
7365
7366 //        *(PPARAM_POWER_MODE) pvQueryBuffer = (PARAM_POWER_MODE)(prAdapter->rWlanInfo.ePowerSaveMode.ucPsProfile);
7367         *(PPARAM_POWER_MODE) pvQueryBuffer = (PARAM_POWER_MODE)(prAdapter->rWlanInfo.arPowerSaveMode[NETWORK_TYPE_AIS_INDEX].ucPsProfile);
7368         *pu4QueryInfoLen = sizeof(PARAM_POWER_MODE);
7369
7370         // hack for CTIA power mode setting function
7371         if (prAdapter->fgEnCtiaPowerMode) {
7372             // set to non-zero value (to prevent MMI query 0, before it intends to set 0, which will skip its following state machine)
7373             *(PPARAM_POWER_MODE) pvQueryBuffer = (PARAM_POWER_MODE)2;
7374         }
7375     }
7376
7377     return WLAN_STATUS_SUCCESS;
7378 }
7379
7380
7381 /*----------------------------------------------------------------------------*/
7382 /*!
7383 * \brief This routine is used to set the power save profile.
7384 *
7385 * \param[in] pvAdapter Pointer to the Adapter structure.
7386 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
7387 * \param[in] u4SetBufferLen The length of the set buffer.
7388 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7389 *                          bytes read from the set buffer. If the call failed
7390 *                          due to invalid length of the set buffer, returns
7391 *                          the amount of storage needed.
7392 *
7393 * \retval WLAN_STATUS_SUCCESS
7394 * \retval WLAN_STATUS_INVALID_LENGTH
7395 */
7396 /*----------------------------------------------------------------------------*/
7397 WLAN_STATUS
7398 wlanoidSet802dot11PowerSaveProfile (
7399     IN  P_ADAPTER_T prAdapter,
7400     IN  PVOID       pvSetBuffer,
7401     IN  UINT_32     u4SetBufferLen,
7402     OUT PUINT_32    pu4SetInfoLen
7403     )
7404 {
7405     WLAN_STATUS status;
7406     PARAM_POWER_MODE ePowerMode;
7407     DEBUGFUNC("wlanoidSet802dot11PowerSaveProfile");
7408
7409     ASSERT(prAdapter);
7410     ASSERT(pu4SetInfoLen);
7411
7412     *pu4SetInfoLen = sizeof(PARAM_POWER_MODE);
7413     if (u4SetBufferLen < sizeof(PARAM_POWER_MODE)) {
7414         DBGLOG(REQ, WARN, ("Invalid length %ld\n", u4SetBufferLen));
7415         return WLAN_STATUS_INVALID_LENGTH;
7416     }
7417     else if (*(PPARAM_POWER_MODE) pvSetBuffer >= Param_PowerModeMax) {
7418         //WARNLOG(("Invalid power mode %d\n",
7419                     //*(PPARAM_POWER_MODE) pvSetBuffer));
7420         return WLAN_STATUS_INVALID_DATA;
7421     }
7422
7423     ePowerMode = *(PPARAM_POWER_MODE) pvSetBuffer;
7424
7425     if (prAdapter->fgEnCtiaPowerMode) {
7426         if (ePowerMode == Param_PowerModeCAM) {
7427
7428         } else {
7429             // User setting to PS mode (Param_PowerModeMAX_PSP or Param_PowerModeFast_PSP)
7430
7431             if (prAdapter->u4CtiaPowerMode == 0) {
7432                 // force to keep in CAM mode
7433                 ePowerMode = Param_PowerModeCAM;
7434             } else if (prAdapter->u4CtiaPowerMode == 1) {
7435                 ePowerMode = Param_PowerModeMAX_PSP;
7436             } else if (prAdapter->u4CtiaPowerMode == 2) {
7437                 ePowerMode = Param_PowerModeFast_PSP;
7438             }
7439         }
7440     }
7441
7442     status = nicConfigPowerSaveProfile(
7443         prAdapter,
7444         NETWORK_TYPE_AIS_INDEX,
7445         ePowerMode,
7446         TRUE);
7447
7448     switch (ePowerMode) {
7449     case Param_PowerModeCAM:
7450         DBGLOG(INIT, INFO, ("Set Wi-Fi PS mode to CAM (%d)\n", ePowerMode));
7451         break;
7452     case Param_PowerModeMAX_PSP:
7453         DBGLOG(INIT, INFO, ("Set Wi-Fi PS mode to MAX PS (%d)\n", ePowerMode));
7454         break;
7455     case Param_PowerModeFast_PSP:
7456         DBGLOG(INIT, INFO, ("Set Wi-Fi PS mode to FAST PS (%d)\n", ePowerMode));
7457         break;
7458     default:
7459         DBGLOG(INIT, INFO, ("invalid Wi-Fi PS mode setting (%d)\n", ePowerMode));
7460         break;
7461     }
7462
7463     return status;
7464
7465 } /* end of wlanoidSetAcpiDevicePowerStateMode() */
7466
7467
7468 /*----------------------------------------------------------------------------*/
7469 /*!
7470 * \brief This routine is called to query current status of AdHoc Mode.
7471 *
7472 * \param[in] prAdapter          Pointer to the Adapter structure.
7473 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
7474 *                               the query.
7475 * \param[in] u4QueryBufferLen   The length of the query buffer.
7476 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
7477 *                               bytes written into the query buffer. If the call
7478 *                               failed due to invalid length of the query buffer,
7479 *                               returns the amount of storage needed.
7480 *
7481 * \retval WLAN_STATUS_SUCCESS
7482 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
7483 */
7484 /*----------------------------------------------------------------------------*/
7485 WLAN_STATUS
7486 wlanoidQueryAdHocMode (
7487     IN  P_ADAPTER_T prAdapter,
7488     OUT PVOID       pvQueryBuffer,
7489     IN  UINT_32     u4QueryBufferLen,
7490     OUT PUINT_32    pu4QueryInfoLen
7491     )
7492 {
7493     return WLAN_STATUS_SUCCESS;
7494 } /* end of wlanoidQueryAdHocMode() */
7495
7496
7497 /*----------------------------------------------------------------------------*/
7498 /*!
7499 * \brief This routine is called to set AdHoc Mode.
7500 *
7501 * \param[in] prAdapter      Pointer to the Adapter structure.
7502 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
7503 * \param[in] u4SetBufferLen The length of the set buffer.
7504 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7505 *                           bytes read from the set buffer. If the call failed
7506 *                           due to invalid length of the set buffer, returns
7507 *                           the amount of storage needed.
7508 *
7509 * \retval WLAN_STATUS_SUCCESS
7510 * \retval WLAN_STATUS_INVALID_LENGTH
7511 * \retval WLAN_STATUS_INVALID_DATA
7512 */
7513 /*----------------------------------------------------------------------------*/
7514 WLAN_STATUS
7515 wlanoidSetAdHocMode (
7516     IN  P_ADAPTER_T prAdapter,
7517     IN  PVOID       pvSetBuffer,
7518     IN  UINT_32     u4SetBufferLen,
7519     OUT PUINT_32    pu4SetInfoLen
7520     )
7521 {
7522     return WLAN_STATUS_SUCCESS;
7523 } /* end of wlanoidSetAdHocMode() */
7524
7525
7526 /*----------------------------------------------------------------------------*/
7527 /*!
7528 * \brief This routine is called to query RF frequency.
7529 *
7530 * \param[in] prAdapter          Pointer to the Adapter structure.
7531 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
7532 *                               the query.
7533 * \param[in] u4QueryBufferLen   The length of the query buffer.
7534 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
7535 *                               bytes written into the query buffer. If the call
7536 *                               failed due to invalid length of the query buffer,
7537 *                               returns the amount of storage needed.
7538 *
7539 * \retval WLAN_STATUS_SUCCESS
7540 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
7541 */
7542 /*----------------------------------------------------------------------------*/
7543 WLAN_STATUS
7544 wlanoidQueryFrequency (
7545     IN  P_ADAPTER_T prAdapter,
7546     OUT PVOID       pvQueryBuffer,
7547     IN  UINT_32     u4QueryBufferLen,
7548     OUT PUINT_32    pu4QueryInfoLen
7549     )
7550 {
7551     DEBUGFUNC("wlanoidQueryFrequency");
7552
7553     ASSERT(prAdapter);
7554     ASSERT(pu4QueryInfoLen);
7555     if (u4QueryBufferLen) {
7556         ASSERT(pvQueryBuffer);
7557     }
7558
7559     if (u4QueryBufferLen < sizeof(UINT_32)) {
7560         return WLAN_STATUS_BUFFER_TOO_SHORT;
7561     }
7562
7563     if (prAdapter->rWifiVar.rConnSettings.eOPMode == NET_TYPE_INFRA) {
7564         if (kalGetMediaStateIndicated(prAdapter->prGlueInfo) == PARAM_MEDIA_STATE_CONNECTED) {
7565             *(PUINT_32)pvQueryBuffer =
7566                 nicChannelNum2Freq(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_AIS_INDEX].ucPrimaryChannel);
7567         }
7568         else {
7569             *(PUINT_32)pvQueryBuffer = 0;
7570         }
7571     }
7572     else {
7573         *(PUINT_32)pvQueryBuffer =
7574             nicChannelNum2Freq(prAdapter->rWifiVar.rConnSettings.ucAdHocChannelNum);
7575     }
7576
7577     return WLAN_STATUS_SUCCESS;
7578 } /* end of wlanoidQueryFrequency() */
7579
7580
7581 /*----------------------------------------------------------------------------*/
7582 /*!
7583 * \brief This routine is called to set RF frequency by User Settings.
7584 *
7585 * \param[in] prAdapter          Pointer to the Adapter structure.
7586 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
7587 *                               the query.
7588 * \param[in] u4QueryBufferLen   The length of the query buffer.
7589 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
7590 *                               bytes written into the query buffer. If the call
7591 *                               failed due to invalid length of the query buffer,
7592 *                               returns the amount of storage needed.
7593 *
7594 * \retval WLAN_STATUS_SUCCESS
7595 * \retval WLAN_STATUS_INVALID_LENGTH
7596 * \retval WLAN_STATUS_INVALID_DATA
7597 */
7598 /*----------------------------------------------------------------------------*/
7599 WLAN_STATUS
7600 wlanoidSetFrequency (
7601     IN  P_ADAPTER_T       prAdapter,
7602     IN  PVOID             pvSetBuffer,
7603     IN  UINT_32           u4SetBufferLen,
7604     OUT PUINT_32          pu4SetInfoLen
7605     )
7606 {
7607     PUINT_32 pu4FreqInKHz;
7608
7609     DEBUGFUNC("wlanoidSetFrequency");
7610
7611     ASSERT(prAdapter);
7612     ASSERT(pu4SetInfoLen);
7613
7614     *pu4SetInfoLen = sizeof(UINT_32);
7615
7616     if (u4SetBufferLen < sizeof(UINT_32)) {
7617         return WLAN_STATUS_INVALID_LENGTH;
7618     }
7619
7620     ASSERT(pvSetBuffer);
7621     pu4FreqInKHz = (PUINT_32)pvSetBuffer;
7622
7623     prAdapter->rWifiVar.rConnSettings.ucAdHocChannelNum
7624         = (UINT_8)nicFreq2ChannelNum(*pu4FreqInKHz);
7625     prAdapter->rWifiVar.rConnSettings.eAdHocBand
7626         = *pu4FreqInKHz < 5000000 ? BAND_2G4 : BAND_5G;
7627
7628     return WLAN_STATUS_SUCCESS;
7629 } /* end of wlanoidSetFrequency() */
7630
7631
7632 /*----------------------------------------------------------------------------*/
7633 /*!
7634 * \brief This routine is called to set 802.11 channel of the radio frequency.
7635 *        This is a proprietary function call to Lunux currently.
7636 *
7637 * \param[in] prAdapter      Pointer to the Adapter structure.
7638 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
7639 * \param[in] u4SetBufferLen The length of the set buffer.
7640 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7641 *                          bytes read from the set buffer. If the call failed
7642 *                          due to invalid length of the set buffer, returns
7643 *                          the amount of storage needed.
7644 *
7645 * \retval WLAN_STATUS_SUCCESS
7646 * \retval WLAN_STATUS_INVALID_LENGTH
7647 * \retval WLAN_STATUS_INVALID_DATA
7648 */
7649 /*----------------------------------------------------------------------------*/
7650 WLAN_STATUS
7651 wlanoidSetChannel (
7652     IN  P_ADAPTER_T       prAdapter,
7653     IN  PVOID             pvSetBuffer,
7654     IN  UINT_32           u4SetBufferLen,
7655     OUT PUINT_32          pu4SetInfoLen
7656     )
7657 {
7658     ASSERT(0); ////
7659
7660     return WLAN_STATUS_SUCCESS;
7661 }
7662
7663
7664 /*----------------------------------------------------------------------------*/
7665 /*!
7666 * \brief This routine is called to query the Beacon Interval from User Settings.
7667 *
7668 * \param[in] prAdapter          Pointer to the Adapter structure.
7669 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
7670 *                               the query.
7671 * \param[in] u4QueryBufferLen   The length of the query buffer.
7672 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
7673 *                               bytes written into the query buffer. If the call
7674 *                               failed due to invalid length of the query buffer,
7675 *                               returns the amount of storage needed.
7676 *
7677 * \retval WLAN_STATUS_SUCCESS
7678 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
7679 */
7680 /*----------------------------------------------------------------------------*/
7681 WLAN_STATUS
7682 wlanoidQueryBeaconInterval (
7683     IN  P_ADAPTER_T prAdapter,
7684     OUT PVOID       pvQueryBuffer,
7685     IN  UINT_32     u4QueryBufferLen,
7686     OUT PUINT_32    pu4QueryInfoLen
7687     )
7688 {
7689     DEBUGFUNC("wlanoidQueryBeaconInterval");
7690     ASSERT(prAdapter);
7691     ASSERT(pu4QueryInfoLen);
7692     if (u4QueryBufferLen) {
7693         ASSERT(pvQueryBuffer);
7694     }
7695
7696     *pu4QueryInfoLen = sizeof(UINT_32);
7697
7698     if (u4QueryBufferLen < sizeof(UINT_32)) {
7699         return WLAN_STATUS_BUFFER_TOO_SHORT;
7700     }
7701
7702     if (kalGetMediaStateIndicated(prAdapter->prGlueInfo) == PARAM_MEDIA_STATE_CONNECTED) {
7703         if (prAdapter->rWifiVar.rConnSettings.eOPMode == NET_TYPE_INFRA) {
7704             *(PUINT_32)pvQueryBuffer =
7705                 prAdapter->rWlanInfo.rCurrBssId.rConfiguration.u4BeaconPeriod;
7706         }
7707         else {
7708             *(PUINT_32)pvQueryBuffer =
7709                 (UINT_32) prAdapter->rWlanInfo.u2BeaconPeriod;
7710         }
7711     }
7712     else {
7713         if (prAdapter->rWifiVar.rConnSettings.eOPMode == NET_TYPE_INFRA) {
7714             *(PUINT_32)pvQueryBuffer = 0;
7715         }
7716         else {
7717             *(PUINT_32)pvQueryBuffer =
7718                 (UINT_32) prAdapter->rWlanInfo.u2BeaconPeriod;
7719         }
7720     }
7721
7722     return WLAN_STATUS_SUCCESS;
7723 } /* end of wlanoidQueryBeaconInterval() */
7724
7725
7726 /*----------------------------------------------------------------------------*/
7727 /*!
7728 * \brief This routine is called to set the Beacon Interval to User Settings.
7729 *
7730 * \param[in] prAdapter      Pointer to the Adapter structure.
7731 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
7732 * \param[in] u4SetBufferLen The length of the set buffer.
7733 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7734 *                           bytes read from the set buffer. If the call failed
7735 *                           due to invalid length of the set buffer, returns
7736 *                           the amount of storage needed.
7737 *
7738 * \retval WLAN_STATUS_SUCCESS
7739 * \retval WLAN_STATUS_INVALID_LENGTH
7740 * \retval WLAN_STATUS_INVALID_DATA
7741 */
7742 /*----------------------------------------------------------------------------*/
7743 WLAN_STATUS
7744 wlanoidSetBeaconInterval (
7745     IN  P_ADAPTER_T prAdapter,
7746     IN  PVOID       pvSetBuffer,
7747     IN  UINT_32     u4SetBufferLen,
7748     OUT PUINT_32    pu4SetInfoLen
7749     )
7750 {
7751     PUINT_32 pu4BeaconInterval;
7752
7753     DEBUGFUNC("wlanoidSetBeaconInterval");
7754
7755     ASSERT(prAdapter);
7756     ASSERT(pu4SetInfoLen);
7757
7758     *pu4SetInfoLen = sizeof(UINT_32);
7759     if (u4SetBufferLen < sizeof(UINT_32)) {
7760         return WLAN_STATUS_INVALID_LENGTH;
7761     }
7762
7763     ASSERT(pvSetBuffer);
7764     pu4BeaconInterval = (PUINT_32)pvSetBuffer;
7765
7766     if ((*pu4BeaconInterval < DOT11_BEACON_PERIOD_MIN) ||
7767             (*pu4BeaconInterval > DOT11_BEACON_PERIOD_MAX)) {
7768         DBGLOG(REQ, TRACE, ("Invalid Beacon Interval = %ld\n", *pu4BeaconInterval));
7769         return WLAN_STATUS_INVALID_DATA;
7770     }
7771
7772     prAdapter->rWlanInfo.u2BeaconPeriod = (UINT_16)*pu4BeaconInterval;
7773
7774     DBGLOG(REQ, INFO, ("Set beacon interval: %d\n",
7775                 prAdapter->rWlanInfo.u2BeaconPeriod));
7776
7777
7778     return WLAN_STATUS_SUCCESS;
7779 } /* end of wlanoidSetBeaconInterval() */
7780
7781
7782 /*----------------------------------------------------------------------------*/
7783 /*!
7784 * \brief This routine is called to query the ATIM window from User Settings.
7785 *
7786 * \param[in] prAdapter          Pointer to the Adapter structure.
7787 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
7788 *                               the query.
7789 * \param[in] u4QueryBufferLen   The length of the query buffer.
7790 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
7791 *                               bytes written into the query buffer. If the call
7792 *                               failed due to invalid length of the query buffer,
7793 *                               returns the amount of storage needed.
7794 *
7795 * \retval WLAN_STATUS_SUCCESS
7796 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
7797 */
7798 /*----------------------------------------------------------------------------*/
7799 WLAN_STATUS
7800 wlanoidQueryAtimWindow (
7801     IN  P_ADAPTER_T prAdapter,
7802     OUT PVOID       pvQueryBuffer,
7803     IN  UINT_32     u4QueryBufferLen,
7804     OUT PUINT_32    pu4QueryInfoLen
7805     )
7806 {
7807     DEBUGFUNC("wlanoidQueryAtimWindow");
7808
7809     ASSERT(prAdapter);
7810     ASSERT(pu4QueryInfoLen);
7811     if (u4QueryBufferLen) {
7812         ASSERT(pvQueryBuffer);
7813     }
7814
7815     *pu4QueryInfoLen = sizeof(UINT_32);
7816
7817     if (u4QueryBufferLen < sizeof(UINT_32)) {
7818         return WLAN_STATUS_BUFFER_TOO_SHORT;
7819     }
7820
7821     if (prAdapter->rWifiVar.rConnSettings.eOPMode == NET_TYPE_INFRA) {
7822         *(PUINT_32)pvQueryBuffer = 0;
7823     }
7824     else {
7825         *(PUINT_32)pvQueryBuffer =
7826             (UINT_32) prAdapter->rWlanInfo.u2AtimWindow;
7827     }
7828
7829     return WLAN_STATUS_SUCCESS;
7830
7831 } /* end of wlanoidQueryAtimWindow() */
7832
7833
7834 /*----------------------------------------------------------------------------*/
7835 /*!
7836 * \brief This routine is called to set the ATIM window to User Settings.
7837 *
7838 * \param[in] prAdapter      Pointer to the Adapter structure.
7839 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
7840 * \param[in] u4SetBufferLen The length of the set buffer.
7841 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7842 *                           bytes read from the set buffer. If the call failed
7843 *                           due to invalid length of the set buffer, returns
7844 *                           the amount of storage needed.
7845 *
7846 * \retval WLAN_STATUS_SUCCESS
7847 * \retval WLAN_STATUS_INVALID_LENGTH
7848 * \retval WLAN_STATUS_INVALID_DATA
7849 */
7850 /*----------------------------------------------------------------------------*/
7851 WLAN_STATUS
7852 wlanoidSetAtimWindow (
7853     IN  P_ADAPTER_T prAdapter,
7854     IN  PVOID       pvSetBuffer,
7855     IN  UINT_32     u4SetBufferLen,
7856     OUT PUINT_32    pu4SetInfoLen
7857     )
7858 {
7859     PUINT_32 pu4AtimWindow;
7860
7861     DEBUGFUNC("wlanoidSetAtimWindow");
7862
7863     ASSERT(prAdapter);
7864     ASSERT(pu4SetInfoLen);
7865
7866     *pu4SetInfoLen = sizeof(UINT_32);
7867
7868     if (u4SetBufferLen < sizeof(UINT_32)) {
7869         return WLAN_STATUS_INVALID_LENGTH;
7870     }
7871
7872     ASSERT(pvSetBuffer);
7873     pu4AtimWindow = (PUINT_32)pvSetBuffer;
7874
7875     prAdapter->rWlanInfo.u2AtimWindow = (UINT_16)*pu4AtimWindow;
7876
7877     return WLAN_STATUS_SUCCESS;
7878 } /* end of wlanoidSetAtimWindow() */
7879
7880 /*----------------------------------------------------------------------------*/
7881 /*!
7882 * \brief This routine is called to Set the MAC address which is currently used by the NIC.
7883 *
7884 * \param[in] prAdapter      Pointer to the Adapter structure.
7885 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
7886 * \param[in] u4SetBufferLen The length of the set buffer.
7887 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7888 *                           bytes read from the set buffer. If the call failed
7889 *                           due to invalid length of the set buffer, returns
7890 *                           the amount of storage needed.
7891 *
7892 *
7893 * \retval WLAN_STATUS_SUCCESS
7894 * \retval WLAN_STATUS_INVALID_LENGTH
7895 * \retval WLAN_STATUS_INVALID_DATA
7896 */
7897 /*----------------------------------------------------------------------------*/
7898 WLAN_STATUS
7899 wlanoidSetCurrentAddr (
7900     IN  P_ADAPTER_T prAdapter,
7901     IN  PVOID       pvSetBuffer,
7902     IN  UINT_32     u4SetBufferLen,
7903     OUT PUINT_32    pu4SetInfoLen
7904     )
7905 {
7906     ASSERT(0); ////
7907
7908     return WLAN_STATUS_SUCCESS;
7909 } /* end of wlanoidSetCurrentAddr() */
7910
7911
7912 #if CFG_TCP_IP_CHKSUM_OFFLOAD
7913 /*----------------------------------------------------------------------------*/
7914 /*!
7915 * \brief Setting the checksum offload function.
7916 *
7917 * \param[in] prAdapter      Pointer to the Adapter structure.
7918 * \param[in] pvSetBuffer    Pointer to the buffer that holds the data to be set.
7919 * \param[in] u4SetBufferLen The length of the set buffer.
7920 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
7921 *                           bytes read from the set buffer. If the call failed
7922 *                           due to invalid length of the set buffer, returns
7923 *                           the amount of storage needed.
7924 *
7925 * \retval WLAN_STATUS_SUCCESS
7926 * \retval WLAN_STATUS_INVALID_LENGTH
7927 * \retval WLAN_STATUS_ADAPTER_NOT_READY
7928 */
7929 /*----------------------------------------------------------------------------*/
7930 WLAN_STATUS
7931 wlanoidSetCSUMOffload (
7932     IN  P_ADAPTER_T prAdapter,
7933     IN  PVOID       pvSetBuffer,
7934     IN  UINT_32     u4SetBufferLen,
7935     OUT PUINT_32    pu4SetInfoLen
7936     )
7937 {
7938     UINT_32 i, u4CSUMFlags;
7939     CMD_BASIC_CONFIG rCmdBasicConfig;
7940
7941     DEBUGFUNC("wlanoidSetCSUMOffload");
7942     DBGLOG(INIT, LOUD, ("\n"));
7943
7944     ASSERT(prAdapter);
7945     ASSERT(pu4SetInfoLen);
7946
7947     *pu4SetInfoLen = sizeof(UINT_32);
7948
7949     if (u4SetBufferLen < sizeof(UINT_32)) {
7950         return WLAN_STATUS_INVALID_LENGTH;
7951     }
7952
7953     ASSERT(pvSetBuffer);
7954     u4CSUMFlags = *(PUINT_32)pvSetBuffer;
7955
7956     kalMemZero(&rCmdBasicConfig, sizeof(CMD_BASIC_CONFIG));
7957
7958     for(i = 0 ; i < 6 ; i++) { // set to broadcast address for not-specified
7959         rCmdBasicConfig.rMyMacAddr[i] = 0xff;
7960     }
7961
7962     rCmdBasicConfig.ucNative80211 = 0; //@FIXME: for Vista
7963
7964     if(u4CSUMFlags & CSUM_OFFLOAD_EN_TX_TCP)
7965         rCmdBasicConfig.rCsumOffload.u2TxChecksum |= BIT(2);
7966
7967     if(u4CSUMFlags & CSUM_OFFLOAD_EN_TX_UDP)
7968         rCmdBasicConfig.rCsumOffload.u2TxChecksum |= BIT(1);
7969
7970     if(u4CSUMFlags & CSUM_OFFLOAD_EN_TX_IP)
7971         rCmdBasicConfig.rCsumOffload.u2TxChecksum |= BIT(0);
7972
7973     if(u4CSUMFlags & CSUM_OFFLOAD_EN_RX_TCP)
7974         rCmdBasicConfig.rCsumOffload.u2RxChecksum |= BIT(2);
7975
7976     if(u4CSUMFlags & CSUM_OFFLOAD_EN_RX_UDP)
7977         rCmdBasicConfig.rCsumOffload.u2RxChecksum |= BIT(1);
7978
7979     if(u4CSUMFlags & (CSUM_OFFLOAD_EN_RX_IPv4 | CSUM_OFFLOAD_EN_RX_IPv6))
7980         rCmdBasicConfig.rCsumOffload.u2RxChecksum |= BIT(0);
7981
7982     prAdapter->u4CSUMFlags = u4CSUMFlags;
7983
7984     return wlanSendSetQueryCmd(prAdapter,
7985             CMD_ID_BASIC_CONFIG,
7986             TRUE,
7987             FALSE,
7988             TRUE,
7989             nicCmdEventSetCommon,
7990             nicOidCmdTimeoutCommon,
7991             sizeof(CMD_BASIC_CONFIG),
7992             (PUINT_8)&rCmdBasicConfig,
7993             pvSetBuffer,
7994             u4SetBufferLen
7995             );
7996 }
7997 #endif /* CFG_TCP_IP_CHKSUM_OFFLOAD */
7998
7999
8000 /*----------------------------------------------------------------------------*/
8001 /*!
8002 * \brief Setting the IP address for pattern search function.
8003 *
8004 * \param[in] prAdapter Pointer to the Adapter structure.
8005 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
8006 * \param[in] u4SetBufferLen The length of the set buffer.
8007 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
8008 *                           bytes read from the set buffer. If the call failed
8009 *                           due to invalid length of the set buffer, returns
8010 *                           the amount of storage needed.
8011 *
8012 * \return WLAN_STATUS_SUCCESS
8013 * \return WLAN_STATUS_ADAPTER_NOT_READY
8014 * \return WLAN_STATUS_INVALID_LENGTH
8015 */
8016 /*----------------------------------------------------------------------------*/
8017 WLAN_STATUS
8018 wlanoidSetNetworkAddress(
8019     IN  P_ADAPTER_T prAdapter,
8020     IN  PVOID       pvSetBuffer,
8021     IN  UINT_32     u4SetBufferLen,
8022     OUT PUINT_32    pu4SetInfoLen
8023     )
8024 {
8025     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
8026     UINT_32 i, j;
8027     P_CMD_SET_NETWORK_ADDRESS_LIST prCmdNetworkAddressList;
8028     P_PARAM_NETWORK_ADDRESS_LIST prNetworkAddressList = (P_PARAM_NETWORK_ADDRESS_LIST)pvSetBuffer;
8029     P_PARAM_NETWORK_ADDRESS prNetworkAddress;
8030     P_PARAM_NETWORK_ADDRESS_IP prNetAddrIp;
8031     UINT_32 u4IpAddressCount, u4CmdSize;
8032         PUINT_8 pucBuf = (PUINT_8)pvSetBuffer;
8033
8034     DEBUGFUNC("wlanoidSetNetworkAddress");
8035     DBGLOG(INIT, LOUD, ("\n"));
8036
8037     ASSERT(prAdapter);
8038     ASSERT(pu4SetInfoLen);
8039
8040     *pu4SetInfoLen = 4;
8041
8042     if (u4SetBufferLen < sizeof(PARAM_NETWORK_ADDRESS_LIST)) {
8043         return WLAN_STATUS_INVALID_DATA;
8044     }
8045
8046     *pu4SetInfoLen = 0;
8047     u4IpAddressCount = 0;
8048
8049     prNetworkAddress = prNetworkAddressList->arAddress;
8050     for ( i = 0 ; i < prNetworkAddressList->u4AddressCount ; i++) {
8051         if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
8052                 prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
8053             u4IpAddressCount++;
8054         }
8055
8056         prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
8057             (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
8058     }
8059
8060     // construct payload of command packet
8061     u4CmdSize = OFFSET_OF(CMD_SET_NETWORK_ADDRESS_LIST, arNetAddress) +
8062         sizeof(IPV4_NETWORK_ADDRESS) * u4IpAddressCount;
8063         if (u4IpAddressCount == 0) {
8064                 u4CmdSize = sizeof(CMD_SET_NETWORK_ADDRESS_LIST);
8065         }
8066
8067     prCmdNetworkAddressList = (P_CMD_SET_NETWORK_ADDRESS_LIST) kalMemAlloc(u4CmdSize, VIR_MEM_TYPE);
8068
8069     if(prCmdNetworkAddressList == NULL)
8070         return WLAN_STATUS_FAILURE;
8071
8072     // fill P_CMD_SET_NETWORK_ADDRESS_LIST
8073     prCmdNetworkAddressList->ucNetTypeIndex = NETWORK_TYPE_AIS_INDEX;
8074
8075     /* only to set IP address to FW once ARP filter is enabled */
8076     if (prAdapter->fgEnArpFilter) {
8077         prCmdNetworkAddressList->ucAddressCount = (UINT_8)u4IpAddressCount;
8078         prNetworkAddress = prNetworkAddressList->arAddress;
8079
8080         DBGLOG(REQ, INFO, ("u4IpAddressCount (%d)\n", u4IpAddressCount));
8081
8082         for (i = 0, j = 0 ; i < prNetworkAddressList->u4AddressCount ; i++) {
8083             if (prNetworkAddress->u2AddressType == PARAM_PROTOCOL_ID_TCP_IP &&
8084                     prNetworkAddress->u2AddressLength == sizeof(PARAM_NETWORK_ADDRESS_IP)) {
8085                 prNetAddrIp = (P_PARAM_NETWORK_ADDRESS_IP)prNetworkAddress->aucAddress;
8086
8087                 kalMemCopy(prCmdNetworkAddressList->arNetAddress[j].aucIpAddr,
8088                         &(prNetAddrIp->in_addr),
8089                         sizeof(UINT_32));
8090
8091                 j++;
8092
8093                 pucBuf = (PUINT_8)&prNetAddrIp->in_addr;
8094                 DBGLOG(REQ, INFO, ("prNetAddrIp->in_addr:%d:%d:%d:%d\n", pucBuf[0], pucBuf[1],pucBuf[2],pucBuf[3]));
8095             }
8096
8097             prNetworkAddress = (P_PARAM_NETWORK_ADDRESS) ((UINT_32) prNetworkAddress +
8098                 (UINT_32) (prNetworkAddress->u2AddressLength + OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress)));
8099         }
8100
8101     } else {
8102         prCmdNetworkAddressList->ucAddressCount = 0;
8103     }
8104
8105     rStatus = wlanSendSetQueryCmd(prAdapter,
8106             CMD_ID_SET_IP_ADDRESS,
8107             TRUE,
8108             FALSE,
8109             TRUE,
8110             nicCmdEventSetIpAddress,
8111             nicOidCmdTimeoutCommon,
8112             u4CmdSize,
8113             (PUINT_8)prCmdNetworkAddressList,
8114             pvSetBuffer,
8115             u4SetBufferLen
8116             );
8117
8118     kalMemFree(prCmdNetworkAddressList, VIR_MEM_TYPE, u4CmdSize);
8119     return rStatus;
8120 }
8121
8122
8123 /*----------------------------------------------------------------------------*/
8124 /*!
8125 * \brief Set driver to switch into RF test mode
8126 *
8127 * \param[in] prAdapter Pointer to the Adapter structure.
8128 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set,
8129 *                        should be NULL
8130 * \param[in] u4SetBufferLen The length of the set buffer, should be 0
8131 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
8132 *                           bytes read from the set buffer. If the call failed
8133 *                           due to invalid length of the set buffer, returns
8134 *                           the amount of storage needed.
8135 *
8136 * \return WLAN_STATUS_SUCCESS
8137 * \return WLAN_STATUS_ADAPTER_NOT_READY
8138 * \return WLAN_STATUS_INVALID_DATA
8139 * \return WLAN_STATUS_INVALID_LENGTH
8140 */
8141 /*----------------------------------------------------------------------------*/
8142 WLAN_STATUS
8143 wlanoidRftestSetTestMode (
8144     IN  P_ADAPTER_T       prAdapter,
8145     IN  PVOID             pvSetBuffer,
8146     IN  UINT_32           u4SetBufferLen,
8147     OUT PUINT_32          pu4SetInfoLen
8148     )
8149 {
8150     WLAN_STATUS rStatus;
8151     CMD_TEST_CTRL_T rCmdTestCtrl;
8152
8153     DEBUGFUNC("wlanoidRftestSetTestMode");
8154
8155     ASSERT(prAdapter);
8156     ASSERT(pvSetBuffer);
8157     ASSERT(pu4SetInfoLen);
8158
8159     *pu4SetInfoLen = 0;
8160
8161     if(u4SetBufferLen == 0) {
8162         if(prAdapter->fgTestMode == FALSE) {
8163             // switch to RF Test mode
8164             rCmdTestCtrl.ucAction = 0; // Switch mode
8165             rCmdTestCtrl.u.u4OpMode = 1; // RF test mode
8166
8167             rStatus = wlanSendSetQueryCmd(prAdapter,
8168                     CMD_ID_TEST_MODE,
8169                     TRUE,
8170                     FALSE,
8171                     TRUE,
8172                     nicCmdEventEnterRfTest,
8173                     nicOidCmdEnterRFTestTimeout,
8174                     sizeof(CMD_TEST_CTRL_T),
8175                     (PUINT_8)&rCmdTestCtrl,
8176                     pvSetBuffer,
8177                     u4SetBufferLen);
8178         }
8179         else {
8180             // already in test mode ..
8181             rStatus = WLAN_STATUS_SUCCESS;
8182         }
8183     }
8184     else {
8185         rStatus = WLAN_STATUS_INVALID_DATA;
8186     }
8187
8188     return rStatus;
8189 }
8190
8191 /*----------------------------------------------------------------------------*/
8192 /*!
8193 * \brief Set driver to switch into normal operation mode from RF test mode
8194 *
8195 * \param[in] prAdapter Pointer to the Adapter structure.
8196 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set
8197 *                        should be NULL
8198 * \param[in] u4SetBufferLen The length of the set buffer, should be 0
8199 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
8200 *                           bytes read from the set buffer. If the call failed
8201 *                           due to invalid length of the set buffer, returns
8202 *                           the amount of storage needed.
8203 *
8204 * \return WLAN_STATUS_SUCCESS
8205 * \return WLAN_STATUS_ADAPTER_NOT_READY
8206 * \return WLAN_STATUS_INVALID_DATA
8207 * \return WLAN_STATUS_INVALID_LENGTH
8208 */
8209 /*----------------------------------------------------------------------------*/
8210 WLAN_STATUS
8211 wlanoidRftestSetAbortTestMode (
8212     IN  P_ADAPTER_T       prAdapter,
8213     IN  PVOID             pvSetBuffer,
8214     IN  UINT_32           u4SetBufferLen,
8215     OUT PUINT_32          pu4SetInfoLen
8216     )
8217 {
8218     WLAN_STATUS rStatus;
8219     CMD_TEST_CTRL_T rCmdTestCtrl;
8220
8221     DEBUGFUNC("wlanoidRftestSetTestMode");
8222
8223     ASSERT(prAdapter);
8224     ASSERT(pvSetBuffer);
8225     ASSERT(pu4SetInfoLen);
8226
8227     *pu4SetInfoLen = 0;
8228
8229     if(u4SetBufferLen == 0) {
8230         if(prAdapter->fgTestMode == TRUE) {
8231             // switch to normal mode
8232             rCmdTestCtrl.ucAction = 0; // Switch mode
8233             rCmdTestCtrl.u.u4OpMode = 0; // normal mode
8234
8235             rStatus = wlanSendSetQueryCmd(prAdapter,
8236                     CMD_ID_TEST_MODE,
8237                     TRUE,
8238                     FALSE,
8239                     TRUE,
8240                     nicCmdEventLeaveRfTest,
8241                     nicOidCmdTimeoutCommon,
8242                     sizeof(CMD_TEST_CTRL_T),
8243                     (PUINT_8)&rCmdTestCtrl,
8244                     pvSetBuffer,
8245                     u4SetBufferLen);
8246         }
8247         else {
8248             // already in normal mode ..
8249             rStatus = WLAN_STATUS_SUCCESS;
8250         }
8251     }
8252     else {
8253         rStatus = WLAN_STATUS_INVALID_DATA;
8254     }
8255
8256     return rStatus;
8257 }
8258
8259
8260 /*----------------------------------------------------------------------------*/
8261 /*!
8262 * \brief query for RF test parameter
8263 *
8264 * \param[in] prAdapter Pointer to the Adapter structure.
8265 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
8266 *                               the query.
8267 * \param[in] u4QueryBufferLen   The length of the query buffer.
8268 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
8269 *                               bytes written into the query buffer. If the call
8270 *                               failed due to invalid length of the query buffer,
8271 *                               returns the amount of storage needed.
8272 *
8273 * \retval WLAN_STATUS_SUCCESS
8274 * \retval WLAN_STATUS_BUFFER_TOO_SHORT
8275 * \retval WLAN_STATUS_NOT_SUPPORTED
8276 * \retval WLAN_STATUS_NOT_ACCEPTED
8277 */
8278 /*----------------------------------------------------------------------------*/
8279 WLAN_STATUS
8280 wlanoidRftestQueryAutoTest (
8281     IN  P_ADAPTER_T prAdapter,
8282     OUT PVOID       pvQueryBuffer,
8283     IN  UINT_32     u4QueryBufferLen,
8284     OUT PUINT_32    pu4QueryInfoLen
8285     )
8286 {
8287     P_PARAM_MTK_WIFI_TEST_STRUC_T  prRfATInfo;
8288     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
8289
8290     DEBUGFUNC("wlanoidRftestQueryAutoTest");
8291
8292     ASSERT(prAdapter);
8293     if (u4QueryBufferLen) {
8294         ASSERT(pvQueryBuffer);
8295     }
8296     ASSERT(pu4QueryInfoLen);
8297
8298     *pu4QueryInfoLen = sizeof(PARAM_MTK_WIFI_TEST_STRUC_T);
8299
8300     if (u4QueryBufferLen != sizeof(PARAM_MTK_WIFI_TEST_STRUC_T)) {
8301         DBGLOG(REQ, ERROR, ("Invalid data. QueryBufferLen: %ld.\n",
8302                     u4QueryBufferLen));
8303         return WLAN_STATUS_INVALID_LENGTH;
8304     }
8305
8306     prRfATInfo = (P_PARAM_MTK_WIFI_TEST_STRUC_T)pvQueryBuffer;
8307     rStatus = rftestQueryATInfo(prAdapter,
8308             prRfATInfo->u4FuncIndex,
8309             prRfATInfo->u4FuncData,
8310             pvQueryBuffer,
8311             u4QueryBufferLen);
8312
8313     return rStatus;
8314 }
8315
8316 /*----------------------------------------------------------------------------*/
8317 /*!
8318 * \brief Set RF test parameter
8319 *
8320 * \param[in] prAdapter Pointer to the Adapter structure.
8321 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
8322 * \param[in] u4SetBufferLen The length of the set buffer.
8323 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
8324 *                           bytes read from the set buffer. If the call failed
8325 *                           due to invalid length of the set buffer, returns
8326 *                           the amount of storage needed.
8327 *
8328 * \return WLAN_STATUS_SUCCESS
8329 * \return WLAN_STATUS_ADAPTER_NOT_READY
8330 * \return WLAN_STATUS_INVALID_LENGTH
8331 */
8332 /*----------------------------------------------------------------------------*/
8333 WLAN_STATUS
8334 wlanoidRftestSetAutoTest (
8335     IN  P_ADAPTER_T prAdapter,
8336     OUT PVOID       pvSetBuffer,
8337     IN  UINT_32     u4SetBufferLen,
8338     OUT PUINT_32    pu4SetInfoLen
8339     )
8340 {
8341     P_PARAM_MTK_WIFI_TEST_STRUC_T  prRfATInfo;
8342     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
8343
8344     DEBUGFUNC("wlanoidRftestSetAutoTest");
8345
8346     ASSERT(prAdapter);
8347     ASSERT(pvSetBuffer);
8348     ASSERT(pu4SetInfoLen);
8349
8350     *pu4SetInfoLen = sizeof(PARAM_MTK_WIFI_TEST_STRUC_T);
8351
8352     if (u4SetBufferLen != sizeof(PARAM_MTK_WIFI_TEST_STRUC_T)) {
8353         DBGLOG(REQ, ERROR, ("Invalid data. SetBufferLen: %ld.\n",
8354                     u4SetBufferLen));
8355         return WLAN_STATUS_INVALID_LENGTH;
8356     }
8357
8358     prRfATInfo = (P_PARAM_MTK_WIFI_TEST_STRUC_T)pvSetBuffer;
8359     rStatus = rftestSetATInfo(prAdapter, prRfATInfo->u4FuncIndex, prRfATInfo->u4FuncData);
8360
8361     return rStatus;
8362 }
8363
8364 /* RF test OID set handler */
8365 WLAN_STATUS
8366 rftestSetATInfo (
8367     IN P_ADAPTER_T  prAdapter,
8368     UINT_32         u4FuncIndex,
8369     UINT_32         u4FuncData
8370     )
8371 {
8372     P_GLUE_INFO_T prGlueInfo;
8373     P_CMD_INFO_T prCmdInfo;
8374     P_WIFI_CMD_T prWifiCmd;
8375     P_CMD_TEST_CTRL_T pCmdTestCtrl;
8376     UINT_8 ucCmdSeqNum;
8377
8378     ASSERT(prAdapter);
8379
8380     prGlueInfo = prAdapter->prGlueInfo;
8381     prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + sizeof(CMD_TEST_CTRL_T)));
8382
8383     if (!prCmdInfo) {
8384         DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
8385         return WLAN_STATUS_FAILURE;
8386     }
8387
8388     // increase command sequence number
8389     ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
8390
8391     // Setup common CMD Info Packet
8392     prCmdInfo->eCmdType = COMMAND_TYPE_GENERAL_IOCTL;
8393     prCmdInfo->u2InfoBufLen = CMD_HDR_SIZE + sizeof(CMD_TEST_CTRL_T);
8394     prCmdInfo->pfCmdDoneHandler = nicCmdEventSetCommon;
8395     prCmdInfo->pfCmdTimeoutHandler = nicOidCmdTimeoutCommon;
8396     prCmdInfo->fgIsOid = TRUE;
8397     prCmdInfo->ucCID = CMD_ID_TEST_MODE;
8398     prCmdInfo->fgSetQuery = TRUE;
8399     prCmdInfo->fgNeedResp = FALSE;
8400     prCmdInfo->fgDriverDomainMCR = FALSE;
8401     prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
8402     prCmdInfo->u4SetInfoLen = sizeof(CMD_TEST_CTRL_T);
8403     prCmdInfo->pvInformationBuffer = NULL;
8404     prCmdInfo->u4InformationBufferLength = 0;
8405
8406     // Setup WIFI_CMD_T (payload = CMD_TEST_CTRL_T)
8407     prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
8408     prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
8409     prWifiCmd->ucCID = prCmdInfo->ucCID;
8410     prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
8411     prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
8412
8413     pCmdTestCtrl = (P_CMD_TEST_CTRL_T)(prWifiCmd->aucBuffer);
8414     pCmdTestCtrl->ucAction = 1; // Set ATInfo
8415     pCmdTestCtrl->u.rRfATInfo.u4FuncIndex = u4FuncIndex;
8416     pCmdTestCtrl->u.rRfATInfo.u4FuncData = u4FuncData;
8417
8418     // insert into prCmdQueue
8419     kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
8420
8421     // wakeup txServiceThread later
8422     GLUE_SET_EVENT(prAdapter->prGlueInfo);
8423
8424     return WLAN_STATUS_PENDING;
8425 }
8426
8427 WLAN_STATUS
8428 rftestQueryATInfo(
8429     IN P_ADAPTER_T  prAdapter,
8430     UINT_32         u4FuncIndex,
8431     UINT_32         u4FuncData,
8432     OUT PVOID       pvQueryBuffer,
8433     IN UINT_32      u4QueryBufferLen
8434     )
8435 {
8436     P_GLUE_INFO_T prGlueInfo;
8437     P_CMD_INFO_T prCmdInfo;
8438     P_WIFI_CMD_T prWifiCmd;
8439     P_CMD_TEST_CTRL_T pCmdTestCtrl;
8440     UINT_8 ucCmdSeqNum;
8441     P_EVENT_TEST_STATUS prTestStatus;
8442
8443     ASSERT(prAdapter);
8444
8445     prGlueInfo = prAdapter->prGlueInfo;
8446
8447     if(u4FuncIndex == RF_AT_FUNCID_FW_INFO) {
8448         /* driver implementation */
8449         prTestStatus = (P_EVENT_TEST_STATUS)pvQueryBuffer;
8450
8451         prTestStatus->rATInfo.u4FuncData =
8452             (prAdapter->rVerInfo.u2FwProductID << 16) | (prAdapter->rVerInfo.u2FwOwnVersion);
8453         u4QueryBufferLen = sizeof(EVENT_TEST_STATUS);
8454
8455         return WLAN_STATUS_SUCCESS;
8456     }
8457     else if(u4FuncIndex == RF_AT_FUNCID_DRV_INFO) {
8458         /* driver implementation */
8459         prTestStatus = (P_EVENT_TEST_STATUS)pvQueryBuffer;
8460
8461         prTestStatus->rATInfo.u4FuncData = CFG_DRV_OWN_VERSION;
8462         u4QueryBufferLen = sizeof(EVENT_TEST_STATUS);
8463
8464         return WLAN_STATUS_SUCCESS;
8465     }
8466     else {
8467         prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + sizeof(CMD_TEST_CTRL_T)));
8468
8469         if (!prCmdInfo) {
8470             DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
8471             return WLAN_STATUS_FAILURE;
8472         }
8473
8474         // increase command sequence number
8475         ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
8476
8477         // Setup common CMD Info Packet
8478         prCmdInfo->eCmdType = COMMAND_TYPE_GENERAL_IOCTL;
8479         prCmdInfo->u2InfoBufLen = CMD_HDR_SIZE + sizeof(CMD_TEST_CTRL_T);
8480         prCmdInfo->pfCmdDoneHandler = nicCmdEventQueryRfTestATInfo;
8481         prCmdInfo->pfCmdTimeoutHandler = nicOidCmdTimeoutCommon;
8482         prCmdInfo->fgIsOid = TRUE;
8483         prCmdInfo->ucCID = CMD_ID_TEST_MODE;
8484         prCmdInfo->fgSetQuery = FALSE;
8485         prCmdInfo->fgNeedResp = TRUE;
8486         prCmdInfo->fgDriverDomainMCR = FALSE;
8487         prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
8488         prCmdInfo->u4SetInfoLen = sizeof(CMD_TEST_CTRL_T);
8489         prCmdInfo->pvInformationBuffer = pvQueryBuffer;
8490         prCmdInfo->u4InformationBufferLength = u4QueryBufferLen;
8491
8492         // Setup WIFI_CMD_T (payload = CMD_TEST_CTRL_T)
8493         prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
8494         prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
8495         prWifiCmd->ucCID = prCmdInfo->ucCID;
8496         prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
8497         prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
8498
8499         pCmdTestCtrl = (P_CMD_TEST_CTRL_T)(prWifiCmd->aucBuffer);
8500         pCmdTestCtrl->ucAction = 2; // Get ATInfo
8501         pCmdTestCtrl->u.rRfATInfo.u4FuncIndex = u4FuncIndex;
8502         pCmdTestCtrl->u.rRfATInfo.u4FuncData = u4FuncData;
8503
8504         // insert into prCmdQueue
8505         kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
8506
8507         // wakeup txServiceThread later
8508         GLUE_SET_EVENT(prAdapter->prGlueInfo);
8509
8510         return WLAN_STATUS_PENDING;
8511     }
8512 }
8513
8514 WLAN_STATUS
8515 rftestSetFrequency(
8516     IN P_ADAPTER_T  prAdapter,
8517     IN UINT_32      u4FreqInKHz,
8518     IN PUINT_32     pu4SetInfoLen
8519     )
8520 {
8521     CMD_TEST_CTRL_T rCmdTestCtrl;
8522
8523     ASSERT(prAdapter);
8524
8525     rCmdTestCtrl.ucAction = 5; // Set Channel Frequency
8526     rCmdTestCtrl.u.u4ChannelFreq = u4FreqInKHz;
8527
8528     return wlanSendSetQueryCmd(prAdapter,
8529             CMD_ID_TEST_MODE,
8530             TRUE,
8531             FALSE,
8532             TRUE,
8533             nicCmdEventSetCommon,
8534             nicOidCmdTimeoutCommon,
8535             sizeof(CMD_TEST_CTRL_T),
8536             (PUINT_8)&rCmdTestCtrl,
8537             NULL,
8538             0);
8539 }
8540
8541
8542 /*----------------------------------------------------------------------------*/
8543 /*!
8544 * \brief command packet generation utility
8545 *
8546 * \param[in] prAdapter          Pointer to the Adapter structure.
8547 * \param[in] ucCID              Command ID
8548 * \param[in] fgSetQuery         Set or Query
8549 * \param[in] fgNeedResp         Need for response
8550 * \param[in] pfCmdDoneHandler   Function pointer when command is done
8551 * \param[in] u4SetQueryInfoLen  The length of the set/query buffer
8552 * \param[in] pucInfoBuffer      Pointer to set/query buffer
8553 *
8554 *
8555 * \retval WLAN_STATUS_PENDING
8556 * \retval WLAN_STATUS_FAILURE
8557 */
8558 /*----------------------------------------------------------------------------*/
8559 WLAN_STATUS
8560 wlanSendSetQueryCmd (
8561     IN P_ADAPTER_T  prAdapter,
8562     UINT_8          ucCID,
8563     BOOLEAN         fgSetQuery,
8564     BOOLEAN         fgNeedResp,
8565     BOOLEAN         fgIsOid,
8566     PFN_CMD_DONE_HANDLER pfCmdDoneHandler,
8567     PFN_CMD_TIMEOUT_HANDLER pfCmdTimeoutHandler,
8568     UINT_32         u4SetQueryInfoLen,
8569     PUINT_8         pucInfoBuffer,
8570     OUT PVOID       pvSetQueryBuffer,
8571     IN UINT_32      u4SetQueryBufferLen
8572     )
8573 {
8574     P_GLUE_INFO_T prGlueInfo;
8575     P_CMD_INFO_T prCmdInfo;
8576     P_WIFI_CMD_T prWifiCmd;
8577     UINT_8 ucCmdSeqNum;
8578
8579     prGlueInfo = prAdapter->prGlueInfo;
8580     prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + u4SetQueryInfoLen));
8581
8582     DEBUGFUNC("wlanSendSetQueryCmd");
8583
8584     if (!prCmdInfo) {
8585         DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
8586         return WLAN_STATUS_FAILURE;
8587     }
8588
8589     // increase command sequence number
8590     ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
8591     DBGLOG(REQ, TRACE, ("ucCmdSeqNum =%d\n", ucCmdSeqNum));
8592
8593     // Setup common CMD Info Packet
8594     prCmdInfo->eCmdType = COMMAND_TYPE_NETWORK_IOCTL;
8595     prCmdInfo->eNetworkType = NETWORK_TYPE_AIS_INDEX;
8596     prCmdInfo->u2InfoBufLen = (UINT_16)(CMD_HDR_SIZE + u4SetQueryInfoLen);
8597     prCmdInfo->pfCmdDoneHandler = pfCmdDoneHandler;
8598     prCmdInfo->pfCmdTimeoutHandler = pfCmdTimeoutHandler;
8599     prCmdInfo->fgIsOid = fgIsOid;
8600     prCmdInfo->ucCID = ucCID;
8601     prCmdInfo->fgSetQuery = fgSetQuery;
8602     prCmdInfo->fgNeedResp = fgNeedResp;
8603     prCmdInfo->fgDriverDomainMCR = FALSE;
8604     prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
8605     prCmdInfo->u4SetInfoLen = u4SetQueryInfoLen;
8606     prCmdInfo->pvInformationBuffer = pvSetQueryBuffer;
8607     prCmdInfo->u4InformationBufferLength = u4SetQueryBufferLen;
8608
8609     // Setup WIFI_CMD_T (no payload)
8610     prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
8611     prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
8612     prWifiCmd->ucCID = prCmdInfo->ucCID;
8613     prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
8614     prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
8615
8616     if(u4SetQueryInfoLen > 0 && pucInfoBuffer != NULL) {
8617         kalMemCopy(prWifiCmd->aucBuffer, pucInfoBuffer, u4SetQueryInfoLen);
8618     }
8619
8620     // insert into prCmdQueue
8621     kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
8622
8623     // wakeup txServiceThread later
8624     GLUE_SET_EVENT(prGlueInfo);
8625     return WLAN_STATUS_PENDING;
8626 }
8627
8628
8629
8630 #if CFG_SUPPORT_WAPI
8631 /*----------------------------------------------------------------------------*/
8632 /*!
8633 * \brief This routine is called by WAPI ui to set wapi mode, which is needed to info the the driver
8634 *          to operation at WAPI mode while driver initialize.
8635 *
8636 * \param[in] prAdapter Pointer to the Adapter structure
8637 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set
8638 * \param[in] u4SetBufferLen The length of the set buffer
8639 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
8640 *   bytes read from the set buffer. If the call failed due to invalid length of
8641 *   the set buffer, returns the amount of storage needed.
8642 *
8643 * \retval WLAN_STATUS_SUCCESS
8644 * \retval WLAN_STATUS_INVALID_DATA If new setting value is wrong.
8645 * \retval WLAN_STATUS_INVALID_LENGTH
8646 *
8647 */
8648 /*----------------------------------------------------------------------------*/
8649 WLAN_STATUS
8650 wlanoidSetWapiMode (
8651     IN  P_ADAPTER_T       prAdapter,
8652     IN  PVOID             pvSetBuffer,
8653     IN  UINT_32           u4SetBufferLen,
8654     OUT PUINT_32          pu4SetInfoLen
8655     )
8656 {
8657     DEBUGFUNC("wlanoidSetWapiMode");
8658     DBGLOG(REQ, LOUD, ("\r\n"));
8659
8660     ASSERT(prAdapter);
8661     ASSERT(pu4SetInfoLen);
8662     ASSERT(pvSetBuffer);
8663
8664     /* Todo:: For support WAPI and Wi-Fi at same driver, use the set wapi assoc ie at the check point */
8665     /*        The Adapter Connection setting fgUseWapi will cleat whil oid set mode (infra),          */
8666     /*        And set fgUseWapi True while set wapi assoc ie                                          */
8667     /*        policay selection, add key all depend on this flag,                                     */
8668     /*        The fgUseWapi may remove later                                                          */
8669     if (*(PUINT_32)pvSetBuffer) {
8670         prAdapter->fgUseWapi = TRUE;
8671     }
8672     else {
8673         prAdapter->fgUseWapi = FALSE;
8674     }
8675
8676 #if 0
8677     prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + 4));
8678
8679     if (!prCmdInfo) {
8680         DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
8681         return WLAN_STATUS_FAILURE;
8682     }
8683
8684     // increase command sequence number
8685     ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
8686
8687     // compose CMD_BUILD_CONNECTION cmd pkt
8688     prCmdInfo->eCmdType = COMMAND_TYPE_NETWORK_IOCTL;
8689     prCmdInfo->eNetworkType = NETWORK_TYPE_AIS_INDEX;
8690     prCmdInfo->u2InfoBufLen = CMD_HDR_SIZE + 4;
8691     prCmdInfo->pfCmdDoneHandler = nicCmdEventSetCommon;
8692     prCmdInfo->pfCmdTimeoutHandler = NULL;
8693     prCmdInfo->fgIsOid = TRUE;
8694     prCmdInfo->ucCID = CMD_ID_WAPI_MODE;
8695     prCmdInfo->fgSetQuery = TRUE;
8696     prCmdInfo->fgNeedResp = FALSE;
8697     prCmdInfo->fgDriverDomainMCR = FALSE;
8698     prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
8699     prCmdInfo->u4SetInfoLen = u4SetBufferLen;
8700     prCmdInfo->pvInformationBuffer = pvSetBuffer;
8701     prCmdInfo->u4InformationBufferLength = u4SetBufferLen;
8702
8703     // Setup WIFI_CMD_T
8704     prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
8705     prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
8706     prWifiCmd->ucCID = prCmdInfo->ucCID;
8707     prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
8708     prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
8709
8710     cp = (PUINT_8)(prWifiCmd->aucBuffer);
8711
8712     kalMemCopy(cp, (PUINT_8)pvSetBuffer, 4);
8713
8714     // insert into prCmdQueue
8715     kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
8716
8717     // wakeup txServiceThread later
8718     GLUE_SET_EVENT(prGlueInfo);
8719
8720     return WLAN_STATUS_PENDING;
8721 #else
8722     return WLAN_STATUS_SUCCESS;
8723 #endif
8724 }
8725
8726
8727 /*----------------------------------------------------------------------------*/
8728 /*!
8729 * \brief This routine is called by WAPI to set the assoc info, which is needed to add to
8730 *          Association request frame while join WAPI AP.
8731 *
8732 * \param[in] prAdapter Pointer to the Adapter structure
8733 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set
8734 * \param[in] u4SetBufferLen The length of the set buffer
8735 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
8736 *   bytes read from the set buffer. If the call failed due to invalid length of
8737 *   the set buffer, returns the amount of storage needed.
8738 *
8739 * \retval WLAN_STATUS_SUCCESS
8740 * \retval WLAN_STATUS_INVALID_DATA If new setting value is wrong.
8741 * \retval WLAN_STATUS_INVALID_LENGTH
8742 *
8743 */
8744 /*----------------------------------------------------------------------------*/
8745 WLAN_STATUS
8746 wlanoidSetWapiAssocInfo (
8747     IN  P_ADAPTER_T       prAdapter,
8748     IN  PVOID             pvSetBuffer,
8749     IN  UINT_32           u4SetBufferLen,
8750     OUT PUINT_32          pu4SetInfoLen
8751     )
8752 {
8753     P_WAPI_INFO_ELEM_T    prWapiInfo;
8754     PUINT_8               cp;
8755     UINT_16               u2AuthSuiteCount = 0;
8756     UINT_16               u2PairSuiteCount = 0;
8757     UINT_32               u4AuthKeyMgtSuite = 0;
8758     UINT_32               u4PairSuite = 0;
8759     UINT_32               u4GroupSuite = 0;
8760
8761     ASSERT(prAdapter);
8762     ASSERT(pvSetBuffer);
8763     ASSERT(pu4SetInfoLen);
8764
8765     DEBUGFUNC("wlanoidSetWapiAssocInfo");
8766     DBGLOG(REQ, LOUD, ("\r\n"));
8767
8768     if (u4SetBufferLen < 20 /* From EID to Group cipher */) {
8769         prAdapter->rWifiVar.rConnSettings.fgWapiMode = FALSE;
8770         return WLAN_STATUS_INVALID_LENGTH;
8771     }
8772
8773     prAdapter->rWifiVar.rConnSettings.fgWapiMode = TRUE;
8774
8775     //if (prWapiInfo->ucElemId != ELEM_ID_WAPI)
8776     //    DBGLOG(SEC, TRACE, ("Not WAPI IE ?!\n"));
8777
8778     //if (prWapiInfo->ucLength < 18)
8779     //    return WLAN_STATUS_INVALID_LENGTH;
8780
8781     *pu4SetInfoLen = u4SetBufferLen;
8782
8783     prWapiInfo = (P_WAPI_INFO_ELEM_T)pvSetBuffer;
8784
8785     if (prWapiInfo->ucElemId != ELEM_ID_WAPI) {
8786         DBGLOG(SEC, TRACE, ("Not WAPI IE ?! u4SetBufferLen = %d\n", u4SetBufferLen));
8787         prAdapter->rWifiVar.rConnSettings.fgWapiMode = FALSE;
8788         return WLAN_STATUS_INVALID_LENGTH;
8789     }
8790
8791     if (prWapiInfo->ucLength < 18)
8792         return WLAN_STATUS_INVALID_LENGTH;
8793
8794     /* Skip Version check */
8795     cp = (PUINT_8)&prWapiInfo->u2AuthKeyMgtSuiteCount;
8796
8797     WLAN_GET_FIELD_16(cp, &u2AuthSuiteCount);
8798
8799     if (u2AuthSuiteCount>1)
8800         return WLAN_STATUS_INVALID_LENGTH;
8801
8802     cp += 2;
8803     WLAN_GET_FIELD_32(cp, &u4AuthKeyMgtSuite);
8804
8805     DBGLOG(SEC, TRACE, ("WAPI: Assoc Info auth mgt suite [%d]: %02x-%02x-%02x-%02x\n",
8806         u2AuthSuiteCount,
8807         (UCHAR) (u4AuthKeyMgtSuite & 0x000000FF),
8808         (UCHAR) ((u4AuthKeyMgtSuite >> 8) & 0x000000FF),
8809         (UCHAR) ((u4AuthKeyMgtSuite >> 16) & 0x000000FF),
8810         (UCHAR) ((u4AuthKeyMgtSuite >> 24) & 0x000000FF)));
8811
8812     if (u4AuthKeyMgtSuite != WAPI_AKM_SUITE_802_1X &&
8813         u4AuthKeyMgtSuite != WAPI_AKM_SUITE_PSK)
8814         ASSERT(FALSE);
8815
8816     cp += 4;
8817     WLAN_GET_FIELD_16(cp, &u2PairSuiteCount);
8818     if (u2PairSuiteCount>1)
8819         return WLAN_STATUS_INVALID_LENGTH;
8820
8821     cp += 2;
8822     WLAN_GET_FIELD_32(cp, &u4PairSuite);
8823     DBGLOG(SEC, TRACE, ("WAPI: Assoc Info pairwise cipher suite [%d]: %02x-%02x-%02x-%02x\n",
8824         u2PairSuiteCount,
8825         (UCHAR) (u4PairSuite & 0x000000FF),
8826         (UCHAR) ((u4PairSuite >> 8) & 0x000000FF),
8827         (UCHAR) ((u4PairSuite >> 16) & 0x000000FF),
8828         (UCHAR) ((u4PairSuite >> 24) & 0x000000FF)));
8829
8830     if (u4PairSuite != WAPI_CIPHER_SUITE_WPI)
8831         ASSERT(FALSE);
8832
8833     cp += 4;
8834     WLAN_GET_FIELD_32(cp, &u4GroupSuite);
8835     DBGLOG(SEC, TRACE, ("WAPI: Assoc Info group cipher suite : %02x-%02x-%02x-%02x\n",
8836         (UCHAR) (u4GroupSuite & 0x000000FF),
8837         (UCHAR) ((u4GroupSuite >> 8) & 0x000000FF),
8838         (UCHAR) ((u4GroupSuite >> 16) & 0x000000FF),
8839         (UCHAR) ((u4GroupSuite >> 24) & 0x000000FF)));
8840
8841     if (u4GroupSuite != WAPI_CIPHER_SUITE_WPI)
8842         ASSERT(FALSE);
8843
8844     prAdapter->rWifiVar.rConnSettings.u4WapiSelectedAKMSuite = u4AuthKeyMgtSuite;
8845     prAdapter->rWifiVar.rConnSettings.u4WapiSelectedPairwiseCipher = u4PairSuite;
8846     prAdapter->rWifiVar.rConnSettings.u4WapiSelectedGroupCipher = u4GroupSuite;
8847
8848     kalMemCopy(prAdapter->prGlueInfo->aucWapiAssocInfoIEs,  pvSetBuffer, u4SetBufferLen);
8849     prAdapter->prGlueInfo->u2WapiAssocInfoIESz = (UINT_16)u4SetBufferLen;
8850     DBGLOG(SEC, TRACE, ("Assoc Info IE sz %ld\n", u4SetBufferLen));
8851
8852     return WLAN_STATUS_SUCCESS;
8853
8854 }
8855
8856
8857 /*----------------------------------------------------------------------------*/
8858 /*!
8859 * \brief This routine is called to set the wpi key to the driver.
8860 *
8861 * \param[in] prAdapter Pointer to the Adapter structure.
8862 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
8863 * \param[in] u4SetBufferLen The length of the set buffer.
8864 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
8865 *                          bytes read from the set buffer. If the call failed
8866 *                          due to invalid length of the set buffer, returns
8867 *                          the amount of storage needed.
8868 *
8869 * \retval WLAN_STATUS_SUCCESS
8870 * \retval WLAN_STATUS_ADAPTER_NOT_READY
8871 * \retval WLAN_STATUS_INVALID_LENGTH
8872 * \retval WLAN_STATUS_INVALID_DATA
8873 *
8874 * \note The setting buffer P_PARAM_WPI_KEY, which is set by NDIS, is unpacked.
8875 */
8876 /*----------------------------------------------------------------------------*/
8877 WLAN_STATUS
8878 wlanoidSetWapiKey (
8879     IN  P_ADAPTER_T       prAdapter,
8880     IN  PVOID             pvSetBuffer,
8881     IN  UINT_32           u4SetBufferLen,
8882     OUT PUINT_32          pu4SetInfoLen
8883     )
8884 {
8885     P_GLUE_INFO_T         prGlueInfo;
8886     P_CMD_INFO_T          prCmdInfo;
8887     P_WIFI_CMD_T          prWifiCmd;
8888     P_PARAM_WPI_KEY_T     prNewKey;
8889     P_CMD_802_11_KEY      prCmdKey;
8890     PUINT_8               pc;
8891     UINT_8                ucCmdSeqNum;
8892
8893     DEBUGFUNC("wlanoidSetWapiKey");
8894     DBGLOG(REQ, LOUD, ("\r\n"));
8895
8896     ASSERT(prAdapter);
8897     ASSERT(pvSetBuffer);
8898     ASSERT(pu4SetInfoLen);
8899
8900     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
8901         DBGLOG(REQ, WARN, ("Fail in set add key! (Adapter not ready). ACPI=D%d, Radio=%d\r\n",
8902                     prAdapter->rAcpiState, prAdapter->fgIsRadioOff));
8903         return WLAN_STATUS_ADAPTER_NOT_READY;
8904     }
8905
8906     prNewKey = (P_PARAM_WPI_KEY_T) pvSetBuffer;
8907
8908     DBGLOG_MEM8(REQ, TRACE, (PUINT_8)pvSetBuffer, 560);
8909     pc = (PUINT_8)pvSetBuffer;
8910
8911     *pu4SetInfoLen = u4SetBufferLen;
8912
8913     /* Exception check */
8914     if (prNewKey->ucKeyID != 0x1 ||
8915         prNewKey->ucKeyID != 0x0) {
8916         prNewKey->ucKeyID = prNewKey->ucKeyID & BIT(0);
8917         //DBGLOG(SEC, INFO, ("Invalid WAPI key ID (%d)\r\n", prNewKey->ucKeyID));
8918     }
8919
8920     /* Dump P_PARAM_WPI_KEY_T content. */
8921     DBGLOG(REQ, TRACE, ("Set: Dump P_PARAM_WPI_KEY_T content\r\n"));
8922     DBGLOG(REQ, TRACE, ("TYPE      : %d\r\n", prNewKey->eKeyType));
8923     DBGLOG(REQ, TRACE, ("Direction : %d\r\n", prNewKey->eDirection));
8924     DBGLOG(REQ, TRACE, ("KeyID     : %d\r\n", prNewKey->ucKeyID));
8925     DBGLOG(REQ, TRACE, ("AddressIndex:\r\n"));
8926     DBGLOG_MEM8(REQ, TRACE, prNewKey->aucAddrIndex, 12);
8927     prNewKey->u4LenWPIEK = 16;
8928
8929     DBGLOG_MEM8(REQ, TRACE, (PUINT_8)prNewKey->aucWPIEK, (UINT_8)prNewKey->u4LenWPIEK);
8930     prNewKey->u4LenWPICK = 16;
8931
8932     DBGLOG(REQ, TRACE, ("CK Key(%d):\r\n", (UINT_8)prNewKey->u4LenWPICK));
8933     DBGLOG_MEM8(REQ, TRACE, (PUINT_8)prNewKey->aucWPICK, (UINT_8)prNewKey->u4LenWPICK);
8934     DBGLOG(REQ, TRACE, ("PN:\r\n"));
8935     if (prNewKey->eKeyType == 0){
8936         prNewKey->aucPN[0] = 0x5c;
8937         prNewKey->aucPN[1] = 0x36;
8938         prNewKey->aucPN[2] = 0x5c;
8939         prNewKey->aucPN[3] = 0x36;
8940         prNewKey->aucPN[4] = 0x5c;
8941         prNewKey->aucPN[5] = 0x36;
8942         prNewKey->aucPN[6] = 0x5c;
8943         prNewKey->aucPN[7] = 0x36;
8944         prNewKey->aucPN[8] = 0x5c;
8945         prNewKey->aucPN[9] = 0x36;
8946         prNewKey->aucPN[10] = 0x5c;
8947         prNewKey->aucPN[11] = 0x36;
8948         prNewKey->aucPN[12] = 0x5c;
8949         prNewKey->aucPN[13] = 0x36;
8950         prNewKey->aucPN[14] = 0x5c;
8951         prNewKey->aucPN[15] = 0x36;
8952     }
8953
8954     DBGLOG_MEM8(REQ, TRACE, (PUINT_8)prNewKey->aucPN, 16);
8955
8956     prGlueInfo = prAdapter->prGlueInfo;
8957
8958     prCmdInfo = cmdBufAllocateCmdInfo(prAdapter, (CMD_HDR_SIZE + u4SetBufferLen));
8959
8960     if (!prCmdInfo) {
8961         DBGLOG(INIT, ERROR, ("Allocate CMD_INFO_T ==> FAILED.\n"));
8962         return WLAN_STATUS_FAILURE;
8963     }
8964
8965     // increase command sequence number
8966     ucCmdSeqNum = nicIncreaseCmdSeqNum(prAdapter);
8967
8968     // compose CMD_ID_ADD_REMOVE_KEY cmd pkt
8969     prCmdInfo->eCmdType = COMMAND_TYPE_NETWORK_IOCTL;
8970     prCmdInfo->eNetworkType = NETWORK_TYPE_AIS_INDEX;
8971     prCmdInfo->u2InfoBufLen = CMD_HDR_SIZE + sizeof(CMD_802_11_KEY);
8972     prCmdInfo->pfCmdDoneHandler = nicCmdEventSetCommon;
8973     prCmdInfo->pfCmdTimeoutHandler = nicOidCmdTimeoutCommon;
8974     prCmdInfo->fgIsOid = TRUE;
8975     prCmdInfo->ucCID = CMD_ID_ADD_REMOVE_KEY;
8976     prCmdInfo->fgSetQuery = TRUE;
8977     prCmdInfo->fgNeedResp = FALSE;
8978     prCmdInfo->fgDriverDomainMCR = FALSE;
8979     prCmdInfo->ucCmdSeqNum = ucCmdSeqNum;
8980     prCmdInfo->u4SetInfoLen = u4SetBufferLen;
8981     prCmdInfo->pvInformationBuffer = pvSetBuffer;
8982     prCmdInfo->u4InformationBufferLength = u4SetBufferLen;
8983
8984     // Setup WIFI_CMD_T
8985     prWifiCmd = (P_WIFI_CMD_T)(prCmdInfo->pucInfoBuffer);
8986     prWifiCmd->u2TxByteCount_UserPriority = prCmdInfo->u2InfoBufLen;
8987     prWifiCmd->ucCID = prCmdInfo->ucCID;
8988     prWifiCmd->ucSetQuery = prCmdInfo->fgSetQuery;
8989     prWifiCmd->ucSeqNum = prCmdInfo->ucCmdSeqNum;
8990
8991     prCmdKey = (P_CMD_802_11_KEY)(prWifiCmd->aucBuffer);
8992
8993     kalMemZero(prCmdKey, sizeof(CMD_802_11_KEY));
8994
8995     prCmdKey->ucAddRemove = 1; /* Add */
8996
8997     if (prNewKey->eKeyType == ENUM_WPI_PAIRWISE_KEY) {
8998         prCmdKey->ucTxKey = 1;
8999         prCmdKey->ucKeyType = 1;
9000     }
9001
9002     kalMemCopy(prCmdKey->aucPeerAddr, (PUINT_8)prNewKey->aucAddrIndex, MAC_ADDR_LEN);
9003
9004     prCmdKey->ucNetType = 0; /* AIS */
9005
9006     prCmdKey->ucKeyId = prNewKey->ucKeyID;
9007
9008     prCmdKey->ucKeyLen = 32;
9009
9010     prCmdKey->ucAlgorithmId = CIPHER_SUITE_WPI;
9011
9012     kalMemCopy(prCmdKey->aucKeyMaterial, (PUINT_8)prNewKey->aucWPIEK, 16);
9013
9014     kalMemCopy(prCmdKey->aucKeyMaterial+16, (PUINT_8)prNewKey->aucWPICK, 16);
9015
9016     kalMemCopy(prCmdKey->aucKeyRsc, (PUINT_8)prNewKey->aucPN, 16);
9017
9018     // insert into prCmdQueue
9019     kalEnqueueCommand(prGlueInfo, (P_QUE_ENTRY_T)prCmdInfo);
9020
9021     // wakeup txServiceThread later
9022     GLUE_SET_EVENT(prGlueInfo);
9023
9024     return WLAN_STATUS_PENDING;
9025 } /* wlanoidSetAddKey */
9026 #endif
9027
9028
9029 #if CFG_SUPPORT_WPS2
9030 /*----------------------------------------------------------------------------*/
9031 /*!
9032 * \brief This routine is called by WSC to set the assoc info, which is needed to add to
9033 *          Association request frame while join WPS AP.
9034 *
9035 * \param[in] prAdapter Pointer to the Adapter structure
9036 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set
9037 * \param[in] u4SetBufferLen The length of the set buffer
9038 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
9039 *   bytes read from the set buffer. If the call failed due to invalid length of
9040 *   the set buffer, returns the amount of storage needed.
9041 *
9042 * \retval WLAN_STATUS_SUCCESS
9043 * \retval WLAN_STATUS_INVALID_DATA If new setting value is wrong.
9044 * \retval WLAN_STATUS_INVALID_LENGTH
9045 *
9046 */
9047 /*----------------------------------------------------------------------------*/
9048 WLAN_STATUS
9049 wlanoidSetWSCAssocInfo (
9050     IN  P_ADAPTER_T       prAdapter,
9051     IN  PVOID             pvSetBuffer,
9052     IN  UINT_32           u4SetBufferLen,
9053     OUT PUINT_32          pu4SetInfoLen
9054     )
9055 {
9056     ASSERT(prAdapter);
9057     ASSERT(pvSetBuffer);
9058     ASSERT(pu4SetInfoLen);
9059
9060     DEBUGFUNC("wlanoidSetWSCAssocInfo");
9061     DBGLOG(REQ, LOUD, ("\r\n"));
9062
9063     if(u4SetBufferLen == 0)
9064         return WLAN_STATUS_INVALID_LENGTH;
9065
9066     *pu4SetInfoLen = u4SetBufferLen;
9067
9068     kalMemCopy(prAdapter->prGlueInfo->aucWSCAssocInfoIE,  pvSetBuffer, u4SetBufferLen);
9069     prAdapter->prGlueInfo->u2WSCAssocInfoIELen = (UINT_16)u4SetBufferLen;
9070     DBGLOG(SEC, TRACE, ("Assoc Info IE sz %ld\n", u4SetBufferLen));
9071
9072     return WLAN_STATUS_SUCCESS;
9073
9074 }
9075 #endif
9076
9077
9078 #if CFG_ENABLE_WAKEUP_ON_LAN
9079 WLAN_STATUS
9080 wlanoidSetAddWakeupPattern (
9081     IN  P_ADAPTER_T   prAdapter,
9082     IN  PVOID         pvSetBuffer,
9083     IN  UINT_32       u4SetBufferLen,
9084     OUT PUINT_32      pu4SetInfoLen
9085     )
9086 {
9087     P_PARAM_PM_PACKET_PATTERN prPacketPattern;
9088
9089     DEBUGFUNC("wlanoidSetAddWakeupPattern");
9090     DBGLOG(REQ, LOUD, ("\r\n"));
9091
9092     ASSERT(prAdapter);
9093     ASSERT(pu4SetInfoLen);
9094
9095     *pu4SetInfoLen = sizeof(PARAM_PM_PACKET_PATTERN);
9096
9097     if (u4SetBufferLen < sizeof(PARAM_PM_PACKET_PATTERN)) {
9098         return WLAN_STATUS_INVALID_LENGTH;
9099     }
9100
9101     ASSERT(pvSetBuffer);
9102
9103     prPacketPattern = (P_PARAM_PM_PACKET_PATTERN) pvSetBuffer;
9104
9105     /* FIXME:
9106      * Send the struct to firmware */
9107
9108     return WLAN_STATUS_FAILURE;
9109 }
9110
9111
9112 WLAN_STATUS
9113 wlanoidSetRemoveWakeupPattern (
9114     IN  P_ADAPTER_T   prAdapter,
9115     IN  PVOID         pvSetBuffer,
9116     IN  UINT_32       u4SetBufferLen,
9117     OUT PUINT_32      pu4SetInfoLen
9118     )
9119 {
9120     P_PARAM_PM_PACKET_PATTERN prPacketPattern;
9121
9122     DEBUGFUNC("wlanoidSetAddWakeupPattern");
9123     DBGLOG(REQ, LOUD, ("\r\n"));
9124
9125     ASSERT(prAdapter);
9126     ASSERT(pu4SetInfoLen);
9127
9128     *pu4SetInfoLen = sizeof(PARAM_PM_PACKET_PATTERN);
9129
9130     if (u4SetBufferLen < sizeof(PARAM_PM_PACKET_PATTERN)) {
9131         return WLAN_STATUS_INVALID_LENGTH;
9132     }
9133
9134     ASSERT(pvSetBuffer);
9135
9136     prPacketPattern = (P_PARAM_PM_PACKET_PATTERN) pvSetBuffer;
9137
9138     /* FIXME:
9139      * Send the struct to firmware */
9140
9141     return WLAN_STATUS_FAILURE;
9142 }
9143
9144
9145 WLAN_STATUS
9146 wlanoidQueryEnableWakeup (
9147     IN  P_ADAPTER_T   prAdapter,
9148     OUT PVOID         pvQueryBuffer,
9149     IN  UINT_32       u4QueryBufferLen,
9150     OUT PUINT_32      pu4QueryInfoLen
9151     )
9152 {
9153     PUINT_32 pu4WakeupEventEnable;
9154
9155     DEBUGFUNC("wlanoidQueryEnableWakeup");
9156     DBGLOG(REQ, LOUD, ("\r\n"));
9157
9158     ASSERT(prAdapter);
9159     ASSERT(pu4QueryInfoLen);
9160     if (u4QueryBufferLen) {
9161         ASSERT(pvQueryBuffer);
9162     }
9163
9164     *pu4QueryInfoLen = sizeof(UINT_32);
9165
9166     if (u4QueryBufferLen < sizeof(UINT_32)) {
9167         return WLAN_STATUS_BUFFER_TOO_SHORT;
9168     }
9169
9170     pu4WakeupEventEnable = (PUINT_32)pvQueryBuffer;
9171
9172     *pu4WakeupEventEnable = prAdapter->u4WakeupEventEnable;
9173
9174     return WLAN_STATUS_SUCCESS;
9175 }
9176
9177 WLAN_STATUS
9178 wlanoidSetEnableWakeup (
9179     IN  P_ADAPTER_T   prAdapter,
9180     IN  PVOID         pvSetBuffer,
9181     IN  UINT_32       u4SetBufferLen,
9182     OUT PUINT_32      pu4SetInfoLen
9183     )
9184 {
9185     PUINT_32 pu4WakeupEventEnable;
9186
9187     DEBUGFUNC("wlanoidSetEnableWakup");
9188     DBGLOG(REQ, LOUD, ("\r\n"));
9189
9190     ASSERT(prAdapter);
9191     ASSERT(pu4SetInfoLen);
9192
9193     *pu4SetInfoLen = sizeof(UINT_32);
9194
9195     if (u4SetBufferLen < sizeof(UINT_32)) {
9196         return WLAN_STATUS_INVALID_LENGTH;
9197     }
9198
9199     ASSERT(pvSetBuffer);
9200
9201     pu4WakeupEventEnable = (PUINT_32)pvSetBuffer;
9202     prAdapter->u4WakeupEventEnable = *pu4WakeupEventEnable;
9203
9204     /* FIXME:
9205      * Send Command Event for setting wakeup-pattern / Magic Packet to firmware
9206      * */
9207
9208     return WLAN_STATUS_FAILURE;
9209 }
9210 #endif
9211
9212 /*----------------------------------------------------------------------------*/
9213 /*!
9214 * \brief This routine is called to configure PS related settings for WMM-PS test.
9215 *
9216 * \param[in] prAdapter Pointer to the Adapter structure.
9217 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
9218 * \param[in] u4SetBufferLen The length of the set buffer.
9219 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
9220 *                           bytes read from the set buffer. If the call failed
9221 *                           due to invalid length of the set buffer, returns
9222 *                           the amount of storage needed.
9223 *
9224 * \retval WLAN_STATUS_SUCCESS
9225 */
9226 /*----------------------------------------------------------------------------*/
9227 WLAN_STATUS
9228 wlanoidSetWiFiWmmPsTest (
9229     IN P_ADAPTER_T  prAdapter,
9230     IN  PVOID       pvSetBuffer,
9231     IN  UINT_32     u4SetBufferLen,
9232     OUT PUINT_32    pu4SetInfoLen
9233     )
9234 {
9235     P_PARAM_CUSTOM_WMM_PS_TEST_STRUC_T prWmmPsTestInfo;
9236     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
9237     CMD_SET_WMM_PS_TEST_STRUC_T rSetWmmPsTestParam;
9238     UINT_16 u2CmdBufLen;
9239     P_PM_PROFILE_SETUP_INFO_T prPmProfSetupInfo;
9240     P_BSS_INFO_T prBssInfo;
9241
9242     DEBUGFUNC("wlanoidSetWiFiWmmPsTest");
9243
9244     ASSERT(prAdapter);
9245     ASSERT(pvSetBuffer);
9246     ASSERT(pu4SetInfoLen);
9247
9248
9249     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_WMM_PS_TEST_STRUC_T);
9250
9251     prWmmPsTestInfo = (P_PARAM_CUSTOM_WMM_PS_TEST_STRUC_T) pvSetBuffer;
9252
9253     rSetWmmPsTestParam.ucNetTypeIndex = NETWORK_TYPE_AIS_INDEX;
9254     rSetWmmPsTestParam.bmfgApsdEnAc  = prWmmPsTestInfo->bmfgApsdEnAc;
9255     rSetWmmPsTestParam.ucIsEnterPsAtOnce  = prWmmPsTestInfo->ucIsEnterPsAtOnce;
9256     rSetWmmPsTestParam.ucIsDisableUcTrigger  = prWmmPsTestInfo->ucIsDisableUcTrigger;
9257
9258     prBssInfo = &(prAdapter->rWifiVar.arBssInfo[rSetWmmPsTestParam.ucNetTypeIndex]);
9259     prPmProfSetupInfo = &prBssInfo->rPmProfSetupInfo;
9260     prPmProfSetupInfo->ucBmpDeliveryAC = (rSetWmmPsTestParam.bmfgApsdEnAc >> 4) & BITS(0, 3);
9261     prPmProfSetupInfo->ucBmpTriggerAC = rSetWmmPsTestParam.bmfgApsdEnAc & BITS(0, 3);
9262
9263     u2CmdBufLen = sizeof(CMD_SET_WMM_PS_TEST_STRUC_T);
9264
9265 #if 0
9266     /* it will apply the disable trig or not immediately */
9267     if (prPmInfo->ucWmmPsDisableUcPoll && prPmInfo->ucWmmPsConnWithTrig) {
9268 //        NIC_PM_WMM_PS_DISABLE_UC_TRIG(prAdapter, TRUE);
9269     }
9270     else {
9271 //        NIC_PM_WMM_PS_DISABLE_UC_TRIG(prAdapter, FALSE);
9272     }
9273 #endif
9274
9275     rStatus = wlanSendSetQueryCmd(prAdapter,
9276             CMD_ID_SET_WMM_PS_TEST_PARMS,
9277             TRUE,
9278             FALSE,
9279             TRUE,
9280             NULL, // TODO?
9281             NULL,
9282             u2CmdBufLen,
9283             (PUINT_8)&rSetWmmPsTestParam,
9284             NULL,
9285             0);
9286
9287
9288     return rStatus;
9289 }   /* wlanoidSetWiFiWmmPsTest */
9290
9291
9292 /*----------------------------------------------------------------------------*/
9293 /*!
9294 * \brief This routine is called to configure enable/disable TX A-MPDU feature.
9295 *
9296 * \param[in] prAdapter Pointer to the Adapter structure.
9297 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
9298 * \param[in] u4SetBufferLen The length of the set buffer.
9299 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
9300 *                           bytes read from the set buffer. If the call failed
9301 *                           due to invalid length of the set buffer, returns
9302 *                           the amount of storage needed.
9303 *
9304 * \retval WLAN_STATUS_SUCCESS
9305 */
9306 /*----------------------------------------------------------------------------*/
9307 WLAN_STATUS
9308 wlanoidSetTxAmpdu (
9309     IN P_ADAPTER_T  prAdapter,
9310     IN  PVOID       pvSetBuffer,
9311     IN  UINT_32     u4SetBufferLen,
9312     OUT PUINT_32    pu4SetInfoLen
9313     )
9314 {
9315     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
9316     CMD_TX_AMPDU_T rTxAmpdu;
9317     UINT_16 u2CmdBufLen;
9318     PBOOLEAN pfgEnable;
9319
9320     DEBUGFUNC("wlanoidSetTxAmpdu");
9321
9322     ASSERT(prAdapter);
9323     ASSERT(pvSetBuffer);
9324     ASSERT(pu4SetInfoLen);
9325
9326
9327     *pu4SetInfoLen = sizeof(BOOLEAN);
9328
9329     pfgEnable = (PBOOLEAN) pvSetBuffer;
9330
9331     rTxAmpdu.fgEnable = *pfgEnable;
9332
9333     u2CmdBufLen = sizeof(CMD_TX_AMPDU_T);
9334
9335     rStatus = wlanSendSetQueryCmd(prAdapter,
9336             CMD_ID_TX_AMPDU,
9337             TRUE,
9338             FALSE,
9339             TRUE,
9340             NULL,
9341             NULL,
9342             u2CmdBufLen,
9343             (PUINT_8)&rTxAmpdu,
9344             NULL,
9345             0);
9346
9347
9348     return rStatus;
9349 }   /* wlanoidSetTxAmpdu */
9350
9351
9352 /*----------------------------------------------------------------------------*/
9353 /*!
9354 * \brief This routine is called to configure reject/accept ADDBA Request.
9355 *
9356 * \param[in] prAdapter Pointer to the Adapter structure.
9357 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
9358 * \param[in] u4SetBufferLen The length of the set buffer.
9359 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
9360 *                           bytes read from the set buffer. If the call failed
9361 *                           due to invalid length of the set buffer, returns
9362 *                           the amount of storage needed.
9363 *
9364 * \retval WLAN_STATUS_SUCCESS
9365 */
9366 /*----------------------------------------------------------------------------*/
9367 WLAN_STATUS
9368 wlanoidSetAddbaReject(
9369     IN P_ADAPTER_T  prAdapter,
9370     IN  PVOID       pvSetBuffer,
9371     IN  UINT_32     u4SetBufferLen,
9372     OUT PUINT_32    pu4SetInfoLen
9373     )
9374 {
9375     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
9376     CMD_ADDBA_REJECT_T rAddbaReject;
9377     UINT_16 u2CmdBufLen;
9378     PBOOLEAN pfgEnable;
9379
9380     DEBUGFUNC("wlanoidSetAddbaReject");
9381
9382     ASSERT(prAdapter);
9383     ASSERT(pvSetBuffer);
9384     ASSERT(pu4SetInfoLen);
9385
9386
9387     *pu4SetInfoLen = sizeof(BOOLEAN);
9388
9389     pfgEnable = (PBOOLEAN) pvSetBuffer;
9390
9391     rAddbaReject.fgEnable = *pfgEnable;
9392
9393     u2CmdBufLen = sizeof(CMD_ADDBA_REJECT_T);
9394
9395     rStatus = wlanSendSetQueryCmd(prAdapter,
9396             CMD_ID_ADDBA_REJECT,
9397             TRUE,
9398             FALSE,
9399             TRUE,
9400             NULL,
9401             NULL,
9402             u2CmdBufLen,
9403             (PUINT_8)&rAddbaReject,
9404             NULL,
9405             0);
9406
9407
9408     return rStatus;
9409 }   /* wlanoidSetAddbaReject */
9410
9411
9412 #if CFG_SLT_SUPPORT
9413
9414 WLAN_STATUS
9415 wlanoidQuerySLTStatus (
9416     IN  P_ADAPTER_T   prAdapter,
9417     OUT PVOID         pvQueryBuffer,
9418     IN  UINT_32       u4QueryBufferLen,
9419     OUT PUINT_32      pu4QueryInfoLen
9420     )
9421 {
9422     WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
9423     P_PARAM_MTK_SLT_TEST_STRUC_T prMtkSltInfo = (P_PARAM_MTK_SLT_TEST_STRUC_T)NULL;
9424     P_SLT_INFO_T prSltInfo = (P_SLT_INFO_T)NULL;
9425
9426     DEBUGFUNC("wlanoidQuerySLTStatus");
9427     DBGLOG(REQ, LOUD, ("\r\n"));
9428
9429     ASSERT(prAdapter);
9430     ASSERT(pu4QueryInfoLen);
9431
9432     *pu4QueryInfoLen = sizeof(PARAM_MTK_SLT_TEST_STRUC_T);
9433
9434     if (u4QueryBufferLen < sizeof(PARAM_MTK_SLT_TEST_STRUC_T)) {
9435         return WLAN_STATUS_INVALID_LENGTH;
9436     }
9437
9438     ASSERT(pvQueryBuffer);
9439
9440     prMtkSltInfo = (P_PARAM_MTK_SLT_TEST_STRUC_T)pvQueryBuffer;
9441
9442     prSltInfo = &(prAdapter->rWifiVar.rSltInfo);
9443
9444     switch (prMtkSltInfo->rSltFuncIdx) {
9445     case ENUM_MTK_SLT_FUNC_LP_SET:
9446         {
9447             P_PARAM_MTK_SLT_LP_TEST_STRUC_T prLpSetting = (P_PARAM_MTK_SLT_LP_TEST_STRUC_T)NULL;
9448
9449             ASSERT(prMtkSltInfo->u4FuncInfoLen == sizeof(PARAM_MTK_SLT_LP_TEST_STRUC_T));
9450
9451             prLpSetting = (P_PARAM_MTK_SLT_LP_TEST_STRUC_T)&prMtkSltInfo->unFuncInfoContent;
9452
9453             prLpSetting->u4BcnRcvNum =  prSltInfo->u4BeaconReceiveCnt;
9454         }
9455         break;
9456     default:
9457         // TBD...
9458         break;
9459     }
9460
9461     return rWlanStatus;
9462 } /* wlanoidQuerySLTStatus */
9463
9464 WLAN_STATUS
9465 wlanoidUpdateSLTMode (
9466     IN P_ADAPTER_T  prAdapter,
9467     IN  PVOID       pvSetBuffer,
9468     IN  UINT_32     u4SetBufferLen,
9469     OUT PUINT_32    pu4SetInfoLen
9470     )
9471 {
9472     WLAN_STATUS rWlanStatus = WLAN_STATUS_SUCCESS;
9473     P_PARAM_MTK_SLT_TEST_STRUC_T prMtkSltInfo = (P_PARAM_MTK_SLT_TEST_STRUC_T)NULL;
9474     P_SLT_INFO_T prSltInfo = (P_SLT_INFO_T)NULL;
9475     P_BSS_DESC_T prBssDesc = (P_BSS_DESC_T)NULL;
9476     P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
9477     P_BSS_INFO_T prBssInfo = (P_BSS_INFO_T)NULL;
9478
9479     /* 1. Action: Update or Initial Set
9480       * 2. Role.
9481       * 3. Target MAC address.
9482       * 4. RF BW & Rate Settings
9483       */
9484
9485     DEBUGFUNC("wlanoidUpdateSLTMode");
9486     DBGLOG(REQ, LOUD, ("\r\n"));
9487
9488     ASSERT(prAdapter);
9489     ASSERT(pu4SetInfoLen);
9490
9491     *pu4SetInfoLen = sizeof(PARAM_MTK_SLT_TEST_STRUC_T);
9492
9493     if (u4SetBufferLen < sizeof(PARAM_MTK_SLT_TEST_STRUC_T)) {
9494         return WLAN_STATUS_INVALID_LENGTH;
9495     }
9496
9497     ASSERT(pvSetBuffer);
9498
9499     prMtkSltInfo = (P_PARAM_MTK_SLT_TEST_STRUC_T) pvSetBuffer;
9500
9501     prSltInfo = &(prAdapter->rWifiVar.rSltInfo);
9502     prBssInfo = &prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_AIS_INDEX];
9503
9504     switch (prMtkSltInfo->rSltFuncIdx) {
9505     case ENUM_MTK_SLT_FUNC_INITIAL: /* Initialize */
9506         {
9507             P_PARAM_MTK_SLT_INITIAL_STRUC_T prMtkSltInit = (P_PARAM_MTK_SLT_INITIAL_STRUC_T)NULL;
9508
9509             ASSERT(prMtkSltInfo->u4FuncInfoLen == sizeof(PARAM_MTK_SLT_INITIAL_STRUC_T));
9510
9511             prMtkSltInit = (P_PARAM_MTK_SLT_INITIAL_STRUC_T)&prMtkSltInfo->unFuncInfoContent;
9512
9513             if (prSltInfo->prPseudoStaRec != NULL) {
9514                 /* The driver has been initialized. */
9515                 prSltInfo->prPseudoStaRec = NULL;
9516             }
9517
9518
9519             prSltInfo->prPseudoBssDesc = scanSearchExistingBssDesc(prAdapter,
9520                                                                           BSS_TYPE_IBSS,
9521                                                                           prMtkSltInit->aucTargetMacAddr,
9522                                                                           prMtkSltInit->aucTargetMacAddr);
9523
9524             prSltInfo->u2SiteID = prMtkSltInit->u2SiteID;
9525
9526             /* Bandwidth 2.4G: Channel 1~14
9527               * Bandwidth 5G: *36, 40, 44, 48, 52, 56, 60, 64,
9528               *                       *100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140,
9529               *                       149, 153, *157, 161,
9530               *                       184, 188, 192, 196, 200, 204, 208, 212, *216
9531               */
9532             prSltInfo->ucChannel2G4 = 1 + (prSltInfo->u2SiteID % 4) * 5;
9533
9534             switch (prSltInfo->ucChannel2G4) {
9535             case 1:
9536                 prSltInfo->ucChannel5G = 36;
9537                 break;
9538             case 6:
9539                 prSltInfo->ucChannel5G = 52;
9540                 break;
9541             case 11:
9542                 prSltInfo->ucChannel5G = 104;
9543                 break;
9544             case 16:
9545                 prSltInfo->ucChannel2G4 = 14;
9546                 prSltInfo->ucChannel5G = 161;
9547                 break;
9548             default:
9549                 ASSERT(FALSE);
9550             }
9551
9552             if (prSltInfo->prPseudoBssDesc == NULL) {
9553                 do {
9554                     prSltInfo->prPseudoBssDesc = scanAllocateBssDesc(prAdapter);
9555
9556                     if (prSltInfo->prPseudoBssDesc == NULL) {
9557                         rWlanStatus = WLAN_STATUS_FAILURE;
9558                         break;
9559                     }
9560                     else {
9561                         prBssDesc = prSltInfo->prPseudoBssDesc;
9562                     }
9563                 } while (FALSE);
9564             }
9565             else {
9566                 prBssDesc = prSltInfo->prPseudoBssDesc;
9567             }
9568
9569             if (prBssDesc) {
9570                 prBssDesc->eBSSType = BSS_TYPE_IBSS;
9571
9572                 COPY_MAC_ADDR(prBssDesc->aucSrcAddr, prMtkSltInit->aucTargetMacAddr);
9573                 COPY_MAC_ADDR(prBssDesc->aucBSSID, prBssInfo->aucOwnMacAddr);
9574
9575                 prBssDesc->u2BeaconInterval = 100;
9576                 prBssDesc->u2ATIMWindow = 0;
9577                 prBssDesc->ucDTIMPeriod = 1;
9578
9579                 prBssDesc->u2IELength = 0;
9580
9581                 prBssDesc->fgIsERPPresent = TRUE;
9582                 prBssDesc->fgIsHTPresent = TRUE;
9583
9584                 prBssDesc->u2OperationalRateSet = BIT(RATE_36M_INDEX);
9585                 prBssDesc->u2BSSBasicRateSet = BIT(RATE_36M_INDEX);
9586                 prBssDesc->fgIsUnknownBssBasicRate = FALSE;
9587
9588                 prBssDesc->fgIsLargerTSF = TRUE;
9589
9590                 prBssDesc->eBand = BAND_2G4;
9591
9592                 prBssDesc->ucChannelNum = prSltInfo->ucChannel2G4;
9593
9594                 prBssDesc->ucPhyTypeSet = PHY_TYPE_SET_802_11ABGN;
9595
9596                 GET_CURRENT_SYSTIME(&prBssDesc->rUpdateTime);
9597             }
9598         }
9599         break;
9600     case ENUM_MTK_SLT_FUNC_RATE_SET: /* Update RF Settings. */
9601         if (prSltInfo->prPseudoStaRec == NULL) {
9602             rWlanStatus = WLAN_STATUS_FAILURE;
9603         }
9604         else {
9605             P_PARAM_MTK_SLT_TR_TEST_STRUC_T prTRSetting = (P_PARAM_MTK_SLT_TR_TEST_STRUC_T)NULL;
9606
9607             ASSERT(prMtkSltInfo->u4FuncInfoLen == sizeof(PARAM_MTK_SLT_TR_TEST_STRUC_T));
9608
9609             prStaRec = prSltInfo->prPseudoStaRec;
9610             prTRSetting = (P_PARAM_MTK_SLT_TR_TEST_STRUC_T)&prMtkSltInfo->unFuncInfoContent;
9611
9612             if (prTRSetting->rNetworkType == PARAM_NETWORK_TYPE_OFDM5) {
9613                 prBssInfo->eBand = BAND_5G;
9614                 prBssInfo->ucPrimaryChannel = prSltInfo->ucChannel5G;
9615             }
9616             if (prTRSetting->rNetworkType == PARAM_NETWORK_TYPE_OFDM24) {
9617                 prBssInfo->eBand = BAND_2G4;
9618                 prBssInfo->ucPrimaryChannel = prSltInfo->ucChannel2G4;
9619             }
9620
9621             if ((prTRSetting->u4FixedRate & FIXED_BW_DL40) != 0) {
9622                 /* RF 40 */
9623                 prStaRec->u2HtCapInfo |= HT_CAP_INFO_SUP_CHNL_WIDTH;   /* It would controls RFBW capability in WTBL. */
9624                 prStaRec->ucDesiredPhyTypeSet = PHY_TYPE_BIT_HT;               /* This controls RF BW, RF BW would be 40 only if
9625                                                                                                                  * 1. PHY_TYPE_BIT_HT is TRUE.
9626                                                                                                                  * 2. SCO is SCA/SCB.
9627                                                                                                                  */
9628
9629                 /* U20/L20 Control. */
9630                 switch (prTRSetting->u4FixedRate & 0xC000) {
9631                 case FIXED_EXT_CHNL_U20:
9632                     prBssInfo->eBssSCO = CHNL_EXT_SCB; // +2
9633                     if (prTRSetting->rNetworkType == PARAM_NETWORK_TYPE_OFDM5) {
9634                         prBssInfo->ucPrimaryChannel += 2;
9635                     }
9636                     else {
9637                         if (prBssInfo->ucPrimaryChannel <5) {
9638                             prBssInfo->ucPrimaryChannel = 8;   // For channel 1, testing L20 at channel 8.
9639                         }
9640                     }
9641                     break;
9642                 case FIXED_EXT_CHNL_L20:
9643                 default:  /* 40M */
9644                     prBssInfo->eBssSCO = CHNL_EXT_SCA;  // -2
9645                     if (prTRSetting->rNetworkType == PARAM_NETWORK_TYPE_OFDM5) {
9646                         prBssInfo->ucPrimaryChannel -= 2;
9647                     }
9648                     else {
9649                         if (prBssInfo->ucPrimaryChannel > 10) {
9650                             prBssInfo->ucPrimaryChannel = 3;  // For channel 11 / 14. testing U20 at channel 3.
9651                         }
9652                     }
9653                     break;
9654                 }
9655             }
9656             else {
9657                 /* RF 20 */
9658                 prStaRec->u2HtCapInfo &= ~HT_CAP_INFO_SUP_CHNL_WIDTH;
9659                 prBssInfo->eBssSCO = CHNL_EXT_SCN;
9660             }
9661
9662             prBssInfo->fgErpProtectMode = FALSE;
9663             prBssInfo->eHtProtectMode = HT_PROTECT_MODE_NONE;
9664             prBssInfo->eGfOperationMode = GF_MODE_NORMAL;
9665
9666             nicUpdateBss(prAdapter, prBssInfo->ucNetTypeIndex);
9667
9668             prStaRec->u2HtCapInfo &= ~(HT_CAP_INFO_SHORT_GI_20M | HT_CAP_INFO_SHORT_GI_40M);
9669
9670             switch (prTRSetting->u4FixedRate & 0xFF) {
9671             case RATE_OFDM_54M:
9672                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_54M_INDEX);
9673                 break;
9674             case RATE_OFDM_48M:
9675                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_48M_INDEX);
9676                 break;
9677             case RATE_OFDM_36M:
9678                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_36M_INDEX);
9679                 break;
9680             case RATE_OFDM_24M:
9681                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_24M_INDEX);
9682                 break;
9683             case RATE_OFDM_6M:
9684                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_6M_INDEX);
9685                 break;
9686             case RATE_CCK_11M_LONG:
9687                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_11M_INDEX);
9688                 break;
9689             case RATE_CCK_1M_LONG:
9690                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_1M_INDEX);
9691                 break;
9692             case RATE_GF_MCS_0:
9693                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_HT_PHY_INDEX);
9694                 prStaRec->u2HtCapInfo |= HT_CAP_INFO_HT_GF;
9695                 break;
9696             case RATE_MM_MCS_7:
9697                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_HT_PHY_INDEX);
9698                 prStaRec->u2HtCapInfo &= ~HT_CAP_INFO_HT_GF;
9699 #if 0  // Only for Current Measurement Mode.
9700                 prStaRec->u2HtCapInfo |= (HT_CAP_INFO_SHORT_GI_20M | HT_CAP_INFO_SHORT_GI_40M);
9701 #endif
9702                 break;
9703             case RATE_GF_MCS_7:
9704                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_HT_PHY_INDEX);
9705                 prStaRec->u2HtCapInfo |= HT_CAP_INFO_HT_GF;
9706                 break;
9707             default:
9708                 prStaRec->u2DesiredNonHTRateSet = BIT(RATE_36M_INDEX);
9709                 break;
9710             }
9711
9712             cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_1);
9713
9714             cnmStaRecChangeState(prAdapter, prStaRec, STA_STATE_3);
9715
9716         }
9717         break;
9718     case ENUM_MTK_SLT_FUNC_LP_SET: /* Reset LP Test Result. */
9719         {
9720             P_PARAM_MTK_SLT_LP_TEST_STRUC_T prLpSetting = (P_PARAM_MTK_SLT_LP_TEST_STRUC_T)NULL;
9721
9722             ASSERT(prMtkSltInfo->u4FuncInfoLen == sizeof(PARAM_MTK_SLT_LP_TEST_STRUC_T));
9723
9724             prLpSetting = (P_PARAM_MTK_SLT_LP_TEST_STRUC_T)&prMtkSltInfo->unFuncInfoContent;
9725
9726             if (prSltInfo->prPseudoBssDesc == NULL) {
9727                 /* Please initial SLT Mode first. */
9728                 break;
9729             }
9730             else {
9731                 prBssDesc = prSltInfo->prPseudoBssDesc;
9732             }
9733
9734             switch (prLpSetting->rLpTestMode) {
9735             case ENUM_MTK_LP_TEST_NORMAL:
9736                 /* In normal mode, we would use target MAC address to be the BSSID. */
9737                 COPY_MAC_ADDR(prBssDesc->aucBSSID, prBssInfo->aucOwnMacAddr);
9738                 prSltInfo->fgIsDUT = FALSE;
9739                 break;
9740             case ENUM_MTK_LP_TEST_GOLDEN_SAMPLE:
9741                 /* 1. Lower AIFS of BCN queue.
9742                   * 2. Fixed Random Number tobe 0.
9743                   */
9744                 prSltInfo->fgIsDUT = FALSE;
9745                 /* In LP test mode, we would use MAC address of Golden Sample to be the BSSID. */
9746                 COPY_MAC_ADDR(prBssDesc->aucBSSID, prBssInfo->aucOwnMacAddr);
9747                 break;
9748             case ENUM_MTK_LP_TEST_DUT:
9749                 /* 1. Enter Sleep Mode.
9750                   * 2. Fix random number a large value & enlarge AIFN of BCN queue.
9751                   */
9752                 COPY_MAC_ADDR(prBssDesc->aucBSSID, prBssDesc->aucSrcAddr);
9753                 prSltInfo->u4BeaconReceiveCnt = 0;
9754                 prSltInfo->fgIsDUT = TRUE;
9755                 break;
9756             }
9757
9758         }
9759
9760         break;
9761     default:
9762         break;
9763     }
9764
9765
9766
9767
9768     return WLAN_STATUS_FAILURE;
9769
9770
9771     return rWlanStatus;
9772 } /* wlanoidUpdateSLTMode */
9773 #endif
9774
9775
9776 /*----------------------------------------------------------------------------*/
9777 /*!
9778 * \brief This routine is called to query NVRAM value.
9779 *
9780 * \param[in] pvAdapter Pointer to the Adapter structure.
9781 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
9782 *                           the query.
9783 * \param[in] u4QueryBufLen The length of the query buffer.
9784 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
9785 *                            bytes written into the query buffer. If the call
9786 *                            failed due to invalid length of the query buffer,
9787 *                            returns the amount of storage needed.
9788 *
9789 * \retval WLAN_STATUS_SUCCESS
9790 * \retval WLAN_STATUS_FAILURE
9791 */
9792 /*----------------------------------------------------------------------------*/
9793 WLAN_STATUS
9794 wlanoidQueryNvramRead (
9795     IN  P_ADAPTER_T  prAdapter,
9796     OUT PVOID        pvQueryBuffer,
9797     IN  UINT_32      u4QueryBufferLen,
9798     OUT PUINT_32     pu4QueryInfoLen
9799     )
9800 {
9801     P_PARAM_CUSTOM_NVRAM_RW_STRUCT_T prNvramRwInfo;
9802     UINT_16     u2Data;
9803     BOOLEAN     fgStatus;
9804     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
9805
9806     DEBUGFUNC("wlanoidQueryNvramRead");
9807
9808     ASSERT(prAdapter);
9809     ASSERT(pu4QueryInfoLen);
9810     if (u4QueryBufferLen) {
9811         ASSERT(pvQueryBuffer);
9812     }
9813
9814     *pu4QueryInfoLen = sizeof(PARAM_CUSTOM_NVRAM_RW_STRUCT_T);
9815
9816     if (u4QueryBufferLen < sizeof(PARAM_CUSTOM_NVRAM_RW_STRUCT_T)) {
9817         return WLAN_STATUS_INVALID_LENGTH;
9818     }
9819
9820     prNvramRwInfo = (P_PARAM_CUSTOM_NVRAM_RW_STRUCT_T)pvQueryBuffer;
9821
9822     if(prNvramRwInfo->ucEepromMethod == PARAM_EEPROM_READ_METHOD_READ) {
9823         fgStatus = kalCfgDataRead16(prAdapter->prGlueInfo,
9824                 prNvramRwInfo->ucEepromIndex << 1, /* change to byte offset */
9825                 &u2Data);
9826
9827         if(fgStatus) {
9828             prNvramRwInfo->u2EepromData = u2Data;
9829             DBGLOG(REQ, INFO, ("NVRAM Read: index=%#X, data=%#02X\r\n",
9830                         prNvramRwInfo->ucEepromIndex, u2Data));
9831         }
9832         else{
9833             DBGLOG(REQ, ERROR, ("NVRAM Read Failed: index=%#x.\r\n",
9834                         prNvramRwInfo->ucEepromIndex));
9835             rStatus = WLAN_STATUS_FAILURE;
9836         }
9837     }
9838     else if (prNvramRwInfo->ucEepromMethod == PARAM_EEPROM_READ_METHOD_GETSIZE) {
9839         prNvramRwInfo->u2EepromData = CFG_FILE_WIFI_REC_SIZE;
9840         DBGLOG(REQ, INFO, ("EEPROM size =%d\r\n", prNvramRwInfo->u2EepromData));
9841     }
9842
9843     *pu4QueryInfoLen = sizeof(PARAM_CUSTOM_EEPROM_RW_STRUC_T);
9844
9845     return rStatus;
9846 }   /* wlanoidQueryNvramRead */
9847
9848
9849 /*----------------------------------------------------------------------------*/
9850 /*!
9851 * \brief This routine is called to write NVRAM value.
9852 *
9853 * \param[in] prAdapter Pointer to the Adapter structure.
9854 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
9855 * \param[in] u4SetBufferLen The length of the set buffer.
9856 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
9857 *                           bytes read from the set buffer. If the call failed
9858 *                           due to invalid length of the set buffer, returns
9859 *                           the amount of storage needed.
9860 *
9861 * \retval WLAN_STATUS_SUCCESS
9862 * \retval WLAN_STATUS_FAILURE
9863 */
9864 /*----------------------------------------------------------------------------*/
9865 WLAN_STATUS
9866 wlanoidSetNvramWrite (
9867     IN P_ADAPTER_T  prAdapter,
9868     IN  PVOID       pvSetBuffer,
9869     IN  UINT_32     u4SetBufferLen,
9870     OUT PUINT_32    pu4SetInfoLen
9871     )
9872 {
9873     P_PARAM_CUSTOM_NVRAM_RW_STRUCT_T prNvramRwInfo;
9874     BOOLEAN     fgStatus;
9875     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
9876
9877
9878     DEBUGFUNC("wlanoidSetNvramWrite");
9879     DBGLOG(INIT, LOUD,("\n"));
9880
9881     ASSERT(prAdapter);
9882     ASSERT(pu4SetInfoLen);
9883
9884     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_NVRAM_RW_STRUCT_T);
9885
9886     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_NVRAM_RW_STRUCT_T)) {
9887         return WLAN_STATUS_INVALID_LENGTH;
9888     }
9889
9890     ASSERT(pvSetBuffer);
9891
9892     prNvramRwInfo = (P_PARAM_CUSTOM_NVRAM_RW_STRUCT_T)pvSetBuffer;
9893
9894     fgStatus = kalCfgDataWrite16(prAdapter->prGlueInfo,
9895             prNvramRwInfo->ucEepromIndex << 1, /* change to byte offset */
9896             prNvramRwInfo->u2EepromData
9897             );
9898
9899     if(fgStatus == FALSE){
9900         DBGLOG(REQ, ERROR, ("NVRAM Write Failed.\r\n"));
9901         rStatus = WLAN_STATUS_FAILURE;
9902     }
9903
9904     return rStatus;
9905 }   /* wlanoidSetNvramWrite */
9906
9907
9908 /*----------------------------------------------------------------------------*/
9909 /*!
9910 * \brief This routine is called to get the config data source type.
9911 *
9912 * \param[in] prAdapter Pointer to the Adapter structure.
9913 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
9914 * \param[in] u4SetBufferLen The length of the set buffer.
9915 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
9916 *                           bytes read from the set buffer. If the call failed
9917 *                           due to invalid length of the set buffer, returns
9918 *                           the amount of storage needed.
9919 *
9920 * \retval WLAN_STATUS_SUCCESS
9921 * \retval WLAN_STATUS_FAILURE
9922 */
9923 /*----------------------------------------------------------------------------*/
9924 WLAN_STATUS
9925 wlanoidQueryCfgSrcType(
9926     IN  P_ADAPTER_T prAdapter,
9927     OUT PVOID       pvQueryBuffer,
9928     IN  UINT_32     u4QueryBufferLen,
9929     OUT PUINT_32    pu4QueryInfoLen
9930     )
9931 {
9932     ASSERT(prAdapter);
9933
9934     *pu4QueryInfoLen = sizeof(ENUM_CFG_SRC_TYPE_T);
9935
9936     if(kalIsConfigurationExist(prAdapter->prGlueInfo) == TRUE) {
9937         *(P_ENUM_CFG_SRC_TYPE_T)pvQueryBuffer = CFG_SRC_TYPE_NVRAM;
9938     }
9939     else {
9940         *(P_ENUM_CFG_SRC_TYPE_T)pvQueryBuffer = CFG_SRC_TYPE_EEPROM;
9941     }
9942
9943     return WLAN_STATUS_SUCCESS;
9944 }
9945
9946
9947 /*----------------------------------------------------------------------------*/
9948 /*!
9949 * \brief This routine is called to get the config data source type.
9950 *
9951 * \param[in] prAdapter Pointer to the Adapter structure.
9952 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
9953 * \param[in] u4SetBufferLen The length of the set buffer.
9954 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
9955 *                           bytes read from the set buffer. If the call failed
9956 *                           due to invalid length of the set buffer, returns
9957 *                           the amount of storage needed.
9958 *
9959 * \retval WLAN_STATUS_SUCCESS
9960 * \retval WLAN_STATUS_FAILURE
9961 */
9962 /*----------------------------------------------------------------------------*/
9963 WLAN_STATUS
9964 wlanoidQueryEepromType(
9965     IN  P_ADAPTER_T       prAdapter,
9966     OUT PVOID             pvQueryBuffer,
9967     IN  UINT_32           u4QueryBufferLen,
9968     OUT PUINT_32          pu4QueryInfoLen
9969     )
9970 {
9971     ASSERT(prAdapter);
9972
9973     *pu4QueryInfoLen = sizeof(P_ENUM_EEPROM_TYPE_T);
9974
9975 #if CFG_SUPPORT_NIC_CAPABILITY
9976     if(prAdapter->fgIsEepromUsed == TRUE) {
9977         *( P_ENUM_EEPROM_TYPE_T )pvQueryBuffer = EEPROM_TYPE_PRESENT;
9978     }
9979     else {
9980         *( P_ENUM_EEPROM_TYPE_T )pvQueryBuffer = EEPROM_TYPE_NO;
9981     }
9982 #else
9983     *( P_ENUM_EEPROM_TYPE_T )pvQueryBuffer = EEPROM_TYPE_NO;
9984 #endif
9985
9986     return WLAN_STATUS_SUCCESS;
9987 }
9988
9989 /*----------------------------------------------------------------------------*/
9990 /*!
9991 * \brief This routine is called to get the config data source type.
9992 *
9993 * \param[in] prAdapter Pointer to the Adapter structure.
9994 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
9995 * \param[in] u4SetBufferLen The length of the set buffer.
9996 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
9997 *                           bytes read from the set buffer. If the call failed
9998 *                           due to invalid length of the set buffer, returns
9999 *                           the amount of storage needed.
10000 *
10001 * \retval WLAN_STATUS_SUCCESS
10002 * \retval WLAN_STATUS_FAILURE
10003 */
10004 /*----------------------------------------------------------------------------*/
10005 WLAN_STATUS
10006 wlanoidSetCountryCode (
10007     IN P_ADAPTER_T  prAdapter,
10008     IN  PVOID       pvSetBuffer,
10009     IN  UINT_32     u4SetBufferLen,
10010     OUT PUINT_32    pu4SetInfoLen
10011     )
10012 {
10013     PUINT_8         pucCountry;
10014
10015     ASSERT(prAdapter);
10016     ASSERT(pvSetBuffer);
10017     ASSERT(u4SetBufferLen == 2);
10018
10019     *pu4SetInfoLen = 2;
10020
10021     pucCountry = pvSetBuffer;
10022
10023     prAdapter->rWifiVar.rConnSettings.u2CountryCode =
10024         (((UINT_16) pucCountry[0]) << 8) | ((UINT_16) pucCountry[1]) ;
10025
10026     prAdapter->prDomainInfo = NULL; /* Force to re-search country code */
10027     rlmDomainSendCmd(prAdapter, TRUE);
10028
10029     return WLAN_STATUS_SUCCESS;
10030 }
10031
10032 #if 0
10033 WLAN_STATUS
10034 wlanoidSetNoaParam (
10035     IN  P_ADAPTER_T       prAdapter,
10036     IN  PVOID             pvSetBuffer,
10037     IN  UINT_32           u4SetBufferLen,
10038     OUT PUINT_32          pu4SetInfoLen
10039     )
10040 {
10041     P_PARAM_CUSTOM_NOA_PARAM_STRUC_T prNoaParam;
10042     CMD_CUSTOM_NOA_PARAM_STRUC_T rCmdNoaParam;
10043
10044     DEBUGFUNC("wlanoidSetNoaParam");
10045     DBGLOG(INIT, LOUD,("\n"));
10046
10047     ASSERT(prAdapter);
10048     ASSERT(pu4SetInfoLen);
10049
10050     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_NOA_PARAM_STRUC_T);
10051
10052     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_NOA_PARAM_STRUC_T)) {
10053         return WLAN_STATUS_INVALID_LENGTH;
10054     }
10055
10056     ASSERT(pvSetBuffer);
10057
10058     prNoaParam = (P_PARAM_CUSTOM_NOA_PARAM_STRUC_T)pvSetBuffer;
10059
10060     kalMemZero(&rCmdNoaParam, sizeof(CMD_CUSTOM_NOA_PARAM_STRUC_T));
10061     rCmdNoaParam.u4NoaDurationMs = prNoaParam->u4NoaDurationMs;
10062     rCmdNoaParam.u4NoaIntervalMs = prNoaParam->u4NoaIntervalMs;
10063     rCmdNoaParam.u4NoaCount = prNoaParam->u4NoaCount;
10064
10065     return wlanSendSetQueryCmd(prAdapter,
10066             CMD_ID_SET_NOA_PARAM,
10067             TRUE,
10068             FALSE,
10069             TRUE,
10070             nicCmdEventSetCommon,
10071             nicOidCmdTimeoutCommon,
10072             sizeof(CMD_CUSTOM_NOA_PARAM_STRUC_T),
10073             (PUINT_8)&rCmdNoaParam,
10074             pvSetBuffer,
10075             u4SetBufferLen
10076             );
10077 }
10078
10079 WLAN_STATUS
10080 wlanoidSetOppPsParam (
10081     IN  P_ADAPTER_T       prAdapter,
10082     IN  PVOID             pvSetBuffer,
10083     IN  UINT_32           u4SetBufferLen,
10084     OUT PUINT_32          pu4SetInfoLen
10085     )
10086 {
10087     P_PARAM_CUSTOM_OPPPS_PARAM_STRUC_T prOppPsParam;
10088     CMD_CUSTOM_OPPPS_PARAM_STRUC_T rCmdOppPsParam;
10089
10090     DEBUGFUNC("wlanoidSetOppPsParam");
10091     DBGLOG(INIT, LOUD,("\n"));
10092
10093     ASSERT(prAdapter);
10094     ASSERT(pu4SetInfoLen);
10095
10096     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_OPPPS_PARAM_STRUC_T);
10097
10098     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_OPPPS_PARAM_STRUC_T)) {
10099         return WLAN_STATUS_INVALID_LENGTH;
10100     }
10101
10102     ASSERT(pvSetBuffer);
10103
10104     prOppPsParam = (P_PARAM_CUSTOM_OPPPS_PARAM_STRUC_T)pvSetBuffer;
10105
10106     kalMemZero(&rCmdOppPsParam, sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T));
10107     rCmdOppPsParam.u4CTwindowMs = prOppPsParam->u4CTwindowMs;
10108
10109     return wlanSendSetQueryCmd(prAdapter,
10110             CMD_ID_SET_OPPPS_PARAM,
10111             TRUE,
10112             FALSE,
10113             TRUE,
10114             nicCmdEventSetCommon,
10115             nicOidCmdTimeoutCommon,
10116             sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
10117             (PUINT_8)&rCmdOppPsParam,
10118             pvSetBuffer,
10119             u4SetBufferLen
10120             );
10121 }
10122
10123 WLAN_STATUS
10124 wlanoidSetUApsdParam (
10125     IN  P_ADAPTER_T       prAdapter,
10126     IN  PVOID             pvSetBuffer,
10127     IN  UINT_32           u4SetBufferLen,
10128     OUT PUINT_32          pu4SetInfoLen
10129     )
10130 {
10131     P_PARAM_CUSTOM_UAPSD_PARAM_STRUC_T prUapsdParam;
10132     CMD_CUSTOM_UAPSD_PARAM_STRUC_T rCmdUapsdParam;
10133     P_PM_PROFILE_SETUP_INFO_T prPmProfSetupInfo;
10134     P_BSS_INFO_T prBssInfo;
10135
10136
10137     DEBUGFUNC("wlanoidSetUApsdParam");
10138     DBGLOG(INIT, LOUD,("\n"));
10139
10140     ASSERT(prAdapter);
10141     ASSERT(pu4SetInfoLen);
10142
10143     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_UAPSD_PARAM_STRUC_T);
10144
10145     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_UAPSD_PARAM_STRUC_T)) {
10146         return WLAN_STATUS_INVALID_LENGTH;
10147     }
10148
10149     ASSERT(pvSetBuffer);
10150
10151     prBssInfo = &(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX]);
10152     prPmProfSetupInfo = &prBssInfo->rPmProfSetupInfo;
10153
10154     prUapsdParam = (P_PARAM_CUSTOM_UAPSD_PARAM_STRUC_T)pvSetBuffer;
10155
10156     kalMemZero(&rCmdUapsdParam, sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T));
10157     rCmdUapsdParam.fgEnAPSD = prUapsdParam->fgEnAPSD;
10158     prAdapter->rWifiVar.fgSupportUAPSD = prUapsdParam->fgEnAPSD;
10159
10160     rCmdUapsdParam.fgEnAPSD_AcBe = prUapsdParam->fgEnAPSD_AcBe;
10161     rCmdUapsdParam.fgEnAPSD_AcBk = prUapsdParam->fgEnAPSD_AcBk;
10162     rCmdUapsdParam.fgEnAPSD_AcVo = prUapsdParam->fgEnAPSD_AcVo;
10163     rCmdUapsdParam.fgEnAPSD_AcVi = prUapsdParam->fgEnAPSD_AcVi;
10164     prPmProfSetupInfo->ucBmpDeliveryAC  =
10165         ((prUapsdParam->fgEnAPSD_AcBe << 0) |
10166         (prUapsdParam->fgEnAPSD_AcBk << 1) |
10167         (prUapsdParam->fgEnAPSD_AcVi << 2) |
10168         (prUapsdParam->fgEnAPSD_AcVo << 3));
10169     prPmProfSetupInfo->ucBmpTriggerAC  =
10170         ((prUapsdParam->fgEnAPSD_AcBe << 0) |
10171         (prUapsdParam->fgEnAPSD_AcBk << 1) |
10172         (prUapsdParam->fgEnAPSD_AcVi << 2) |
10173         (prUapsdParam->fgEnAPSD_AcVo << 3));
10174
10175     rCmdUapsdParam.ucMaxSpLen = prUapsdParam->ucMaxSpLen;
10176     prPmProfSetupInfo->ucUapsdSp  = prUapsdParam->ucMaxSpLen;
10177
10178     return wlanSendSetQueryCmd(prAdapter,
10179             CMD_ID_SET_UAPSD_PARAM,
10180             TRUE,
10181             FALSE,
10182             TRUE,
10183             nicCmdEventSetCommon,
10184             nicOidCmdTimeoutCommon,
10185             sizeof(CMD_CUSTOM_OPPPS_PARAM_STRUC_T),
10186             (PUINT_8)&rCmdUapsdParam,
10187             pvSetBuffer,
10188             u4SetBufferLen
10189             );
10190 }
10191 #endif
10192
10193 /*----------------------------------------------------------------------------*/
10194 /*!
10195 * \brief This routine is called to set BT profile or BT information and the
10196 *        driver will set the built-in PTA configuration into chip.
10197 *
10198 *
10199 * \param[in] prAdapter      Pointer to the Adapter structure.
10200 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
10201 * \param[in] u4SetBufferLen The length of the set buffer.
10202 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
10203 *                          bytes read from the set buffer. If the call failed
10204 *                          due to invalid length of the set buffer, returns
10205 *                          the amount of storage needed.
10206 *
10207 * \retval WLAN_STATUS_SUCCESS
10208 * \retval WLAN_STATUS_INVALID_LENGTH
10209 */
10210 /*----------------------------------------------------------------------------*/
10211 WLAN_STATUS
10212 wlanoidSetBT (
10213     IN  P_ADAPTER_T prAdapter,
10214     IN  PVOID       pvSetBuffer,
10215     IN  UINT_32     u4SetBufferLen,
10216     OUT PUINT_32    pu4SetInfoLen
10217     )
10218 {
10219
10220     P_PTA_IPC_T   prPtaIpc;
10221
10222     DEBUGFUNC("wlanoidSetBT.\n");
10223
10224     ASSERT(prAdapter);
10225     ASSERT(pu4SetInfoLen);
10226
10227     *pu4SetInfoLen = sizeof(PTA_IPC_T);
10228     if (u4SetBufferLen != sizeof(PTA_IPC_T)) {
10229         WARNLOG(("Invalid length %ld\n", u4SetBufferLen));
10230         return WLAN_STATUS_INVALID_LENGTH;
10231     }
10232
10233     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
10234         DBGLOG(REQ, WARN, ("Fail to set BT profile because of ACPI_D3\n"));
10235         return WLAN_STATUS_ADAPTER_NOT_READY;
10236     }
10237
10238     ASSERT(pvSetBuffer);
10239     prPtaIpc = (P_PTA_IPC_T)pvSetBuffer;
10240
10241 #if CFG_SUPPORT_BCM && CFG_SUPPORT_BCM_BWCS && CFG_SUPPORT_BCM_BWCS_DEBUG
10242     printk(KERN_INFO DRV_NAME "BCM BWCS CMD: BWCS CMD = %02x%02x%02x%02x\n",
10243             prPtaIpc->u.aucBTPParams[0], prPtaIpc->u.aucBTPParams[1], prPtaIpc->u.aucBTPParams[2], prPtaIpc->u.aucBTPParams[3]);
10244
10245     printk(KERN_INFO DRV_NAME "BCM BWCS CMD: aucBTPParams[0] = %02x, aucBTPParams[1] = %02x, aucBTPParams[2] = %02x, aucBTPParams[3] = %02x.\n",
10246             prPtaIpc->u.aucBTPParams[0],
10247             prPtaIpc->u.aucBTPParams[1],
10248             prPtaIpc->u.aucBTPParams[2],
10249             prPtaIpc->u.aucBTPParams[3]);
10250 #endif
10251
10252     wlanSendSetQueryCmd(prAdapter,
10253             CMD_ID_SET_BWCS,
10254             TRUE,
10255             FALSE,
10256             FALSE,
10257             NULL,
10258             NULL,
10259             sizeof(PTA_IPC_T),
10260             (PUINT_8)prPtaIpc,
10261             NULL,
10262             0);
10263
10264     return WLAN_STATUS_SUCCESS;
10265 }
10266
10267 /*----------------------------------------------------------------------------*/
10268 /*!
10269 * \brief This routine is called to query current BT profile and BTCR values
10270 *
10271 * \param[in] prAdapter          Pointer to the Adapter structure.
10272 * \param[in] pvQueryBuffer      Pointer to the buffer that holds the result of
10273 *                               the query.
10274 * \param[in] u4QueryBufferLen   The length of the query buffer.
10275 * \param[out] pu4QueryInfoLen   If the call is successful, returns the number of
10276 *                               bytes written into the query buffer. If the call
10277 *                               failed due to invalid length of the query buffer,
10278 *                               returns the amount of storage needed.
10279 *
10280 * \retval WLAN_STATUS_SUCCESS
10281 * \retval WLAN_STATUS_INVALID_LENGTH
10282 */
10283 /*----------------------------------------------------------------------------*/
10284 WLAN_STATUS
10285 wlanoidQueryBT (
10286     IN  P_ADAPTER_T prAdapter,
10287     OUT PVOID       pvQueryBuffer,
10288     IN  UINT_32     u4QueryBufferLen,
10289     OUT PUINT_32    pu4QueryInfoLen
10290     )
10291 {
10292 //    P_PARAM_PTA_IPC_T prPtaIpc;
10293 //    UINT_32 u4QueryBuffLen;
10294
10295     ASSERT(prAdapter);
10296     ASSERT(pu4QueryInfoLen);
10297     if (u4QueryBufferLen) {
10298         ASSERT(pvQueryBuffer);
10299     }
10300
10301     *pu4QueryInfoLen = sizeof(PTA_IPC_T);
10302
10303     /* Check for query buffer length */
10304     if (u4QueryBufferLen != sizeof(PTA_IPC_T)) {
10305         DBGLOG(REQ, WARN, ("Invalid length %lu\n", u4QueryBufferLen));
10306         return WLAN_STATUS_INVALID_LENGTH;
10307     }
10308
10309     ASSERT(pvQueryBuffer);
10310 //    prPtaIpc = (P_PTA_IPC_T)pvQueryBuffer;
10311 //    prPtaIpc->ucCmd = BT_CMD_PROFILE;
10312 //    prPtaIpc->ucLen = sizeof(prPtaIpc->u);
10313 //    nicPtaGetProfile(prAdapter, (PUINT_8)&prPtaIpc->u, &u4QueryBuffLen);
10314
10315     return WLAN_STATUS_SUCCESS;
10316 }
10317
10318 #if 0
10319 WLAN_STATUS
10320 wlanoidQueryBtSingleAntenna (
10321     IN  P_ADAPTER_T prAdapter,
10322     OUT PVOID       pvQueryBuffer,
10323     IN  UINT_32     u4QueryBufferLen,
10324     OUT PUINT_32    pu4QueryInfoLen
10325     )
10326 {
10327     P_PTA_INFO_T prPtaInfo;
10328     PUINT_32 pu4SingleAntenna;
10329
10330     ASSERT(prAdapter);
10331     ASSERT(pu4QueryInfoLen);
10332     if (u4QueryBufferLen) {
10333         ASSERT(pvQueryBuffer);
10334     }
10335
10336     *pu4QueryInfoLen = sizeof(UINT_32);
10337
10338     /* Check for query buffer length */
10339     if (u4QueryBufferLen != sizeof(UINT_32)) {
10340         DBGLOG(REQ, WARN, ("Invalid length %lu\n", u4QueryBufferLen));
10341         return WLAN_STATUS_INVALID_LENGTH;
10342     }
10343
10344     ASSERT(pvQueryBuffer);
10345
10346     prPtaInfo = &prAdapter->rPtaInfo;
10347     pu4SingleAntenna = (PUINT_32)pvQueryBuffer;
10348
10349     if(prPtaInfo->fgSingleAntenna) {
10350         //printk(KERN_WARNING DRV_NAME"Q Single Ant = 1\r\n");
10351         *pu4SingleAntenna = 1;
10352     } else {
10353         //printk(KERN_WARNING DRV_NAME"Q Single Ant = 0\r\n");
10354         *pu4SingleAntenna = 0;
10355     }
10356
10357     return WLAN_STATUS_SUCCESS;
10358 }
10359
10360
10361 WLAN_STATUS
10362 wlanoidSetBtSingleAntenna (
10363     IN  P_ADAPTER_T prAdapter,
10364     IN  PVOID       pvSetBuffer,
10365     IN  UINT_32     u4SetBufferLen,
10366     OUT PUINT_32    pu4SetInfoLen
10367     )
10368 {
10369
10370     PUINT_32        pu4SingleAntenna;
10371     UINT_32         u4SingleAntenna;
10372     P_PTA_INFO_T    prPtaInfo;
10373
10374     ASSERT(prAdapter);
10375     ASSERT(pu4SetInfoLen);
10376
10377     prPtaInfo = &prAdapter->rPtaInfo;
10378
10379     *pu4SetInfoLen = sizeof(UINT_32);
10380     if (u4SetBufferLen != sizeof(UINT_32)) {
10381         return WLAN_STATUS_INVALID_LENGTH;
10382     }
10383
10384     if (IS_ARB_IN_RFTEST_STATE(prAdapter)) {
10385         return WLAN_STATUS_SUCCESS;
10386     }
10387
10388     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
10389         DBGLOG(REQ, WARN, ("Fail to set antenna because of ACPI_D3\n"));
10390         return WLAN_STATUS_ADAPTER_NOT_READY;
10391     }
10392
10393     ASSERT(pvSetBuffer);
10394     pu4SingleAntenna = (PUINT_32)pvSetBuffer;
10395     u4SingleAntenna = *pu4SingleAntenna;
10396
10397     if (u4SingleAntenna == 0) {
10398         //printk(KERN_WARNING DRV_NAME"Set Single Ant = 0\r\n");
10399         prPtaInfo->fgSingleAntenna = FALSE;
10400     } else {
10401         //printk(KERN_WARNING DRV_NAME"Set Single Ant = 1\r\n");
10402         prPtaInfo->fgSingleAntenna = TRUE;
10403     }
10404     ptaFsmRunEventSetConfig(prAdapter, &prPtaInfo->rPtaParam);
10405
10406     return WLAN_STATUS_SUCCESS;
10407 }
10408
10409
10410 #if CFG_SUPPORT_BCM && CFG_SUPPORT_BCM_BWCS
10411 WLAN_STATUS
10412 wlanoidQueryPta (
10413     IN  P_ADAPTER_T prAdapter,
10414     OUT PVOID       pvQueryBuffer,
10415     IN  UINT_32     u4QueryBufferLen,
10416     OUT PUINT_32    pu4QueryInfoLen
10417     )
10418 {
10419     P_PTA_INFO_T prPtaInfo;
10420     PUINT_32 pu4Pta;
10421
10422     ASSERT(prAdapter);
10423     ASSERT(pu4QueryInfoLen);
10424     if (u4QueryBufferLen) {
10425         ASSERT(pvQueryBuffer);
10426     }
10427
10428     *pu4QueryInfoLen = sizeof(UINT_32);
10429
10430     /* Check for query buffer length */
10431     if (u4QueryBufferLen != sizeof(UINT_32)) {
10432         DBGLOG(REQ, WARN, ("Invalid length %lu\n", u4QueryBufferLen));
10433         return WLAN_STATUS_INVALID_LENGTH;
10434     }
10435
10436     ASSERT(pvQueryBuffer);
10437
10438     prPtaInfo = &prAdapter->rPtaInfo;
10439     pu4Pta = (PUINT_32)pvQueryBuffer;
10440
10441     if(prPtaInfo->fgEnabled) {
10442         //printk(KERN_WARNING DRV_NAME"PTA = 1\r\n");
10443         *pu4Pta = 1;
10444     } else {
10445         //printk(KERN_WARNING DRV_NAME"PTA = 0\r\n");
10446         *pu4Pta = 0;
10447     }
10448
10449     return WLAN_STATUS_SUCCESS;
10450 }
10451
10452
10453 WLAN_STATUS
10454 wlanoidSetPta (
10455     IN  P_ADAPTER_T prAdapter,
10456     IN  PVOID       pvSetBuffer,
10457     IN  UINT_32     u4SetBufferLen,
10458     OUT PUINT_32    pu4SetInfoLen
10459     )
10460 {
10461     PUINT_32    pu4PtaCtrl;
10462     UINT_32     u4PtaCtrl;
10463
10464     ASSERT(prAdapter);
10465     ASSERT(pu4SetInfoLen);
10466
10467     *pu4SetInfoLen = sizeof(UINT_32);
10468     if (u4SetBufferLen != sizeof(UINT_32)) {
10469         return WLAN_STATUS_INVALID_LENGTH;
10470     }
10471
10472     if (IS_ARB_IN_RFTEST_STATE(prAdapter)) {
10473         return WLAN_STATUS_SUCCESS;
10474     }
10475
10476     if (prAdapter->rAcpiState == ACPI_STATE_D3) {
10477         DBGLOG(REQ, WARN, ("Fail to set BT setting because of ACPI_D3\n"));
10478         return WLAN_STATUS_ADAPTER_NOT_READY;
10479     }
10480
10481     ASSERT(pvSetBuffer);
10482     pu4PtaCtrl = (PUINT_32)pvSetBuffer;
10483     u4PtaCtrl = *pu4PtaCtrl;
10484
10485     if (u4PtaCtrl == 0) {
10486         //printk(KERN_WARNING DRV_NAME"Set Pta= 0\r\n");
10487         nicPtaSetFunc(prAdapter, FALSE);
10488     } else {
10489         //printk(KERN_WARNING DRV_NAME"Set Pta= 1\r\n");
10490         nicPtaSetFunc(prAdapter, TRUE);
10491     }
10492
10493     return WLAN_STATUS_SUCCESS;
10494 }
10495 #endif
10496
10497 #endif
10498
10499 /*----------------------------------------------------------------------------*/
10500 /*!
10501 * \brief This routine is called to set Tx power profile.
10502 *
10503 *
10504 * \param[in] prAdapter      Pointer to the Adapter structure.
10505 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
10506 * \param[in] u4SetBufferLen The length of the set buffer.
10507 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
10508 *                          bytes read from the set buffer. If the call failed
10509 *                          due to invalid length of the set buffer, returns
10510 *                          the amount of storage needed.
10511 *
10512 * \retval WLAN_STATUS_SUCCESS
10513 * \retval WLAN_STATUS_INVALID_LENGTH
10514 */
10515 /*----------------------------------------------------------------------------*/
10516 WLAN_STATUS
10517 wlanoidSetTxPower (
10518     IN  P_ADAPTER_T prAdapter,
10519     IN  PVOID       pvSetBuffer,
10520     IN  UINT_32     u4SetBufferLen,
10521     OUT PUINT_32    pu4SetInfoLen
10522     )
10523 {
10524     //P_SET_TXPWR_CTRL_T pTxPwr = (P_SET_TXPWR_CTRL_T)pvSetBuffer;
10525     //UINT_32 i;
10526     WLAN_STATUS     rStatus;
10527
10528     DEBUGFUNC("wlanoidSetTxPower");
10529     DBGLOG(REQ, LOUD, ("\r\n"));
10530
10531     ASSERT(prAdapter);
10532     ASSERT(pvSetBuffer);
10533
10534 #if 0
10535     printk("c2GLegacyStaPwrOffset=%d\n", pTxPwr->c2GLegacyStaPwrOffset);
10536     printk("c2GHotspotPwrOffset=%d\n", pTxPwr->c2GHotspotPwrOffset);
10537     printk("c2GP2pPwrOffset=%d\n", pTxPwr->c2GP2pPwrOffset);
10538     printk("c2GBowPwrOffset=%d\n", pTxPwr->c2GBowPwrOffset);
10539     printk("c5GLegacyStaPwrOffset=%d\n", pTxPwr->c5GLegacyStaPwrOffset);
10540     printk("c5GHotspotPwrOffset=%d\n", pTxPwr->c5GHotspotPwrOffset);
10541     printk("c5GP2pPwrOffset=%d\n", pTxPwr->c5GP2pPwrOffset);
10542     printk("c5GBowPwrOffset=%d\n", pTxPwr->c5GBowPwrOffset);
10543     printk("ucConcurrencePolicy=%d\n", pTxPwr->ucConcurrencePolicy);
10544
10545     for (i=0; i<14;i++)
10546         printk("acTxPwrLimit2G[%d]=%d\n", i, pTxPwr->acTxPwrLimit2G[i]);
10547
10548     for (i=0; i<4;i++)
10549         printk("acTxPwrLimit5G[%d]=%d\n", i, pTxPwr->acTxPwrLimit5G[i]);
10550 #endif
10551
10552     rStatus = wlanSendSetQueryCmd (
10553                 prAdapter,                  /* prAdapter */
10554                 CMD_ID_SET_TXPWR_CTRL,      /* ucCID */
10555                 TRUE,                       /* fgSetQuery */
10556                 FALSE,                      /* fgNeedResp */
10557                 TRUE,                       /* fgIsOid */
10558                 NULL,                       /* pfCmdDoneHandler*/
10559                 NULL,                       /* pfCmdTimeoutHandler */
10560                 u4SetBufferLen,             /* u4SetQueryInfoLen */
10561                 (PUINT_8) pvSetBuffer,      /* pucInfoBuffer */
10562                 NULL,                       /* pvSetQueryBuffer */
10563                 0                           /* u4SetQueryBufferLen */
10564                 );
10565
10566     ASSERT(rStatus == WLAN_STATUS_PENDING);
10567
10568     return rStatus;
10569
10570 }
10571
10572 WLAN_STATUS
10573 wlanSendMemDumpCmd (
10574     IN P_ADAPTER_T  prAdapter,
10575     IN PVOID        pvQueryBuffer,
10576     IN UINT_32      u4QueryBufferLen
10577     )
10578 {
10579     P_PARAM_CUSTOM_MEM_DUMP_STRUC_T prMemDumpInfo;
10580     P_CMD_DUMP_MEM prCmdDumpMem;
10581     CMD_DUMP_MEM rCmdDumpMem;
10582     WLAN_STATUS rStatus = WLAN_STATUS_SUCCESS;
10583     UINT_32 u4MemSize = PARAM_MEM_DUMP_MAX_SIZE;
10584
10585     UINT_32 u4RemainLeng = 0;
10586     UINT_32 u4CurAddr = 0;
10587     UINT_8  ucFragNum = 0;
10588
10589     prCmdDumpMem = &rCmdDumpMem;
10590     prMemDumpInfo = (P_PARAM_CUSTOM_MEM_DUMP_STRUC_T)pvQueryBuffer;
10591
10592     u4RemainLeng = prMemDumpInfo->u4RemainLength;
10593     u4CurAddr = prMemDumpInfo->u4Address + prMemDumpInfo->u4Length;
10594     ucFragNum = prMemDumpInfo->ucFragNum + 1;
10595
10596     /* Query. If request length is larger than max length, do it as ping pong.
10597          * Send a command and wait for a event. Send next command while the event is received.
10598          *
10599          */
10600     do{
10601         UINT_32 u4CurLeng = 0;
10602
10603         if(u4RemainLeng > u4MemSize) {
10604             u4CurLeng = u4MemSize;
10605             u4RemainLeng -= u4MemSize;
10606         } else {
10607             u4CurLeng = u4RemainLeng;
10608             u4RemainLeng = 0;
10609         }
10610
10611         prCmdDumpMem->u4Address = u4CurAddr;
10612         prCmdDumpMem->u4Length = u4CurLeng;
10613         prCmdDumpMem->u4RemainLength = u4RemainLeng;
10614         prCmdDumpMem->ucFragNum = ucFragNum;
10615
10616         DBGLOG(REQ, TRACE, ("[%d] 0x%X, len %d, remain len %d\n",
10617             ucFragNum,
10618             prCmdDumpMem->u4Address,
10619             prCmdDumpMem->u4Length,
10620             prCmdDumpMem->u4RemainLength));
10621
10622         rStatus = wlanSendSetQueryCmd(prAdapter,
10623                 CMD_ID_DUMP_MEM,
10624                 FALSE,
10625                 TRUE,
10626                 TRUE,
10627                 nicCmdEventQueryMemDump,
10628                 nicOidCmdTimeoutCommon,
10629                 sizeof(CMD_DUMP_MEM),
10630                 (PUINT_8)prCmdDumpMem,
10631                 pvQueryBuffer,
10632                 u4QueryBufferLen
10633                 );
10634
10635     }while(FALSE);
10636
10637     return rStatus;
10638 }
10639
10640
10641 /*----------------------------------------------------------------------------*/
10642 /*!
10643 * \brief This routine is called to dump memory.
10644 *
10645 * \param[in] pvAdapter Pointer to the Adapter structure.
10646 * \param[out] pvQueryBuf A pointer to the buffer that holds the result of
10647 *                           the query.
10648 * \param[in] u4QueryBufLen The length of the query buffer.
10649 * \param[out] pu4QueryInfoLen If the call is successful, returns the number of
10650 *                            bytes written into the query buffer. If the call
10651 *                            failed due to invalid length of the query buffer,
10652 *                            returns the amount of storage needed.
10653 *
10654 * \retval WLAN_STATUS_SUCCESS
10655 * \retval WLAN_STATUS_INVALID_LENGTH
10656 */
10657 /*----------------------------------------------------------------------------*/
10658 WLAN_STATUS
10659 wlanoidQueryMemDump (
10660     IN P_ADAPTER_T  prAdapter,
10661     IN PVOID        pvQueryBuffer,
10662     IN UINT_32      u4QueryBufferLen,
10663     OUT PUINT_32    pu4QueryInfoLen
10664     )
10665 {
10666     P_PARAM_CUSTOM_MEM_DUMP_STRUC_T prMemDumpInfo;
10667
10668     DEBUGFUNC("wlanoidQueryMemDump");
10669     DBGLOG(INIT, LOUD,("\n"));
10670
10671     ASSERT(prAdapter);
10672     ASSERT(pu4QueryInfoLen);
10673     if (u4QueryBufferLen) {
10674         ASSERT(pvQueryBuffer);
10675     }
10676
10677     *pu4QueryInfoLen = sizeof(UINT_32);
10678
10679     prMemDumpInfo = (P_PARAM_CUSTOM_MEM_DUMP_STRUC_T)pvQueryBuffer;
10680     DBGLOG(REQ, TRACE, ("Dump 0x%X, len %d\n", prMemDumpInfo->u4Address, prMemDumpInfo->u4Length));
10681
10682     prMemDumpInfo->u4RemainLength = prMemDumpInfo->u4Length;
10683     prMemDumpInfo->u4Length = 0;
10684     prMemDumpInfo->ucFragNum = 0;
10685
10686     return wlanSendMemDumpCmd(
10687                 prAdapter,
10688                 pvQueryBuffer,
10689                 u4QueryBufferLen);
10690
10691 } /* end of wlanoidQueryMcrRead() */
10692
10693
10694 #if CFG_ENABLE_WIFI_DIRECT
10695 /*----------------------------------------------------------------------------*/
10696 /*!
10697 * \brief This routine is used to set the p2p mode.
10698 *
10699 * \param[in] pvAdapter Pointer to the Adapter structure.
10700 * \param[in] pvSetBuffer A pointer to the buffer that holds the data to be set.
10701 * \param[in] u4SetBufferLen The length of the set buffer.
10702 * \param[out] pu4SetInfoLen If the call is successful, returns the number of
10703 *                          bytes read from the set buffer. If the call failed
10704 *                          due to invalid length of the set buffer, returns
10705 *                          the amount of storage needed.
10706 *
10707 * \retval WLAN_STATUS_SUCCESS
10708 * \retval WLAN_STATUS_INVALID_LENGTH
10709 */
10710 /*----------------------------------------------------------------------------*/
10711 WLAN_STATUS
10712 wlanoidSetP2pMode (
10713     IN  P_ADAPTER_T prAdapter,
10714     IN  PVOID       pvSetBuffer,
10715     IN  UINT_32     u4SetBufferLen,
10716     OUT PUINT_32    pu4SetInfoLen
10717     )
10718 {
10719     WLAN_STATUS status;
10720     P_PARAM_CUSTOM_P2P_SET_STRUC_T prSetP2P = (P_PARAM_CUSTOM_P2P_SET_STRUC_T)NULL;
10721     //P_MSG_P2P_NETDEV_REGISTER_T prP2pNetdevRegMsg = (P_MSG_P2P_NETDEV_REGISTER_T)NULL;
10722     DEBUGFUNC("wlanoidSetP2pMode");
10723
10724     ASSERT(prAdapter);
10725     ASSERT(pu4SetInfoLen);
10726
10727     *pu4SetInfoLen = sizeof(PARAM_CUSTOM_P2P_SET_STRUC_T);
10728     if (u4SetBufferLen < sizeof(PARAM_CUSTOM_P2P_SET_STRUC_T)) {
10729         DBGLOG(REQ, WARN, ("Invalid length %ld\n", u4SetBufferLen));
10730         return WLAN_STATUS_INVALID_LENGTH;
10731     }
10732
10733     prSetP2P = (P_PARAM_CUSTOM_P2P_SET_STRUC_T) pvSetBuffer;
10734
10735     DBGLOG(P2P, INFO, ("Set P2P enable[%ld] mode[%ld]\n", prSetP2P->u4Enable, prSetP2P->u4Mode));
10736
10737     /*
10738         *    enable = 1, mode = 0  => init P2P network
10739         *    enable = 1, mode = 1  => init Soft AP network
10740         *    enable = 0                   => uninit P2P/AP network
10741         */
10742
10743     if (prSetP2P->u4Enable) {
10744         p2pSetMode((prSetP2P->u4Mode == 1)?TRUE:FALSE);
10745
10746         if (p2pLaunch(prAdapter->prGlueInfo)) {
10747             ASSERT(prAdapter->fgIsP2PRegistered);
10748         }
10749
10750     }
10751     else {
10752         if (prAdapter->fgIsP2PRegistered) {
10753             p2pRemove(prAdapter->prGlueInfo);
10754         }
10755
10756     }
10757
10758
10759 #if 0
10760     prP2pNetdevRegMsg = (P_MSG_P2P_NETDEV_REGISTER_T)cnmMemAlloc(
10761                                                             prAdapter,
10762                                                             RAM_TYPE_MSG,
10763                                                             (sizeof(MSG_P2P_NETDEV_REGISTER_T)));
10764
10765     if (prP2pNetdevRegMsg == NULL) {
10766         ASSERT(FALSE);
10767         status = WLAN_STATUS_RESOURCES;
10768         return status;
10769     }
10770
10771
10772     prP2pNetdevRegMsg->rMsgHdr.eMsgId = MID_MNY_P2P_NET_DEV_REGISTER;
10773     prP2pNetdevRegMsg->fgIsEnable = (prSetP2P->u4Enable == 1)?TRUE:FALSE;
10774     prP2pNetdevRegMsg->ucMode = (UINT_8)prSetP2P->u4Mode;
10775
10776     mboxSendMsg(prAdapter,
10777             MBOX_ID_0,
10778             (P_MSG_HDR_T)prP2pNetdevRegMsg,
10779             MSG_SEND_METHOD_BUF);
10780 #endif
10781
10782     return status;
10783
10784 }
10785 #endif
10786
10787