drivers/net/wireless/mt5931/nic/nic_rx.c

   1 /*
   2 ** $Id: //Department/DaVinci/BRANCHES/MT6620_WIFI_DRIVER_V2_3/nic/nic_rx.c#3 $
   3 */
   4
   5 /*! \file   nic_rx.c
   6     \brief  Functions that provide many rx-related functions
   7
   8     This file includes the functions used to process RFB and dispatch RFBs to
   9     the appropriate related rx functions for protocols.
  10 */
  11
  12
  13
  14 /*
  15 ** $Log: nic_rx.c $
  16 **
  17 ** 08 31 2012 yuche.tsai
  18 ** [ALPS00349585] [6577JB][WiFi direct][KE]Establish p2p connection while both device have connected to AP previously,one device reboots automatically with KE
  19 ** Fix possible KE when concurrent & disconnect.
  20  *
  21  * 07 17 2012 yuche.tsai
  22  * NULL
  23  * Let netdev bring up.
  24  *
  25  * 07 17 2012 yuche.tsai
  26  * NULL
  27  * Compile no error before trial run.
  28  *
  29  * 03 02 2012 terry.wu
  30  * NULL
  31  * Sync CFG80211 modification from branch 2,2.
  32  *
  33  * 02 14 2012 cp.wu
  34  * NULL
  35  * remove another assertion by error message dump
  36  *
  37  * 01 05 2012 tsaiyuan.hsu
  38  * [WCXRP00001157] [MT6620 Wi-Fi][FW][DRV] add timing measurement support for 802.11v
  39  * add timing measurement support for 802.11v.
  40  *
  41  * 11 19 2011 yuche.tsai
  42  * NULL
  43  * Update RSSI for P2P.
  44  *
  45  * 11 18 2011 yuche.tsai
  46  * NULL
  47  * CONFIG P2P support RSSI query, default turned off.
  48  *
  49  * 11 17 2011 tsaiyuan.hsu
  50  * [WCXRP00001115] [MT6620 Wi-Fi][DRV] avoid deactivating staRec when changing state 3 to 3.
  51  * avoid deactivating staRec when changing state from 3 to 3.
  52  *
  53  * 11 11 2011 wh.su
  54  * [WCXRP00001078] [MT6620 Wi-Fi][Driver] Adding the mediatek log improment support : XLOG
  55  * modify the xlog related code.
  56  *
  57  * 11 10 2011 eddie.chen
  58  * [WCXRP00001096] [MT6620 Wi-Fi][Driver/FW] Enhance the log function (xlog)
  59  * Modify the QM xlog level and remove LOG_FUNC.
  60  *
  61  * 11 09 2011 eddie.chen
  62  * [WCXRP00001096] [MT6620 Wi-Fi][Driver/FW] Enhance the log function (xlog)
  63  * Add xlog for beacon timeout and sta aging timeout.
  64  *
  65  * 11 08 2011 eddie.chen
  66  * [WCXRP00001096] [MT6620 Wi-Fi][Driver/FW] Enhance the log function (xlog)
  67  * Add xlog function.
  68  *
  69  * 11 07 2011 tsaiyuan.hsu
  70  * [WCXRP00001083] [MT6620 Wi-Fi][DRV]] dump debug counter or frames when debugging is triggered
  71  * add debug counters and periodically dump counters for debugging.
  72  *
  73  * 10 21 2011 eddie.chen
  74  * [WCXRP00001051] [MT6620 Wi-Fi][Driver/Fw] Adjust the STA aging timeout
  75  * Add switch to ignore the STA aging timeout.
  76  *
  77  * 10 12 2011 wh.su
  78  * [WCXRP00001036] [MT6620 Wi-Fi][Driver][FW] Adding the 802.11w code for MFP
  79  * adding the 802.11w related function and define .
  80  *
  81  * 08 26 2011 cp.wu
  82  * [WCXRP00000958] [MT6620 Wi-Fi][Driver] Extend polling timeout from 25ms to 1sec due to RF calibration might took up to 600ms
  83  * extend polling RX response timeout period from 25ms to 1000ms.
  84  *
  85  * 08 11 2011 cp.wu
  86  * [WCXRP00000830] [MT6620 Wi-Fi][Firmware] Use MDRDY counter to detect empty channel for shortening scan time
  87  * sparse channel detection:
  88  * driver: collect sparse channel information with scan-done event
  89  *
  90  * 07 28 2011 chinghwa.yu
  91  * [WCXRP00000063] Update BCM CoEx design and settings
  92  * Add BWCS cmd and event.
  93  *
  94  * 07 27 2011 cp.wu
  95  * [WCXRP00000876] [MT5931][Drver] Decide to retain according to currently availble RX counter and QUE_MGT used count
  96  * correct comment.
  97  *
  98  * 07 27 2011 cp.wu
  99  * [WCXRP00000876] [MT5931][Drver] Decide to retain according to currently availble RX counter and QUE_MGT used count
 100  * take use of QUE_MGT exported function to estimate currently RX buffer usage count.
 101  *
 102  * 07 18 2011 chinghwa.yu
 103  * [WCXRP00000063] Update BCM CoEx design and settings[WCXRP00000612] [MT6620 Wi-Fi] [FW] CSD update SWRDD algorithm
 104  * Add CMD/Event for RDD and BWCS.
 105  *
 106  * 06 09 2011 tsaiyuan.hsu
 107  * [WCXRP00000760] [MT5931 Wi-Fi][FW] Refine rxmHandleMacRxDone to reduce code size
 108  * move send_auth at rxmHandleMacRxDone in firmware to driver to reduce code size.
 109  *
 110  * 05 11 2011 eddie.chen
 111  * [WCXRP00000709] [MT6620 Wi-Fi][Driver] Check free number before copying broadcast packet
 112  * Fix dest type when GO packet copying.
 113  *
 114  * 05 09 2011 eddie.chen
 115  * [WCXRP00000709] [MT6620 Wi-Fi][Driver] Check free number before copying broadcast packet
 116  * Check free number before copying broadcast packet.
 117  *
 118  * 05 05 2011 cp.wu
 119  * [WCXRP00000702] [MT5931][Driver] Modify initialization sequence for E1 ASIC
 120  * add delay after whole-chip resetting for MT5931 E1 ASIC.
 121  *
 122  * 04 18 2011 terry.wu
 123  * [WCXRP00000660] [MT6620 Wi-Fi][Driver] Remove flag CFG_WIFI_DIRECT_MOVED
 124  * Remove flag CFG_WIFI_DIRECT_MOVED.
 125  *
 126  * 04 12 2011 cm.chang
 127  * [WCXRP00000634] [MT6620 Wi-Fi][Driver][FW] 2nd BSS will not support 40MHz bandwidth for concurrency
 128  * .
 129  *
 130  * 04 08 2011 yuche.tsai
 131  * [WCXRP00000624] [Volunteer Patch][MT6620][Driver] Add device discoverability support for GO.
 132  * Add device discoverability support for GO.
 133  *
 134  * 04 01 2011 tsaiyuan.hsu
 135  * [WCXRP00000615] [MT 6620 Wi-Fi][Driver] Fix klocwork issues
 136  * fix the klocwork issues, 57500, 57501, 57502 and 57503.
 137  *
 138  * 03 19 2011 yuche.tsai
 139  * [WCXRP00000584] [Volunteer Patch][MT6620][Driver] Add beacon timeout support for WiFi Direct.
 140  * Add beacon timeout support for WiFi Direct Network.
 141  *
 142  * 03 18 2011 wh.su
 143  * [WCXRP00000530] [MT6620 Wi-Fi] [Driver] skip doing p2pRunEventAAAComplete after send assoc response Tx Done
 144  * enable the Anti_piracy check at driver .
 145  *
 146  * 03 17 2011 cp.wu
 147  * [WCXRP00000562] [MT6620 Wi-Fi][Driver] I/O buffer pre-allocation to avoid physically continuous memory shortage after system running for a long period
 148  * use pre-allocated buffer for storing enhanced interrupt response as well
 149  *
 150  * 03 15 2011 cp.wu
 151  * [WCXRP00000559] [MT6620 Wi-Fi][Driver] Combine TX/RX DMA buffers into a single one to reduce physically continuous memory consumption
 152  * 1. deprecate CFG_HANDLE_IST_IN_SDIO_CALLBACK
 153  * 2. Use common coalescing buffer for both TX/RX directions
 154  *
 155  *
 156  * 03 07 2011 wh.su
 157  * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
 158  * rename the define to anti_pviracy.
 159  *
 160  * 03 05 2011 wh.su
 161  * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
 162  * add the code to get the check rsponse and indicate to app.
 163  *
 164  * 03 02 2011 wh.su
 165  * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
 166  * Add security check code.
 167  *
 168  * 03 02 2011 cp.wu
 169  * [WCXRP00000503] [MT6620 Wi-Fi][Driver] Take RCPI brought by association response as initial RSSI right after connection is built.
 170  * use RCPI brought by ASSOC-RESP after connection is built as initial RCPI to avoid using a uninitialized MAC-RX RCPI.
 171  *
 172  * 02 10 2011 yuche.tsai
 173  * [WCXRP00000419] [Volunteer Patch][MT6620/MT5931][Driver] Provide function of disconnect to target station for AAA module.
 174  * Remove Station Record after Aging timeout.
 175  *
 176  * 02 10 2011 cp.wu
 177  * [WCXRP00000434] [MT6620 Wi-Fi][Driver] Obsolete unused event packet handlers
 178  * EVENT_ID_CONNECTION_STATUS has been obsoleted and no need to handle.
 179  *
 180  * 02 09 2011 yuche.tsai
 181  * [WCXRP00000431] [Volunteer Patch][MT6620][Driver] Add MLME support for deauthentication under AP(Hot-Spot) mode.
 182  * Add MLME deauthentication support for Hot-Spot mode.
 183  *
 184  * 02 09 2011 eddie.chen
 185  * [WCXRP00000426] [MT6620 Wi-Fi][FW/Driver] Add STA aging timeout and defualtHwRatein AP mode
 186  * Adjust variable order.
 187  *
 188  * 02 08 2011 eddie.chen
 189  * [WCXRP00000426] [MT6620 Wi-Fi][FW/Driver] Add STA aging timeout and defualtHwRatein AP mode
 190  * Add event STA agint timeout
 191  *
 192  * 01 27 2011 tsaiyuan.hsu
 193  * [WCXRP00000392] [MT6620 Wi-Fi][Driver] Add Roaming Support
 194  * add roaming fsm
 195  * 1. not support 11r, only use strength of signal to determine roaming.
 196  * 2. not enable CFG_SUPPORT_ROAMING until completion of full test.
 197  * 3. in 6620, adopt work-around to avoid sign extension problem of cck of hw
 198  * 4. assume that change of link quality in smooth way.
 199  *
 200  * 01 26 2011 cm.chang
 201  * [WCXRP00000395] [MT6620 Wi-Fi][Driver][FW] Search STA_REC with additional net type index argument
 202  * .
 203  *
 204  * 01 24 2011 eddie.chen
 205  * [WCXRP00000385] [MT6620 Wi-Fi][DRV] Add destination decision for forwarding packets
 206  * Remove comments.
 207  *
 208  * 01 24 2011 eddie.chen
 209  * [WCXRP00000385] [MT6620 Wi-Fi][DRV] Add destination decision for forwarding packets
 210  * Add destination decision in AP mode.
 211  *
 212  * 01 24 2011 cm.chang
 213  * [WCXRP00000384] [MT6620 Wi-Fi][Driver][FW] Handle 20/40 action frame in AP mode and stop ampdu timer when sta_rec is freed
 214  * Process received 20/40 coexistence action frame for AP mode
 215  *
 216  * 01 24 2011 cp.wu
 217  * [WCXRP00000382] [MT6620 Wi-Fi][Driver] Track forwarding packet number with notifying tx thread for serving
 218  * 1. add an extra counter for tracking pending forward frames.
 219  * 2. notify TX service thread as well when there is pending forward frame
 220  * 3. correct build errors leaded by introduction of Wi-Fi direct separation module
 221  *
 222  * 01 12 2011 cp.wu
 223  * [WCXRP00000357] [MT6620 Wi-Fi][Driver][Bluetooth over Wi-Fi] add another net device interface for BT AMP
 224  * implementation of separate BT_OVER_WIFI data path.
 225  *
 226  * 12 29 2010 eddie.chen
 227  * [WCXRP00000322] Add WMM IE in beacon,
 228 Add per station flow control when STA is in PS
 229
 230  * 1) PS flow control event
 231  *
 232  * 2) WMM IE in beacon, assoc resp, probe resp
 233  *
 234  * 12 15 2010 george.huang
 235  * [WCXRP00000152] [MT6620 Wi-Fi] AP mode power saving function
 236  * update beacon for NoA
 237  *
 238  * 11 01 2010 cp.wu
 239  * [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
 240  * 1) Query link speed (TX rate) from firmware directly with buffering mechanism to reduce overhead
 241  * 2) Remove CNM CH-RECOVER event handling
 242  * 3) cfg read/write API renamed with kal prefix for unified naming rules.
 243  *
 244  * 10 27 2010 george.huang
 245  * [WCXRP00000127] [MT6620 Wi-Fi][Driver] Add a registry to disable Beacon Timeout function for SQA test by using E1 EVB
 246  * Support registry option for disable beacon lost detection.
 247  *
 248  * 10 20 2010 wh.su
 249  * NULL
 250  * add a cmd to reset the p2p key
 251  *
 252  * 10 20 2010 wh.su
 253  * [WCXRP00000124] [MT6620 Wi-Fi] [Driver] Support the dissolve P2P Group
 254  * Add the code to support disconnect p2p group
 255  *
 256  * 09 29 2010 wh.su
 257  * [WCXRP00000072] [MT6620 Wi-Fi][Driver] Fix TKIP Counter Measure EAPoL callback register issue
 258  * fixed compilier error.
 259  *
 260  * 09 29 2010 wh.su
 261  * [WCXRP00000072] [MT6620 Wi-Fi][Driver] Fix TKIP Counter Measure EAPoL callback register issue
 262  * [MT6620 Wi-Fi][Driver] Fix TKIP Counter Measure EAPoL callback register issue.
 263  *
 264  * 09 23 2010 cp.wu
 265  * [WCXRP00000052] [MT6620 Wi-Fi][Driver] Eliminate Linux Compile Warning
 266  * eliminate reference of CFG_RESPONSE_MAX_PKT_SIZE
 267  *
 268  * 09 21 2010 cp.wu
 269  * [WCXRP00000053] [MT6620 Wi-Fi][Driver] Reset incomplete and might leads to BSOD when entering RF test with AIS associated
 270  * release RX packet to packet pool when in RF test mode
 271  *
 272  * 09 21 2010 cp.wu
 273  * [WCXRP00000053] [MT6620 Wi-Fi][Driver] Reset incomplete and might leads to BSOD when entering RF test with AIS associated
 274  * Do a complete reset with STA-REC null checking for RF test re-entry
 275  *
 276  * 09 08 2010 cp.wu
 277  * NULL
 278  * use static memory pool for storing IEs of scanning result.
 279  *
 280  * 09 07 2010 yuche.tsai
 281  * NULL
 282  * Add a common buffer, store the IE of a P2P device in this common buffer.
 283  *
 284  * 09 03 2010 kevin.huang
 285  * NULL
 286  * Refine #include sequence and solve recursive/nested #include issue
 287  *
 288  * 08 31 2010 kevin.huang
 289  * NULL
 290  * Use LINK LIST operation to process SCAN result
 291  *
 292  * 08 30 2010 cp.wu
 293  * NULL
 294  * eliminate klockwork errors
 295  *
 296  * 08 20 2010 cm.chang
 297  * NULL
 298  * Migrate RLM code to host from FW
 299  *
 300  * 08 20 2010 yuche.tsai
 301  * NULL
 302  * When enable WiFi Direct function, check each packet to tell which interface to indicate.
 303  *
 304  * 08 05 2010 yuche.tsai
 305  * NULL
 306  * Add P2P Device Discovery Function.
 307  *
 308  * 08 03 2010 cp.wu
 309  * NULL
 310  * surpress compilation warning.
 311  *
 312  * 08 03 2010 george.huang
 313  * NULL
 314  * handle event for updating NOA parameters indicated from FW
 315  *
 316  * 08 02 2010 yuche.tsai
 317  * NULL
 318  * Add support API for RX public action frame.
 319  *
 320  * 08 02 2010 jeffrey.chang
 321  * NULL
 322  * 1) modify tx service thread to avoid busy looping
 323  * 2) add spin lock declartion for linux build
 324  *
 325  * 07 30 2010 cp.wu
 326  * NULL
 327  * 1) BoW wrapper: use definitions instead of hard-coded constant for error code
 328  * 2) AIS-FSM: eliminate use of desired RF parameters, use prTargetBssDesc instead
 329  * 3) add handling for RX_PKT_DESTINATION_HOST_WITH_FORWARD for GO-broadcast frames
 330  *
 331  * 07 26 2010 yuche.tsai
 332  *
 333  * Update Device Capability Bitmap & Group Capability Bitmap from 16 bits to 8 bits.
 334  *
 335  * 07 24 2010 wh.su
 336  *
 337  * .support the Wi-Fi RSN
 338  *
 339  * 07 23 2010 cp.wu
 340  *
 341  * add AIS-FSM handling for beacon timeout event.
 342  *
 343  * 07 21 2010 yuche.tsai
 344  *
 345  * Add P2P Scan & Scan Result Parsing & Saving.
 346  *
 347  * 07 19 2010 cm.chang
 348  *
 349  * Set RLM parameters and enable CNM channel manager
 350  *
 351  * 07 19 2010 cp.wu
 352  *
 353  * [WPD00003833] [MT6620 and MT5931] Driver migration.
 354  * Add Ad-Hoc support to AIS-FSM
 355  *
 356  * 07 19 2010 jeffrey.chang
 357  *
 358  * Linux port modification
 359  *
 360  * 07 16 2010 yarco.yang
 361  *
 362  * 1. Support BSS Absence/Presence Event
 363  * 2. Support STA change PS mode Event
 364  * 3. Support BMC forwarding for AP mode.
 365  *
 366  * 07 15 2010 cp.wu
 367  *
 368  * sync. bluetooth-over-Wi-Fi interface to driver interface document v0.2.6.
 369  *
 370  * 07 08 2010 cp.wu
 371  *
 372  * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
 373  *
 374  * 07 07 2010 cp.wu
 375  * [WPD00003833][MT6620 and MT5931] Driver migration
 376  * fill ucStaRecIdx into SW_RFB_T.
 377  *
 378  * 07 02 2010 cp.wu
 379  * [WPD00003833][MT6620 and MT5931] Driver migration
 380  * 1) for event packet, no need to fill RFB.
 381  * 2) when wlanAdapterStart() failed, no need to initialize state machines
 382  * 3) after Beacon/ProbeResp parsing, corresponding BSS_DESC_T should be marked as IE-parsed
 383  *
 384  * 07 01 2010 cp.wu
 385  * [WPD00003833][MT6620 and MT5931] Driver migration
 386  * implementation of DRV-SCN and related mailbox message handling.
 387  *
 388  * 06 29 2010 yarco.yang
 389  * [WPD00003837][MT6620]Data Path Refine
 390  * replace g_rQM with Adpater->rQM
 391  *
 392  * 06 23 2010 yarco.yang
 393  * [WPD00003837][MT6620]Data Path Refine
 394  * Merge g_arStaRec[] into adapter->arStaRec[]
 395  *
 396  * 06 22 2010 cp.wu
 397  * [WPD00003833][MT6620 and MT5931] Driver migration
 398  * 1) add command warpper for STA-REC/BSS-INFO sync.
 399  * 2) enhance command packet sending procedure for non-oid part
 400  * 3) add command packet definitions for STA-REC/BSS-INFO sync.
 401  *
 402  * 06 21 2010 cp.wu
 403  * [WPD00003833][MT6620 and MT5931] Driver migration
 404  * refine TX-DONE callback.
 405  *
 406  * 06 21 2010 cp.wu
 407  * [WPD00003833][MT6620 and MT5931] Driver migration
 408  * implement TX_DONE callback path.
 409  *
 410  * 06 21 2010 yarco.yang
 411  * [WPD00003837][MT6620]Data Path Refine
 412  * Add TX Done Event handle entry
 413  *
 414  * 06 21 2010 wh.su
 415  * [WPD00003840][MT6620 5931] Security migration
 416  * remove duplicate variable for migration.
 417  *
 418  * 06 15 2010 cp.wu
 419  * [WPD00003833][MT6620 and MT5931] Driver migration
 420  * .
 421  *
 422  * 06 15 2010 cp.wu
 423  * [WPD00003833][MT6620 and MT5931] Driver migration
 424  * .
 425  *
 426  * 06 14 2010 cp.wu
 427  * [WPD00003833][MT6620 and MT5931] Driver migration
 428  * saa_fsm.c is migrated.
 429  *
 430  * 06 14 2010 cp.wu
 431  * [WPD00003833][MT6620 and MT5931] Driver migration
 432  * add management dispatching function table.
 433  *
 434  * 06 11 2010 cp.wu
 435  * [WPD00003833][MT6620 and MT5931] Driver migration
 436  * 1) migrate assoc.c.
 437  * 2) add ucTxSeqNum for tracking frames which needs TX-DONE awareness
 438  * 3) add configuration options for CNM_MEM and RSN modules
 439  * 4) add data path for management frames
 440  * 5) eliminate rPacketInfo of MSDU_INFO_T
 441  *
 442  * 06 10 2010 cp.wu
 443  * [WPD00003833][MT6620 and MT5931] Driver migration
 444  * 1) eliminate CFG_CMD_EVENT_VERSION_0_9
 445  * 2) when disconnected, indicate nic directly (no event is needed)
 446  *
 447  * 06 08 2010 cp.wu
 448  * [WPD00003833][MT6620 and MT5931] Driver migration
 449  * cnm_timer has been migrated.
 450  *
 451  * 06 07 2010 cp.wu
 452  * [WPD00003833][MT6620 and MT5931] Driver migration
 453  * merge wlan_def.h.
 454  *
 455  * 06 07 2010 cp.wu
 456  * [WPD00003833][MT6620 and MT5931] Driver migration
 457  * sync with MT6620 driver for scan result replacement policy
 458  *
 459  * 06 06 2010 kevin.huang
 460  * [WPD00003832][MT6620 5931] Create driver base
 461  * [MT6620 5931] Create driver base
 462  *
 463  * 05 20 2010 cp.wu
 464  * [WPD00001943]Create WiFi test driver framework on WinXP
 465  * 1) integrate OID_GEN_NETWORK_LAYER_ADDRESSES with CMD_ID_SET_IP_ADDRESS
 466  * 2) buffer statistics data for 2 seconds
 467  * 3) use default value for adhoc parameters instead of 0
 468  *
 469  * 05 19 2010 cp.wu
 470  * [WPD00001943]Create WiFi test driver framework on WinXP
 471  * 1) do not take timeout mechanism for power mode oids
 472  * 2) retrieve network type from connection status
 473  * 3) after disassciation, set radio state to off
 474  * 4) TCP option over IPv6 is supported
 475  *
 476  * 04 29 2010 wh.su
 477  * [WPD00003816][MT6620 Wi-Fi] Adding the security support
 478  * fixing the PMKID candicate indicate code.
 479  *
 480  * 04 28 2010 cp.wu
 481  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 482  * change prefix for data structure used to communicate with 802.11 PAL
 483  * to avoid ambiguous naming with firmware interface
 484  *
 485  * 04 27 2010 cp.wu
 486  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 487  * basic implementation for EVENT_BT_OVER_WIFI
 488  *
 489  * 04 23 2010 cp.wu
 490  * [WPD00001943]Create WiFi test driver framework on WinXP
 491  * surpress compiler warning
 492  *
 493  * 04 22 2010 jeffrey.chang
 494  * [WPD00003826]Initial import for Linux port
 495  *
 496  * 1) modify rx path code for supporting Wi-Fi direct
 497  * 2) modify config.h since Linux dont need to consider retaining packet
 498  *
 499  * 04 16 2010 cp.wu
 500  * [WPD00001943]Create WiFi test driver framework on WinXP
 501  * treat BUS access failure as kind of card removal.
 502  *
 503  * 04 14 2010 cp.wu
 504  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 505  * nicRxProcessEvent packet doesn't access spin-lock directly from now on.
 506  *
 507  * 04 14 2010 cp.wu
 508  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 509  * do not need to release the spin lock due to it is done inside nicGetPendingCmdInfo()
 510  *
 511  * 04 13 2010 cp.wu
 512  * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
 513  * add framework for BT-over-Wi-Fi support.
 514  *  *  *  *  *  *  *  *  *  *  *  *  *  *  * 1) prPendingCmdInfo is replaced by queue for multiple handler capability
 515  *  *  *  *  *  *  *  *  *  *  *  *  *  *  * 2) command sequence number is now increased atomically
 516  *  *  *  *  *  *  *  *  *  *  *  *  *  *  * 3) private data could be hold and taken use for other purpose
 517  *
 518  * 04 12 2010 cp.wu
 519  * [WPD00001943]Create WiFi test driver framework on WinXP
 520  * add channel frequency <-> number conversion
 521  *
 522  * 04 09 2010 jeffrey.chang
 523  * [WPD00003826]Initial import for Linux port
 524  * 1) add spinlock
 525  * 2) add KAPI for handling association info
 526  *
 527  * 04 07 2010 cp.wu
 528  * [WPD00001943]Create WiFi test driver framework on WinXP
 529  * rWlanInfo should be placed at adapter rather than glue due to most operations
 530  *  *  *  *  * are done in adapter layer.
 531  *
 532  * 04 07 2010 cp.wu
 533  * [WPD00001943]Create WiFi test driver framework on WinXP
 534  * eliminate direct access to prGlueInfo->eParamMediaStateIndicated from non-glue layer
 535  *
 536  * 04 06 2010 cp.wu
 537  * [WPD00001943]Create WiFi test driver framework on WinXP
 538  * eliminate direct access for prGlueInfo->fgIsCardRemoved in non-glue layer
 539  *
 540  * 04 01 2010 jeffrey.chang
 541  * [WPD00003826]Initial import for Linux port
 542  * improve Linux supplicant compliance
 543  *
 544  * 03 31 2010 jeffrey.chang
 545  * [WPD00003826]Initial import for Linux port
 546  * fix ioctl which may cause cmdinfo memory leak
 547  *
 548  * 03 30 2010 cp.wu
 549  * [WPD00001943]Create WiFi test driver framework on WinXP
 550  * remove driver-land statistics.
 551  *
 552  * 03 29 2010 jeffrey.chang
 553  * [WPD00003826]Initial import for Linux port
 554  * improve none-glue code portability
 555  *
 556  * 03 28 2010 jeffrey.chang
 557  * [WPD00003826]Initial import for Linux port
 558  * rWlanInfo is modified before data is indicated to OS
 559  *
 560  * 03 28 2010 jeffrey.chang
 561  * [WPD00003826]Initial import for Linux port
 562  * rWlanInfo is modified before data is indicated to OS
 563  *
 564  * 03 26 2010 cp.wu
 565  * [WPD00001943]Create WiFi test driver framework on WinXP
 566  * add a temporary flag for integration with CMD/EVENT v0.9.
 567  *
 568  * 03 25 2010 cp.wu
 569  * [WPD00001943]Create WiFi test driver framework on WinXP
 570  * 1) correct OID_802_11_CONFIGURATION with frequency setting behavior.
 571  *  *  * the frequency is used for adhoc connection only
 572  *  *  * 2) update with SD1 v0.9 CMD/EVENT documentation
 573  *
 574  * 03 24 2010 jeffrey.chang
 575  * [WPD00003826]Initial import for Linux port
 576  * initial import for Linux port
 577  *
 578  * 03 24 2010 cp.wu
 579  * [WPD00001943]Create WiFi test driver framework on WinXP
 580  * .
 581  *
 582  * 03 24 2010 cp.wu
 583  * [WPD00001943]Create WiFi test driver framework on WinXP
 584  * generate information for OID_GEN_RCV_OK & OID_GEN_XMIT_OK
 585  *  *  *  *
 586  *
 587  * 03 19 2010 cp.wu
 588  * [WPD00001943]Create WiFi test driver framework on WinXP
 589  * 1) add ACPI D0/D3 state switching support
 590  *  *  *  *  *  *  *  *  * 2) use more formal way to handle interrupt when the status is retrieved from enhanced RX response
 591  *
 592  * 03 15 2010 kevin.huang
 593  * [WPD00003820][MT6620 Wi-Fi] Modify the code for meet the WHQL test
 594  * Add event for activate STA_RECORD_T
 595  *
 596  * 03 12 2010 cp.wu
 597  * [WPD00001943]Create WiFi test driver framework on WinXP
 598  * correct fgSetQuery/fgNeedResp check
 599  *
 600  * 03 11 2010 cp.wu
 601  * [WPD00003821][BUG] Host driver stops processing RX packets from HIF RX0
 602  * add RX starvation warning debug message controlled by CFG_HIF_RX_STARVATION_WARNING
 603  *
 604  * 03 10 2010 cp.wu
 605  * [WPD00001943]Create WiFi test driver framework on WinXP
 606  * code clean: removing unused variables and structure definitions
 607  *
 608  * 03 08 2010 cp.wu
 609  * [WPD00001943]Create WiFi test driver framework on WinXP
 610  * 1) add another spin-lock to protect MsduInfoList due to it might be accessed by different thread.
 611  *  *  * 2) change own-back acquiring procedure to wait for up to 16.67 seconds
 612  *
 613  * 03 02 2010 cp.wu
 614  * [WPD00001943]Create WiFi test driver framework on WinXP
 615  * 1) the use of prPendingOid revised, all accessing are now protected by spin lock
 616  *  *  *  * 2) ensure wlanReleasePendingOid will clear all command queues
 617  *
 618  * 03 02 2010 cp.wu
 619  * [WPD00001943]Create WiFi test driver framework on WinXP
 620  * add mutex to avoid multiple access to qmTxQueue simultaneously.
 621  *
 622  * 02 26 2010 cp.wu
 623  * [WPD00001943]Create WiFi test driver framework on WinXP
 624  * move EVENT_ID_ASSOC_INFO from nic_rx.c to gl_kal_ndis_51.c
 625  *  * 'cause it involves OS dependent data structure handling
 626  *
 627  * 02 25 2010 cp.wu
 628  * [WPD00001943]Create WiFi test driver framework on WinXP
 629  * correct behavior to prevent duplicated RX handling for RX0_DONE and RX1_DONE
 630  *
 631  * 02 24 2010 tehuang.liu
 632  * [WPD00001943]Create WiFi test driver framework on WinXP
 633  * Updated API interfaces for qmHandleEventRxAddBa() and qmHandleEventRxDelBa()
 634  *
 635  * 02 10 2010 cp.wu
 636  * [WPD00001943]Create WiFi test driver framework on WinXP
 637  * implement host-side firmware download logic
 638  *
 639  * 02 10 2010 cp.wu
 640  * [WPD00001943]Create WiFi test driver framework on WinXP
 641  * 1) remove unused function in nic_rx.c [which has been handled in que_mgt.c]
 642  *  *  *  *  * 2) firmware image length is now retrieved via NdisFileOpen
 643  *  *  *  *  * 3) firmware image is not structured by (P_IMG_SEC_HDR_T) anymore
 644  *  *  *  *  * 4) nicRxWaitResponse() revised
 645  *  *  *  *  * 5) another set of TQ counter default value is added for fw-download state
 646  *  *  *  *  * 6) Wi-Fi load address is now retrieved from registry too
 647  *
 648  * 02 09 2010 cp.wu
 649  * [WPD00001943]Create WiFi test driver framework on WinXP
 650  * 1. Permanent and current MAC address are now retrieved by CMD/EVENT packets instead of hard-coded address
 651  *  *  *  *  *  *  *  * 2. follow MSDN defined behavior when associates to another AP
 652  *  *  *  *  *  *  *  * 3. for firmware download, packet size could be up to 2048 bytes
 653  *
 654  * 01 27 2010 wh.su
 655  * [WPD00003816][MT6620 Wi-Fi] Adding the security support
 656  * .
 657  *
 658  * 01 22 2010 cp.wu
 659  * [WPD00001943]Create WiFi test driver framework on WinXP
 660  * implement following 802.11 OIDs:
 661  *  *  *  *  *  * OID_802_11_RSSI,
 662  *  *  *  *  *  * OID_802_11_RSSI_TRIGGER,
 663  *  *  *  *  *  * OID_802_11_STATISTICS,
 664  *  *  *  *  *  * OID_802_11_DISASSOCIATE,
 665  *  *  *  *  *  * OID_802_11_POWER_MODE
 666  *
 667  * 12 30 2009 cp.wu
 668  * [WPD00001943]Create WiFi test driver framework on WinXP
 669  * 1) According to CMD/EVENT documentation v0.8,
 670  *  *  *  *  *  *  *  *  * OID_CUSTOM_TEST_RX_STATUS & OID_CUSTOM_TEST_TX_STATUS is no longer used,
 671  *  *  *  *  *  *  *  *  * and result is retrieved by get ATInfo instead
 672  *  *  *  *  *  *  *  *  * 2) add 4 counter for recording aggregation statistics
 673  *
 674  * 12 23 2009 cp.wu
 675  * [WPD00001943]Create WiFi test driver framework on WinXP
 676  * add a precheck: if free sw rfb is not enough, do not invoke read transactionu1rwduu`wvpghlqg|fu+rp
 677  *
 678  * 12 22 2009 cp.wu
 679  * [WPD00003809][Bug] Host driver will crash when processing reordered MSDUs
 680  * The root cause is pointer accessing by mistake. After dequeued from reordering-buffer, handling logic should access returned pointer instead of pointer which has been passed in before.
 681 **  \main\maintrunk.MT6620WiFiDriver_Prj\58 2009-12-17 13:40:33 GMT mtk02752
 682 **  always update prAdapter->rSDIOCtrl when enhanced response is read by RX
 683 **  \main\maintrunk.MT6620WiFiDriver_Prj\57 2009-12-16 18:01:38 GMT mtk02752
 684 **  if interrupt enhanced response is fetched by RX enhanced response, RX needs to invoke interrupt handlers too
 685 **  \main\maintrunk.MT6620WiFiDriver_Prj\56 2009-12-16 14:16:52 GMT mtk02752
 686 **  \main\maintrunk.MT6620WiFiDriver_Prj\55 2009-12-15 20:03:12 GMT mtk02752
 687 **  ASSERT when RX FreeSwRfb is not enough
 688 **  \main\maintrunk.MT6620WiFiDriver_Prj\54 2009-12-15 17:01:29 GMT mtk02752
 689 **  when CFG_SDIO_RX_ENHANCE is enabled, after enhanced response is read, rx procedure should process 1) TX_DONE_INT 2) D2H INT as well
 690 **  \main\maintrunk.MT6620WiFiDriver_Prj\53 2009-12-14 20:45:28 GMT mtk02752
 691 **  when CFG_SDIO_RX_ENHANCE is set, TC counter must be updated each time RX enhance response is read
 692 **
 693 **  \main\maintrunk.MT6620WiFiDriver_Prj\52 2009-12-14 11:34:16 GMT mtk02752
 694 **  correct a trivial logic issue
 695 **  \main\maintrunk.MT6620WiFiDriver_Prj\51 2009-12-14 10:28:25 GMT mtk02752
 696 **  add a protection to avoid out-of-boundary access
 697 **  \main\maintrunk.MT6620WiFiDriver_Prj\50 2009-12-10 16:55:18 GMT mtk02752
 698 **  code clean
 699 **  \main\maintrunk.MT6620WiFiDriver_Prj\49 2009-12-09 14:06:47 GMT MTK02468
 700 **  Added parsing event packets with EVENT_ID_RX_ADDBA or EVENT_ID_RX_DELBA
 701 **  \main\maintrunk.MT6620WiFiDriver_Prj\48 2009-12-08 17:37:51 GMT mtk02752
 702 **  handle EVENT_ID_TEST_STATUS as well
 703 **  \main\maintrunk.MT6620WiFiDriver_Prj\47 2009-12-04 17:59:11 GMT mtk02752
 704 **  to pass free-build compilation check
 705 **  \main\maintrunk.MT6620WiFiDriver_Prj\46 2009-12-04 12:09:52 GMT mtk02752
 706 **  correct trivial mistake
 707 **  \main\maintrunk.MT6620WiFiDriver_Prj\45 2009-12-04 11:53:37 GMT mtk02752
 708 **  all API should be compilable under SD1_SD3_DATAPATH_INTEGRATION == 0
 709 **  \main\maintrunk.MT6620WiFiDriver_Prj\44 2009-12-03 16:19:48 GMT mtk01461
 710 **  Fix the Connected Event
 711 **  \main\maintrunk.MT6620WiFiDriver_Prj\43 2009-11-30 10:56:18 GMT mtk02752
 712 **  1st DW of WIFI_EVENT_T is shared with HIF_RX_HEADER_T
 713 **  \main\maintrunk.MT6620WiFiDriver_Prj\42 2009-11-30 10:11:27 GMT mtk02752
 714 **  implement replacement for bss scan result
 715 **  \main\maintrunk.MT6620WiFiDriver_Prj\41 2009-11-27 11:08:05 GMT mtk02752
 716 **  add flush for reset
 717 **  \main\maintrunk.MT6620WiFiDriver_Prj\40 2009-11-26 09:38:59 GMT mtk02752
 718 **  \main\maintrunk.MT6620WiFiDriver_Prj\39 2009-11-26 09:29:40 GMT mtk02752
 719 **  enable packet forwarding path (for AP mode)
 720 **  \main\maintrunk.MT6620WiFiDriver_Prj\38 2009-11-25 21:37:00 GMT mtk02752
 721 **  sync. with EVENT_SCAN_RESULT_T change, and add an assert for checking event size
 722 **  \main\maintrunk.MT6620WiFiDriver_Prj\37 2009-11-25 20:17:41 GMT mtk02752
 723 **  fill HIF_TX_HEADER_T.u2SeqNo
 724 **  \main\maintrunk.MT6620WiFiDriver_Prj\36 2009-11-25 18:18:57 GMT mtk02752
 725 **  buffer scan result to prGlueInfo->rWlanInfo.arScanResult directly.
 726 **  \main\maintrunk.MT6620WiFiDriver_Prj\35 2009-11-24 22:42:45 GMT mtk02752
 727 **  add nicRxAddScanResult() to prepare to handle SCAN_RESULT event (not implemented yet)
 728 **  \main\maintrunk.MT6620WiFiDriver_Prj\34 2009-11-24 20:51:41 GMT mtk02752
 729 **  integrate with SD1's data path API
 730 **  \main\maintrunk.MT6620WiFiDriver_Prj\33 2009-11-24 19:56:17 GMT mtk02752
 731 **  adopt P_HIF_RX_HEADER_T in new path
 732 **  \main\maintrunk.MT6620WiFiDriver_Prj\32 2009-11-23 20:31:21 GMT mtk02752
 733 **  payload to send into pfCmdDoneHandler() will not include WIFI_EVENT_T
 734 **  \main\maintrunk.MT6620WiFiDriver_Prj\31 2009-11-23 17:51:34 GMT mtk02752
 735 **  when event packet corresponding to some pendingOID is received, pendingOID should be cleared
 736 **  \main\maintrunk.MT6620WiFiDriver_Prj\30 2009-11-23 14:46:54 GMT mtk02752
 737 **  implement nicRxProcessEventPacket()
 738 **  \main\maintrunk.MT6620WiFiDriver_Prj\29 2009-11-17 22:40:54 GMT mtk01084
 739 **  \main\maintrunk.MT6620WiFiDriver_Prj\28 2009-11-16 21:48:22 GMT mtk02752
 740 **  add SD1_SD3_DATAPATH_INTEGRATION data path handling
 741 **  \main\maintrunk.MT6620WiFiDriver_Prj\27 2009-11-16 15:41:18 GMT mtk01084
 742 **  modify the length to be read in emu mode
 743 **  \main\maintrunk.MT6620WiFiDriver_Prj\26 2009-11-13 17:00:12 GMT mtk02752
 744 **  add blank function for event packet
 745 **  \main\maintrunk.MT6620WiFiDriver_Prj\25 2009-11-13 13:54:24 GMT mtk01084
 746 **  \main\maintrunk.MT6620WiFiDriver_Prj\24 2009-11-11 14:41:51 GMT mtk02752
 747 **  fix typo
 748 **  \main\maintrunk.MT6620WiFiDriver_Prj\23 2009-11-11 14:33:46 GMT mtk02752
 749 **  add protection when there is no packet avilable
 750 **  \main\maintrunk.MT6620WiFiDriver_Prj\22 2009-11-11 12:33:36 GMT mtk02752
 751 **  add RX1 read path for aggregated/enhanced/normal packet read procedures
 752 **  \main\maintrunk.MT6620WiFiDriver_Prj\21 2009-11-11 10:36:18 GMT mtk01084
 753 **  \main\maintrunk.MT6620WiFiDriver_Prj\20 2009-11-04 14:11:08 GMT mtk01084
 754 **  modify lines in RX aggregation
 755 **  \main\maintrunk.MT6620WiFiDriver_Prj\19 2009-10-30 18:17:23 GMT mtk01084
 756 **  modify RX aggregation handling
 757 **  \main\maintrunk.MT6620WiFiDriver_Prj\18 2009-10-29 19:56:12 GMT mtk01084
 758 **  modify HAL part
 759 **  \main\maintrunk.MT6620WiFiDriver_Prj\17 2009-10-23 16:08:34 GMT mtk01084
 760 **  \main\maintrunk.MT6620WiFiDriver_Prj\16 2009-10-13 21:59:20 GMT mtk01084
 761 **  update for new HW design
 762 **  \main\maintrunk.MT6620WiFiDriver_Prj\15 2009-10-02 13:59:08 GMT mtk01725
 763 **  \main\maintrunk.MT6620WiFiDriver_Prj\14 2009-05-21 23:39:05 GMT mtk01461
 764 **  Fix the paste error of RX STATUS in OOB of HIF Loopback CTRL
 765 **  \main\maintrunk.MT6620WiFiDriver_Prj\13 2009-05-20 12:25:32 GMT mtk01461
 766 **  Fix process of Read Done, and add u4MaxEventBufferLen to nicRxWaitResponse()
 767 **  \main\maintrunk.MT6620WiFiDriver_Prj\12 2009-05-18 21:13:18 GMT mtk01426
 768 **  Fixed compiler error
 769 **  \main\maintrunk.MT6620WiFiDriver_Prj\11 2009-05-18 21:05:29 GMT mtk01426
 770 **  Fixed nicRxSDIOAggReceiveRFBs() ASSERT issue
 771 **  \main\maintrunk.MT6620WiFiDriver_Prj\10 2009-04-28 10:38:43 GMT mtk01461
 772 **  Fix RX STATUS is DW align for SDIO_STATUS_ENHANCE mode and refine  nicRxSDIOAggeceiveRFBs() for RX Aggregation
 773 **  \main\maintrunk.MT6620WiFiDriver_Prj\9 2009-04-22 09:12:17 GMT mtk01461
 774 **  Fix nicRxProcessHIFLoopbackPacket(), the size of HIF CTRL LENTH field is 1 byte
 775 **  \main\maintrunk.MT6620WiFiDriver_Prj\8 2009-04-14 15:51:26 GMT mtk01426
 776 **  Update RX OOB Setting
 777 **  \main\maintrunk.MT6620WiFiDriver_Prj\7 2009-04-03 14:58:58 GMT mtk01426
 778 **  Fixed logical error
 779 **  \main\maintrunk.MT6620WiFiDriver_Prj\6 2009-04-01 10:58:31 GMT mtk01461
 780 **  Rename the HIF_PKT_TYPE_DATA
 781 **  \main\maintrunk.MT6620WiFiDriver_Prj\5 2009-03-23 21:51:18 GMT mtk01461
 782 **  Fix u4HeaderOffset in nicRxProcessHIFLoopbackPacket()
 783 **  \main\maintrunk.MT6620WiFiDriver_Prj\4 2009-03-18 21:02:58 GMT mtk01426
 784 **  Add CFG_SDIO_RX_ENHANCE and CFG_HIF_LOOPBACK support
 785 **  \main\maintrunk.MT6620WiFiDriver_Prj\3 2009-03-17 20:20:59 GMT mtk01426
 786 **  Add nicRxWaitResponse function
 787 **  \main\maintrunk.MT6620WiFiDriver_Prj\2 2009-03-10 20:26:01 GMT mtk01426
 788 **  Init for develop
 789 **
 790 */
 791
 792 /*******************************************************************************
 793 *                         C O M P I L E R   F L A G S
 794 ********************************************************************************
 795 */
 796
 797 /*******************************************************************************
 798 *                    E X T E R N A L   R E F E R E N C E S
 799 ********************************************************************************
 800 */
 801 #include "precomp.h"
 802
 803 #ifndef LINUX
 804 #include <limits.h>
 805 #else
 806 #include <linux/limits.h>
 807 #endif
 808
 809 /*******************************************************************************
 810 *                              C O N S T A N T S
 811 ********************************************************************************
 812 */
 813 #define RX_RESPONSE_TIMEOUT (1000)
 814
 815 /*******************************************************************************
 816 *                             D A T A   T Y P E S
 817 ********************************************************************************
 818 */
 819
 820 /*******************************************************************************
 821 *                            P U B L I C   D A T A
 822 ********************************************************************************
 823 */
 824
 825 /*******************************************************************************
 826 *                           P R I V A T E   D A T A
 827 ********************************************************************************
 828 */
 829
 830 #if CFG_MGMT_FRAME_HANDLING
 831 static PROCESS_RX_MGT_FUNCTION apfnProcessRxMgtFrame[MAX_NUM_OF_FC_SUBTYPES] = {
 832     #if CFG_SUPPORT_AAA
 833     aaaFsmRunEventRxAssoc,              /* subtype 0000: Association request */
 834     #else
 835     NULL,                               /* subtype 0000: Association request */
 836     #endif /* CFG_SUPPORT_AAA */
 837     saaFsmRunEventRxAssoc,              /* subtype 0001: Association response */
 838     #if CFG_SUPPORT_AAA
 839     aaaFsmRunEventRxAssoc,              /* subtype 0010: Reassociation request */
 840     #else
 841     NULL,                               /* subtype 0010: Reassociation request */
 842     #endif /* CFG_SUPPORT_AAA */
 843     saaFsmRunEventRxAssoc,              /* subtype 0011: Reassociation response */
 844     #if CFG_SUPPORT_ADHOC
 845     bssProcessProbeRequest,             /* subtype 0100: Probe request */
 846     #else
 847     NULL,                               /* subtype 0100: Probe request */
 848     #endif /* CFG_SUPPORT_ADHOC */
 849     scanProcessBeaconAndProbeResp,      /* subtype 0101: Probe response */
 850     NULL,                               /* subtype 0110: reserved */
 851     NULL,                               /* subtype 0111: reserved */
 852     scanProcessBeaconAndProbeResp,      /* subtype 1000: Beacon */
 853     NULL,                               /* subtype 1001: ATIM */
 854     saaFsmRunEventRxDisassoc,           /* subtype 1010: Disassociation */
 855     authCheckRxAuthFrameTransSeq,       /* subtype 1011: Authentication */
 856     saaFsmRunEventRxDeauth,             /* subtype 1100: Deauthentication */
 857     nicRxProcessActionFrame,            /* subtype 1101: Action */
 858     NULL,                               /* subtype 1110: reserved */
 859     NULL                                /* subtype 1111: reserved */
 860 };
 861 #endif
 862
 863
 864 /*******************************************************************************
 865 *                                 M A C R O S
 866 ********************************************************************************
 867 */
 868
 869 /*******************************************************************************
 870 *                   F U N C T I O N   D E C L A R A T I O N S
 871 ********************************************************************************
 872 */
 873
 874 /*******************************************************************************
 875 *                              F U N C T I O N S
 876 ********************************************************************************
 877 */
 878 /*----------------------------------------------------------------------------*/
 879 /*!
 880 * @brief Initialize the RFBs
 881 *
 882 * @param prAdapter      Pointer to the Adapter structure.
 883 *
 884 * @return (none)
 885 */
 886 /*----------------------------------------------------------------------------*/
 887 VOID
 888 nicRxInitialize (
 889     IN P_ADAPTER_T prAdapter
 890     )
 891 {
 892     P_RX_CTRL_T prRxCtrl;
 893     PUINT_8 pucMemHandle;
 894     P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
 895     UINT_32 i;
 896
 897     DEBUGFUNC("nicRxInitialize");
 898
 899     ASSERT(prAdapter);
 900     prRxCtrl = &prAdapter->rRxCtrl;
 901
 902     //4 <0> Clear allocated memory.
 903     kalMemZero((PVOID) prRxCtrl->pucRxCached, prRxCtrl->u4RxCachedSize);
 904
 905     //4 <1> Initialize the RFB lists
 906     QUEUE_INITIALIZE(&prRxCtrl->rFreeSwRfbList);
 907     QUEUE_INITIALIZE(&prRxCtrl->rReceivedRfbList);
 908     QUEUE_INITIALIZE(&prRxCtrl->rIndicatedRfbList);
 909
 910     pucMemHandle = prRxCtrl->pucRxCached;
 911     for (i = CFG_RX_MAX_PKT_NUM; i != 0; i--) {
 912         prSwRfb = (P_SW_RFB_T)pucMemHandle;
 913
 914         nicRxSetupRFB(prAdapter, prSwRfb);
 915         nicRxReturnRFB(prAdapter, prSwRfb);
 916
 917         pucMemHandle += ALIGN_4(sizeof(SW_RFB_T));
 918     }
 919
 920     ASSERT(prRxCtrl->rFreeSwRfbList.u4NumElem == CFG_RX_MAX_PKT_NUM);
 921     /* Check if the memory allocation consist with this initialization function */
 922     ASSERT((UINT_32)(pucMemHandle - prRxCtrl->pucRxCached) == prRxCtrl->u4RxCachedSize);
 923
 924     //4 <2> Clear all RX counters
 925     RX_RESET_ALL_CNTS(prRxCtrl);
 926
 927 #if CFG_SDIO_RX_AGG
 928     prRxCtrl->pucRxCoalescingBufPtr = prAdapter->pucCoalescingBufCached;
 929     #if !defined(MT5931)
 930     HAL_CFG_MAX_HIF_RX_LEN_NUM(prAdapter, CFG_SDIO_MAX_RX_AGG_NUM);
 931     #endif
 932 #else
 933     #if !defined(MT5931)
 934     HAL_CFG_MAX_HIF_RX_LEN_NUM(prAdapter, 1);
 935     #endif
 936 #endif
 937
 938 #if CFG_HIF_STATISTICS
 939     prRxCtrl->u4TotalRxAccessNum = 0;
 940     prRxCtrl->u4TotalRxPacketNum = 0;
 941 #endif
 942
 943 #if CFG_HIF_RX_STARVATION_WARNING
 944     prRxCtrl->u4QueuedCnt = 0;
 945     prRxCtrl->u4DequeuedCnt = 0;
 946 #endif
 947
 948     return;
 949 } /* end of nicRxInitialize() */
 950
 951
 952 #if defined(MT5931)
 953 /*----------------------------------------------------------------------------*/
 954 /*!
 955 * @brief Initialize HIF RX control registers explicitly
 956 *
 957 * @param prAdapter      Pointer to the Adapter structure.
 958 *
 959 * @return (none)
 960 */
 961 /*----------------------------------------------------------------------------*/
 962 VOID
 963 nicRxPostInitialize (
 964     IN P_ADAPTER_T prAdapter
 965     )
 966 {
 967     P_RX_CTRL_T prRxCtrl;
 968     DEBUGFUNC("nicRxPostInitialize");
 969
 970     ASSERT(prAdapter);
 971     prRxCtrl = &prAdapter->rRxCtrl;
 972
 973 #if CFG_SDIO_RX_AGG
 974     HAL_CFG_MAX_HIF_RX_LEN_NUM(prAdapter, CFG_SDIO_MAX_RX_AGG_NUM);
 975 #else
 976     HAL_CFG_MAX_HIF_RX_LEN_NUM(prAdapter, 1);
 977 #endif
 978
 979 } /* end of nicRxPostInitialize() */
 980 #endif
 981
 982
 983 /*----------------------------------------------------------------------------*/
 984 /*!
 985 * @brief Uninitialize the RFBs
 986 *
 987 * @param prAdapter      Pointer to the Adapter structure.
 988 *
 989 * @return (none)
 990 */
 991 /*----------------------------------------------------------------------------*/
 992 VOID
 993 nicRxUninitialize (
 994     IN P_ADAPTER_T prAdapter
 995     )
 996 {
 997     P_RX_CTRL_T prRxCtrl;
 998     P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
 999     KAL_SPIN_LOCK_DECLARATION();
1000
1001     ASSERT(prAdapter);
1002     prRxCtrl = &prAdapter->rRxCtrl;
1003     ASSERT(prRxCtrl);
1004
1005     nicRxFlush(prAdapter);
1006
1007     do {
1008         KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
1009         QUEUE_REMOVE_HEAD(&prRxCtrl->rReceivedRfbList, prSwRfb, P_SW_RFB_T);
1010         KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
1011         if (prSwRfb){
1012             if (prSwRfb->pvPacket) {
1013                 kalPacketFree(prAdapter->prGlueInfo, prSwRfb->pvPacket);
1014             }
1015             prSwRfb->pvPacket = NULL;
1016         }
1017         else {
1018             break;
1019         }
1020     }while (TRUE);
1021
1022     do {
1023         KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
1024         QUEUE_REMOVE_HEAD(&prRxCtrl->rFreeSwRfbList, prSwRfb, P_SW_RFB_T);
1025         KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
1026         if (prSwRfb){
1027             if (prSwRfb->pvPacket) {
1028                 kalPacketFree(prAdapter->prGlueInfo, prSwRfb->pvPacket);
1029             }
1030             prSwRfb->pvPacket = NULL;
1031         }
1032         else {
1033             break;
1034         }
1035     }while (TRUE);
1036
1037     return;
1038 } /* end of nicRxUninitialize() */
1039
1040
1041 /*----------------------------------------------------------------------------*/
1042 /*!
1043 * @brief Fill RFB
1044 *
1045 * @param prAdapter pointer to the Adapter handler
1046 * @param prSWRfb   specify the RFB to receive rx data
1047 *
1048 * @return (none)
1049 *
1050 */
1051 /*----------------------------------------------------------------------------*/
1052 VOID
1053 nicRxFillRFB (
1054     IN P_ADAPTER_T    prAdapter,
1055     IN OUT P_SW_RFB_T prSwRfb
1056     )
1057 {
1058     P_HIF_RX_HEADER_T prHifRxHdr;
1059
1060     UINT_32 u4PktLen = 0;
1061     UINT_32 u4MacHeaderLen;
1062     UINT_32 u4HeaderOffset;
1063
1064     DEBUGFUNC("nicRxFillRFB");
1065
1066     ASSERT(prAdapter);
1067     ASSERT(prSwRfb);
1068
1069     prHifRxHdr = prSwRfb->prHifRxHdr;
1070     ASSERT(prHifRxHdr);
1071
1072     u4PktLen= prHifRxHdr->u2PacketLen;
1073
1074     u4HeaderOffset = (UINT_32)(prHifRxHdr->ucHerderLenOffset & HIF_RX_HDR_HEADER_OFFSET_MASK);
1075     u4MacHeaderLen = (UINT_32)(prHifRxHdr->ucHerderLenOffset & HIF_RX_HDR_HEADER_LEN)
1076                     >> HIF_RX_HDR_HEADER_LEN_OFFSET;
1077
1078     //DBGLOG(RX, TRACE, ("u4HeaderOffset = %d, u4MacHeaderLen = %d\n",
1079     //    u4HeaderOffset, u4MacHeaderLen));
1080
1081     prSwRfb->u2HeaderLen = (UINT_16)u4MacHeaderLen;
1082     prSwRfb->pvHeader = (PUINT_8)prHifRxHdr + HIF_RX_HDR_SIZE + u4HeaderOffset;
1083     prSwRfb->u2PacketLen = (UINT_16)(u4PktLen - (HIF_RX_HDR_SIZE + u4HeaderOffset));
1084
1085     //DBGLOG(RX, TRACE, ("Dump Rx packet, u2PacketLen = %d\n", prSwRfb->u2PacketLen));
1086     //DBGLOG_MEM8(RX, TRACE, prSwRfb->pvHeader, prSwRfb->u2PacketLen);
1087
1088 #if 0
1089     if (prHifRxHdr->ucReorder & HIF_RX_HDR_80211_HEADER_FORMAT){
1090         prSwRfb->u4HifRxHdrFlag |= HIF_RX_HDR_FLAG_802_11_FORMAT;
1091         DBGLOG(RX, TRACE, ("HIF_RX_HDR_FLAG_802_11_FORMAT\n"));
1092     }
1093
1094     if (prHifRxHdr->ucReorder & HIF_RX_HDR_DO_REORDER){
1095         prSwRfb->u4HifRxHdrFlag |= HIF_RX_HDR_FLAG_DO_REORDERING;
1096         DBGLOG(RX, TRACE, ("HIF_RX_HDR_FLAG_DO_REORDERING\n"));
1097
1098         /* Get Seq. No and TID, Wlan Index info */
1099         if (prHifRxHdr->u2SeqNoTid & HIF_RX_HDR_BAR_FRAME){
1100             prSwRfb->u4HifRxHdrFlag |= HIF_RX_HDR_FLAG_BAR_FRAME;
1101             DBGLOG(RX, TRACE, ("HIF_RX_HDR_FLAG_BAR_FRAME\n"));
1102         }
1103
1104         prSwRfb->u2SSN = prHifRxHdr->u2SeqNoTid & HIF_RX_HDR_SEQ_NO_MASK;
1105         prSwRfb->ucTid = (UINT_8)((prHifRxHdr->u2SeqNoTid & HIF_RX_HDR_TID_MASK)
1106                         >> HIF_RX_HDR_TID_OFFSET);
1107         DBGLOG(RX, TRACE, ("u2SSN = %d, ucTid = %d\n",
1108             prSwRfb->u2SSN, prSwRfb->ucTid));
1109     }
1110
1111     if (prHifRxHdr->ucReorder & HIF_RX_HDR_WDS){
1112         prSwRfb->u4HifRxHdrFlag |= HIF_RX_HDR_FLAG_AMP_WDS;
1113         DBGLOG(RX, TRACE, ("HIF_RX_HDR_FLAG_AMP_WDS\n"));
1114     }
1115 #endif
1116 }
1117
1118
1119 #if CFG_TCP_IP_CHKSUM_OFFLOAD || CFG_TCP_IP_CHKSUM_OFFLOAD_NDIS_60
1120 /*----------------------------------------------------------------------------*/
1121 /*!
1122 * @brief Fill checksum status in RFB
1123 *
1124 * @param prAdapter pointer to the Adapter handler
1125 * @param prSWRfb the RFB to receive rx data
1126 * @param u4TcpUdpIpCksStatus specify the Checksum status
1127 *
1128 * @return (none)
1129 *
1130 */
1131 /*----------------------------------------------------------------------------*/
1132 VOID
1133 nicRxFillChksumStatus(
1134     IN  P_ADAPTER_T   prAdapter,
1135     IN OUT P_SW_RFB_T prSwRfb,
1136     IN  UINT_32 u4TcpUdpIpCksStatus
1137 )
1138 {
1139
1140     ASSERT(prAdapter);
1141     ASSERT(prSwRfb);
1142
1143     if (prAdapter->u4CSUMFlags != CSUM_NOT_SUPPORTED){
1144         if (u4TcpUdpIpCksStatus & RX_CS_TYPE_IPv4) { // IPv4 packet
1145             prSwRfb->aeCSUM[CSUM_TYPE_IPV6] = CSUM_RES_NONE;
1146             if(u4TcpUdpIpCksStatus & RX_CS_STATUS_IP) { //IP packet csum failed
1147                 prSwRfb->aeCSUM[CSUM_TYPE_IPV4] = CSUM_RES_FAILED;
1148             } else {
1149                 prSwRfb->aeCSUM[CSUM_TYPE_IPV4] = CSUM_RES_SUCCESS;
1150             }
1151
1152             if (u4TcpUdpIpCksStatus & RX_CS_TYPE_TCP) { //TCP packet
1153                 prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_NONE;
1154                 if(u4TcpUdpIpCksStatus & RX_CS_STATUS_TCP) { //TCP packet csum failed
1155                     prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_FAILED;
1156                 } else {
1157                     prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_SUCCESS;
1158                 }
1159             }
1160             else if (u4TcpUdpIpCksStatus & RX_CS_TYPE_UDP) { //UDP packet
1161                 prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_NONE;
1162                 if(u4TcpUdpIpCksStatus & RX_CS_STATUS_UDP) { //UDP packet csum failed
1163                     prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_FAILED;
1164                 } else {
1165                     prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_SUCCESS;
1166                 }
1167             }
1168             else {
1169                 prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_NONE;
1170                 prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_NONE;
1171             }
1172         }
1173         else if (u4TcpUdpIpCksStatus & RX_CS_TYPE_IPv6) {//IPv6 packet
1174             prSwRfb->aeCSUM[CSUM_TYPE_IPV4] = CSUM_RES_NONE;
1175             prSwRfb->aeCSUM[CSUM_TYPE_IPV6] = CSUM_RES_SUCCESS;
1176
1177             if (u4TcpUdpIpCksStatus & RX_CS_TYPE_TCP) { //TCP packet
1178                 prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_NONE;
1179                 if(u4TcpUdpIpCksStatus & RX_CS_STATUS_TCP) { //TCP packet csum failed
1180                     prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_FAILED;
1181                 } else {
1182                     prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_SUCCESS;
1183                 }
1184             }
1185             else if (u4TcpUdpIpCksStatus & RX_CS_TYPE_UDP) { //UDP packet
1186                 prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_NONE;
1187                 if(u4TcpUdpIpCksStatus & RX_CS_STATUS_UDP) { //UDP packet csum failed
1188                     prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_FAILED;
1189                 } else {
1190                     prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_SUCCESS;
1191                 }
1192             }
1193             else {
1194                 prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_NONE;
1195                 prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_NONE;
1196             }
1197         }
1198         else {
1199             prSwRfb->aeCSUM[CSUM_TYPE_IPV4] = CSUM_RES_NONE;
1200             prSwRfb->aeCSUM[CSUM_TYPE_IPV6] = CSUM_RES_NONE;
1201         }
1202     }
1203
1204 }
1205 #endif /* CFG_TCP_IP_CHKSUM_OFFLOAD */
1206
1207
1208 /*----------------------------------------------------------------------------*/
1209 /*!
1210 * @brief Process packet doesn't need to do buffer reordering
1211 *
1212 * @param prAdapter pointer to the Adapter handler
1213 * @param prSWRfb the RFB to receive rx data
1214 *
1215 * @return (none)
1216 *
1217 */
1218 /*----------------------------------------------------------------------------*/
1219 VOID
1220 nicRxProcessPktWithoutReorder (
1221     IN P_ADAPTER_T prAdapter,
1222     IN P_SW_RFB_T  prSwRfb
1223     )
1224 {
1225     P_RX_CTRL_T prRxCtrl;
1226     P_TX_CTRL_T prTxCtrl;
1227     BOOL fgIsRetained = FALSE;
1228     UINT_32 u4CurrentRxBufferCount;
1229     P_STA_RECORD_T prStaRec = (P_STA_RECORD_T)NULL;
1230
1231     DEBUGFUNC("nicRxProcessPktWithoutReorder");
1232     //DBGLOG(RX, TRACE, ("\n"));
1233
1234     ASSERT(prAdapter);
1235     ASSERT(prSwRfb);
1236
1237     prRxCtrl = &prAdapter->rRxCtrl;
1238     ASSERT(prRxCtrl);
1239
1240     prTxCtrl = &prAdapter->rTxCtrl;
1241     ASSERT(prTxCtrl);
1242
1243     u4CurrentRxBufferCount = prRxCtrl->rFreeSwRfbList.u4NumElem;
1244     /* QM USED = $A, AVAILABLE COUNT = $B, INDICATED TO OS = $C
1245      * TOTAL = $A + $B + $C
1246      *
1247      * Case #1 (Retain)
1248      * -------------------------------------------------------
1249      * $A + $B < THRESHOLD := $A + $B + $C < THRESHOLD + $C := $TOTAL - THRESHOLD < $C
1250      * => $C used too much, retain
1251      *
1252      * Case #2 (Non-Retain)
1253      * -------------------------------------------------------
1254      * $A + $B > THRESHOLD := $A + $B + $C > THRESHOLD + $C := $TOTAL - THRESHOLD > $C
1255      * => still availble for $C to use
1256      *
1257      */
1258     fgIsRetained = (((u4CurrentRxBufferCount +
1259                     qmGetRxReorderQueuedBufferCount(prAdapter) +
1260                     prTxCtrl->i4PendingFwdFrameCount) < CFG_RX_RETAINED_PKT_THRESHOLD) ?
1261                            TRUE : FALSE);
1262
1263     //DBGLOG(RX, INFO, ("fgIsRetained = %d\n", fgIsRetained));
1264
1265     if (kalProcessRxPacket(prAdapter->prGlueInfo,
1266                          prSwRfb->pvPacket,
1267                          prSwRfb->pvHeader,
1268                          (UINT_32)prSwRfb->u2PacketLen,
1269                          fgIsRetained,
1270                          prSwRfb->aeCSUM) != WLAN_STATUS_SUCCESS) {
1271         DBGLOG(RX, ERROR, ("kalProcessRxPacket return value != WLAN_STATUS_SUCCESS\n"));
1272         ASSERT(0);
1273
1274         nicRxReturnRFB(prAdapter, prSwRfb);
1275         return;
1276     }
1277     else {
1278         prStaRec = cnmGetStaRecByIndex(prAdapter, prSwRfb->ucStaRecIdx);
1279
1280         if (prStaRec) {
1281 #if CFG_ENABLE_WIFI_DIRECT
1282             if (prStaRec->ucNetTypeIndex == NETWORK_TYPE_P2P_INDEX &&
1283                 prAdapter->fgIsP2PRegistered == TRUE) {
1284                 GLUE_SET_PKT_FLAG_P2P(prSwRfb->pvPacket);
1285             }
1286 #endif
1287 #if CFG_ENABLE_BT_OVER_WIFI
1288             if (prStaRec->ucNetTypeIndex == NETWORK_TYPE_BOW_INDEX) {
1289                 GLUE_SET_PKT_FLAG_PAL(prSwRfb->pvPacket);
1290             }
1291 #endif
1292         }
1293         prRxCtrl->apvIndPacket[prRxCtrl->ucNumIndPacket] = prSwRfb->pvPacket;
1294         prRxCtrl->ucNumIndPacket++;
1295     }
1296
1297     if (fgIsRetained) {
1298         prRxCtrl->apvRetainedPacket[prRxCtrl->ucNumRetainedPacket] = prSwRfb->pvPacket;
1299         prRxCtrl->ucNumRetainedPacket++;
1300             /* TODO : error handling of nicRxSetupRFB */
1301         nicRxSetupRFB(prAdapter, prSwRfb);
1302         nicRxReturnRFB(prAdapter, prSwRfb);
1303     }
1304     else{
1305         prSwRfb->pvPacket = NULL;
1306         nicRxReturnRFB(prAdapter, prSwRfb);
1307     }
1308 }
1309
1310
1311 /*----------------------------------------------------------------------------*/
1312 /*!
1313 * @brief Process forwarding data packet
1314 *
1315 * @param prAdapter pointer to the Adapter handler
1316 * @param prSWRfb the RFB to receive rx data
1317 *
1318 * @return (none)
1319 *
1320 */
1321 /*----------------------------------------------------------------------------*/
1322 VOID
1323 nicRxProcessForwardPkt (
1324     IN P_ADAPTER_T prAdapter,
1325     IN P_SW_RFB_T  prSwRfb
1326     )
1327 {
1328     P_MSDU_INFO_T prMsduInfo, prRetMsduInfoList;
1329     P_TX_CTRL_T prTxCtrl;
1330     P_RX_CTRL_T prRxCtrl;
1331     KAL_SPIN_LOCK_DECLARATION();
1332
1333     DEBUGFUNC("nicRxProcessForwardPkt");
1334
1335     ASSERT(prAdapter);
1336     ASSERT(prSwRfb);
1337
1338     prTxCtrl = &prAdapter->rTxCtrl;
1339     prRxCtrl = &prAdapter->rRxCtrl;
1340
1341     KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_TX_MSDU_INFO_LIST);
1342     QUEUE_REMOVE_HEAD(&prTxCtrl->rFreeMsduInfoList, prMsduInfo, P_MSDU_INFO_T);
1343     KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_TX_MSDU_INFO_LIST);
1344
1345     if(prMsduInfo && kalProcessRxPacket(prAdapter->prGlueInfo,
1346                 prSwRfb->pvPacket,
1347                 prSwRfb->pvHeader,
1348                 (UINT_32)prSwRfb->u2PacketLen,
1349                 prRxCtrl->rFreeSwRfbList.u4NumElem < CFG_RX_RETAINED_PKT_THRESHOLD ? TRUE : FALSE,
1350                 prSwRfb->aeCSUM) == WLAN_STATUS_SUCCESS) {
1351
1352         prMsduInfo->eSrc = TX_PACKET_FORWARDING;
1353         // pack into MSDU_INFO_T
1354         nicTxFillMsduInfo(prAdapter, prMsduInfo, (P_NATIVE_PACKET)(prSwRfb->pvPacket));
1355         // Overwrite the ucNetworkType
1356         prMsduInfo->ucNetworkType = HIF_RX_HDR_GET_NETWORK_IDX(prSwRfb->prHifRxHdr);
1357
1358         // release RX buffer (to rIndicatedRfbList)
1359         prSwRfb->pvPacket = NULL;
1360         nicRxReturnRFB(prAdapter, prSwRfb);
1361
1362         // increase forward frame counter
1363         GLUE_INC_REF_CNT(prTxCtrl->i4PendingFwdFrameCount);
1364
1365         // send into TX queue
1366         KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_QM_TX_QUEUE);
1367         prRetMsduInfoList = qmEnqueueTxPackets(prAdapter, prMsduInfo);
1368         KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_QM_TX_QUEUE);
1369
1370         if(prRetMsduInfoList != NULL) { // TX queue refuses queuing the packet
1371             nicTxFreeMsduInfoPacket(prAdapter, prRetMsduInfoList);
1372             nicTxReturnMsduInfo(prAdapter, prRetMsduInfoList);
1373         }
1374         /* indicate service thread for sending */
1375         if(prTxCtrl->i4PendingFwdFrameCount > 0) {
1376             kalSetEvent(prAdapter->prGlueInfo);
1377         }
1378     }
1379     else { // no TX resource
1380         nicRxReturnRFB(prAdapter, prSwRfb);
1381     }
1382
1383     return;
1384 }
1385
1386
1387 /*----------------------------------------------------------------------------*/
1388 /*!
1389 * @brief Process broadcast data packet for both host and forwarding
1390 *
1391 * @param prAdapter pointer to the Adapter handler
1392 * @param prSWRfb the RFB to receive rx data
1393 *
1394 * @return (none)
1395 *
1396 */
1397 /*----------------------------------------------------------------------------*/
1398 VOID
1399 nicRxProcessGOBroadcastPkt (
1400     IN P_ADAPTER_T prAdapter,
1401     IN P_SW_RFB_T  prSwRfb
1402     )
1403 {
1404     P_SW_RFB_T prSwRfbDuplicated;
1405     P_TX_CTRL_T prTxCtrl;
1406     P_RX_CTRL_T prRxCtrl;
1407     P_HIF_RX_HEADER_T prHifRxHdr;
1408
1409     KAL_SPIN_LOCK_DECLARATION();
1410
1411     DEBUGFUNC("nicRxProcessGOBroadcastPkt");
1412
1413     ASSERT(prAdapter);
1414     ASSERT(prSwRfb);
1415
1416     prTxCtrl = &prAdapter->rTxCtrl;
1417     prRxCtrl = &prAdapter->rRxCtrl;
1418
1419     prHifRxHdr = prSwRfb->prHifRxHdr;
1420     ASSERT(prHifRxHdr);
1421
1422     ASSERT(CFG_NUM_OF_QM_RX_PKT_NUM >= 16);
1423
1424     if( prRxCtrl->rFreeSwRfbList.u4NumElem
1425                     >= (CFG_RX_MAX_PKT_NUM - (CFG_NUM_OF_QM_RX_PKT_NUM - 16 /* Reserved for others */) )  ) {
1426
1427         /* 1. Duplicate SW_RFB_T */
1428         KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
1429         QUEUE_REMOVE_HEAD(&prRxCtrl->rFreeSwRfbList, prSwRfbDuplicated, P_SW_RFB_T);
1430         KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
1431
1432         if(prSwRfbDuplicated){
1433             kalMemCopy(prSwRfbDuplicated->pucRecvBuff,
1434                     prSwRfb->pucRecvBuff,
1435                     ALIGN_4(prHifRxHdr->u2PacketLen + HIF_RX_HW_APPENDED_LEN));
1436
1437             prSwRfbDuplicated->ucPacketType = HIF_RX_PKT_TYPE_DATA;
1438             prSwRfbDuplicated->ucStaRecIdx = (UINT_8)(prHifRxHdr->ucStaRecIdx);
1439             nicRxFillRFB(prAdapter, prSwRfbDuplicated);
1440
1441             /* 2. Modify eDst */
1442             prSwRfbDuplicated->eDst = RX_PKT_DESTINATION_FORWARD;
1443
1444             /* 4. Forward */
1445             nicRxProcessForwardPkt(prAdapter, prSwRfbDuplicated);
1446         }
1447     }
1448     else {
1449         DBGLOG(RX, WARN, ("Stop to forward BMC packet due to less free Sw Rfb %u\n", prRxCtrl->rFreeSwRfbList.u4NumElem));
1450     }
1451
1452     /* 3. Indicate to host */
1453     prSwRfb->eDst = RX_PKT_DESTINATION_HOST;
1454     nicRxProcessPktWithoutReorder(prAdapter, prSwRfb);
1455
1456     return;
1457 }
1458
1459
1460 /*----------------------------------------------------------------------------*/
1461 /*!
1462 * @brief Process HIF data packet
1463 *
1464 * @param prAdapter pointer to the Adapter handler
1465 * @param prSWRfb the RFB to receive rx data
1466 *
1467 * @return (none)
1468 *
1469 */
1470 /*----------------------------------------------------------------------------*/
1471 VOID
1472 nicRxProcessDataPacket (
1473     IN P_ADAPTER_T    prAdapter,
1474     IN OUT P_SW_RFB_T prSwRfb
1475     )
1476 {
1477     P_RX_CTRL_T prRxCtrl;
1478     P_SW_RFB_T prRetSwRfb, prNextSwRfb;
1479     P_HIF_RX_HEADER_T prHifRxHdr;
1480     P_STA_RECORD_T prStaRec;
1481
1482     DEBUGFUNC("nicRxProcessDataPacket");
1483     //DBGLOG(INIT, TRACE, ("\n"));
1484
1485     ASSERT(prAdapter);
1486     ASSERT(prSwRfb);
1487
1488     prHifRxHdr = prSwRfb->prHifRxHdr;
1489     prRxCtrl = &prAdapter->rRxCtrl;
1490
1491     nicRxFillRFB(prAdapter, prSwRfb);
1492
1493 #if 1 /* Check 1x Pkt */
1494     if (prSwRfb->u2PacketLen > 14) {
1495         PUINT_8 pc = (PUINT_8)prSwRfb->pvHeader;
1496         UINT_16 u2Etype = 0;
1497
1498         u2Etype = (pc[ETH_TYPE_LEN_OFFSET] << 8) | (pc[ETH_TYPE_LEN_OFFSET + 1]);
1499
1500 #if CFG_SUPPORT_WAPI
1501         if (u2Etype == ETH_P_1X || u2Etype == ETH_WPI_1X) {
1502             DBGLOG(RSN, INFO, ("R1X len=%d\n", prSwRfb->u2PacketLen));
1503         }
1504 #else
1505         if (u2Etype == ETH_P_1X) {
1506             DBGLOG(RSN, INFO, ("R1X len=%d\n", prSwRfb->u2PacketLen));
1507         }
1508 #endif
1509         else if (u2Etype == ETH_P_PRE_1X) {
1510             DBGLOG(RSN, INFO, ("Pre R1X len=%d\n", prSwRfb->u2PacketLen));
1511         }
1512     }
1513 #endif
1514
1515 #if CFG_TCP_IP_CHKSUM_OFFLOAD || CFG_TCP_IP_CHKSUM_OFFLOAD_NDIS_60
1516     {
1517         UINT_32 u4TcpUdpIpCksStatus;
1518
1519         u4TcpUdpIpCksStatus = *((PUINT_32)((UINT_32)prHifRxHdr +
1520                 (UINT_32)(ALIGN_4(prHifRxHdr->u2PacketLen))));
1521         nicRxFillChksumStatus(prAdapter, prSwRfb, u4TcpUdpIpCksStatus);
1522
1523     }
1524 #endif /* CFG_TCP_IP_CHKSUM_OFFLOAD */
1525
1526     prStaRec = cnmGetStaRecByIndex(prAdapter, prHifRxHdr->ucStaRecIdx);
1527     if(secCheckClassError(prAdapter, prSwRfb, prStaRec) == TRUE &&
1528          prAdapter->fgTestMode == FALSE) {
1529 #if CFG_HIF_RX_STARVATION_WARNING
1530         prRxCtrl->u4QueuedCnt++;
1531 #endif
1532
1533         if((prRetSwRfb = qmHandleRxPackets(prAdapter, prSwRfb)) != NULL) {
1534             do {
1535                 // save next first
1536                 prNextSwRfb = (P_SW_RFB_T)QUEUE_GET_NEXT_ENTRY((P_QUE_ENTRY_T)prRetSwRfb);
1537
1538                 switch(prRetSwRfb->eDst) {
1539                 case RX_PKT_DESTINATION_HOST:
1540                     nicRxProcessPktWithoutReorder(prAdapter, prRetSwRfb);
1541                     break;
1542
1543                 case RX_PKT_DESTINATION_FORWARD:
1544                     nicRxProcessForwardPkt(prAdapter, prRetSwRfb);
1545                     break;
1546
1547                 case RX_PKT_DESTINATION_HOST_WITH_FORWARD:
1548                     nicRxProcessGOBroadcastPkt(prAdapter, prRetSwRfb);
1549                     break;
1550
1551                 case RX_PKT_DESTINATION_NULL:
1552                     nicRxReturnRFB(prAdapter, prRetSwRfb);
1553                     RX_INC_CNT(prRxCtrl, RX_DST_NULL_DROP_COUNT);
1554                     RX_INC_CNT(prRxCtrl, RX_DROP_TOTAL_COUNT);
1555                     break;
1556
1557                 default:
1558                     break;
1559                 }
1560 #if CFG_HIF_RX_STARVATION_WARNING
1561                 prRxCtrl->u4DequeuedCnt++;
1562 #endif
1563                 prRetSwRfb = prNextSwRfb;
1564             } while(prRetSwRfb);
1565         }
1566     }
1567     else {
1568         nicRxReturnRFB(prAdapter, prSwRfb);
1569         RX_INC_CNT(prRxCtrl, RX_CLASS_ERR_DROP_COUNT);
1570         RX_INC_CNT(prRxCtrl, RX_DROP_TOTAL_COUNT);
1571     }
1572 }
1573
1574
1575 /*----------------------------------------------------------------------------*/
1576 /*!
1577 * @brief Process HIF event packet
1578 *
1579 * @param prAdapter pointer to the Adapter handler
1580 * @param prSWRfb the RFB to receive rx data
1581 *
1582 * @return (none)
1583 *
1584 */
1585 /*----------------------------------------------------------------------------*/
1586 VOID
1587 nicRxProcessEventPacket (
1588     IN P_ADAPTER_T    prAdapter,
1589     IN OUT P_SW_RFB_T prSwRfb
1590     )
1591 {
1592     P_CMD_INFO_T prCmdInfo;
1593     P_MSDU_INFO_T prMsduInfo;
1594     P_WIFI_EVENT_T prEvent;
1595     P_GLUE_INFO_T prGlueInfo;
1596
1597     DEBUGFUNC("nicRxProcessEventPacket");
1598     //DBGLOG(INIT, TRACE, ("\n"));
1599
1600     ASSERT(prAdapter);
1601     ASSERT(prSwRfb);
1602
1603     prEvent = (P_WIFI_EVENT_T) prSwRfb->pucRecvBuff;
1604     prGlueInfo = prAdapter->prGlueInfo;
1605
1606     // Event Handling
1607     switch(prEvent->ucEID) {
1608     case EVENT_ID_CMD_RESULT:
1609         prCmdInfo = nicGetPendingCmdInfo(prAdapter, prEvent->ucSeqNum);
1610
1611         if(prCmdInfo != NULL) {
1612             P_EVENT_CMD_RESULT prCmdResult;
1613             prCmdResult = (P_EVENT_CMD_RESULT) ((PUINT_8)prEvent + EVENT_HDR_SIZE);
1614
1615             /* CMD_RESULT should be only in response to Set commands */
1616             ASSERT(prCmdInfo->fgSetQuery == FALSE || prCmdInfo->fgNeedResp == TRUE);
1617
1618             if(prCmdResult->ucStatus == 0) { // success
1619                 if(prCmdInfo->pfCmdDoneHandler) {
1620                     prCmdInfo->pfCmdDoneHandler(prAdapter, prCmdInfo, prEvent->aucBuffer);
1621                 }
1622                 else if(prCmdInfo->fgIsOid == TRUE) {
1623                     kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_SUCCESS);
1624                 }
1625             }
1626             else if(prCmdResult->ucStatus == 1) { // reject
1627                 if(prCmdInfo->fgIsOid == TRUE)
1628                     kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_FAILURE);
1629             }
1630             else if(prCmdResult->ucStatus == 2) { // unknown CMD
1631                 if(prCmdInfo->fgIsOid == TRUE)
1632                     kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_NOT_SUPPORTED);
1633             }
1634
1635             // return prCmdInfo
1636             cmdBufFreeCmdInfo(prAdapter, prCmdInfo);
1637         }
1638
1639         break;
1640
1641 #if 0
1642     case EVENT_ID_CONNECTION_STATUS:
1643         /* OBSELETE */
1644         {
1645             P_EVENT_CONNECTION_STATUS prConnectionStatus;
1646             prConnectionStatus = (P_EVENT_CONNECTION_STATUS) (prEvent->aucBuffer);
1647
1648             DbgPrint("RX EVENT: EVENT_ID_CONNECTION_STATUS = %d\n", prConnectionStatus->ucMediaStatus);
1649             if (prConnectionStatus->ucMediaStatus == PARAM_MEDIA_STATE_DISCONNECTED) { // disconnected
1650                 if(kalGetMediaStateIndicated(prGlueInfo) != PARAM_MEDIA_STATE_DISCONNECTED) {
1651
1652                     kalIndicateStatusAndComplete(prGlueInfo,
1653                             WLAN_STATUS_MEDIA_DISCONNECT,
1654                             NULL,
1655                             0);
1656
1657                     prAdapter->rWlanInfo.u4SysTime = kalGetTimeTick();
1658                 }
1659             }
1660             else if(prConnectionStatus->ucMediaStatus == PARAM_MEDIA_STATE_CONNECTED) { // connected
1661                 prAdapter->rWlanInfo.u4SysTime = kalGetTimeTick();
1662
1663                 // fill information for association result
1664                 prAdapter->rWlanInfo.rCurrBssId.rSsid.u4SsidLen
1665                     = prConnectionStatus->ucSsidLen;
1666                 kalMemCopy(prAdapter->rWlanInfo.rCurrBssId.rSsid.aucSsid,
1667                         prConnectionStatus->aucSsid,
1668                         prConnectionStatus->ucSsidLen);
1669
1670                 kalMemCopy(prAdapter->rWlanInfo.rCurrBssId.arMacAddress,
1671                         prConnectionStatus->aucBssid,
1672                         MAC_ADDR_LEN);
1673
1674                 prAdapter->rWlanInfo.rCurrBssId.u4Privacy
1675                     = prConnectionStatus->ucEncryptStatus; // @FIXME
1676                 prAdapter->rWlanInfo.rCurrBssId.rRssi
1677                     = 0; //@FIXME
1678                 prAdapter->rWlanInfo.rCurrBssId.eNetworkTypeInUse
1679                     = PARAM_NETWORK_TYPE_AUTOMODE; //@FIXME
1680                 prAdapter->rWlanInfo.rCurrBssId.rConfiguration.u4BeaconPeriod
1681                     = prConnectionStatus->u2BeaconPeriod;
1682                 prAdapter->rWlanInfo.rCurrBssId.rConfiguration.u4ATIMWindow
1683                     = prConnectionStatus->u2ATIMWindow;
1684                 prAdapter->rWlanInfo.rCurrBssId.rConfiguration.u4DSConfig
1685                     = prConnectionStatus->u4FreqInKHz;
1686                 prAdapter->rWlanInfo.ucNetworkType
1687                     = prConnectionStatus->ucNetworkType;
1688
1689                 switch(prConnectionStatus->ucInfraMode) {
1690                 case 0:
1691                     prAdapter->rWlanInfo.rCurrBssId.eOpMode = NET_TYPE_IBSS;
1692                     break;
1693                 case 1:
1694                     prAdapter->rWlanInfo.rCurrBssId.eOpMode = NET_TYPE_INFRA;
1695                     break;
1696                 case 2:
1697                 default:
1698                     prAdapter->rWlanInfo.rCurrBssId.eOpMode = NET_TYPE_AUTO_SWITCH;
1699                     break;
1700                 }
1701                 // always indicate to OS according to MSDN (re-association/roaming)
1702                 kalIndicateStatusAndComplete(prGlueInfo,
1703                         WLAN_STATUS_MEDIA_CONNECT,
1704                         NULL,
1705                         0);
1706             }
1707         }
1708         break;
1709
1710     case EVENT_ID_SCAN_RESULT:
1711         /* OBSELETE */
1712         break;
1713 #endif
1714
1715     case EVENT_ID_RX_ADDBA:
1716         /* The FW indicates that an RX BA agreement will be established */
1717         qmHandleEventRxAddBa(prAdapter, prEvent);
1718         break;
1719
1720     case EVENT_ID_RX_DELBA:
1721         /* The FW indicates that an RX BA agreement has been deleted */
1722         qmHandleEventRxDelBa(prAdapter, prEvent);
1723         break;
1724
1725     case EVENT_ID_LINK_QUALITY:
1726 #if CFG_ENABLE_WIFI_DIRECT && CFG_SUPPORT_P2P_RSSI_QUERY
1727         if (prEvent->u2PacketLen == EVENT_HDR_SIZE + sizeof(EVENT_LINK_QUALITY_EX)) {
1728             P_EVENT_LINK_QUALITY_EX prLqEx = (P_EVENT_LINK_QUALITY_EX)(prEvent->aucBuffer);
1729
1730             if (prLqEx->ucIsLQ0Rdy) {
1731                 nicUpdateLinkQuality(prAdapter, NETWORK_TYPE_AIS_INDEX, (P_EVENT_LINK_QUALITY)prLqEx);
1732             }
1733             if (prLqEx->ucIsLQ1Rdy) {
1734                 nicUpdateLinkQuality(prAdapter, NETWORK_TYPE_P2P_INDEX, (P_EVENT_LINK_QUALITY)prLqEx);
1735             }
1736         }
1737         else {
1738             /* For old FW, P2P may invoke link quality query, and make driver flag becone TRUE. */
1739             DBGLOG(P2P, WARN, ("Old FW version, not support P2P RSSI query.\n"));
1740
1741             /* Must not use NETWORK_TYPE_P2P_INDEX, cause the structure is mismatch. */
1742         nicUpdateLinkQuality(prAdapter, NETWORK_TYPE_AIS_INDEX, (P_EVENT_LINK_QUALITY)(prEvent->aucBuffer));
1743         }
1744 #else
1745         nicUpdateLinkQuality(prAdapter, NETWORK_TYPE_AIS_INDEX, (P_EVENT_LINK_QUALITY)(prEvent->aucBuffer));
1746 #endif
1747
1748         /* command response handling */
1749         prCmdInfo = nicGetPendingCmdInfo(prAdapter, prEvent->ucSeqNum);
1750
1751         if(prCmdInfo != NULL) {
1752             if (prCmdInfo->pfCmdDoneHandler) {
1753                 prCmdInfo->pfCmdDoneHandler(prAdapter, prCmdInfo, prEvent->aucBuffer);
1754             }
1755             else if(prCmdInfo->fgIsOid) {
1756                 kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_SUCCESS);
1757             }
1758
1759             // return prCmdInfo
1760             cmdBufFreeCmdInfo(prAdapter, prCmdInfo);
1761         }
1762
1763         #ifndef LINUX
1764         if(prAdapter->rWlanInfo.eRssiTriggerType == ENUM_RSSI_TRIGGER_GREATER &&
1765                 prAdapter->rWlanInfo.rRssiTriggerValue >= (PARAM_RSSI)(prAdapter->rLinkQuality.cRssi)) {
1766             prAdapter->rWlanInfo.eRssiTriggerType = ENUM_RSSI_TRIGGER_TRIGGERED;
1767
1768             kalIndicateStatusAndComplete(prGlueInfo,
1769                     WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
1770                     (PVOID) &(prAdapter->rWlanInfo.rRssiTriggerValue), sizeof(PARAM_RSSI));
1771         }
1772         else if(prAdapter->rWlanInfo.eRssiTriggerType == ENUM_RSSI_TRIGGER_LESS &&
1773                 prAdapter->rWlanInfo.rRssiTriggerValue <= (PARAM_RSSI)(prAdapter->rLinkQuality.cRssi)) {
1774             prAdapter->rWlanInfo.eRssiTriggerType = ENUM_RSSI_TRIGGER_TRIGGERED;
1775
1776             kalIndicateStatusAndComplete(prGlueInfo,
1777                     WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
1778                     (PVOID) &(prAdapter->rWlanInfo.rRssiTriggerValue), sizeof(PARAM_RSSI));
1779         }
1780         #endif
1781
1782         break;
1783
1784     case EVENT_ID_MIC_ERR_INFO:
1785         {
1786             P_EVENT_MIC_ERR_INFO prMicError;
1787             //P_PARAM_AUTH_EVENT_T prAuthEvent;
1788             P_STA_RECORD_T prStaRec;
1789
1790             DBGLOG(RSN, EVENT, ("EVENT_ID_MIC_ERR_INFO\n"));
1791
1792             prMicError = (P_EVENT_MIC_ERR_INFO)(prEvent->aucBuffer);
1793             prStaRec = cnmGetStaRecByAddress(prAdapter,
1794                             (UINT_8) NETWORK_TYPE_AIS_INDEX,
1795                             prAdapter->rWlanInfo.rCurrBssId.arMacAddress);
1796             ASSERT(prStaRec);
1797
1798             if (prStaRec) {
1799                 rsnTkipHandleMICFailure(prAdapter, prStaRec, (BOOLEAN)prMicError->u4Flags);
1800             }
1801             else {
1802                 DBGLOG(RSN, INFO, ("No STA rec!!\n"));
1803             }
1804 #if 0
1805             prAuthEvent = (P_PARAM_AUTH_EVENT_T)prAdapter->aucIndicationEventBuffer;
1806
1807             /* Status type: Authentication Event */
1808             prAuthEvent->rStatus.eStatusType = ENUM_STATUS_TYPE_AUTHENTICATION;
1809
1810             /* Authentication request */
1811             prAuthEvent->arRequest[0].u4Length = sizeof(PARAM_AUTH_REQUEST_T);
1812             kalMemCopy((PVOID)prAuthEvent->arRequest[0].arBssid,
1813                 (PVOID)prAdapter->rWlanInfo.rCurrBssId.arMacAddress, /* whsu:Todo? */
1814                 PARAM_MAC_ADDR_LEN);
1815
1816             if (prMicError->u4Flags != 0) {
1817                 prAuthEvent->arRequest[0].u4Flags = PARAM_AUTH_REQUEST_GROUP_ERROR;
1818             }
1819             else {
1820                 prAuthEvent->arRequest[0].u4Flags = PARAM_AUTH_REQUEST_PAIRWISE_ERROR;
1821             }
1822
1823             kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
1824                 WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
1825                 (PVOID)prAuthEvent,
1826                 sizeof(PARAM_STATUS_INDICATION_T) + sizeof(PARAM_AUTH_REQUEST_T));
1827 #endif
1828         }
1829         break;
1830
1831     case EVENT_ID_ASSOC_INFO:
1832         {
1833             P_EVENT_ASSOC_INFO prAssocInfo;
1834             prAssocInfo = (P_EVENT_ASSOC_INFO)(prEvent->aucBuffer);
1835
1836             kalHandleAssocInfo(prAdapter->prGlueInfo, prAssocInfo);
1837         }
1838         break;
1839
1840     case EVENT_ID_802_11_PMKID:
1841         {
1842             P_PARAM_AUTH_EVENT_T           prAuthEvent;
1843             PUINT_8                        cp;
1844             UINT_32                        u4LenOfUsedBuffer;
1845
1846             prAuthEvent = (P_PARAM_AUTH_EVENT_T)prAdapter->aucIndicationEventBuffer;
1847
1848             prAuthEvent->rStatus.eStatusType = ENUM_STATUS_TYPE_CANDIDATE_LIST;
1849
1850             u4LenOfUsedBuffer = (UINT_32)(prEvent->u2PacketLen - 8);
1851
1852             prAuthEvent->arRequest[0].u4Length = u4LenOfUsedBuffer;
1853
1854             cp = (PUINT_8)&prAuthEvent->arRequest[0];
1855
1856             /* Status type: PMKID Candidatelist Event */
1857             kalMemCopy(cp, (P_EVENT_PMKID_CANDIDATE_LIST_T)(prEvent->aucBuffer), prEvent->u2PacketLen - 8);
1858
1859             kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
1860                 WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
1861                 (PVOID)prAuthEvent,
1862                 sizeof(PARAM_STATUS_INDICATION_T) + u4LenOfUsedBuffer);
1863         }
1864         break;
1865
1866 #if 0
1867     case EVENT_ID_ACTIVATE_STA_REC_T:
1868         {
1869             P_EVENT_ACTIVATE_STA_REC_T prActivateStaRec;
1870             prActivateStaRec = (P_EVENT_ACTIVATE_STA_REC_T)(prEvent->aucBuffer);
1871
1872             DbgPrint("RX EVENT: EVENT_ID_ACTIVATE_STA_REC_T Index:%d, MAC:["MACSTR"]\n",
1873                 prActivateStaRec->ucStaRecIdx,
1874                 MAC2STR(prActivateStaRec->aucMacAddr));
1875
1876             qmActivateStaRec(prAdapter,
1877                              (UINT_32)prActivateStaRec->ucStaRecIdx,
1878                              ((prActivateStaRec->fgIsQoS) ? TRUE: FALSE),
1879                              prActivateStaRec->ucNetworkTypeIndex,
1880                              ((prActivateStaRec->fgIsAP) ? TRUE: FALSE),
1881                              prActivateStaRec->aucMacAddr);
1882
1883         }
1884         break;
1885
1886     case EVENT_ID_DEACTIVATE_STA_REC_T:
1887         {
1888             P_EVENT_DEACTIVATE_STA_REC_T prDeactivateStaRec;
1889             prDeactivateStaRec = (P_EVENT_DEACTIVATE_STA_REC_T)(prEvent->aucBuffer);
1890
1891             DbgPrint("RX EVENT: EVENT_ID_DEACTIVATE_STA_REC_T Index:%d, MAC:["MACSTR"]\n",
1892                 prDeactivateStaRec->ucStaRecIdx);
1893
1894             qmDeactivateStaRec(prAdapter,
1895                                prDeactivateStaRec->ucStaRecIdx);
1896         }
1897         break;
1898 #endif
1899
1900     case EVENT_ID_SCAN_DONE:
1901         scnEventScanDone(prAdapter, (P_EVENT_SCAN_DONE)(prEvent->aucBuffer));
1902         break;
1903
1904     case EVENT_ID_TX_DONE:
1905         {
1906             P_EVENT_TX_DONE_T prTxDone;
1907             prTxDone = (P_EVENT_TX_DONE_T)(prEvent->aucBuffer);
1908
1909             DBGLOG(INIT, TRACE,("EVENT_ID_TX_DONE PacketSeq:%u ucStatus: %u SN: %u\n",
1910                 prTxDone->ucPacketSeq, prTxDone->ucStatus, prTxDone->u2SequenceNumber));
1911
1912             /* call related TX Done Handler */
1913             prMsduInfo = nicGetPendingTxMsduInfo(prAdapter, prTxDone->ucPacketSeq);
1914
1915 #if CFG_SUPPORT_802_11V_TIMING_MEASUREMENT
1916             DBGLOG(INIT, TRACE, ("EVENT_ID_TX_DONE u4TimeStamp = %x u2AirDelay = %x\n",
1917                 prTxDone->au4Reserved1, prTxDone->au4Reserved2));
1918
1919             wnmReportTimingMeas(prAdapter, prMsduInfo->ucStaRecIndex,
1920                                 prTxDone->au4Reserved1, prTxDone->au4Reserved1 + prTxDone->au4Reserved2);
1921 #endif
1922
1923             if(prMsduInfo) {
1924                 prMsduInfo->pfTxDoneHandler(prAdapter, prMsduInfo, (ENUM_TX_RESULT_CODE_T)(prTxDone->ucStatus));
1925
1926                 cnmMgtPktFree(prAdapter, prMsduInfo);
1927             }
1928         }
1929         break;
1930
1931     case EVENT_ID_SLEEPY_NOTIFY:
1932         {
1933             P_EVENT_SLEEPY_NOTIFY prEventSleepyNotify;
1934             prEventSleepyNotify = (P_EVENT_SLEEPY_NOTIFY)(prEvent->aucBuffer);
1935
1936             //DBGLOG(RX, INFO, ("ucSleepyState = %d\n", prEventSleepyNotify->ucSleepyState));
1937
1938             prAdapter->fgWiFiInSleepyState = (BOOLEAN)(prEventSleepyNotify->ucSleepyState);
1939         }
1940         break;
1941     case EVENT_ID_BT_OVER_WIFI:
1942 #if CFG_ENABLE_BT_OVER_WIFI
1943         {
1944             UINT_8 aucTmp[sizeof(AMPC_EVENT) + sizeof(BOW_LINK_DISCONNECTED)];
1945             P_EVENT_BT_OVER_WIFI prEventBtOverWifi;
1946             P_AMPC_EVENT prBowEvent;
1947             P_BOW_LINK_CONNECTED prBowLinkConnected;
1948             P_BOW_LINK_DISCONNECTED prBowLinkDisconnected;
1949
1950             prEventBtOverWifi = (P_EVENT_BT_OVER_WIFI)(prEvent->aucBuffer);
1951
1952             // construct event header
1953             prBowEvent = (P_AMPC_EVENT)aucTmp;
1954
1955             if(prEventBtOverWifi->ucLinkStatus == 0) {
1956                 // Connection
1957                 prBowEvent->rHeader.ucEventId = BOW_EVENT_ID_LINK_CONNECTED;
1958                 prBowEvent->rHeader.ucSeqNumber = 0;
1959                 prBowEvent->rHeader.u2PayloadLength = sizeof(BOW_LINK_CONNECTED);
1960
1961                 // fill event body
1962                 prBowLinkConnected = (P_BOW_LINK_CONNECTED)(prBowEvent->aucPayload);
1963                 prBowLinkConnected->rChannel.ucChannelNum = prEventBtOverWifi->ucSelectedChannel;
1964                 kalMemZero(prBowLinkConnected->aucPeerAddress, MAC_ADDR_LEN); //@FIXME
1965
1966                 kalIndicateBOWEvent(prAdapter->prGlueInfo, prBowEvent);
1967             }
1968             else {
1969                 // Disconnection
1970                 prBowEvent->rHeader.ucEventId = BOW_EVENT_ID_LINK_DISCONNECTED;
1971                 prBowEvent->rHeader.ucSeqNumber = 0;
1972                 prBowEvent->rHeader.u2PayloadLength = sizeof(BOW_LINK_DISCONNECTED);
1973
1974                 // fill event body
1975                 prBowLinkDisconnected = (P_BOW_LINK_DISCONNECTED)(prBowEvent->aucPayload);
1976                 prBowLinkDisconnected->ucReason = 0; //@FIXME
1977                 kalMemZero(prBowLinkDisconnected->aucPeerAddress, MAC_ADDR_LEN); //@FIXME
1978
1979                 kalIndicateBOWEvent(prAdapter->prGlueInfo, prBowEvent);
1980             }
1981         }
1982         break;
1983 #endif
1984     case EVENT_ID_STATISTICS:
1985         /* buffer statistics for further query */
1986         prAdapter->fgIsStatValid = TRUE;
1987         prAdapter->rStatUpdateTime = kalGetTimeTick();
1988         kalMemCopy(&prAdapter->rStatStruct, prEvent->aucBuffer, sizeof(EVENT_STATISTICS));
1989
1990         /* command response handling */
1991         prCmdInfo = nicGetPendingCmdInfo(prAdapter, prEvent->ucSeqNum);
1992
1993         if(prCmdInfo != NULL) {
1994             if (prCmdInfo->pfCmdDoneHandler) {
1995                 prCmdInfo->pfCmdDoneHandler(prAdapter, prCmdInfo, prEvent->aucBuffer);
1996             }
1997             else if(prCmdInfo->fgIsOid) {
1998                 kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_SUCCESS);
1999             }
2000
2001             // return prCmdInfo
2002             cmdBufFreeCmdInfo(prAdapter, prCmdInfo);
2003         }
2004
2005         break;
2006
2007     case EVENT_ID_CH_PRIVILEGE:
2008         cnmChMngrHandleChEvent(prAdapter, prEvent);
2009         break;
2010
2011     case EVENT_ID_BSS_ABSENCE_PRESENCE:
2012         qmHandleEventBssAbsencePresence(prAdapter, prEvent);
2013         break;
2014
2015     case EVENT_ID_STA_CHANGE_PS_MODE:
2016         qmHandleEventStaChangePsMode(prAdapter, prEvent);
2017         break;
2018 #if CFG_ENABLE_WIFI_DIRECT
2019     case EVENT_ID_STA_UPDATE_FREE_QUOTA:
2020         qmHandleEventStaUpdateFreeQuota(prAdapter, prEvent);
2021         break;
2022 #endif
2023     case EVENT_ID_BSS_BEACON_TIMEOUT:
2024         DBGLOG(INIT, INFO,("EVENT_ID_BSS_BEACON_TIMEOUT\n"));
2025
2026         if (prAdapter->fgDisBcnLostDetection == FALSE) {
2027             P_EVENT_BSS_BEACON_TIMEOUT_T prEventBssBeaconTimeout;
2028             prEventBssBeaconTimeout = (P_EVENT_BSS_BEACON_TIMEOUT_T)(prEvent->aucBuffer);
2029
2030             if(prEventBssBeaconTimeout->ucNetTypeIndex == NETWORK_TYPE_AIS_INDEX) {
2031                 aisBssBeaconTimeout(prAdapter);
2032             }
2033 #if CFG_ENABLE_WIFI_DIRECT
2034             else if((prAdapter->fgIsP2PRegistered) &&
2035                 (prEventBssBeaconTimeout->ucNetTypeIndex == NETWORK_TYPE_P2P_INDEX)) {
2036
2037                 p2pFsmRunEventBeaconTimeout(prAdapter);
2038             }
2039 #endif
2040 #if CFG_ENABLE_BT_OVER_WIFI
2041             else if(prEventBssBeaconTimeout->ucNetTypeIndex == NETWORK_TYPE_BOW_INDEX) {
2042             }
2043 #endif
2044             else {
2045                 DBGLOG(RX, ERROR, ("EVENT_ID_BSS_BEACON_TIMEOUT: (ucNetTypeIdx = %d)\n",
2046                             prEventBssBeaconTimeout->ucNetTypeIndex));
2047             }
2048         }
2049
2050         break;
2051     case EVENT_ID_UPDATE_NOA_PARAMS:
2052 #if CFG_ENABLE_WIFI_DIRECT
2053         if(prAdapter->fgIsP2PRegistered){
2054             P_EVENT_UPDATE_NOA_PARAMS_T prEventUpdateNoaParam;
2055             prEventUpdateNoaParam = (P_EVENT_UPDATE_NOA_PARAMS_T)(prEvent->aucBuffer);
2056
2057             if (prEventUpdateNoaParam->ucNetTypeIndex == NETWORK_TYPE_P2P_INDEX) {
2058                 p2pProcessEvent_UpdateNOAParam(prAdapter,
2059                                                 prEventUpdateNoaParam->ucNetTypeIndex,
2060                                                 prEventUpdateNoaParam);
2061             } else {
2062                 ASSERT(0);
2063             }
2064         }
2065 #else
2066         ASSERT(0);
2067 #endif
2068         break;
2069
2070     case EVENT_ID_STA_AGING_TIMEOUT:
2071 #if CFG_ENABLE_WIFI_DIRECT
2072         {
2073             if (prAdapter->fgDisStaAgingTimeoutDetection == FALSE) {
2074                 P_EVENT_STA_AGING_TIMEOUT_T prEventStaAgingTimeout;
2075                 P_STA_RECORD_T prStaRec;
2076                 P_BSS_INFO_T prBssInfo = (P_BSS_INFO_T)NULL;
2077
2078                 prEventStaAgingTimeout = (P_EVENT_STA_AGING_TIMEOUT_T)(prEvent->aucBuffer);
2079                 prStaRec = cnmGetStaRecByIndex(prAdapter, prEventStaAgingTimeout->ucStaRecIdx);
2080                 if (prStaRec == NULL) {
2081                     break;
2082                 }
2083
2084                 DBGLOG(INIT, INFO,("EVENT_ID_STA_AGING_TIMEOUT %u " MACSTR "\n",
2085                                 prEventStaAgingTimeout->ucStaRecIdx, MAC2STR(prStaRec->aucMacAddr)));
2086
2087                 prBssInfo = &(prAdapter->rWifiVar.arBssInfo[prStaRec->ucNetTypeIndex]);
2088
2089                 bssRemoveStaRecFromClientList(prAdapter, prBssInfo, prStaRec);
2090
2091                 /* Call False Auth */
2092                 if (prAdapter->fgIsP2PRegistered) {
2093                     p2pFuncDisconnect(prAdapter, prStaRec, TRUE, REASON_CODE_DISASSOC_INACTIVITY);
2094                 }
2095
2096
2097             } /* gDisStaAgingTimeoutDetection */
2098
2099         }
2100 #endif
2101         break;
2102
2103     case EVENT_ID_AP_OBSS_STATUS:
2104 #if CFG_ENABLE_WIFI_DIRECT
2105         if(prAdapter->fgIsP2PRegistered){
2106             rlmHandleObssStatusEventPkt(prAdapter, (P_EVENT_AP_OBSS_STATUS_T) prEvent->aucBuffer);
2107         }
2108 #endif
2109         break;
2110
2111     case EVENT_ID_ROAMING_STATUS:
2112 #if CFG_SUPPORT_ROAMING
2113         {
2114             P_ROAMING_PARAM_T prParam;
2115
2116             prParam = (P_ROAMING_PARAM_T)(prEvent->aucBuffer);
2117             roamingFsmProcessEvent(prAdapter, prParam);
2118         }
2119 #endif /* CFG_SUPPORT_ROAMING */
2120         break;
2121     case EVENT_ID_SEND_DEAUTH:
2122 #if DBG
2123         {
2124             P_WLAN_MAC_HEADER_T prWlanMacHeader;
2125
2126             prWlanMacHeader = (P_WLAN_MAC_HEADER_T)&prEvent->aucBuffer[0];
2127             DBGLOG(RX, INFO, ("nicRx: aucAddr1: "MACSTR"\n", MAC2STR(prWlanMacHeader->aucAddr1)));
2128             DBGLOG(RX, INFO, ("nicRx: aucAddr2: "MACSTR"\n", MAC2STR(prWlanMacHeader->aucAddr2)));
2129         }
2130 #endif
2131           /* receive packets without StaRec */
2132           prSwRfb->pvHeader = (P_WLAN_MAC_HEADER_T)&prEvent->aucBuffer[0];
2133           if (WLAN_STATUS_SUCCESS == authSendDeauthFrame(prAdapter,
2134                                                        NULL,
2135                                                        prSwRfb,
2136                                                        REASON_CODE_CLASS_3_ERR,
2137                                                        (PFN_TX_DONE_HANDLER)NULL)) {
2138             DBGLOG(RX, INFO, ("Send Deauth Error\n"));
2139         }
2140           break;
2141
2142 #if CFG_SUPPORT_RDD_TEST_MODE
2143     case EVENT_ID_UPDATE_RDD_STATUS:
2144         {
2145             P_EVENT_RDD_STATUS_T prEventRddStatus;
2146
2147             prEventRddStatus = (P_EVENT_RDD_STATUS_T) (prEvent->aucBuffer);
2148
2149             prAdapter->ucRddStatus = prEventRddStatus->ucRddStatus;
2150         }
2151
2152         break;
2153 #endif
2154
2155 #if CFG_SUPPORT_BCM && CFG_SUPPORT_BCM_BWCS
2156     case EVENT_ID_UPDATE_BWCS_STATUS:
2157         {
2158             P_PTA_IPC_T prEventBwcsStatus;
2159
2160             prEventBwcsStatus = (P_PTA_IPC_T) (prEvent->aucBuffer);
2161
2162 #if CFG_SUPPORT_BCM_BWCS_DEBUG
2163             printk(KERN_INFO DRV_NAME "BCM BWCS Event: %02x%02x%02x%02x\n", prEventBwcsStatus->u.aucBTPParams[0],
2164                 prEventBwcsStatus->u.aucBTPParams[1],
2165                 prEventBwcsStatus->u.aucBTPParams[2],
2166                 prEventBwcsStatus->u.aucBTPParams[3]);
2167
2168             printk(KERN_INFO DRV_NAME "BCM BWCS Event: aucBTPParams[0] = %02x, aucBTPParams[1] = %02x, aucBTPParams[2] = %02x, aucBTPParams[3] = %02x\n",
2169                 prEventBwcsStatus->u.aucBTPParams[0],
2170                 prEventBwcsStatus->u.aucBTPParams[1],
2171                 prEventBwcsStatus->u.aucBTPParams[2],
2172                 prEventBwcsStatus->u.aucBTPParams[3]);
2173 #endif
2174
2175             kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
2176                 WLAN_STATUS_BWCS_UPDATE,
2177                 (PVOID) prEventBwcsStatus,
2178                 sizeof(PTA_IPC_T));
2179         }
2180
2181         break;
2182
2183     case EVENT_ID_UPDATE_BCM_DEBUG:
2184         {
2185             P_PTA_IPC_T prEventBwcsStatus;
2186
2187             prEventBwcsStatus = (P_PTA_IPC_T) (prEvent->aucBuffer);
2188
2189 #if CFG_SUPPORT_BCM_BWCS_DEBUG
2190             printk(KERN_INFO DRV_NAME "BCM FW status: %02x%02x%02x%02x\n", prEventBwcsStatus->u.aucBTPParams[0],
2191                 prEventBwcsStatus->u.aucBTPParams[1],
2192                 prEventBwcsStatus->u.aucBTPParams[2],
2193                 prEventBwcsStatus->u.aucBTPParams[3]);
2194
2195             printk(KERN_INFO DRV_NAME "BCM FW status: aucBTPParams[0] = %02x, aucBTPParams[1] = %02x, aucBTPParams[2] = %02x, aucBTPParams[3] = %02x\n",
2196                 prEventBwcsStatus->u.aucBTPParams[0],
2197                 prEventBwcsStatus->u.aucBTPParams[1],
2198                 prEventBwcsStatus->u.aucBTPParams[2],
2199                 prEventBwcsStatus->u.aucBTPParams[3]);
2200 #endif
2201         }
2202
2203         break;
2204 #endif
2205
2206     case EVENT_ID_ACCESS_REG:
2207     case EVENT_ID_NIC_CAPABILITY:
2208     case EVENT_ID_BASIC_CONFIG:
2209     case EVENT_ID_MAC_MCAST_ADDR:
2210     case EVENT_ID_ACCESS_EEPROM:
2211     case EVENT_ID_TEST_STATUS:
2212     default:
2213         prCmdInfo = nicGetPendingCmdInfo(prAdapter, prEvent->ucSeqNum);
2214
2215         if(prCmdInfo != NULL) {
2216             if (prCmdInfo->pfCmdDoneHandler) {
2217                 prCmdInfo->pfCmdDoneHandler(prAdapter, prCmdInfo, prEvent->aucBuffer);
2218             }
2219             else if(prCmdInfo->fgIsOid) {
2220                 kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_SUCCESS);
2221             }
2222
2223             // return prCmdInfo
2224             cmdBufFreeCmdInfo(prAdapter, prCmdInfo);
2225         }
2226
2227         break;
2228     }
2229
2230     nicRxReturnRFB(prAdapter, prSwRfb);
2231 }
2232
2233
2234 /*----------------------------------------------------------------------------*/
2235 /*!
2236 * @brief nicRxProcessMgmtPacket is used to dispatch management frames
2237 *        to corresponding modules
2238 *
2239 * @param prAdapter Pointer to the Adapter structure.
2240 * @param prSWRfb the RFB to receive rx data
2241 *
2242 * @return (none)
2243 */
2244 /*----------------------------------------------------------------------------*/
2245 VOID
2246 nicRxProcessMgmtPacket (
2247     IN P_ADAPTER_T    prAdapter,
2248     IN OUT P_SW_RFB_T prSwRfb
2249     )
2250 {
2251     UINT_8 ucSubtype;
2252 #if CFG_SUPPORT_802_11W
2253     BOOL   fgMfgDrop = FALSE;
2254 #endif
2255     ASSERT(prAdapter);
2256     ASSERT(prSwRfb);
2257
2258     nicRxFillRFB(prAdapter, prSwRfb);
2259
2260     ucSubtype = (*(PUINT_8)(prSwRfb->pvHeader) & MASK_FC_SUBTYPE )>> OFFSET_OF_FC_SUBTYPE;
2261
2262 #if CFG_RX_PKTS_DUMP
2263     {
2264         P_HIF_RX_HEADER_T   prHifRxHdr;
2265         UINT_16 u2TxFrameCtrl;
2266
2267         prHifRxHdr = prSwRfb->prHifRxHdr;
2268         u2TxFrameCtrl = (*(PUINT_8)(prSwRfb->pvHeader) & MASK_FRAME_TYPE);
2269         if (prAdapter->rRxCtrl.u4RxPktsDumpTypeMask & BIT(HIF_RX_PKT_TYPE_MANAGEMENT)) {
2270             if (u2TxFrameCtrl == MAC_FRAME_BEACON ||
2271                   u2TxFrameCtrl == MAC_FRAME_PROBE_RSP) {
2272
2273                 DBGLOG(SW4, INFO, ("QM RX MGT: net %u sta idx %u wlan idx %u ssn %u ptype %u subtype %u 11 %u\n",
2274                     HIF_RX_HDR_GET_NETWORK_IDX(prHifRxHdr),
2275                     prHifRxHdr->ucStaRecIdx,
2276                     prSwRfb->ucWlanIdx,
2277                     HIF_RX_HDR_GET_SN(prHifRxHdr),  /* The new SN of the frame */
2278                     prSwRfb->ucPacketType,
2279                     ucSubtype,
2280                     HIF_RX_HDR_GET_80211_FLAG(prHifRxHdr)));
2281
2282                 DBGLOG_MEM8(SW4, TRACE, (PUINT_8)prSwRfb->pvHeader, prSwRfb->u2PacketLen);
2283             }
2284         }
2285     }
2286 #endif
2287
2288     if(prAdapter->fgTestMode == FALSE) {
2289 #if CFG_MGMT_FRAME_HANDLING
2290 #if CFG_SUPPORT_802_11W
2291         fgMfgDrop = rsnCheckRxMgmt(prAdapter, prSwRfb, ucSubtype);
2292         if (fgMfgDrop) {
2293             #if DBG
2294             LOG_FUNC("QM RX MGT: Drop Unprotected Mgmt frame!!!\n");
2295             #endif
2296             nicRxReturnRFB(prAdapter, prSwRfb);
2297             RX_INC_CNT(prRxCtrl, RX_DROP_TOTAL_COUNT);
2298             return;
2299         }
2300         else
2301 #endif
2302         if(apfnProcessRxMgtFrame[ucSubtype]) {
2303             switch(apfnProcessRxMgtFrame[ucSubtype](prAdapter, prSwRfb)){
2304             case WLAN_STATUS_PENDING:
2305                 return;
2306             case WLAN_STATUS_SUCCESS:
2307             case WLAN_STATUS_FAILURE:
2308                 break;
2309
2310             default:
2311                 DBGLOG(RX, WARN, ("Unexpected MMPDU(0x%02X) returned with abnormal status\n", ucSubtype));
2312                 break;
2313             }
2314         }
2315 #endif
2316     }
2317
2318     nicRxReturnRFB(prAdapter, prSwRfb);
2319 }
2320
2321 /*----------------------------------------------------------------------------*/
2322 /*!
2323 * @brief nicProcessRFBs is used to process RFBs in the rReceivedRFBList queue.
2324 *
2325 * @param prAdapter Pointer to the Adapter structure.
2326 *
2327 * @return (none)
2328 */
2329 /*----------------------------------------------------------------------------*/
2330 VOID
2331 nicRxProcessRFBs (
2332     IN  P_ADAPTER_T prAdapter
2333     )
2334 {
2335     P_RX_CTRL_T prRxCtrl;
2336     P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
2337     KAL_SPIN_LOCK_DECLARATION();
2338
2339     DEBUGFUNC("nicRxProcessRFBs");
2340
2341     ASSERT(prAdapter);
2342
2343     prRxCtrl = &prAdapter->rRxCtrl;
2344     ASSERT(prRxCtrl);
2345
2346     prRxCtrl->ucNumIndPacket = 0;
2347     prRxCtrl->ucNumRetainedPacket = 0;
2348
2349     do {
2350         KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2351         QUEUE_REMOVE_HEAD(&prRxCtrl->rReceivedRfbList, prSwRfb, P_SW_RFB_T);
2352         KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2353
2354         if (prSwRfb){
2355             switch(prSwRfb->ucPacketType){
2356                 case HIF_RX_PKT_TYPE_DATA:
2357                     nicRxProcessDataPacket(prAdapter, prSwRfb);
2358                     break;
2359
2360                 case HIF_RX_PKT_TYPE_EVENT:
2361                     nicRxProcessEventPacket(prAdapter, prSwRfb);
2362                     break;
2363
2364                 case HIF_RX_PKT_TYPE_TX_LOOPBACK:
2365                     DBGLOG(RX, ERROR, ("ucPacketType = %d\n", prSwRfb->ucPacketType));
2366                     break;
2367
2368                 case HIF_RX_PKT_TYPE_MANAGEMENT:
2369                     nicRxProcessMgmtPacket(prAdapter, prSwRfb);
2370                     break;
2371
2372                 default:
2373                     RX_INC_CNT(prRxCtrl, RX_TYPE_ERR_DROP_COUNT);
2374                     RX_INC_CNT(prRxCtrl, RX_DROP_TOTAL_COUNT);
2375                     DBGLOG(RX, ERROR, ("ucPacketType = %d\n", prSwRfb->ucPacketType));
2376                     break;
2377             }
2378         }
2379         else {
2380             break;
2381         }
2382     }while(TRUE);
2383
2384      if (prRxCtrl->ucNumIndPacket > 0) {
2385         RX_ADD_CNT(prRxCtrl, RX_DATA_INDICATION_COUNT, prRxCtrl->ucNumIndPacket);
2386         RX_ADD_CNT(prRxCtrl, RX_DATA_RETAINED_COUNT, prRxCtrl->ucNumRetainedPacket);
2387
2388         //DBGLOG(RX, INFO, ("%d packets indicated, Retained cnt = %d\n",
2389         //    prRxCtrl->ucNumIndPacket, prRxCtrl->ucNumRetainedPacket));
2390     #if CFG_NATIVE_802_11
2391         kalRxIndicatePkts(prAdapter->prGlueInfo, (UINT_32)prRxCtrl->ucNumIndPacket, (UINT_32)prRxCtrl->ucNumRetainedPacket);
2392     #else
2393         kalRxIndicatePkts(prAdapter->prGlueInfo, prRxCtrl->apvIndPacket, (UINT_32)prRxCtrl->ucNumIndPacket);
2394     #endif
2395     }
2396
2397 } /* end of nicRxProcessRFBs() */
2398
2399
2400 #if !CFG_SDIO_INTR_ENHANCE
2401 /*----------------------------------------------------------------------------*/
2402 /*!
2403 * @brief Read the rx data from data port and setup RFB
2404 *
2405 * @param prAdapter pointer to the Adapter handler
2406 * @param prSWRfb the RFB to receive rx data
2407 *
2408 * @retval WLAN_STATUS_SUCCESS: SUCCESS
2409 * @retval WLAN_STATUS_FAILURE: FAILURE
2410 *
2411 */
2412 /*----------------------------------------------------------------------------*/
2413 WLAN_STATUS
2414 nicRxReadBuffer (
2415     IN P_ADAPTER_T prAdapter,
2416     IN OUT P_SW_RFB_T prSwRfb
2417     )
2418 {
2419     P_RX_CTRL_T prRxCtrl;
2420     PUINT_8 pucBuf;
2421     P_HIF_RX_HEADER_T prHifRxHdr;
2422     UINT_32 u4PktLen = 0, u4ReadBytes;
2423     WLAN_STATUS u4Status = WLAN_STATUS_SUCCESS;
2424     BOOL fgResult = TRUE;
2425     UINT_32 u4RegValue;
2426     UINT_32 rxNum;
2427
2428     DEBUGFUNC("nicRxReadBuffer");
2429
2430     ASSERT(prAdapter);
2431     ASSERT(prSwRfb);
2432
2433     prRxCtrl = &prAdapter->rRxCtrl;
2434     ASSERT(prRxCtrl);
2435
2436     pucBuf = prSwRfb->pucRecvBuff;
2437     prHifRxHdr = prSwRfb->prHifRxHdr;
2438     ASSERT(pucBuf);
2439     DBGLOG(RX, TRACE, ("pucBuf= 0x%x, prHifRxHdr= 0x%x\n", pucBuf, prHifRxHdr));
2440
2441     do {
2442         /* Read the RFB DW length and packet length */
2443         HAL_MCR_RD(prAdapter, MCR_WRPLR, &u4RegValue);
2444         if (!fgResult) {
2445             DBGLOG(RX, ERROR, ("Read RX Packet Lentgh Error\n"));
2446             return WLAN_STATUS_FAILURE;
2447         }
2448
2449         //20091021 move the line to get the HIF RX header (for RX0/1)
2450         if(u4RegValue == 0) {
2451             DBGLOG(RX, ERROR, ("No RX packet\n"));
2452             return WLAN_STATUS_FAILURE;
2453         }
2454
2455         u4PktLen = u4RegValue & BITS(0, 15);
2456         if(u4PktLen != 0) {
2457             rxNum = 0;
2458         }
2459         else {
2460             rxNum = 1;
2461             u4PktLen = (u4RegValue & BITS(16, 31)) >> 16;
2462         }
2463
2464         DBGLOG(RX, TRACE, ("RX%d: u4PktLen = %d\n", rxNum, u4PktLen));
2465
2466         //4 <4> Read Entire RFB and packet, include HW appended DW (Checksum Status)
2467         u4ReadBytes = ALIGN_4(u4PktLen) + 4;
2468         HAL_READ_RX_PORT(prAdapter, rxNum, u4ReadBytes, pucBuf, CFG_RX_MAX_PKT_SIZE);
2469
2470         //20091021 move the line to get the HIF RX header
2471         //u4PktLen = (UINT_32)prHifRxHdr->u2PacketLen;
2472         if (u4PktLen != (UINT_32)prHifRxHdr->u2PacketLen) {
2473            DBGLOG(RX, ERROR, ("Read u4PktLen = %d, prHifRxHdr->u2PacketLen: %d\n",
2474                                 u4PktLen, prHifRxHdr->u2PacketLen));
2475     #if DBG
2476             dumpMemory8((PUINT_8)prHifRxHdr, (prHifRxHdr->u2PacketLen > 4096) ? 4096 : prHifRxHdr->u2PacketLen);
2477     #endif
2478             ASSERT(0);
2479         }
2480         /* u4PktLen is byte unit, not inlude HW appended DW */
2481
2482         prSwRfb->ucPacketType = (UINT_8)(prHifRxHdr->u2PacketType & HIF_RX_HDR_PACKET_TYPE_MASK);
2483         DBGLOG(RX, TRACE, ("ucPacketType = %d\n", prSwRfb->ucPacketType));
2484
2485         prSwRfb->ucStaRecIdx = (UINT_8)(prHifRxHdr->ucStaRecIdx);
2486
2487         /* fgResult will be updated in MACRO */
2488         if (!fgResult) {
2489             return WLAN_STATUS_FAILURE;
2490         }
2491
2492         DBGLOG(RX, TRACE, ("Dump RX buffer, length = 0x%x\n", u4ReadBytes));
2493         DBGLOG_MEM8(RX, TRACE, pucBuf, u4ReadBytes);
2494     }while(FALSE);
2495
2496     return u4Status;
2497 }
2498
2499
2500 /*----------------------------------------------------------------------------*/
2501 /*!
2502 * @brief Read frames from the data port, fill RFB
2503 *        and put each frame into the rReceivedRFBList queue.
2504 *
2505 * @param prAdapter   Pointer to the Adapter structure.
2506 *
2507 * @return (none)
2508 */
2509 /*----------------------------------------------------------------------------*/
2510 VOID
2511 nicRxReceiveRFBs (
2512     IN P_ADAPTER_T  prAdapter
2513     )
2514 {
2515     P_RX_CTRL_T prRxCtrl;
2516     P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
2517     P_HIF_RX_HEADER_T prHifRxHdr;
2518
2519     UINT_32 u4HwAppendDW;
2520
2521     KAL_SPIN_LOCK_DECLARATION();
2522
2523     DEBUGFUNC("nicRxReceiveRFBs");
2524
2525     ASSERT(prAdapter);
2526
2527     prRxCtrl = &prAdapter->rRxCtrl;
2528     ASSERT(prRxCtrl);
2529
2530     do {
2531         KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2532         QUEUE_REMOVE_HEAD(&prRxCtrl->rFreeSwRfbList, prSwRfb, P_SW_RFB_T);
2533         KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2534
2535         if (!prSwRfb) {
2536             DBGLOG(RX, TRACE, ("No More RFB\n"));
2537             break;
2538         }
2539
2540         // need to consider
2541         if (nicRxReadBuffer(prAdapter, prSwRfb) == WLAN_STATUS_FAILURE) {
2542             DBGLOG(RX, TRACE, ("halRxFillRFB failed\n"));
2543             nicRxReturnRFB(prAdapter, prSwRfb);
2544             break;
2545         }
2546
2547         KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2548         QUEUE_INSERT_TAIL(&prRxCtrl->rReceivedRfbList, &prSwRfb->rQueEntry);
2549         RX_INC_CNT(prRxCtrl, RX_MPDU_TOTAL_COUNT);
2550         KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2551
2552         prHifRxHdr = prSwRfb->prHifRxHdr;
2553         u4HwAppendDW = *((PUINT_32)((UINT_32)prHifRxHdr +
2554             (UINT_32)(ALIGN_4(prHifRxHdr->u2PacketLen))));
2555         DBGLOG(RX, TRACE, ("u4HwAppendDW = 0x%x\n", u4HwAppendDW));
2556         DBGLOG(RX, TRACE, ("u2PacketLen = 0x%x\n", prHifRxHdr->u2PacketLen));
2557       }
2558 //    while (RX_STATUS_TEST_MORE_FLAG(u4HwAppendDW));
2559     while (FALSE);
2560
2561     return;
2562
2563 } /* end of nicReceiveRFBs() */
2564
2565 #else
2566 /*----------------------------------------------------------------------------*/
2567 /*!
2568 * @brief Read frames from the data port, fill RFB
2569 *        and put each frame into the rReceivedRFBList queue.
2570 *
2571 * @param prAdapter      Pointer to the Adapter structure.
2572 * @param u4DataPort     Specify which port to read
2573 * @param u2RxLength     Specify to the the rx packet length in Byte.
2574 * @param prSwRfb        the RFB to receive rx data.
2575 *
2576 * @return (none)
2577 */
2578 /*----------------------------------------------------------------------------*/
2579
2580 WLAN_STATUS
2581 nicRxEnhanceReadBuffer (
2582     IN P_ADAPTER_T prAdapter,
2583     IN UINT_32      u4DataPort,
2584     IN UINT_16      u2RxLength,
2585     IN OUT P_SW_RFB_T prSwRfb
2586     )
2587 {
2588     P_RX_CTRL_T prRxCtrl;
2589     PUINT_8 pucBuf;
2590     P_HIF_RX_HEADER_T prHifRxHdr;
2591     UINT_32 u4PktLen = 0;
2592     WLAN_STATUS u4Status = WLAN_STATUS_FAILURE;
2593     BOOL fgResult = TRUE;
2594
2595     DEBUGFUNC("nicRxEnhanceReadBuffer");
2596
2597     ASSERT(prAdapter);
2598     ASSERT(prSwRfb);
2599
2600     prRxCtrl = &prAdapter->rRxCtrl;
2601     ASSERT(prRxCtrl);
2602
2603     pucBuf = prSwRfb->pucRecvBuff;
2604     ASSERT(pucBuf);
2605
2606     prHifRxHdr = prSwRfb->prHifRxHdr;
2607     ASSERT(prHifRxHdr);
2608
2609     //DBGLOG(RX, TRACE, ("u2RxLength = %d\n", u2RxLength));
2610
2611     do {
2612         //4 <1> Read RFB frame from MCR_WRDR0, include HW appended DW
2613         HAL_READ_RX_PORT(prAdapter,
2614                          u4DataPort,
2615                          ALIGN_4(u2RxLength + HIF_RX_HW_APPENDED_LEN),
2616                          pucBuf,
2617                          CFG_RX_MAX_PKT_SIZE);
2618
2619         if (!fgResult) {
2620             DBGLOG(RX, ERROR, ("Read RX Packet Lentgh Error\n"));
2621             break;
2622         }
2623
2624         u4PktLen = (UINT_32)(prHifRxHdr->u2PacketLen);
2625         //DBGLOG(RX, TRACE, ("u4PktLen = %d\n", u4PktLen));
2626
2627         prSwRfb->ucPacketType = (UINT_8)(prHifRxHdr->u2PacketType & HIF_RX_HDR_PACKET_TYPE_MASK);
2628         //DBGLOG(RX, TRACE, ("ucPacketType = %d\n", prSwRfb->ucPacketType));
2629
2630         prSwRfb->ucStaRecIdx = (UINT_8)(prHifRxHdr->ucStaRecIdx);
2631
2632         //4 <2> if the RFB dw size or packet size is zero
2633         if (u4PktLen == 0) {
2634             DBGLOG(RX, ERROR, ("Packet Length = %d\n", u4PktLen));
2635             ASSERT(0);
2636             break;
2637         }
2638
2639         //4 <3> if the packet is too large or too small
2640         if (u4PktLen > CFG_RX_MAX_PKT_SIZE) {
2641             DBGLOG(RX, TRACE, ("Read RX Packet Lentgh Error (%d)\n", u4PktLen));
2642             ASSERT(0);
2643             break;
2644         }
2645
2646         u4Status = WLAN_STATUS_SUCCESS;
2647     }
2648     while (FALSE);
2649
2650     DBGLOG_MEM8(RX, TRACE, pucBuf, ALIGN_4(u2RxLength + HIF_RX_HW_APPENDED_LEN));
2651     return u4Status;
2652 }
2653
2654
2655 /*----------------------------------------------------------------------------*/
2656 /*!
2657 * @brief Read frames from the data port for SDIO
2658 *        I/F, fill RFB and put each frame into the rReceivedRFBList queue.
2659 *
2660 * @param prAdapter      Pointer to the Adapter structure.
2661 *
2662 * @return (none)
2663 */
2664 /*----------------------------------------------------------------------------*/
2665 VOID
2666 nicRxSDIOReceiveRFBs (
2667     IN  P_ADAPTER_T prAdapter
2668     )
2669 {
2670     P_SDIO_CTRL_T prSDIOCtrl;
2671     P_RX_CTRL_T prRxCtrl;
2672     P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
2673     UINT_32 i, rxNum;
2674     UINT_16 u2RxPktNum, u2RxLength = 0, u2Tmp = 0;
2675     KAL_SPIN_LOCK_DECLARATION();
2676
2677     DEBUGFUNC("nicRxSDIOReceiveRFBs");
2678
2679     ASSERT(prAdapter);
2680
2681     prSDIOCtrl = prAdapter->prSDIOCtrl;
2682     ASSERT(prSDIOCtrl);
2683
2684     prRxCtrl = &prAdapter->rRxCtrl;
2685     ASSERT(prRxCtrl);
2686
2687     for (rxNum = 0 ; rxNum < 2 ; rxNum++) {
2688         u2RxPktNum = (rxNum == 0 ? prSDIOCtrl->rRxInfo.u.u2NumValidRx0Len : prSDIOCtrl->rRxInfo.u.u2NumValidRx1Len);
2689
2690         if(u2RxPktNum == 0) {
2691             continue;
2692         }
2693
2694         for (i = 0; i < u2RxPktNum; i++) {
2695             if(rxNum == 0) {
2696                 HAL_READ_RX_LENGTH(prAdapter, &u2RxLength, &u2Tmp);
2697             }
2698             else if(rxNum == 1) {
2699                 HAL_READ_RX_LENGTH(prAdapter, &u2Tmp, &u2RxLength);
2700             }
2701
2702             if (!u2RxLength) {
2703                 break;
2704             }
2705
2706
2707             KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2708             QUEUE_REMOVE_HEAD(&prRxCtrl->rFreeSwRfbList, prSwRfb, P_SW_RFB_T);
2709             KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2710
2711             if (!prSwRfb) {
2712                 DBGLOG(RX, TRACE, ("No More RFB\n"));
2713                 break;
2714             }
2715             ASSERT(prSwRfb);
2716
2717             if (nicRxEnhanceReadBuffer(prAdapter, rxNum, u2RxLength, prSwRfb) == WLAN_STATUS_FAILURE) {
2718                 DBGLOG(RX, TRACE, ("nicRxEnhanceRxReadBuffer failed\n"));
2719                 nicRxReturnRFB(prAdapter, prSwRfb);
2720                 break;
2721             }
2722
2723             //prSDIOCtrl->au4RxLength[i] = 0;
2724
2725             KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2726             QUEUE_INSERT_TAIL(&prRxCtrl->rReceivedRfbList, &prSwRfb->rQueEntry);
2727             RX_INC_CNT(prRxCtrl, RX_MPDU_TOTAL_COUNT);
2728             KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2729         }
2730     }
2731
2732     prSDIOCtrl->rRxInfo.u.u2NumValidRx0Len = 0;
2733     prSDIOCtrl->rRxInfo.u.u2NumValidRx1Len = 0;
2734
2735     return;
2736 }/* end of nicRxSDIOReceiveRFBs() */
2737
2738 #endif /* CFG_SDIO_INTR_ENHANCE */
2739
2740
2741
2742 #if CFG_SDIO_RX_AGG
2743 /*----------------------------------------------------------------------------*/
2744 /*!
2745 * @brief Read frames from the data port for SDIO with Rx aggregation enabled
2746 *        I/F, fill RFB and put each frame into the rReceivedRFBList queue.
2747 *
2748 * @param prAdapter      Pointer to the Adapter structure.
2749 *
2750 * @return (none)
2751 */
2752 /*----------------------------------------------------------------------------*/
2753 VOID
2754 nicRxSDIOAggReceiveRFBs (
2755     IN  P_ADAPTER_T prAdapter
2756     )
2757 {
2758     P_ENHANCE_MODE_DATA_STRUCT_T prEnhDataStr;
2759     P_RX_CTRL_T prRxCtrl;
2760     P_SDIO_CTRL_T prSDIOCtrl;
2761     P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
2762     UINT_32 u4RxLength;
2763     UINT_32 i, rxNum;
2764     UINT_32 u4RxAggCount = 0, u4RxAggLength = 0;
2765     UINT_32 u4RxAvailAggLen, u4CurrAvailFreeRfbCnt;
2766     PUINT_8 pucSrcAddr;
2767     P_HIF_RX_HEADER_T prHifRxHdr;
2768     BOOL fgResult = TRUE;
2769     BOOLEAN fgIsRxEnhanceMode;
2770     UINT_16 u2RxPktNum;
2771 #if CFG_SDIO_RX_ENHANCE
2772     UINT_32 u4MaxLoopCount = CFG_MAX_RX_ENHANCE_LOOP_COUNT;
2773 #endif
2774
2775     KAL_SPIN_LOCK_DECLARATION();
2776
2777     DEBUGFUNC("nicRxSDIOAggReceiveRFBs");
2778
2779     ASSERT(prAdapter);
2780     prEnhDataStr = prAdapter->prSDIOCtrl;
2781     prRxCtrl = &prAdapter->rRxCtrl;
2782     prSDIOCtrl = prAdapter->prSDIOCtrl;
2783
2784 #if CFG_SDIO_RX_ENHANCE
2785     fgIsRxEnhanceMode = TRUE;
2786 #else
2787     fgIsRxEnhanceMode = FALSE;
2788 #endif
2789
2790     do {
2791 #if CFG_SDIO_RX_ENHANCE
2792         /* to limit maximum loop for RX */
2793         u4MaxLoopCount--;
2794         if (u4MaxLoopCount == 0) {
2795             break;
2796         }
2797 #endif
2798
2799         if(prEnhDataStr->rRxInfo.u.u2NumValidRx0Len == 0 &&
2800                 prEnhDataStr->rRxInfo.u.u2NumValidRx1Len == 0) {
2801             break;
2802         }
2803
2804         for(rxNum = 0 ; rxNum < 2 ; rxNum++) {
2805             u2RxPktNum = (rxNum == 0 ? prEnhDataStr->rRxInfo.u.u2NumValidRx0Len : prEnhDataStr->rRxInfo.u.u2NumValidRx1Len);
2806             //DBGLOG(RX, TRACE, ("RxPktNum %d in rxPort %d\n", u2RxPktNum, rxNum));
2807
2808             // if this assertion happened, it is most likely a F/W bug
2809             ASSERT(u2RxPktNum <= 16);
2810
2811             if (u2RxPktNum > 16)
2812                   continue;
2813
2814             if(u2RxPktNum == 0)
2815                 continue;
2816
2817     #if CFG_HIF_STATISTICS
2818             prRxCtrl->u4TotalRxAccessNum++;
2819             prRxCtrl->u4TotalRxPacketNum += u2RxPktNum;
2820     #endif
2821
2822             u4CurrAvailFreeRfbCnt = prRxCtrl->rFreeSwRfbList.u4NumElem;
2823
2824             // if SwRfb is not enough, abort reading this time
2825              if(u4CurrAvailFreeRfbCnt < u2RxPktNum) {
2826     #if CFG_HIF_RX_STARVATION_WARNING
2827                 DbgPrint("FreeRfb is not enough: %d available, need %d\n", u4CurrAvailFreeRfbCnt, u2RxPktNum);
2828                 DbgPrint("Queued Count: %d / Dequeud Count: %d\n", prRxCtrl->u4QueuedCnt, prRxCtrl->u4DequeuedCnt);
2829     #endif
2830                 continue;
2831             }
2832
2833 #if CFG_SDIO_RX_ENHANCE
2834             u4RxAvailAggLen = CFG_RX_COALESCING_BUFFER_SIZE - (sizeof(ENHANCE_MODE_DATA_STRUCT_T) + 4/* extra HW padding */);
2835 #else
2836             u4RxAvailAggLen = CFG_RX_COALESCING_BUFFER_SIZE;
2837 #endif
2838             u4RxAggCount = 0;
2839
2840             for (i = 0; i < u2RxPktNum ; i++) {
2841                 u4RxLength = (rxNum == 0 ?
2842                         (UINT_32)prEnhDataStr->rRxInfo.u.au2Rx0Len[i] :
2843                         (UINT_32)prEnhDataStr->rRxInfo.u.au2Rx1Len[i]);
2844
2845                 if (!u4RxLength) {
2846                     ASSERT(0);
2847                     break;
2848                 }
2849
2850                 if (ALIGN_4(u4RxLength + HIF_RX_HW_APPENDED_LEN) < u4RxAvailAggLen) {
2851                     if (u4RxAggCount < u4CurrAvailFreeRfbCnt) {
2852                         u4RxAvailAggLen -= ALIGN_4(u4RxLength + HIF_RX_HW_APPENDED_LEN);
2853                         u4RxAggCount++;
2854                     }
2855                     else {
2856                         // no FreeSwRfb for rx packet
2857                         ASSERT(0);
2858                         break;
2859                     }
2860                 }
2861                 else {
2862                     // CFG_RX_COALESCING_BUFFER_SIZE is not large enough
2863                     ASSERT(0);
2864                     break;
2865                 }
2866             }
2867
2868             u4RxAggLength = (CFG_RX_COALESCING_BUFFER_SIZE - u4RxAvailAggLen);
2869             //DBGLOG(RX, INFO, ("u4RxAggCount = %d, u4RxAggLength = %d\n",
2870             //            u4RxAggCount, u4RxAggLength));
2871
2872             HAL_READ_RX_PORT(prAdapter,
2873                          rxNum,
2874                          u4RxAggLength,
2875                          prRxCtrl->pucRxCoalescingBufPtr,
2876                          CFG_RX_COALESCING_BUFFER_SIZE);
2877             if (!fgResult) {
2878                 DBGLOG(RX, ERROR, ("Read RX Agg Packet Error\n"));
2879                 continue;
2880             }
2881
2882             pucSrcAddr = prRxCtrl->pucRxCoalescingBufPtr;
2883             for (i = 0; i < u4RxAggCount; i++) {
2884                 UINT_16 u2PktLength;
2885
2886                 u2PktLength = (rxNum == 0 ?
2887                         prEnhDataStr->rRxInfo.u.au2Rx0Len[i] :
2888                         prEnhDataStr->rRxInfo.u.au2Rx1Len[i]);
2889
2890                 KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2891                 QUEUE_REMOVE_HEAD(&prRxCtrl->rFreeSwRfbList, prSwRfb, P_SW_RFB_T);
2892                 KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2893
2894                 ASSERT(prSwRfb);
2895                 kalMemCopy(prSwRfb->pucRecvBuff, pucSrcAddr,
2896                         ALIGN_4(u2PktLength + HIF_RX_HW_APPENDED_LEN));
2897
2898                 prHifRxHdr = prSwRfb->prHifRxHdr;
2899                 ASSERT(prHifRxHdr);
2900
2901                 prSwRfb->ucPacketType = (UINT_8)(prHifRxHdr->u2PacketType & HIF_RX_HDR_PACKET_TYPE_MASK);
2902                 //DBGLOG(RX, TRACE, ("ucPacketType = %d\n", prSwRfb->ucPacketType));
2903
2904                 prSwRfb->ucStaRecIdx = (UINT_8)(prHifRxHdr->ucStaRecIdx);
2905
2906                 KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2907                 QUEUE_INSERT_TAIL(&prRxCtrl->rReceivedRfbList, &prSwRfb->rQueEntry);
2908                 RX_INC_CNT(prRxCtrl, RX_MPDU_TOTAL_COUNT);
2909                 KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2910
2911                 pucSrcAddr += ALIGN_4(u2PktLength + HIF_RX_HW_APPENDED_LEN);
2912                 //prEnhDataStr->au4RxLength[i] = 0;
2913             }
2914
2915 #if CFG_SDIO_RX_ENHANCE
2916             kalMemCopy(prAdapter->prSDIOCtrl, (pucSrcAddr + 4), sizeof(ENHANCE_MODE_DATA_STRUCT_T));
2917
2918             /* do the same thing what nicSDIOReadIntStatus() does */
2919             if((prSDIOCtrl->u4WHISR & WHISR_TX_DONE_INT) == 0 &&
2920                     (prSDIOCtrl->rTxInfo.au4WTSR[0] | prSDIOCtrl->rTxInfo.au4WTSR[1])) {
2921                 prSDIOCtrl->u4WHISR |= WHISR_TX_DONE_INT;
2922             }
2923
2924             if((prSDIOCtrl->u4WHISR & BIT(31)) == 0 &&
2925                     HAL_GET_MAILBOX_READ_CLEAR(prAdapter) == TRUE &&
2926                     (prSDIOCtrl->u4RcvMailbox0 != 0 || prSDIOCtrl->u4RcvMailbox1 != 0)) {
2927                 prSDIOCtrl->u4WHISR |= BIT(31);
2928             }
2929
2930             /* dispatch to interrupt handler with RX bits masked */
2931             nicProcessIST_impl(prAdapter, prSDIOCtrl->u4WHISR & (~(WHISR_RX0_DONE_INT | WHISR_RX1_DONE_INT)));
2932 #endif
2933         }
2934
2935 #if !CFG_SDIO_RX_ENHANCE
2936         prEnhDataStr->rRxInfo.u.u2NumValidRx0Len = 0;
2937         prEnhDataStr->rRxInfo.u.u2NumValidRx1Len = 0;
2938 #endif
2939     }
2940     while ((prEnhDataStr->rRxInfo.u.u2NumValidRx0Len
2941                 || prEnhDataStr->rRxInfo.u.u2NumValidRx1Len)
2942             && fgIsRxEnhanceMode);
2943
2944     return;
2945 }
2946 #endif /* CFG_SDIO_RX_AGG */
2947
2948
2949 /*----------------------------------------------------------------------------*/
2950 /*!
2951 * @brief Setup a RFB and allocate the os packet to the RFB
2952 *
2953 * @param prAdapter      Pointer to the Adapter structure.
2954 * @param prSwRfb        Pointer to the RFB
2955 *
2956 * @retval WLAN_STATUS_SUCCESS
2957 * @retval WLAN_STATUS_RESOURCES
2958 */
2959 /*----------------------------------------------------------------------------*/
2960 WLAN_STATUS
2961 nicRxSetupRFB (
2962     IN P_ADAPTER_T prAdapter,
2963     IN P_SW_RFB_T  prSwRfb
2964     )
2965 {
2966     PVOID   pvPacket;
2967     PUINT_8 pucRecvBuff;
2968
2969     ASSERT(prAdapter);
2970     ASSERT(prSwRfb);
2971
2972     if (!prSwRfb->pvPacket) {
2973         kalMemZero(prSwRfb, sizeof(SW_RFB_T));
2974         pvPacket = kalPacketAlloc(prAdapter->prGlueInfo, CFG_RX_MAX_PKT_SIZE,
2975             &pucRecvBuff);
2976         if (pvPacket == NULL) {
2977             return WLAN_STATUS_RESOURCES;
2978         }
2979
2980         prSwRfb->pvPacket = pvPacket;
2981         prSwRfb->pucRecvBuff= (PVOID)pucRecvBuff;
2982     }
2983     else {
2984         kalMemZero(((PUINT_8)prSwRfb + OFFSET_OF(SW_RFB_T, prHifRxHdr)),
2985             (sizeof(SW_RFB_T)-OFFSET_OF(SW_RFB_T, prHifRxHdr)));
2986     }
2987
2988     prSwRfb->prHifRxHdr = (P_HIF_RX_HEADER_T)(prSwRfb->pucRecvBuff);
2989
2990     return WLAN_STATUS_SUCCESS;
2991
2992 } /* end of nicRxSetupRFB() */
2993
2994
2995 /*----------------------------------------------------------------------------*/
2996 /*!
2997 * @brief This routine is called to put a RFB back onto the "RFB with Buffer" list
2998 *        or "RFB without buffer" list according to pvPacket.
2999 *
3000 * @param prAdapter      Pointer to the Adapter structure.
3001 * @param prSwRfb          Pointer to the RFB
3002 *
3003 * @return (none)
3004 */
3005 /*----------------------------------------------------------------------------*/
3006 VOID
3007 nicRxReturnRFB (
3008     IN P_ADAPTER_T prAdapter,
3009     IN P_SW_RFB_T  prSwRfb
3010     )
3011 {
3012     P_RX_CTRL_T prRxCtrl;
3013     P_QUE_ENTRY_T prQueEntry;
3014     KAL_SPIN_LOCK_DECLARATION();
3015
3016     ASSERT(prAdapter);
3017     ASSERT(prSwRfb);
3018     prRxCtrl = &prAdapter->rRxCtrl;
3019     prQueEntry = &prSwRfb->rQueEntry;
3020
3021     ASSERT(prQueEntry);
3022
3023     /* The processing on this RFB is done, so put it back on the tail of
3024        our list */
3025     KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
3026
3027     if (prSwRfb->pvPacket) {
3028         QUEUE_INSERT_TAIL(&prRxCtrl->rFreeSwRfbList, prQueEntry);
3029     }
3030     else {
3031         QUEUE_INSERT_TAIL(&prRxCtrl->rIndicatedRfbList, prQueEntry);
3032     }
3033
3034     KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
3035     return;
3036 } /* end of nicRxReturnRFB() */
3037
3038 /*----------------------------------------------------------------------------*/
3039 /*!
3040 * @brief Process rx interrupt. When the rx
3041 *        Interrupt is asserted, it means there are frames in queue.
3042 *
3043 * @param prAdapter      Pointer to the Adapter structure.
3044 *
3045 * @return (none)
3046 */
3047 /*----------------------------------------------------------------------------*/
3048 VOID
3049 nicProcessRxInterrupt (
3050     IN  P_ADAPTER_T prAdapter
3051     )
3052 {
3053     ASSERT(prAdapter);
3054
3055 #if CFG_SDIO_INTR_ENHANCE
3056     #if CFG_SDIO_RX_AGG
3057         nicRxSDIOAggReceiveRFBs(prAdapter);
3058     #else
3059         nicRxSDIOReceiveRFBs(prAdapter);
3060     #endif
3061 #else
3062     nicRxReceiveRFBs(prAdapter);
3063 #endif /* CFG_SDIO_INTR_ENHANCE */
3064
3065     nicRxProcessRFBs(prAdapter);
3066
3067     return;
3068
3069 } /* end of nicProcessRxInterrupt() */
3070
3071
3072 #if CFG_TCP_IP_CHKSUM_OFFLOAD
3073 /*----------------------------------------------------------------------------*/
3074 /*!
3075 * @brief Used to update IP/TCP/UDP checksum statistics of RX Module.
3076 *
3077 * @param prAdapter  Pointer to the Adapter structure.
3078 * @param aeCSUM     The array of checksum result.
3079 *
3080 * @return (none)
3081 */
3082 /*----------------------------------------------------------------------------*/
3083 VOID
3084 nicRxUpdateCSUMStatistics (
3085     IN P_ADAPTER_T prAdapter,
3086     IN const ENUM_CSUM_RESULT_T aeCSUM[]
3087     )
3088 {
3089     P_RX_CTRL_T prRxCtrl;
3090
3091     ASSERT(prAdapter);
3092     ASSERT(aeCSUM);
3093
3094     prRxCtrl = &prAdapter->rRxCtrl;
3095     ASSERT(prRxCtrl);
3096
3097     if ((aeCSUM[CSUM_TYPE_IPV4] == CSUM_RES_SUCCESS) ||
3098         (aeCSUM[CSUM_TYPE_IPV6] == CSUM_RES_SUCCESS)) {
3099
3100         RX_INC_CNT(prRxCtrl, RX_CSUM_IP_SUCCESS_COUNT);
3101     }
3102     else if ((aeCSUM[CSUM_TYPE_IPV4] == CSUM_RES_FAILED) ||
3103              (aeCSUM[CSUM_TYPE_IPV6] == CSUM_RES_FAILED)) {
3104
3105         RX_INC_CNT(prRxCtrl, RX_CSUM_IP_FAILED_COUNT);
3106     }
3107     else if ((aeCSUM[CSUM_TYPE_IPV4] == CSUM_RES_NONE) &&
3108              (aeCSUM[CSUM_TYPE_IPV6] == CSUM_RES_NONE)) {
3109
3110         RX_INC_CNT(prRxCtrl, RX_CSUM_UNKNOWN_L3_PKT_COUNT);
3111     }
3112     else {
3113         ASSERT(0);
3114     }
3115
3116     if (aeCSUM[CSUM_TYPE_TCP] == CSUM_RES_SUCCESS) {
3117         RX_INC_CNT(prRxCtrl, RX_CSUM_TCP_SUCCESS_COUNT);
3118     }
3119     else if (aeCSUM[CSUM_TYPE_TCP] == CSUM_RES_FAILED) {
3120         RX_INC_CNT(prRxCtrl, RX_CSUM_TCP_FAILED_COUNT);
3121     }
3122     else if (aeCSUM[CSUM_TYPE_UDP] == CSUM_RES_SUCCESS) {
3123         RX_INC_CNT(prRxCtrl, RX_CSUM_UDP_SUCCESS_COUNT);
3124     }
3125     else if (aeCSUM[CSUM_TYPE_UDP] == CSUM_RES_FAILED) {
3126         RX_INC_CNT(prRxCtrl, RX_CSUM_UDP_FAILED_COUNT);
3127     }
3128     else if ((aeCSUM[CSUM_TYPE_UDP] == CSUM_RES_NONE) &&
3129              (aeCSUM[CSUM_TYPE_TCP] == CSUM_RES_NONE)) {
3130
3131         RX_INC_CNT(prRxCtrl, RX_CSUM_UNKNOWN_L4_PKT_COUNT);
3132     }
3133     else {
3134         ASSERT(0);
3135     }
3136
3137     return;
3138 } /* end of nicRxUpdateCSUMStatistics() */
3139 #endif /* CFG_TCP_IP_CHKSUM_OFFLOAD */
3140
3141
3142 /*----------------------------------------------------------------------------*/
3143 /*!
3144 * @brief This function is used to query current status of RX Module.
3145 *
3146 * @param prAdapter      Pointer to the Adapter structure.
3147 * @param pucBuffer      Pointer to the message buffer.
3148 * @param pu4Count      Pointer to the buffer of message length count.
3149 *
3150 * @return (none)
3151 */
3152 /*----------------------------------------------------------------------------*/
3153 VOID
3154 nicRxQueryStatus (
3155     IN P_ADAPTER_T prAdapter,
3156     IN PUINT_8 pucBuffer,
3157     OUT PUINT_32 pu4Count
3158     )
3159 {
3160     P_RX_CTRL_T prRxCtrl;
3161     PUINT_8 pucCurrBuf = pucBuffer;
3162
3163
3164     ASSERT(prAdapter);
3165     prRxCtrl = &prAdapter->rRxCtrl;
3166     ASSERT(prRxCtrl);
3167
3168     //if (pucBuffer) {} /* For Windows, we'll print directly instead of sprintf() */
3169     ASSERT(pu4Count);
3170
3171     SPRINTF(pucCurrBuf, ("\n\nRX CTRL STATUS:"));
3172     SPRINTF(pucCurrBuf, ("\n==============="));
3173     SPRINTF(pucCurrBuf, ("\nFREE RFB w/i BUF LIST :%9ld", prRxCtrl->rFreeSwRfbList.u4NumElem));
3174     SPRINTF(pucCurrBuf, ("\nFREE RFB w/o BUF LIST :%9ld", prRxCtrl->rIndicatedRfbList.u4NumElem));
3175     SPRINTF(pucCurrBuf, ("\nRECEIVED RFB LIST     :%9ld", prRxCtrl->rReceivedRfbList.u4NumElem));
3176
3177     SPRINTF(pucCurrBuf, ("\n\n"));
3178
3179     //*pu4Count = (UINT_32)((UINT_32)pucCurrBuf - (UINT_32)pucBuffer);
3180
3181     return;
3182 } /* end of nicRxQueryStatus() */
3183
3184
3185 /*----------------------------------------------------------------------------*/
3186 /*!
3187 * @brief Clear RX related counters
3188 *
3189 * @param prAdapter Pointer of Adapter Data Structure
3190 *
3191 * @return - (none)
3192 */
3193 /*----------------------------------------------------------------------------*/
3194 VOID
3195 nicRxClearStatistics (
3196     IN P_ADAPTER_T prAdapter
3197     )
3198 {
3199     P_RX_CTRL_T prRxCtrl;
3200
3201     ASSERT(prAdapter);
3202     prRxCtrl = &prAdapter->rRxCtrl;
3203     ASSERT(prRxCtrl);
3204
3205     RX_RESET_ALL_CNTS(prRxCtrl);
3206     return;
3207 }
3208
3209
3210 /*----------------------------------------------------------------------------*/
3211 /*!
3212 * @brief This function is used to query current statistics of RX Module.
3213 *
3214 * @param prAdapter      Pointer to the Adapter structure.
3215 * @param pucBuffer      Pointer to the message buffer.
3216 * @param pu4Count      Pointer to the buffer of message length count.
3217 *
3218 * @return (none)
3219 */
3220 /*----------------------------------------------------------------------------*/
3221 VOID
3222 nicRxQueryStatistics (
3223     IN P_ADAPTER_T prAdapter,
3224     IN PUINT_8 pucBuffer,
3225     OUT PUINT_32 pu4Count
3226     )
3227 {
3228     P_RX_CTRL_T prRxCtrl;
3229     PUINT_8 pucCurrBuf = pucBuffer;
3230
3231     ASSERT(prAdapter);
3232     prRxCtrl = &prAdapter->rRxCtrl;
3233     ASSERT(prRxCtrl);
3234
3235     //if (pucBuffer) {} /* For Windows, we'll print directly instead of sprintf() */
3236     ASSERT(pu4Count);
3237
3238 #define SPRINTF_RX_COUNTER(eCounter) \
3239     SPRINTF(pucCurrBuf, ("%-30s : %ld\n", #eCounter, (UINT_32)prRxCtrl->au8Statistics[eCounter]))
3240
3241     SPRINTF_RX_COUNTER(RX_MPDU_TOTAL_COUNT);
3242     SPRINTF_RX_COUNTER(RX_SIZE_ERR_DROP_COUNT);
3243     SPRINTF_RX_COUNTER(RX_DATA_INDICATION_COUNT);
3244     SPRINTF_RX_COUNTER(RX_DATA_RETURNED_COUNT);
3245     SPRINTF_RX_COUNTER(RX_DATA_RETAINED_COUNT);
3246
3247 #if CFG_TCP_IP_CHKSUM_OFFLOAD || CFG_TCP_IP_CHKSUM_OFFLOAD_NDIS_60
3248     SPRINTF_RX_COUNTER(RX_CSUM_TCP_FAILED_COUNT);
3249     SPRINTF_RX_COUNTER(RX_CSUM_UDP_FAILED_COUNT);
3250     SPRINTF_RX_COUNTER(RX_CSUM_IP_FAILED_COUNT);
3251     SPRINTF_RX_COUNTER(RX_CSUM_TCP_SUCCESS_COUNT);
3252     SPRINTF_RX_COUNTER(RX_CSUM_UDP_SUCCESS_COUNT);
3253     SPRINTF_RX_COUNTER(RX_CSUM_IP_SUCCESS_COUNT);
3254     SPRINTF_RX_COUNTER(RX_CSUM_UNKNOWN_L4_PKT_COUNT);
3255     SPRINTF_RX_COUNTER(RX_CSUM_UNKNOWN_L3_PKT_COUNT);
3256     SPRINTF_RX_COUNTER(RX_IP_V6_PKT_CCOUNT);
3257 #endif
3258
3259     //*pu4Count = (UINT_32)(pucCurrBuf - pucBuffer);
3260
3261     nicRxClearStatistics(prAdapter);
3262
3263     return;
3264 }
3265
3266 /*----------------------------------------------------------------------------*/
3267 /*!
3268 * @brief Read the Response data from data port
3269 *
3270 * @param prAdapter pointer to the Adapter handler
3271 * @param pucRspBuffer pointer to the Response buffer
3272 *
3273 * @retval WLAN_STATUS_SUCCESS: Response packet has been read
3274 * @retval WLAN_STATUS_FAILURE: Read Response packet timeout or error occurred
3275 *
3276 */
3277 /*----------------------------------------------------------------------------*/
3278 WLAN_STATUS
3279 nicRxWaitResponse (
3280     IN P_ADAPTER_T prAdapter,
3281     IN UINT_8 ucPortIdx,
3282     OUT PUINT_8 pucRspBuffer,
3283     IN UINT_32 u4MaxRespBufferLen,
3284     OUT PUINT_32 pu4Length
3285     )
3286 {
3287     UINT_32 u4Value = 0, u4PktLen = 0, i = 0;
3288     WLAN_STATUS u4Status = WLAN_STATUS_SUCCESS;
3289     BOOL fgResult = TRUE;
3290     UINT_32 u4Time, u4Current;
3291
3292     DEBUGFUNC("nicRxWaitResponse");
3293
3294     ASSERT(prAdapter);
3295     ASSERT(pucRspBuffer);
3296     ASSERT(ucPortIdx < 2);
3297
3298     u4Time = (UINT_32)kalGetTimeTick();
3299
3300     do {
3301         /* Read the packet length */
3302         HAL_MCR_RD(prAdapter, MCR_WRPLR, &u4Value);
3303
3304         if (!fgResult) {
3305             DBGLOG(RX, ERROR, ("Read Response Packet Error\n"));
3306             return WLAN_STATUS_FAILURE;
3307         }
3308
3309         if(ucPortIdx == 0) {
3310             u4PktLen = u4Value & 0xFFFF;
3311         }
3312         else {
3313             u4PktLen = (u4Value >> 16) & 0xFFFF;
3314         }
3315
3316         DBGLOG(RX, TRACE, ("i = %d, u4PktLen = %d\n", i, u4PktLen));
3317
3318         if (u4PktLen == 0) {
3319             /* timeout exceeding check */
3320             u4Current = (UINT_32)kalGetTimeTick();
3321
3322             if((u4Current > u4Time) && ((u4Current - u4Time) > RX_RESPONSE_TIMEOUT)) {
3323                 return WLAN_STATUS_FAILURE;
3324             }
3325             else if(u4Current < u4Time && ((u4Current + (0xFFFFFFFF - u4Time)) > RX_RESPONSE_TIMEOUT)) {
3326                 return WLAN_STATUS_FAILURE;
3327             }
3328
3329             /* Response packet is not ready */
3330             kalUdelay(50);
3331
3332             i++;
3333         }
3334         else if (u4PktLen > u4MaxRespBufferLen) {
3335             DBGLOG(RX, WARN, ("Not enough Event Buffer: required length = 0x%x, available buffer length = %d\n",
3336                 u4PktLen, u4MaxRespBufferLen));
3337
3338             return WLAN_STATUS_FAILURE;
3339         }
3340         else {
3341             HAL_PORT_RD(prAdapter,
3342                         ucPortIdx == 0 ? MCR_WRDR0 : MCR_WRDR1,
3343                         u4PktLen,
3344                         pucRspBuffer,
3345                         u4MaxRespBufferLen);
3346
3347             /* fgResult will be updated in MACRO */
3348             if (!fgResult) {
3349                 DBGLOG(RX, ERROR, ("Read Response Packet Error\n"));
3350                 return WLAN_STATUS_FAILURE;
3351             }
3352
3353             DBGLOG(RX, TRACE, ("Dump Response buffer, length = 0x%x\n",
3354                 u4PktLen));
3355             DBGLOG_MEM8(RX, TRACE, pucRspBuffer, u4PktLen);
3356
3357             *pu4Length = u4PktLen;
3358             break;
3359         }
3360     } while(TRUE);
3361
3362     return u4Status;
3363 }
3364
3365 /*----------------------------------------------------------------------------*/
3366 /*!
3367 * @brief Set filter to enable Promiscuous Mode
3368 *
3369 * @param prAdapter          Pointer to the Adapter structure.
3370 *
3371 * @return (none)
3372 */
3373 /*----------------------------------------------------------------------------*/
3374 VOID
3375 nicRxEnablePromiscuousMode (
3376     IN P_ADAPTER_T prAdapter
3377     )
3378 {
3379     ASSERT(prAdapter);
3380
3381     return;
3382 } /* end of nicRxEnablePromiscuousMode() */
3383
3384
3385 /*----------------------------------------------------------------------------*/
3386 /*!
3387 * @brief Set filter to disable Promiscuous Mode
3388 *
3389 * @param prAdapter  Pointer to the Adapter structure.
3390 *
3391 * @return (none)
3392 */
3393 /*----------------------------------------------------------------------------*/
3394 VOID
3395 nicRxDisablePromiscuousMode (
3396     IN P_ADAPTER_T prAdapter
3397     )
3398 {
3399     ASSERT(prAdapter);
3400
3401     return;
3402 } /* end of nicRxDisablePromiscuousMode() */
3403
3404
3405 /*----------------------------------------------------------------------------*/
3406 /*!
3407 * @brief this function flushes all packets queued in reordering module
3408 *
3409 * @param prAdapter              Pointer to the Adapter structure.
3410 *
3411 * @retval WLAN_STATUS_SUCCESS   Flushed successfully
3412 */
3413 /*----------------------------------------------------------------------------*/
3414 WLAN_STATUS
3415 nicRxFlush (
3416     IN P_ADAPTER_T  prAdapter
3417     )
3418 {
3419     P_SW_RFB_T prSwRfb;
3420
3421     ASSERT(prAdapter);
3422
3423     if((prSwRfb = qmFlushRxQueues(prAdapter)) != NULL) {
3424         do {
3425             P_SW_RFB_T prNextSwRfb;
3426
3427             // save next first
3428             prNextSwRfb = (P_SW_RFB_T)QUEUE_GET_NEXT_ENTRY((P_QUE_ENTRY_T)prSwRfb);
3429
3430             // free
3431             nicRxReturnRFB(prAdapter, prSwRfb);
3432
3433             prSwRfb = prNextSwRfb;
3434         } while(prSwRfb);
3435     }
3436
3437     return WLAN_STATUS_SUCCESS;
3438 }
3439
3440
3441 /*----------------------------------------------------------------------------*/
3442 /*!
3443 * @brief
3444 *
3445 * @param
3446 *
3447 * @retval
3448 */
3449 /*----------------------------------------------------------------------------*/
3450 WLAN_STATUS
3451 nicRxProcessActionFrame (
3452     IN P_ADAPTER_T      prAdapter,
3453     IN P_SW_RFB_T       prSwRfb
3454     )
3455 {
3456     P_WLAN_ACTION_FRAME prActFrame;
3457
3458     ASSERT(prAdapter);
3459     ASSERT(prSwRfb);
3460
3461     if (prSwRfb->u2PacketLen < sizeof(WLAN_ACTION_FRAME) - 1) {
3462         return WLAN_STATUS_INVALID_PACKET;
3463     }
3464     prActFrame = (P_WLAN_ACTION_FRAME) prSwRfb->pvHeader;
3465
3466     switch (prActFrame->ucCategory) {
3467     case CATEGORY_PUBLIC_ACTION:
3468
3469     #if CFG_ENABLE_WIFI_DIRECT
3470         if (prAdapter->fgIsP2PRegistered) {
3471             rlmProcessPublicAction(prAdapter, prSwRfb);
3472
3473             p2pFuncValidateRxActionFrame(
3474                         prAdapter, prSwRfb);
3475
3476         }
3477     #endif
3478         break;
3479
3480     case CATEGORY_HT_ACTION:
3481     #if CFG_ENABLE_WIFI_DIRECT
3482         if (prAdapter->fgIsP2PRegistered) {
3483             rlmProcessHtAction(prAdapter, prSwRfb);
3484         }
3485     #endif
3486         break;
3487     case CATEGORY_VENDOR_SPECIFIC_ACTION:
3488     #if CFG_ENABLE_WIFI_DIRECT
3489         if (prAdapter->fgIsP2PRegistered) {
3490             p2pFuncValidateRxActionFrame(prAdapter, prSwRfb);
3491         }
3492     #endif
3493         break;
3494 #if CFG_SUPPORT_802_11W
3495     case CATEGORY_SA_QUERT_ACTION:
3496         {
3497             P_HIF_RX_HEADER_T   prHifRxHdr;
3498
3499             prHifRxHdr = prSwRfb->prHifRxHdr;
3500
3501             if ((HIF_RX_HDR_GET_NETWORK_IDX(prHifRxHdr) == NETWORK_TYPE_AIS_INDEX) &&
3502                 prAdapter->rWifiVar.rAisSpecificBssInfo.fgMgmtProtection /* Use MFP */
3503                 ) {
3504                 if (!(prHifRxHdr->ucReserved & CONTROL_FLAG_UC_MGMT_NO_ENC)) {
3505                     /* MFP test plan 5.3.3.4 */
3506                     rsnSaQueryAction(prAdapter, prSwRfb);
3507                 }
3508                 else {
3509                     DBGLOG(RSN, TRACE, ("Un-Protected SA Query, do nothing\n"));
3510                 }
3511             }
3512         }
3513         break;
3514 #endif
3515 #if CFG_SUPPORT_802_11V
3516     case CATEGORY_WNM_ACTION:
3517         {
3518             wnmWNMAction(prAdapter, prSwRfb);
3519         }
3520         break;
3521 #endif
3522     default:
3523         break;
3524     } /* end of switch case */
3525
3526     return WLAN_STATUS_SUCCESS;
3527 }
3528
3529