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