drivers/mtk_wcn_combo/drv_wlan/wlan/nic/nic_cmd_event.c

   1 /*
   2 ** $Id: //Department/DaVinci/BRANCHES/MT6620_WIFI_DRIVER_V2_2/nic/nic_cmd_event.c#1 $
   3 */
   4
   5 /*! \file   nic_cmd_event.c
   6     \brief  Callback functions for Command packets.
   7
   8         Various Event packet handlers which will be setup in the callback function of
   9     a command packet.
  10 */
  11
  12 /*******************************************************************************
  13 * Copyright (c) 2007 MediaTek Inc.
  14 *
  15 * All rights reserved. Copying, compilation, modification, distribution
  16 * or any other use whatsoever of this material is strictly prohibited
  17 * except in accordance with a Software License Agreement with
  18 * MediaTek Inc.
  19 ********************************************************************************
  20 */
  21
  22 /*******************************************************************************
  23 * LEGAL DISCLAIMER
  24 *
  25 * BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND
  26 * AGREES THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK
  27 * SOFTWARE") RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE
  28 * PROVIDED TO BUYER ON AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY
  29 * DISCLAIMS ANY AND ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT
  30 * LIMITED TO THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  31 * PARTICULAR PURPOSE OR NONINFRINGEMENT. NEITHER DOES MEDIATEK PROVIDE
  32 * ANY WARRANTY WHATSOEVER WITH RESPECT TO THE SOFTWARE OF ANY THIRD PARTY
  33 * WHICH MAY BE USED BY, INCORPORATED IN, OR SUPPLIED WITH THE MEDIATEK
  34 * SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY
  35 * WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO NOT BE RESPONSIBLE
  36 * FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S SPECIFICATION OR TO
  37 * CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
  38 *
  39 * BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
  40 * LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL
  41 * BE, AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT
  42 * ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY
  43 * BUYER TO MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
  44 *
  45 * THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
  46 * WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT
  47 * OF LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING
  48 * THEREOF AND RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN
  49 * FRANCISCO, CA, UNDER THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE
  50 * (ICC).
  51 ********************************************************************************
  52 */
  53
  54 /*
  55 ** $Log: nic_cmd_event.c $
  56  *
  57  * 01 27 2012 yuche.tsai
  58  * [ALPS00118350] [ALPS.ICS][WiFi Direct] Dirver update for wifi direct connection
  59  * Fix compile warning & update latest driver 2.2.
  60  * Davinci Label: 20120127_ALPS_WIFI_P2P_DRIVER_V2_1
  61  *
  62  * 06 15 2011 cm.chang
  63  * [WCXRP00000785] [MT6620 Wi-Fi][Driver][FW] P2P/BOW MAC address is XOR with AIS MAC address
  64  * P2P/BOW mac address XOR with local bit instead of OR
  65  *
  66  * 03 18 2011 cp.wu
  67  * [WCXRP00000577] [MT6620 Wi-Fi][Driver][FW] Create V2.0 branch for firmware and driver
  68  * create V2.0 driver release based on label "MT6620_WIFI_DRIVER_V2_0_110318_1600" from main trunk
  69  *
  70  * 03 05 2011 wh.su
  71  * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
  72  * add the code to get the check rsponse and indicate to app.
  73  *
  74  * 03 02 2011 wh.su
  75  * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
  76  * Add security check code.
  77  *
  78  * 02 24 2011 cp.wu
  79  * [WCXRP00000493] [MT6620 Wi-Fi][Driver] Do not indicate redundant disconnection to host when entering into RF test mode
  80  * only indicate DISCONNECTION to host when entering RF test if necessary (connected -> disconnected cases)
  81  *
  82  * 01 20 2011 eddie.chen
  83  * [WCXRP00000374] [MT6620 Wi-Fi][DRV] SW debug control
  84  * Add Oid for sw control debug command
  85  *
  86  * 12 31 2010 cp.wu
  87  * [WCXRP00000335] [MT6620 Wi-Fi][Driver] change to use milliseconds sleep instead of delay to avoid blocking to system scheduling
  88  * change to use msleep() and shorten waiting interval to reduce blocking to other task while Wi-Fi driver is being loaded
  89  *
  90  * 12 01 2010 cp.wu
  91  * [WCXRP00000223] MT6620 Wi-Fi][Driver][FW] Adopt NVRAM parameters when enter/exit RF test mode
  92  * reload NVRAM settings before entering RF test mode and leaving from RF test mode.
  93  *
  94  * 11 01 2010 cp.wu
  95  * [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
  96  * 1) Query link speed (TX rate) from firmware directly with buffering mechanism to reduce overhead
  97  * 2) Remove CNM CH-RECOVER event handling
  98  * 3) cfg read/write API renamed with kal prefix for unified naming rules.
  99  *
 100  * 10 20 2010 cp.wu
 101  * [WCXRP00000117] [MT6620 Wi-Fi][Driver] Add logic for suspending driver when MT6620 is not responding anymore
 102  * use OID_CUSTOM_TEST_MODE as indication for driver reset
 103  * by dropping pending TX packets
 104  *
 105  * 10 18 2010 cp.wu
 106  * [WCXRP00000056] [MT6620 Wi-Fi][Driver] NVRAM implementation with Version Check[WCXRP00000086] [MT6620 Wi-Fi][Driver] The mac address is all zero at android
 107  * complete implementation of Android NVRAM access
 108  *
 109  * 09 21 2010 cp.wu
 110  * [WCXRP00000053] [MT6620 Wi-Fi][Driver] Reset incomplete and might leads to BSOD when entering RF test with AIS associated
 111  * Do a complete reset with STA-REC null checking for RF test re-entry
 112  *
 113  * 09 15 2010 yuche.tsai
 114  * NULL
 115  * Start to test AT GO only when P2P state is not IDLE.
 116  *
 117  * 09 09 2010 yuche.tsai
 118  * NULL
 119  * Add AT GO Test mode after MAC address available.
 120  *
 121  * 09 03 2010 kevin.huang
 122  * NULL
 123  * Refine #include sequence and solve recursive/nested #include issue
 124  *
 125  * 08 30 2010 cp.wu
 126  * NULL
 127  * eliminate klockwork errors
 128  *
 129  * 08 16 2010 cp.wu
 130  * NULL
 131  * Replace CFG_SUPPORT_BOW by CFG_ENABLE_BT_OVER_WIFI.
 132  * There is no CFG_SUPPORT_BOW in driver domain source.
 133  *
 134  * 08 12 2010 cp.wu
 135  * NULL
 136  * [AIS-FSM] honor registry setting for adhoc running mode. (A/B/G)
 137  *
 138  * 08 11 2010 yuche.tsai
 139  * NULL
 140  * Add support for P2P Device Address query from FW.
 141  *
 142  * 08 03 2010 cp.wu
 143  * NULL
 144  * Centralize mgmt/system service procedures into independent calls.
 145  *
 146  * 08 02 2010 cp.wu
 147  * NULL
 148  * reset FSMs before entering RF test mode.
 149  *
 150  * 07 22 2010 cp.wu
 151  *
 152  * 1) refine AIS-FSM indent.
 153  * 2) when entering RF Test mode, flush 802.1X frames as well
 154  * 3) when entering D3 state, flush 802.1X frames as well
 155  *
 156  * 07 08 2010 cp.wu
 157  *
 158  * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
 159  *
 160  * 07 05 2010 cp.wu
 161  * [WPD00003833][MT6620 and MT5931] Driver migration
 162  * 1) change fake BSS_DESC from channel 6 to channel 1 due to channel switching is not done yet.
 163  * 2) after MAC address is queried from firmware, all related variables in driver domain should be updated as well
 164  *
 165  * 06 21 2010 wh.su
 166  * [WPD00003840][MT6620 5931] Security migration
 167  * remove duplicate variable for migration.
 168  *
 169  * 06 06 2010 kevin.huang
 170  * [WPD00003832][MT6620 5931] Create driver base
 171  * [MT6620 5931] Create driver base
 172  *
 173  * 05 29 2010 cp.wu
 174  * [WPD00001943]Create WiFi test driver framework on WinXP
 175  * change upon request: indicate as disconnected in driver domain when leaving from RF test mode
 176  *
 177  * 05 24 2010 cp.wu
 178  * [WPD00001943]Create WiFi test driver framework on WinXP
 179  * do not clear scanning list array after disassociation
 180  *
 181  * 05 22 2010 cp.wu
 182  * [WPD00001943]Create WiFi test driver framework on WinXP
 183  * 1) disable NETWORK_LAYER_ADDRESSES handling temporally.
 184  * 2) finish statistics OIDs
 185  *
 186  * 05 22 2010 cp.wu
 187  * [WPD00001943]Create WiFi test driver framework on WinXP
 188  * change OID behavior to meet WHQL requirement.
 189  *
 190  * 05 20 2010 cp.wu
 191  * [WPD00001943]Create WiFi test driver framework on WinXP
 192  * 1) integrate OID_GEN_NETWORK_LAYER_ADDRESSES with CMD_ID_SET_IP_ADDRESS
 193  * 2) buffer statistics data for 2 seconds
 194  * 3) use default value for adhoc parameters instead of 0
 195  *
 196  * 05 19 2010 cp.wu
 197  * [WPD00001943]Create WiFi test driver framework on WinXP
 198  * 1) do not take timeout mechanism for power mode oids
 199  * 2) retrieve network type from connection status
 200  * 3) after disassciation, set radio state to off
 201  * 4) TCP option over IPv6 is supported
 202  *
 203  * 05 17 2010 cp.wu
 204  * [WPD00001943]Create WiFi test driver framework on WinXP
 205  * correct OID_802_11_DISASSOCIATE handling.
 206  *
 207  * 05 17 2010 cp.wu
 208  * [WPD00003831][MT6620 Wi-Fi] Add framework for Wi-Fi Direct support
 209  * 1) add timeout handler mechanism for pending command packets
 210  * 2) add p2p add/removal key
 211  *
 212  * 04 16 2010 cp.wu
 213  * [WPD00001943]Create WiFi test driver framework on WinXP
 214  * treat BUS access failure as kind of card removal.
 215  *
 216  * 04 14 2010 cp.wu
 217  * [WPD00001943]Create WiFi test driver framework on WinXP
 218  * information buffer for query oid/ioctl is now buffered in prCmdInfo
 219  *  *  *  *  *  * instead of glue-layer variable to improve multiple oid/ioctl capability
 220  *
 221  * 04 13 2010 cp.wu
 222  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 223  * add framework for BT-over-Wi-Fi support.
 224  *  *  *  *  *  *  *  *  *  *  *  *  *  * 1) prPendingCmdInfo is replaced by queue for multiple handler capability
 225  *  *  *  *  *  *  *  *  *  *  *  *  *  * 2) command sequence number is now increased atomically
 226  *  *  *  *  *  *  *  *  *  *  *  *  *  * 3) private data could be hold and taken use for other purpose
 227  *
 228  * 04 07 2010 cp.wu
 229  * [WPD00001943]Create WiFi test driver framework on WinXP
 230  * accessing to firmware load/start address, and access to OID handling information
 231  * are now handled in glue layer
 232  *
 233  * 04 07 2010 cp.wu
 234  * [WPD00001943]Create WiFi test driver framework on WinXP
 235  * rWlanInfo should be placed at adapter rather than glue due to most operations
 236  *  *  *  * are done in adapter layer.
 237  *
 238  * 04 06 2010 cp.wu
 239  * [WPD00001943]Create WiFi test driver framework on WinXP
 240  * add KAL API: kalFlushPendingTxPackets(), and take use of the API
 241  *
 242  * 04 06 2010 cp.wu
 243  * [WPD00001943]Create WiFi test driver framework on WinXP
 244  * eliminate direct access to prGlueInfo->rWlanInfo.eLinkAttr.ucMediaStreamMode from non-glue layer.
 245  *
 246  * 04 06 2010 jeffrey.chang
 247  * [WPD00003826]Initial import for Linux port
 248  * improve none-glude code portability
 249  *
 250  * 04 06 2010 cp.wu
 251  * [WPD00001943]Create WiFi test driver framework on WinXP
 252  * sync statistics data structure definition with firmware implementation
 253  *
 254  * 04 06 2010 cp.wu
 255  * [WPD00001943]Create WiFi test driver framework on WinXP
 256  * code refine: fgTestMode should be at adapter rather than glue due to the device/fw is also involved
 257  *
 258  * 04 06 2010 cp.wu
 259  * [WPD00001943]Create WiFi test driver framework on WinXP
 260  * eliminate direct access for prGlueInfo->fgIsCardRemoved in non-glue layer
 261  *
 262  * 03 30 2010 cp.wu
 263  * [WPD00001943]Create WiFi test driver framework on WinXP
 264  * statistics information OIDs are now handled by querying from firmware domain
 265  *
 266  * 03 26 2010 cp.wu
 267  * [WPD00001943]Create WiFi test driver framework on WinXP
 268  * indicate media stream mode after set is done
 269  *
 270  * 03 24 2010 jeffrey.chang
 271  * [WPD00003826]Initial import for Linux port
 272  * initial import for Linux port
 273  *
 274  * 03 03 2010 cp.wu
 275  * [WPD00001943]Create WiFi test driver framework on WinXP
 276  * implement custom OID: EEPROM read/write access
 277  *
 278  * 03 03 2010 cp.wu
 279  * [WPD00001943]Create WiFi test driver framework on WinXP
 280  * implement OID_802_3_MULTICAST_LIST oid handling
 281  *
 282  * 02 25 2010 cp.wu
 283  * [WPD00001943]Create WiFi test driver framework on WinXP
 284  * limit RSSI return value to microsoft defined range.
 285  *
 286  * 02 09 2010 cp.wu
 287  * [WPD00001943]Create WiFi test driver framework on WinXP
 288  * 1. Permanent and current MAC address are now retrieved by CMD/EVENT packets instead of hard-coded address
 289  *  *  *  *  *  *  * 2. follow MSDN defined behavior when associates to another AP
 290  *  *  *  *  *  *  * 3. for firmware download, packet size could be up to 2048 bytes
 291  *
 292  * 01 29 2010 cp.wu
 293  * [WPD00001943]Create WiFi test driver framework on WinXP
 294  * block until firmware finished RF test enter/leave then indicate completion to upper layer
 295  *
 296  * 01 29 2010 cp.wu
 297  * [WPD00001943]Create WiFi test driver framework on WinXP
 298  * when entering RF test mode and leaving from RF test mode, wait for W_FUNC_RDY bit to be asserted forever until it is set or card is removed.
 299  *
 300  * 01 27 2010 cp.wu
 301  * [WPD00001943]Create WiFi test driver framework on WinXP
 302  * 1. eliminate improper variable in rHifInfo
 303  *  *  *  *  *  *  *  * 2. block TX/ordinary OID when RF test mode is engaged
 304  *  *  *  *  *  *  *  * 3. wait until firmware finish operation when entering into and leaving from RF test mode
 305  *  *  *  *  *  *  *  * 4. correct some HAL implementation
 306  *
 307  * 01 26 2010 cp.wu
 308  * [WPD00001943]Create WiFi test driver framework on WinXP
 309  * Under WinXP with SDIO, use prGlueInfo->rHifInfo.pvInformationBuffer instead of prGlueInfo->pvInformationBuffer
 310  *
 311  * 01 22 2010 cp.wu
 312  * [WPD00001943]Create WiFi test driver framework on WinXP
 313  * implement following 802.11 OIDs:
 314  *  *  *  *  * OID_802_11_RSSI,
 315  *  *  *  *  * OID_802_11_RSSI_TRIGGER,
 316  *  *  *  *  * OID_802_11_STATISTICS,
 317  *  *  *  *  * OID_802_11_DISASSOCIATE,
 318  *  *  *  *  * OID_802_11_POWER_MODE
 319  *
 320  * 01 21 2010 cp.wu
 321  * [WPD00001943]Create WiFi test driver framework on WinXP
 322  * implement OID_802_11_MEDIA_STREAM_MODE
 323  *
 324  * 12 30 2009 cp.wu
 325  * [WPD00001943]Create WiFi test driver framework on WinXP
 326  * 1) According to CMD/EVENT documentation v0.8,
 327  *  *  *  *  *  *  *  * OID_CUSTOM_TEST_RX_STATUS & OID_CUSTOM_TEST_TX_STATUS is no longer used,
 328  *  *  *  *  *  *  *  * and result is retrieved by get ATInfo instead
 329  *  *  *  *  *  *  *  * 2) add 4 counter for recording aggregation statistics
 330 **  \main\maintrunk.MT6620WiFiDriver_Prj\10 2009-12-10 16:47:47 GMT mtk02752
 331 **  only handle MCR read when accessing FW domain register
 332 **  \main\maintrunk.MT6620WiFiDriver_Prj\9 2009-12-08 17:37:28 GMT mtk02752
 333 **  * refine nicCmdEventQueryMcrRead
 334 **  + add TxStatus/RxStatus for RF test QueryInformation OIDs
 335 **  \main\maintrunk.MT6620WiFiDriver_Prj\8 2009-12-02 22:05:45 GMT mtk02752
 336 **  kalOidComplete() will decrease i4OidPendingCount
 337 **  \main\maintrunk.MT6620WiFiDriver_Prj\7 2009-12-01 23:02:57 GMT mtk02752
 338 **  remove unnecessary spin locks
 339 **  \main\maintrunk.MT6620WiFiDriver_Prj\6 2009-12-01 22:51:18 GMT mtk02752
 340 **  maintein i4OidPendingCount
 341 **  \main\maintrunk.MT6620WiFiDriver_Prj\5 2009-11-30 10:55:03 GMT mtk02752
 342 **  modify for compatibility
 343 **  \main\maintrunk.MT6620WiFiDriver_Prj\4 2009-11-23 14:46:32 GMT mtk02752
 344 **  add another version of command-done handler upon new event structure
 345 **  \main\maintrunk.MT6620WiFiDriver_Prj\3 2009-04-29 15:42:33 GMT mtk01461
 346 **  Add comment
 347 **  \main\maintrunk.MT6620WiFiDriver_Prj\2 2009-04-21 19:32:42 GMT mtk01461
 348 **  Add nicCmdEventSetCommon() for general set OID
 349 **  \main\maintrunk.MT6620WiFiDriver_Prj\1 2009-04-21 01:40:35 GMT mtk01461
 350 **  Command Done Handler
 351 */
 352
 353 /*******************************************************************************
 354 *                         C O M P I L E R   F L A G S
 355 ********************************************************************************
 356 */
 357
 358 /*******************************************************************************
 359 *                    E X T E R N A L   R E F E R E N C E S
 360 ********************************************************************************
 361 */
 362 #include "precomp.h"
 363
 364
 365 /*******************************************************************************
 366 *                              C O N S T A N T S
 367 ********************************************************************************
 368 */
 369
 370 /*******************************************************************************
 371 *                             D A T A   T Y P E S
 372 ********************************************************************************
 373 */
 374
 375 /*******************************************************************************
 376 *                            P U B L I C   D A T A
 377 ********************************************************************************
 378 */
 379
 380 VOID
 381 nicCmdEventQueryMcrRead (
 382     IN P_ADAPTER_T  prAdapter,
 383     IN P_CMD_INFO_T prCmdInfo,
 384     IN PUINT_8      pucEventBuf
 385     )
 386 {
 387     UINT_32 u4QueryInfoLen;
 388     P_PARAM_CUSTOM_MCR_RW_STRUC_T prMcrRdInfo;
 389     P_GLUE_INFO_T prGlueInfo;
 390     P_CMD_ACCESS_REG prCmdAccessReg;
 391
 392
 393     ASSERT(prAdapter);
 394     ASSERT(prCmdInfo);
 395     ASSERT(pucEventBuf);
 396
 397     //4 <2> Update information of OID
 398     if (prCmdInfo->fgIsOid) {
 399         prGlueInfo = prAdapter->prGlueInfo;
 400         prCmdAccessReg = (P_CMD_ACCESS_REG)(pucEventBuf);
 401
 402         u4QueryInfoLen = sizeof(PARAM_CUSTOM_MCR_RW_STRUC_T);
 403
 404         prMcrRdInfo = (P_PARAM_CUSTOM_MCR_RW_STRUC_T) prCmdInfo->pvInformationBuffer;
 405         prMcrRdInfo->u4McrOffset = prCmdAccessReg->u4Address;
 406         prMcrRdInfo->u4McrData = prCmdAccessReg->u4Data;
 407
 408         kalOidComplete(prGlueInfo, prCmdInfo->fgSetQuery, u4QueryInfoLen, WLAN_STATUS_SUCCESS);
 409     }
 410
 411     return;
 412
 413 }
 414
 415
 416 VOID
 417 nicCmdEventQuerySwCtrlRead (
 418     IN P_ADAPTER_T  prAdapter,
 419     IN P_CMD_INFO_T prCmdInfo,
 420     IN PUINT_8      pucEventBuf
 421     )
 422 {
 423     UINT_32 u4QueryInfoLen;
 424     P_PARAM_CUSTOM_SW_CTRL_STRUC_T prSwCtrlInfo;
 425     P_GLUE_INFO_T prGlueInfo;
 426     P_CMD_SW_DBG_CTRL_T prCmdSwCtrl;
 427
 428     ASSERT(prAdapter);
 429     ASSERT(prCmdInfo);
 430     ASSERT(pucEventBuf);
 431
 432     //4 <2> Update information of OID
 433     if (prCmdInfo->fgIsOid) {
 434         prGlueInfo = prAdapter->prGlueInfo;
 435         prCmdSwCtrl = (P_CMD_SW_DBG_CTRL_T)(pucEventBuf);
 436
 437         u4QueryInfoLen = sizeof(PARAM_CUSTOM_SW_CTRL_STRUC_T);
 438
 439         prSwCtrlInfo = (P_PARAM_CUSTOM_SW_CTRL_STRUC_T) prCmdInfo->pvInformationBuffer;
 440         prSwCtrlInfo->u4Id = prCmdSwCtrl->u4Id;
 441         prSwCtrlInfo->u4Data = prCmdSwCtrl->u4Data;
 442
 443         kalOidComplete(prGlueInfo, prCmdInfo->fgSetQuery, u4QueryInfoLen, WLAN_STATUS_SUCCESS);
 444     }
 445
 446     return;
 447
 448 }
 449
 450
 451
 452 VOID
 453 nicCmdEventSetCommon (
 454     IN P_ADAPTER_T  prAdapter,
 455     IN P_CMD_INFO_T prCmdInfo,
 456     IN PUINT_8      pucEventBuf
 457     )
 458 {
 459     ASSERT(prAdapter);
 460     ASSERT(prCmdInfo);
 461
 462     if (prCmdInfo->fgIsOid) {
 463         /* Update Set Infomation Length */
 464         kalOidComplete(prAdapter->prGlueInfo,
 465                        prCmdInfo->fgSetQuery,
 466                        prCmdInfo->u4InformationBufferLength,
 467                        WLAN_STATUS_SUCCESS);
 468     }
 469
 470     return;
 471 }
 472
 473 VOID
 474 nicCmdEventSetDisassociate (
 475     IN P_ADAPTER_T  prAdapter,
 476     IN P_CMD_INFO_T prCmdInfo,
 477     IN PUINT_8      pucEventBuf
 478     )
 479 {
 480     ASSERT(prAdapter);
 481     ASSERT(prCmdInfo);
 482
 483     if (prCmdInfo->fgIsOid) {
 484         /* Update Set Infomation Length */
 485         kalOidComplete(prAdapter->prGlueInfo,
 486                        prCmdInfo->fgSetQuery,
 487                        0,
 488                        WLAN_STATUS_SUCCESS);
 489     }
 490
 491     kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
 492                     WLAN_STATUS_MEDIA_DISCONNECT,
 493                     NULL,
 494                     0);
 495
 496 #if !defined(LINUX)
 497     prAdapter->fgIsRadioOff = TRUE;
 498 #endif
 499
 500     return;
 501 }
 502
 503 VOID
 504 nicCmdEventSetIpAddress (
 505     IN P_ADAPTER_T  prAdapter,
 506     IN P_CMD_INFO_T prCmdInfo,
 507     IN PUINT_8      pucEventBuf
 508     )
 509 {
 510     UINT_32 u4Count;
 511
 512     ASSERT(prAdapter);
 513     ASSERT(prCmdInfo);
 514
 515     u4Count = (prCmdInfo->u4SetInfoLen - OFFSET_OF(CMD_SET_NETWORK_ADDRESS_LIST, arNetAddress))
 516         / sizeof(IPV4_NETWORK_ADDRESS) ;
 517
 518     if (prCmdInfo->fgIsOid) {
 519         /* Update Set Infomation Length */
 520         kalOidComplete(prAdapter->prGlueInfo,
 521                        prCmdInfo->fgSetQuery,
 522                        OFFSET_OF(PARAM_NETWORK_ADDRESS_LIST, arAddress) + u4Count *
 523                                 (OFFSET_OF(PARAM_NETWORK_ADDRESS, aucAddress) + sizeof(PARAM_NETWORK_ADDRESS_IP)),
 524                        WLAN_STATUS_SUCCESS);
 525     }
 526
 527     return;
 528 }
 529
 530 VOID
 531 nicCmdEventQueryRfTestATInfo(
 532     IN P_ADAPTER_T  prAdapter,
 533     IN P_CMD_INFO_T prCmdInfo,
 534     IN PUINT_8      pucEventBuf
 535     )
 536 {
 537     P_EVENT_TEST_STATUS prTestStatus, prQueryBuffer;
 538     P_GLUE_INFO_T prGlueInfo;
 539     UINT_32 u4QueryInfoLen;
 540
 541     ASSERT(prAdapter);
 542     ASSERT(prCmdInfo);
 543
 544     prTestStatus = (P_EVENT_TEST_STATUS)pucEventBuf;
 545
 546     if (prCmdInfo->fgIsOid) {
 547         prGlueInfo = prAdapter->prGlueInfo;
 548         prQueryBuffer = (P_EVENT_TEST_STATUS) prCmdInfo->pvInformationBuffer;
 549
 550         kalMemCopy(prQueryBuffer, prTestStatus, sizeof(EVENT_TEST_STATUS));
 551
 552         u4QueryInfoLen = sizeof(EVENT_TEST_STATUS);
 553
 554         /* Update Query Infomation Length */
 555         kalOidComplete(prGlueInfo,
 556                        prCmdInfo->fgSetQuery,
 557                        u4QueryInfoLen,
 558                        WLAN_STATUS_SUCCESS);
 559     }
 560
 561     return;
 562 }
 563
 564 VOID
 565 nicCmdEventQueryLinkQuality(
 566     IN P_ADAPTER_T  prAdapter,
 567     IN P_CMD_INFO_T prCmdInfo,
 568     IN PUINT_8      pucEventBuf
 569     )
 570 {
 571     PARAM_RSSI rRssi, *prRssi;
 572     P_EVENT_LINK_QUALITY prLinkQuality;
 573     P_GLUE_INFO_T prGlueInfo;
 574     UINT_32 u4QueryInfoLen;
 575
 576     ASSERT(prAdapter);
 577     ASSERT(prCmdInfo);
 578
 579     prLinkQuality = (P_EVENT_LINK_QUALITY)pucEventBuf;
 580
 581     rRssi = (PARAM_RSSI)prLinkQuality->cRssi; // ranged from (-128 ~ 30) in unit of dBm
 582
 583     if(rRssi > PARAM_WHQL_RSSI_MAX_DBM)
 584         rRssi = PARAM_WHQL_RSSI_MAX_DBM;
 585     else if(rRssi < PARAM_WHQL_RSSI_MIN_DBM)
 586         rRssi = PARAM_WHQL_RSSI_MIN_DBM;
 587
 588     if (prCmdInfo->fgIsOid) {
 589         prGlueInfo = prAdapter->prGlueInfo;
 590         prRssi = (PARAM_RSSI *) prCmdInfo->pvInformationBuffer;
 591
 592         kalMemCopy(prRssi, &rRssi, sizeof(PARAM_RSSI));
 593         u4QueryInfoLen = sizeof(PARAM_RSSI);
 594
 595         kalOidComplete(prGlueInfo,
 596                        prCmdInfo->fgSetQuery,
 597                        u4QueryInfoLen,
 598                        WLAN_STATUS_SUCCESS);
 599     }
 600 }
 601
 602
 603 /*----------------------------------------------------------------------------*/
 604 /*!
 605 * @brief This routine is in response of OID_GEN_LINK_SPEED query request
 606 *
 607 * @param prAdapter      Pointer to the Adapter structure.
 608 * @param prCmdInfo      Pointer to the pending command info
 609 * @param pucEventBuf
 610 *
 611 * @retval none
 612 */
 613 /*----------------------------------------------------------------------------*/
 614 VOID
 615 nicCmdEventQueryLinkSpeed(
 616     IN P_ADAPTER_T  prAdapter,
 617     IN P_CMD_INFO_T prCmdInfo,
 618     IN PUINT_8      pucEventBuf
 619     )
 620 {
 621     P_EVENT_LINK_QUALITY prLinkQuality;
 622     P_GLUE_INFO_T prGlueInfo;
 623     UINT_32 u4QueryInfoLen;
 624     PUINT_32 pu4LinkSpeed;
 625
 626     ASSERT(prAdapter);
 627     ASSERT(prCmdInfo);
 628
 629     prLinkQuality = (P_EVENT_LINK_QUALITY)pucEventBuf;
 630
 631     if (prCmdInfo->fgIsOid) {
 632         prGlueInfo = prAdapter->prGlueInfo;
 633         pu4LinkSpeed = (PUINT_32)(prCmdInfo->pvInformationBuffer);
 634
 635         if(prLinkQuality->u2LinkSpeed == 0) {
 636             *pu4LinkSpeed = 10000; /* 10K * 100bps = 1Mbps */
 637         }
 638         else {
 639             *pu4LinkSpeed = prLinkQuality->u2LinkSpeed * 5000;
 640         }
 641
 642         u4QueryInfoLen = sizeof(UINT_32);
 643
 644         kalOidComplete(prGlueInfo,
 645                        prCmdInfo->fgSetQuery,
 646                        u4QueryInfoLen,
 647                        WLAN_STATUS_SUCCESS);
 648     }
 649 }
 650
 651
 652 VOID
 653 nicCmdEventQueryStatistics(
 654     IN P_ADAPTER_T  prAdapter,
 655     IN P_CMD_INFO_T prCmdInfo,
 656     IN PUINT_8      pucEventBuf
 657     )
 658 {
 659     P_PARAM_802_11_STATISTICS_STRUCT_T prStatistics;
 660     P_EVENT_STATISTICS prEventStatistics;
 661     P_GLUE_INFO_T prGlueInfo;
 662     UINT_32 u4QueryInfoLen;
 663
 664     ASSERT(prAdapter);
 665     ASSERT(prCmdInfo);
 666
 667     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
 668
 669     if (prCmdInfo->fgIsOid) {
 670         prGlueInfo = prAdapter->prGlueInfo;
 671
 672         u4QueryInfoLen = sizeof(PARAM_802_11_STATISTICS_STRUCT_T);
 673         prStatistics = (P_PARAM_802_11_STATISTICS_STRUCT_T) prCmdInfo->pvInformationBuffer;
 674
 675         prStatistics->u4Length = sizeof(PARAM_802_11_STATISTICS_STRUCT_T);
 676         prStatistics->rTransmittedFragmentCount
 677             = prEventStatistics->rTransmittedFragmentCount;
 678         prStatistics->rMulticastTransmittedFrameCount
 679             = prEventStatistics->rMulticastTransmittedFrameCount;
 680         prStatistics->rFailedCount
 681             = prEventStatistics->rFailedCount;
 682         prStatistics->rRetryCount
 683             = prEventStatistics->rRetryCount;
 684         prStatistics->rMultipleRetryCount
 685             = prEventStatistics->rMultipleRetryCount;
 686         prStatistics->rRTSSuccessCount
 687             = prEventStatistics->rRTSSuccessCount;
 688         prStatistics->rRTSFailureCount
 689             = prEventStatistics->rRTSFailureCount;
 690         prStatistics->rACKFailureCount
 691             = prEventStatistics->rACKFailureCount;
 692         prStatistics->rFrameDuplicateCount
 693             = prEventStatistics->rFrameDuplicateCount;
 694         prStatistics->rReceivedFragmentCount
 695             = prEventStatistics->rReceivedFragmentCount;
 696         prStatistics->rMulticastReceivedFrameCount
 697             = prEventStatistics->rMulticastReceivedFrameCount;
 698         prStatistics->rFCSErrorCount
 699             = prEventStatistics->rFCSErrorCount;
 700         prStatistics->rTKIPLocalMICFailures.QuadPart
 701             = 0;
 702         prStatistics->rTKIPICVErrors.QuadPart
 703             = 0;
 704         prStatistics->rTKIPCounterMeasuresInvoked.QuadPart
 705             = 0;
 706         prStatistics->rTKIPReplays.QuadPart
 707             = 0;
 708         prStatistics->rCCMPFormatErrors.QuadPart
 709             = 0;
 710         prStatistics->rCCMPReplays.QuadPart
 711             = 0;
 712         prStatistics->rCCMPDecryptErrors.QuadPart
 713             = 0;
 714         prStatistics->rFourWayHandshakeFailures.QuadPart
 715             = 0;
 716         prStatistics->rWEPUndecryptableCount.QuadPart
 717             = 0;
 718         prStatistics->rWEPICVErrorCount.QuadPart
 719             = 0;
 720         prStatistics->rDecryptSuccessCount.QuadPart
 721             = 0;
 722         prStatistics->rDecryptFailureCount.QuadPart
 723             = 0;
 724
 725         kalOidComplete(prGlueInfo,
 726                        prCmdInfo->fgSetQuery,
 727                        u4QueryInfoLen,
 728                        WLAN_STATUS_SUCCESS);
 729     }
 730 }
 731
 732 VOID
 733 nicCmdEventEnterRfTest(
 734     IN P_ADAPTER_T  prAdapter,
 735     IN P_CMD_INFO_T prCmdInfo,
 736     IN PUINT_8      pucEventBuf
 737     )
 738 {
 739     UINT_32 u4WHISR = 0, u4Value = 0;
 740     UINT_8 aucTxCount[8];
 741
 742     ASSERT(prAdapter);
 743     ASSERT(prCmdInfo);
 744
 745     // [driver-land]
 746     prAdapter->fgTestMode = TRUE;
 747
 748     // 0. always indicate disconnection
 749     if(kalGetMediaStateIndicated(prAdapter->prGlueInfo) != PARAM_MEDIA_STATE_DISCONNECTED) {
 750         kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
 751                 WLAN_STATUS_MEDIA_DISCONNECT,
 752                 NULL,
 753                 0);
 754     }
 755
 756     // 1. Remove pending TX
 757     nicTxRelease(prAdapter);
 758
 759     // 1.1 clear pending Security / Management Frames
 760     kalClearSecurityFrames(prAdapter->prGlueInfo);
 761     kalClearMgmtFrames(prAdapter->prGlueInfo);
 762
 763     // 1.2 clear pending TX packet queued in glue layer
 764     kalFlushPendingTxPackets(prAdapter->prGlueInfo);
 765
 766     // 2. Reset driver-domain FSMs
 767     nicUninitMGMT(prAdapter);
 768
 769     nicResetSystemService(prAdapter);
 770     nicInitMGMT(prAdapter, NULL);
 771
 772     // 3. Disable Interrupt
 773     HAL_INTR_DISABLE(prAdapter);
 774
 775     // 4. Block til firmware completed entering into RF test mode
 776     kalMsleep(500);
 777     while(1) {
 778         HAL_MCR_RD(prAdapter, MCR_WCIR, &u4Value);
 779
 780         if (u4Value & WCIR_WLAN_READY) {
 781             break;
 782         }
 783         else if(kalIsCardRemoved(prAdapter->prGlueInfo) == TRUE
 784                 || fgIsBusAccessFailed == TRUE) {
 785             if (prCmdInfo->fgIsOid) {
 786                 /* Update Set Infomation Length */
 787                 kalOidComplete(prAdapter->prGlueInfo,
 788                         prCmdInfo->fgSetQuery,
 789                         prCmdInfo->u4SetInfoLen,
 790                         WLAN_STATUS_NOT_SUPPORTED);
 791
 792             }
 793             return;
 794         }
 795         else
 796             kalMsleep(10);
 797     }
 798
 799     // 5. Clear Interrupt Status
 800     HAL_READ_INTR_STATUS(prAdapter, 4, (PUINT_8)&u4WHISR);
 801     if(HAL_IS_TX_DONE_INTR(u4WHISR)) {
 802         HAL_READ_TX_RELEASED_COUNT(prAdapter, aucTxCount);
 803     }
 804
 805     // 6. Reset TX Counter
 806     nicTxResetResource(prAdapter);
 807
 808     // 7. Re-enable Interrupt
 809     HAL_INTR_ENABLE(prAdapter);
 810
 811     // 8. completion indication
 812     if (prCmdInfo->fgIsOid) {
 813         /* Update Set Infomation Length */
 814         kalOidComplete(prAdapter->prGlueInfo,
 815                        prCmdInfo->fgSetQuery,
 816                        prCmdInfo->u4SetInfoLen,
 817                        WLAN_STATUS_SUCCESS);
 818     }
 819
 820 #if CFG_SUPPORT_NVRAM
 821     // 9. load manufacture data
 822     wlanLoadManufactureData(prAdapter, kalGetConfiguration(prAdapter->prGlueInfo));
 823 #endif
 824
 825     return;
 826 }
 827
 828 VOID
 829 nicCmdEventLeaveRfTest(
 830     IN P_ADAPTER_T  prAdapter,
 831     IN P_CMD_INFO_T prCmdInfo,
 832     IN PUINT_8      pucEventBuf
 833     )
 834 {
 835     UINT_32 u4WHISR = 0, u4Value = 0;
 836     UINT_8 aucTxCount[8];
 837
 838     ASSERT(prAdapter);
 839     ASSERT(prCmdInfo);
 840
 841     // 1. Disable Interrupt
 842     HAL_INTR_DISABLE(prAdapter);
 843
 844     // 2. Block til firmware completed leaving from RF test mode
 845     kalMsleep(500);
 846     while(1) {
 847         HAL_MCR_RD(prAdapter, MCR_WCIR, &u4Value);
 848
 849         if (u4Value & WCIR_WLAN_READY) {
 850             break;
 851         }
 852         else if(kalIsCardRemoved(prAdapter->prGlueInfo) == TRUE
 853                 || fgIsBusAccessFailed == TRUE) {
 854             if (prCmdInfo->fgIsOid) {
 855                 /* Update Set Infomation Length */
 856                 kalOidComplete(prAdapter->prGlueInfo,
 857                         prCmdInfo->fgSetQuery,
 858                         prCmdInfo->u4SetInfoLen,
 859                         WLAN_STATUS_NOT_SUPPORTED);
 860
 861             }
 862             return;
 863         }
 864         else {
 865             kalMsleep(10);
 866         }
 867     }
 868
 869     // 3. Clear Interrupt Status
 870     HAL_READ_INTR_STATUS(prAdapter, 4, (PUINT_8)&u4WHISR);
 871     if(HAL_IS_TX_DONE_INTR(u4WHISR)) {
 872         HAL_READ_TX_RELEASED_COUNT(prAdapter, aucTxCount);
 873     }
 874
 875     // 4. Reset TX Counter
 876     nicTxResetResource(prAdapter);
 877
 878     // 5. Re-enable Interrupt
 879     HAL_INTR_ENABLE(prAdapter);
 880
 881     // 6. set driver-land variable
 882     prAdapter->fgTestMode = FALSE;
 883
 884     // 7. completion indication
 885     if (prCmdInfo->fgIsOid) {
 886         /* Update Set Infomation Length */
 887         kalOidComplete(prAdapter->prGlueInfo,
 888                        prCmdInfo->fgSetQuery,
 889                        prCmdInfo->u4SetInfoLen,
 890                        WLAN_STATUS_SUCCESS);
 891     }
 892
 893     /* 8. Indicate as disconnected */
 894     if(kalGetMediaStateIndicated(prAdapter->prGlueInfo) != PARAM_MEDIA_STATE_DISCONNECTED) {
 895
 896         kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
 897                 WLAN_STATUS_MEDIA_DISCONNECT,
 898                 NULL,
 899                 0);
 900
 901         prAdapter->rWlanInfo.u4SysTime = kalGetTimeTick();
 902     }
 903
 904 #if CFG_SUPPORT_NVRAM
 905     /* 9. load manufacture data */
 906     wlanLoadManufactureData(prAdapter, kalGetConfiguration(prAdapter->prGlueInfo));
 907 #endif
 908
 909     /* 10. Override network address */
 910     wlanUpdateNetworkAddress(prAdapter);
 911
 912     return;
 913 }
 914
 915 VOID
 916 nicCmdEventQueryAddress(
 917     IN P_ADAPTER_T  prAdapter,
 918     IN P_CMD_INFO_T prCmdInfo,
 919     IN PUINT_8      pucEventBuf
 920     )
 921 {
 922     UINT_32 u4QueryInfoLen;
 923     P_GLUE_INFO_T prGlueInfo;
 924     P_EVENT_BASIC_CONFIG prEventBasicConfig;
 925
 926     ASSERT(prAdapter);
 927     ASSERT(prCmdInfo);
 928     ASSERT(pucEventBuf);
 929
 930     prEventBasicConfig = (P_EVENT_BASIC_CONFIG)(pucEventBuf);
 931
 932     // copy to adapter
 933     kalMemCopy(&(prAdapter->rMyMacAddr), &(prEventBasicConfig->rMyMacAddr), MAC_ADDR_LEN);
 934
 935     //4 <2> Update information of OID
 936     if (prCmdInfo->fgIsOid) {
 937         prGlueInfo = prAdapter->prGlueInfo;
 938
 939         kalMemCopy(prCmdInfo->pvInformationBuffer, &(prEventBasicConfig->rMyMacAddr), MAC_ADDR_LEN);
 940         u4QueryInfoLen = MAC_ADDR_LEN;
 941
 942         kalOidComplete(prGlueInfo, prCmdInfo->fgSetQuery, u4QueryInfoLen, WLAN_STATUS_SUCCESS);
 943     }
 944
 945     //4 <3> Update new MAC address and all 3 networks
 946     COPY_MAC_ADDR(prAdapter->rWifiVar.aucMacAddress, prAdapter->rMyMacAddr);
 947     COPY_MAC_ADDR(prAdapter->rWifiVar.aucDeviceAddress, prAdapter->rMyMacAddr);
 948     prAdapter->rWifiVar.aucDeviceAddress[0] ^= MAC_ADDR_LOCAL_ADMIN;
 949
 950     COPY_MAC_ADDR(prAdapter->rWifiVar.aucInterfaceAddress, prAdapter->rMyMacAddr);
 951     prAdapter->rWifiVar.aucInterfaceAddress[0] ^= MAC_ADDR_LOCAL_ADMIN;
 952
 953     COPY_MAC_ADDR(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_AIS_INDEX].aucOwnMacAddr,
 954             prAdapter->rMyMacAddr);
 955
 956 #if CFG_ENABLE_WIFI_DIRECT
 957     if(prAdapter->fgIsP2PRegistered) {
 958         COPY_MAC_ADDR(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_P2P_INDEX].aucOwnMacAddr,
 959                 prAdapter->rWifiVar.aucDeviceAddress);
 960     }
 961 #endif
 962
 963 #if CFG_ENABLE_BT_OVER_WIFI
 964     COPY_MAC_ADDR(prAdapter->rWifiVar.arBssInfo[NETWORK_TYPE_BOW_INDEX].aucOwnMacAddr,
 965             prAdapter->rWifiVar.aucDeviceAddress);
 966 #endif
 967
 968 #if CFG_TEST_WIFI_DIRECT_GO
 969     if (prAdapter->rWifiVar.prP2pFsmInfo->eCurrentState == P2P_STATE_IDLE) {
 970         wlanEnableP2pFunction(prAdapter);
 971
 972         wlanEnableATGO(prAdapter);
 973     }
 974 #endif
 975
 976     kalUpdateMACAddress(prAdapter->prGlueInfo, prAdapter->rWifiVar.aucMacAddress);
 977
 978     return;
 979 }
 980
 981 VOID
 982 nicCmdEventQueryMcastAddr(
 983     IN P_ADAPTER_T  prAdapter,
 984     IN P_CMD_INFO_T prCmdInfo,
 985     IN PUINT_8      pucEventBuf
 986     )
 987 {
 988     UINT_32 u4QueryInfoLen;
 989     P_GLUE_INFO_T prGlueInfo;
 990     P_EVENT_MAC_MCAST_ADDR prEventMacMcastAddr;
 991
 992     ASSERT(prAdapter);
 993     ASSERT(prCmdInfo);
 994     ASSERT(pucEventBuf);
 995
 996     //4 <2> Update information of OID
 997     if (prCmdInfo->fgIsOid) {
 998         prGlueInfo = prAdapter->prGlueInfo;
 999         prEventMacMcastAddr = (P_EVENT_MAC_MCAST_ADDR)(pucEventBuf);
1000
1001         u4QueryInfoLen = prEventMacMcastAddr->u4NumOfGroupAddr * MAC_ADDR_LEN;
1002
1003         // buffer length check
1004         if (prCmdInfo->u4InformationBufferLength < u4QueryInfoLen) {
1005             kalOidComplete(prGlueInfo, prCmdInfo->fgSetQuery, u4QueryInfoLen, WLAN_STATUS_BUFFER_TOO_SHORT);
1006         }
1007         else {
1008             kalMemCopy(prCmdInfo->pvInformationBuffer,
1009                     prEventMacMcastAddr->arAddress,
1010                     prEventMacMcastAddr->u4NumOfGroupAddr * MAC_ADDR_LEN);
1011
1012             kalOidComplete(prGlueInfo, prCmdInfo->fgSetQuery, u4QueryInfoLen, WLAN_STATUS_SUCCESS);
1013         }
1014     }
1015 }
1016
1017 VOID
1018 nicCmdEventQueryEepromRead(
1019     IN P_ADAPTER_T  prAdapter,
1020     IN P_CMD_INFO_T prCmdInfo,
1021     IN PUINT_8      pucEventBuf
1022     )
1023 {
1024     UINT_32 u4QueryInfoLen;
1025     P_PARAM_CUSTOM_EEPROM_RW_STRUC_T prEepromRdInfo;
1026     P_GLUE_INFO_T prGlueInfo;
1027     P_EVENT_ACCESS_EEPROM prEventAccessEeprom;
1028
1029     ASSERT(prAdapter);
1030     ASSERT(prCmdInfo);
1031     ASSERT(pucEventBuf);
1032
1033     //4 <2> Update information of OID
1034     if (prCmdInfo->fgIsOid) {
1035         prGlueInfo = prAdapter->prGlueInfo;
1036         prEventAccessEeprom = (P_EVENT_ACCESS_EEPROM)(pucEventBuf);
1037
1038         u4QueryInfoLen = sizeof(PARAM_CUSTOM_EEPROM_RW_STRUC_T);
1039
1040         prEepromRdInfo = (P_PARAM_CUSTOM_EEPROM_RW_STRUC_T) prCmdInfo->pvInformationBuffer;
1041         prEepromRdInfo->ucEepromIndex = (UINT_8)(prEventAccessEeprom->u2Offset);
1042         prEepromRdInfo->u2EepromData = prEventAccessEeprom->u2Data;
1043
1044         kalOidComplete(prGlueInfo, prCmdInfo->fgSetQuery, u4QueryInfoLen, WLAN_STATUS_SUCCESS);
1045     }
1046
1047     return;
1048
1049 }
1050
1051
1052 VOID
1053 nicCmdEventSetMediaStreamMode(
1054     IN P_ADAPTER_T  prAdapter,
1055     IN P_CMD_INFO_T prCmdInfo,
1056     IN PUINT_8      pucEventBuf
1057     )
1058 {
1059     PARAM_MEDIA_STREAMING_INDICATION rParamMediaStreamIndication;
1060
1061     ASSERT(prAdapter);
1062     ASSERT(prCmdInfo);
1063
1064     if (prCmdInfo->fgIsOid) {
1065         /* Update Set Infomation Length */
1066         kalOidComplete(prAdapter->prGlueInfo,
1067                        prCmdInfo->fgSetQuery,
1068                        prCmdInfo->u4SetInfoLen,
1069                        WLAN_STATUS_SUCCESS);
1070     }
1071
1072     rParamMediaStreamIndication.rStatus.eStatusType =
1073         ENUM_STATUS_TYPE_MEDIA_STREAM_MODE;
1074     rParamMediaStreamIndication.eMediaStreamMode =
1075         prAdapter->rWlanInfo.eLinkAttr.ucMediaStreamMode == 0 ?
1076             ENUM_MEDIA_STREAM_OFF : ENUM_MEDIA_STREAM_ON;
1077
1078     kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
1079                 WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
1080                 (PVOID)&rParamMediaStreamIndication,
1081                 sizeof(PARAM_MEDIA_STREAMING_INDICATION));
1082 }
1083
1084
1085 /* Statistics responder */
1086 VOID
1087 nicCmdEventQueryXmitOk(
1088     IN P_ADAPTER_T  prAdapter,
1089     IN P_CMD_INFO_T prCmdInfo,
1090     IN PUINT_8      pucEventBuf
1091     )
1092 {
1093     P_EVENT_STATISTICS prEventStatistics;
1094     P_GLUE_INFO_T prGlueInfo;
1095     UINT_32 u4QueryInfoLen;
1096     PUINT_32 pu4Data;
1097     PUINT_64 pu8Data;
1098
1099     ASSERT(prAdapter);
1100     ASSERT(prCmdInfo);
1101
1102     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
1103
1104     if (prCmdInfo->fgIsOid) {
1105         prGlueInfo = prAdapter->prGlueInfo;
1106
1107         if(prCmdInfo->u4InformationBufferLength == sizeof(UINT_32)) {
1108             u4QueryInfoLen = sizeof(UINT_32);
1109
1110             pu4Data = (PUINT_32) prCmdInfo->pvInformationBuffer;
1111             *pu4Data = (UINT_32) prEventStatistics->rTransmittedFragmentCount.QuadPart;
1112         }
1113         else {
1114             u4QueryInfoLen = sizeof(UINT_64);
1115
1116             pu8Data = (PUINT_64) prCmdInfo->pvInformationBuffer;
1117             *pu8Data = prEventStatistics->rTransmittedFragmentCount.QuadPart;
1118         }
1119
1120         kalOidComplete(prGlueInfo,
1121                        prCmdInfo->fgSetQuery,
1122                        u4QueryInfoLen,
1123                        WLAN_STATUS_SUCCESS);
1124     }
1125 }
1126
1127
1128 VOID
1129 nicCmdEventQueryRecvOk(
1130     IN P_ADAPTER_T  prAdapter,
1131     IN P_CMD_INFO_T prCmdInfo,
1132     IN PUINT_8      pucEventBuf
1133     )
1134 {
1135     P_EVENT_STATISTICS prEventStatistics;
1136     P_GLUE_INFO_T prGlueInfo;
1137     UINT_32 u4QueryInfoLen;
1138     PUINT_32 pu4Data;
1139     PUINT_64 pu8Data;
1140
1141     ASSERT(prAdapter);
1142     ASSERT(prCmdInfo);
1143
1144     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
1145
1146     if (prCmdInfo->fgIsOid) {
1147         prGlueInfo = prAdapter->prGlueInfo;
1148
1149         if(prCmdInfo->u4InformationBufferLength == sizeof(UINT_32)) {
1150             u4QueryInfoLen = sizeof(UINT_32);
1151
1152             pu4Data = (PUINT_32) prCmdInfo->pvInformationBuffer;
1153             *pu4Data = (UINT_32) prEventStatistics->rReceivedFragmentCount.QuadPart;
1154         }
1155         else {
1156             u4QueryInfoLen = sizeof(UINT_64);
1157
1158             pu8Data = (PUINT_64) prCmdInfo->pvInformationBuffer;
1159             *pu8Data = prEventStatistics->rReceivedFragmentCount.QuadPart;
1160         }
1161
1162         kalOidComplete(prGlueInfo,
1163                        prCmdInfo->fgSetQuery,
1164                        u4QueryInfoLen,
1165                        WLAN_STATUS_SUCCESS);
1166     }
1167 }
1168
1169 VOID
1170 nicCmdEventQueryXmitError(
1171     IN P_ADAPTER_T  prAdapter,
1172     IN P_CMD_INFO_T prCmdInfo,
1173     IN PUINT_8      pucEventBuf
1174     )
1175 {
1176     P_EVENT_STATISTICS prEventStatistics;
1177     P_GLUE_INFO_T prGlueInfo;
1178     UINT_32 u4QueryInfoLen;
1179     PUINT_32 pu4Data;
1180     PUINT_64 pu8Data;
1181
1182     ASSERT(prAdapter);
1183     ASSERT(prCmdInfo);
1184
1185     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
1186
1187     if (prCmdInfo->fgIsOid) {
1188         prGlueInfo = prAdapter->prGlueInfo;
1189
1190         if(prCmdInfo->u4InformationBufferLength == sizeof(UINT_32)) {
1191             u4QueryInfoLen = sizeof(UINT_32);
1192
1193             pu4Data = (PUINT_32) prCmdInfo->pvInformationBuffer;
1194             *pu4Data = (UINT_32) prEventStatistics->rFailedCount.QuadPart;
1195         }
1196         else {
1197             u4QueryInfoLen = sizeof(UINT_64);
1198
1199             pu8Data = (PUINT_64) prCmdInfo->pvInformationBuffer;
1200             *pu8Data = (UINT_64) prEventStatistics->rFailedCount.QuadPart;
1201         }
1202
1203         kalOidComplete(prGlueInfo,
1204                        prCmdInfo->fgSetQuery,
1205                        u4QueryInfoLen,
1206                        WLAN_STATUS_SUCCESS);
1207     }
1208 }
1209
1210
1211 VOID
1212 nicCmdEventQueryRecvError(
1213     IN P_ADAPTER_T  prAdapter,
1214     IN P_CMD_INFO_T prCmdInfo,
1215     IN PUINT_8      pucEventBuf
1216     )
1217 {
1218     P_EVENT_STATISTICS prEventStatistics;
1219     P_GLUE_INFO_T prGlueInfo;
1220     UINT_32 u4QueryInfoLen;
1221     PUINT_32 pu4Data;
1222     PUINT_64 pu8Data;
1223
1224     ASSERT(prAdapter);
1225     ASSERT(prCmdInfo);
1226
1227     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
1228
1229     if (prCmdInfo->fgIsOid) {
1230         prGlueInfo = prAdapter->prGlueInfo;
1231
1232         if(prCmdInfo->u4InformationBufferLength == sizeof(UINT_32)) {
1233             u4QueryInfoLen = sizeof(UINT_32);
1234
1235             pu4Data = (PUINT_32) prCmdInfo->pvInformationBuffer;
1236             *pu4Data = (UINT_32) prEventStatistics->rFCSErrorCount.QuadPart;
1237             // @FIXME, RX_ERROR_DROP_COUNT/RX_FIFO_FULL_DROP_COUNT is not calculated
1238         }
1239         else {
1240             u4QueryInfoLen = sizeof(UINT_64);
1241
1242             pu8Data = (PUINT_64) prCmdInfo->pvInformationBuffer;
1243             *pu8Data = prEventStatistics->rFCSErrorCount.QuadPart;
1244             // @FIXME, RX_ERROR_DROP_COUNT/RX_FIFO_FULL_DROP_COUNT is not calculated
1245         }
1246
1247         kalOidComplete(prGlueInfo,
1248                        prCmdInfo->fgSetQuery,
1249                        u4QueryInfoLen,
1250                        WLAN_STATUS_SUCCESS);
1251     }
1252 }
1253
1254
1255 VOID
1256 nicCmdEventQueryRecvNoBuffer(
1257     IN P_ADAPTER_T  prAdapter,
1258     IN P_CMD_INFO_T prCmdInfo,
1259     IN PUINT_8      pucEventBuf
1260     )
1261 {
1262     P_EVENT_STATISTICS prEventStatistics;
1263     P_GLUE_INFO_T prGlueInfo;
1264     UINT_32 u4QueryInfoLen;
1265     PUINT_32 pu4Data;
1266     PUINT_64 pu8Data;
1267
1268     ASSERT(prAdapter);
1269     ASSERT(prCmdInfo);
1270
1271     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
1272
1273     if (prCmdInfo->fgIsOid) {
1274         prGlueInfo = prAdapter->prGlueInfo;
1275
1276         if(prCmdInfo->u4InformationBufferLength == sizeof(UINT_32)) {
1277             u4QueryInfoLen = sizeof(UINT_32);
1278
1279             pu4Data = (PUINT_32) prCmdInfo->pvInformationBuffer;
1280             *pu4Data = 0; // @FIXME?
1281         }
1282         else {
1283             u4QueryInfoLen = sizeof(UINT_64);
1284
1285             pu8Data = (PUINT_64) prCmdInfo->pvInformationBuffer;
1286             *pu8Data = 0; //@FIXME?
1287         }
1288
1289         kalOidComplete(prGlueInfo,
1290                        prCmdInfo->fgSetQuery,
1291                        u4QueryInfoLen,
1292                        WLAN_STATUS_SUCCESS);
1293     }
1294 }
1295
1296
1297 VOID
1298 nicCmdEventQueryRecvCrcError(
1299     IN P_ADAPTER_T  prAdapter,
1300     IN P_CMD_INFO_T prCmdInfo,
1301     IN PUINT_8      pucEventBuf
1302     )
1303 {
1304     P_EVENT_STATISTICS prEventStatistics;
1305     P_GLUE_INFO_T prGlueInfo;
1306     UINT_32 u4QueryInfoLen;
1307     PUINT_32 pu4Data;
1308     PUINT_64 pu8Data;
1309
1310     ASSERT(prAdapter);
1311     ASSERT(prCmdInfo);
1312
1313     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
1314
1315     if (prCmdInfo->fgIsOid) {
1316         prGlueInfo = prAdapter->prGlueInfo;
1317
1318         if(prCmdInfo->u4InformationBufferLength == sizeof(UINT_32)) {
1319             u4QueryInfoLen = sizeof(UINT_32);
1320
1321             pu4Data = (PUINT_32) prCmdInfo->pvInformationBuffer;
1322             *pu4Data = (UINT_32) prEventStatistics->rFCSErrorCount.QuadPart;
1323         }
1324         else {
1325             u4QueryInfoLen = sizeof(UINT_64);
1326
1327             pu8Data = (PUINT_64) prCmdInfo->pvInformationBuffer;
1328             *pu8Data = prEventStatistics->rFCSErrorCount.QuadPart;
1329         }
1330
1331         kalOidComplete(prGlueInfo,
1332                        prCmdInfo->fgSetQuery,
1333                        u4QueryInfoLen,
1334                        WLAN_STATUS_SUCCESS);
1335     }
1336 }
1337
1338
1339 VOID
1340 nicCmdEventQueryRecvErrorAlignment(
1341     IN P_ADAPTER_T  prAdapter,
1342     IN P_CMD_INFO_T prCmdInfo,
1343     IN PUINT_8      pucEventBuf
1344     )
1345 {
1346     P_EVENT_STATISTICS prEventStatistics;
1347     P_GLUE_INFO_T prGlueInfo;
1348     UINT_32 u4QueryInfoLen;
1349     PUINT_32 pu4Data;
1350     PUINT_64 pu8Data;
1351
1352     ASSERT(prAdapter);
1353     ASSERT(prCmdInfo);
1354
1355     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
1356
1357     if (prCmdInfo->fgIsOid) {
1358         prGlueInfo = prAdapter->prGlueInfo;
1359
1360         if(prCmdInfo->u4InformationBufferLength == sizeof(UINT_32)) {
1361             u4QueryInfoLen = sizeof(UINT_32);
1362
1363             pu4Data = (PUINT_32) prCmdInfo->pvInformationBuffer;
1364             *pu4Data = (UINT_32) 0; //@FIXME
1365         }
1366         else {
1367             u4QueryInfoLen = sizeof(UINT_64);
1368
1369             pu8Data = (PUINT_64) prCmdInfo->pvInformationBuffer;
1370             *pu8Data = 0; //@FIXME
1371         }
1372
1373         kalOidComplete(prGlueInfo,
1374                        prCmdInfo->fgSetQuery,
1375                        u4QueryInfoLen,
1376                        WLAN_STATUS_SUCCESS);
1377     }
1378 }
1379
1380
1381 VOID
1382 nicCmdEventQueryXmitOneCollision(
1383     IN P_ADAPTER_T  prAdapter,
1384     IN P_CMD_INFO_T prCmdInfo,
1385     IN PUINT_8      pucEventBuf
1386     )
1387 {
1388     P_EVENT_STATISTICS prEventStatistics;
1389     P_GLUE_INFO_T prGlueInfo;
1390     UINT_32 u4QueryInfoLen;
1391     PUINT_32 pu4Data;
1392     PUINT_64 pu8Data;
1393
1394     ASSERT(prAdapter);
1395     ASSERT(prCmdInfo);
1396
1397     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
1398
1399     if (prCmdInfo->fgIsOid) {
1400         prGlueInfo = prAdapter->prGlueInfo;
1401
1402         if(prCmdInfo->u4InformationBufferLength == sizeof(UINT_32)) {
1403             u4QueryInfoLen = sizeof(UINT_32);
1404
1405             pu4Data = (PUINT_32) prCmdInfo->pvInformationBuffer;
1406             *pu4Data = (UINT_32) (prEventStatistics->rMultipleRetryCount.QuadPart - prEventStatistics->rRetryCount.QuadPart);
1407         }
1408         else {
1409             u4QueryInfoLen = sizeof(UINT_64);
1410
1411             pu8Data = (PUINT_64) prCmdInfo->pvInformationBuffer;
1412             *pu8Data = (UINT_64) (prEventStatistics->rMultipleRetryCount.QuadPart - prEventStatistics->rRetryCount.QuadPart);
1413         }
1414
1415         kalOidComplete(prGlueInfo,
1416                        prCmdInfo->fgSetQuery,
1417                        u4QueryInfoLen,
1418                        WLAN_STATUS_SUCCESS);
1419     }
1420 }
1421
1422
1423 VOID
1424 nicCmdEventQueryXmitMoreCollisions(
1425     IN P_ADAPTER_T  prAdapter,
1426     IN P_CMD_INFO_T prCmdInfo,
1427     IN PUINT_8      pucEventBuf
1428     )
1429 {
1430     P_EVENT_STATISTICS prEventStatistics;
1431     P_GLUE_INFO_T prGlueInfo;
1432     UINT_32 u4QueryInfoLen;
1433     PUINT_32 pu4Data;
1434     PUINT_64 pu8Data;
1435
1436     ASSERT(prAdapter);
1437     ASSERT(prCmdInfo);
1438
1439     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
1440
1441     if (prCmdInfo->fgIsOid) {
1442         prGlueInfo = prAdapter->prGlueInfo;
1443
1444         if(prCmdInfo->u4InformationBufferLength == sizeof(UINT_32)) {
1445             u4QueryInfoLen = sizeof(UINT_32);
1446
1447             pu4Data = (PUINT_32) prCmdInfo->pvInformationBuffer;
1448             *pu4Data = (UINT_32) prEventStatistics->rMultipleRetryCount.QuadPart;
1449         }
1450         else {
1451             u4QueryInfoLen = sizeof(UINT_64);
1452
1453             pu8Data = (PUINT_64) prCmdInfo->pvInformationBuffer;
1454             *pu8Data = (UINT_64) prEventStatistics->rMultipleRetryCount.QuadPart;
1455         }
1456
1457         kalOidComplete(prGlueInfo,
1458                        prCmdInfo->fgSetQuery,
1459                        u4QueryInfoLen,
1460                        WLAN_STATUS_SUCCESS);
1461     }
1462 }
1463
1464
1465 VOID
1466 nicCmdEventQueryXmitMaxCollisions(
1467     IN P_ADAPTER_T  prAdapter,
1468     IN P_CMD_INFO_T prCmdInfo,
1469     IN PUINT_8      pucEventBuf
1470     )
1471 {
1472     P_EVENT_STATISTICS prEventStatistics;
1473     P_GLUE_INFO_T prGlueInfo;
1474     UINT_32 u4QueryInfoLen;
1475     PUINT_32 pu4Data;
1476     PUINT_64 pu8Data;
1477
1478     ASSERT(prAdapter);
1479     ASSERT(prCmdInfo);
1480
1481     prEventStatistics = (P_EVENT_STATISTICS)pucEventBuf;
1482
1483     if (prCmdInfo->fgIsOid) {
1484         prGlueInfo = prAdapter->prGlueInfo;
1485
1486         if(prCmdInfo->u4InformationBufferLength == sizeof(UINT_32)) {
1487             u4QueryInfoLen = sizeof(UINT_32);
1488
1489             pu4Data = (PUINT_32) prCmdInfo->pvInformationBuffer;
1490             *pu4Data = (UINT_32) prEventStatistics->rFailedCount.QuadPart;
1491         }
1492         else {
1493             u4QueryInfoLen = sizeof(UINT_64);
1494
1495             pu8Data = (PUINT_64) prCmdInfo->pvInformationBuffer;
1496             *pu8Data = (UINT_64) prEventStatistics->rFailedCount.QuadPart;
1497         }
1498
1499         kalOidComplete(prGlueInfo,
1500                        prCmdInfo->fgSetQuery,
1501                        u4QueryInfoLen,
1502                        WLAN_STATUS_SUCCESS);
1503     }
1504 }
1505
1506
1507 /*----------------------------------------------------------------------------*/
1508 /*!
1509 * @brief This function is called when command by OID/ioctl has been timeout
1510 *
1511 * @param prAdapter          Pointer to the Adapter structure.
1512 * @param prCmdInfo          Pointer to the command information
1513 *
1514 * @return TRUE
1515 *         FALSE
1516 */
1517 /*----------------------------------------------------------------------------*/
1518 VOID
1519 nicOidCmdTimeoutCommon (
1520     IN P_ADAPTER_T  prAdapter,
1521     IN P_CMD_INFO_T prCmdInfo
1522     )
1523 {
1524     ASSERT(prAdapter);
1525
1526     kalOidComplete(prAdapter->prGlueInfo,
1527             prCmdInfo->fgSetQuery,
1528             0,
1529             WLAN_STATUS_FAILURE);
1530 }
1531
1532
1533 /*----------------------------------------------------------------------------*/
1534 /*!
1535 * @brief This function is a generic command timeout handler
1536 *
1537 * @param pfnOidHandler      Pointer to the OID handler
1538 *
1539 * @return none
1540 */
1541 /*----------------------------------------------------------------------------*/
1542 VOID
1543 nicCmdTimeoutCommon (
1544     IN P_ADAPTER_T  prAdapter,
1545     IN P_CMD_INFO_T prCmdInfo
1546     )
1547 {
1548     ASSERT(prAdapter);
1549 }
1550
1551
1552 /*----------------------------------------------------------------------------*/
1553 /*!
1554 * @brief This function is called when command for entering RF test has
1555 *        failed sending due to timeout (highly possibly by firmware crash)
1556 *
1557 * @param prAdapter          Pointer to the Adapter structure.
1558 * @param prCmdInfo          Pointer to the command information
1559 *
1560 * @return none
1561 *
1562 */
1563 /*----------------------------------------------------------------------------*/
1564 VOID
1565 nicOidCmdEnterRFTestTimeout (
1566     IN P_ADAPTER_T  prAdapter,
1567     IN P_CMD_INFO_T prCmdInfo
1568     )
1569 {
1570     ASSERT(prAdapter);
1571
1572     // 1. Remove pending TX frames
1573     nicTxRelease(prAdapter);
1574
1575     // 1.1 clear pending Security / Management Frames
1576     kalClearSecurityFrames(prAdapter->prGlueInfo);
1577     kalClearMgmtFrames(prAdapter->prGlueInfo);
1578
1579     // 1.2 clear pending TX packet queued in glue layer
1580     kalFlushPendingTxPackets(prAdapter->prGlueInfo);
1581
1582     // 2. indiate for OID failure
1583     kalOidComplete(prAdapter->prGlueInfo,
1584             prCmdInfo->fgSetQuery,
1585             0,
1586             WLAN_STATUS_FAILURE);
1587 }
1588