drivers/net/wireless/rockchip_wlan/mt5931_kk/drv_wlan/nic/nic_cmd_event.c

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