2 ** $Id: //Department/DaVinci/BRANCHES/MT6620_WIFI_DRIVER_V2_3/nic/nic_rx.c#3 $
6 \brief Functions that provide many rx-related functions
8 This file includes the functions used to process RFB and dispatch RFBs to
9 the appropriate related rx functions for protocols.
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.
21 * 07 17 2012 yuche.tsai
23 * Let netdev bring up.
25 * 07 17 2012 yuche.tsai
27 * Compile no error before trial run.
31 * Sync CFG80211 modification from branch 2,2.
35 * remove another assertion by error message dump
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.
41 * 11 19 2011 yuche.tsai
43 * Update RSSI for P2P.
45 * 11 18 2011 yuche.tsai
47 * CONFIG P2P support RSSI query, default turned off.
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.
54 * [WCXRP00001078] [MT6620 Wi-Fi][Driver] Adding the mediatek log improment support : XLOG
55 * modify the xlog related code.
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.
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.
65 * 11 08 2011 eddie.chen
66 * [WCXRP00001096] [MT6620 Wi-Fi][Driver/FW] Enhance the log function (xlog)
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.
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.
78 * [WCXRP00001036] [MT6620 Wi-Fi][Driver][FW] Adding the 802.11w code for MFP
79 * adding the 802.11w related function and define .
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.
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
90 * 07 28 2011 chinghwa.yu
91 * [WCXRP00000063] Update BCM CoEx design and settings
92 * Add BWCS cmd and event.
95 * [WCXRP00000876] [MT5931][Drver] Decide to retain according to currently availble RX counter and QUE_MGT used count
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.
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.
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.
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.
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.
119 * [WCXRP00000702] [MT5931][Driver] Modify initialization sequence for E1 ASIC
120 * add delay after whole-chip resetting for MT5931 E1 ASIC.
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.
126 * 04 12 2011 cm.chang
127 * [WCXRP00000634] [MT6620 Wi-Fi][Driver][FW] 2nd BSS will not support 40MHz bandwidth for concurrency
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.
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.
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.
143 * [WCXRP00000530] [MT6620 Wi-Fi] [Driver] skip doing p2pRunEventAAAComplete after send assoc response Tx Done
144 * enable the Anti_piracy check at driver .
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
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
157 * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
158 * rename the define to anti_pviracy.
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.
165 * [WCXRP00000506] [MT6620 Wi-Fi][Driver][FW] Add Security check related code
166 * Add security check code.
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.
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.
177 * [WCXRP00000434] [MT6620 Wi-Fi][Driver] Obsolete unused event packet handlers
178 * EVENT_ID_CONNECTION_STATUS has been obsoleted and no need to handle.
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.
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.
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
192 * 01 27 2011 tsaiyuan.hsu
193 * [WCXRP00000392] [MT6620 Wi-Fi][Driver] Add Roaming Support
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.
200 * 01 26 2011 cm.chang
201 * [WCXRP00000395] [MT6620 Wi-Fi][Driver][FW] Search STA_REC with additional net type index argument
204 * 01 24 2011 eddie.chen
205 * [WCXRP00000385] [MT6620 Wi-Fi][DRV] Add destination decision for forwarding packets
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.
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
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
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.
226 * 12 29 2010 eddie.chen
227 * [WCXRP00000322] Add WMM IE in beacon,
228 Add per station flow control when STA is in PS
230 * 1) PS flow control event
232 * 2) WMM IE in beacon, assoc resp, probe resp
234 * 12 15 2010 george.huang
235 * [WCXRP00000152] [MT6620 Wi-Fi] AP mode power saving function
236 * update beacon for NoA
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.
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.
250 * add a cmd to reset the p2p key
253 * [WCXRP00000124] [MT6620 Wi-Fi] [Driver] Support the dissolve P2P Group
254 * Add the code to support disconnect p2p group
257 * [WCXRP00000072] [MT6620 Wi-Fi][Driver] Fix TKIP Counter Measure EAPoL callback register issue
258 * fixed compilier error.
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.
265 * [WCXRP00000052] [MT6620 Wi-Fi][Driver] Eliminate Linux Compile Warning
266 * eliminate reference of CFG_RESPONSE_MAX_PKT_SIZE
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
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
278 * use static memory pool for storing IEs of scanning result.
280 * 09 07 2010 yuche.tsai
282 * Add a common buffer, store the IE of a P2P device in this common buffer.
284 * 09 03 2010 kevin.huang
286 * Refine #include sequence and solve recursive/nested #include issue
288 * 08 31 2010 kevin.huang
290 * Use LINK LIST operation to process SCAN result
294 * eliminate klockwork errors
296 * 08 20 2010 cm.chang
298 * Migrate RLM code to host from FW
300 * 08 20 2010 yuche.tsai
302 * When enable WiFi Direct function, check each packet to tell which interface to indicate.
304 * 08 05 2010 yuche.tsai
306 * Add P2P Device Discovery Function.
310 * surpress compilation warning.
312 * 08 03 2010 george.huang
314 * handle event for updating NOA parameters indicated from FW
316 * 08 02 2010 yuche.tsai
318 * Add support API for RX public action frame.
320 * 08 02 2010 jeffrey.chang
322 * 1) modify tx service thread to avoid busy looping
323 * 2) add spin lock declartion for linux build
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
331 * 07 26 2010 yuche.tsai
333 * Update Device Capability Bitmap & Group Capability Bitmap from 16 bits to 8 bits.
337 * .support the Wi-Fi RSN
341 * add AIS-FSM handling for beacon timeout event.
343 * 07 21 2010 yuche.tsai
345 * Add P2P Scan & Scan Result Parsing & Saving.
347 * 07 19 2010 cm.chang
349 * Set RLM parameters and enable CNM channel manager
353 * [WPD00003833] [MT6620 and MT5931] Driver migration.
354 * Add Ad-Hoc support to AIS-FSM
356 * 07 19 2010 jeffrey.chang
358 * Linux port modification
360 * 07 16 2010 yarco.yang
362 * 1. Support BSS Absence/Presence Event
363 * 2. Support STA change PS mode Event
364 * 3. Support BMC forwarding for AP mode.
368 * sync. bluetooth-over-Wi-Fi interface to driver interface document v0.2.6.
372 * [WPD00003833] [MT6620 and MT5931] Driver migration - move to new repository.
375 * [WPD00003833][MT6620 and MT5931] Driver migration
376 * fill ucStaRecIdx into SW_RFB_T.
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
385 * [WPD00003833][MT6620 and MT5931] Driver migration
386 * implementation of DRV-SCN and related mailbox message handling.
388 * 06 29 2010 yarco.yang
389 * [WPD00003837][MT6620]Data Path Refine
390 * replace g_rQM with Adpater->rQM
392 * 06 23 2010 yarco.yang
393 * [WPD00003837][MT6620]Data Path Refine
394 * Merge g_arStaRec[] into adapter->arStaRec[]
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.
403 * [WPD00003833][MT6620 and MT5931] Driver migration
404 * refine TX-DONE callback.
407 * [WPD00003833][MT6620 and MT5931] Driver migration
408 * implement TX_DONE callback path.
410 * 06 21 2010 yarco.yang
411 * [WPD00003837][MT6620]Data Path Refine
412 * Add TX Done Event handle entry
415 * [WPD00003840][MT6620 5931] Security migration
416 * remove duplicate variable for migration.
419 * [WPD00003833][MT6620 and MT5931] Driver migration
423 * [WPD00003833][MT6620 and MT5931] Driver migration
427 * [WPD00003833][MT6620 and MT5931] Driver migration
428 * saa_fsm.c is migrated.
431 * [WPD00003833][MT6620 and MT5931] Driver migration
432 * add management dispatching function table.
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
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)
448 * [WPD00003833][MT6620 and MT5931] Driver migration
449 * cnm_timer has been migrated.
452 * [WPD00003833][MT6620 and MT5931] Driver migration
456 * [WPD00003833][MT6620 and MT5931] Driver migration
457 * sync with MT6620 driver for scan result replacement policy
459 * 06 06 2010 kevin.huang
460 * [WPD00003832][MT6620 5931] Create driver base
461 * [MT6620 5931] Create driver base
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
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
477 * [WPD00003816][MT6620 Wi-Fi] Adding the security support
478 * fixing the PMKID candicate indicate code.
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
486 * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
487 * basic implementation for EVENT_BT_OVER_WIFI
490 * [WPD00001943]Create WiFi test driver framework on WinXP
491 * surpress compiler warning
493 * 04 22 2010 jeffrey.chang
494 * [WPD00003826]Initial import for Linux port
496 * 1) modify rx path code for supporting Wi-Fi direct
497 * 2) modify config.h since Linux dont need to consider retaining packet
500 * [WPD00001943]Create WiFi test driver framework on WinXP
501 * treat BUS access failure as kind of card removal.
504 * [WPD00003823][MT6620 Wi-Fi] Add Bluetooth-over-Wi-Fi support
505 * nicRxProcessEvent packet doesn't access spin-lock directly from now on.
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()
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
519 * [WPD00001943]Create WiFi test driver framework on WinXP
520 * add channel frequency <-> number conversion
522 * 04 09 2010 jeffrey.chang
523 * [WPD00003826]Initial import for Linux port
525 * 2) add KAPI for handling association info
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.
533 * [WPD00001943]Create WiFi test driver framework on WinXP
534 * eliminate direct access to prGlueInfo->eParamMediaStateIndicated from non-glue layer
537 * [WPD00001943]Create WiFi test driver framework on WinXP
538 * eliminate direct access for prGlueInfo->fgIsCardRemoved in non-glue layer
540 * 04 01 2010 jeffrey.chang
541 * [WPD00003826]Initial import for Linux port
542 * improve Linux supplicant compliance
544 * 03 31 2010 jeffrey.chang
545 * [WPD00003826]Initial import for Linux port
546 * fix ioctl which may cause cmdinfo memory leak
549 * [WPD00001943]Create WiFi test driver framework on WinXP
550 * remove driver-land statistics.
552 * 03 29 2010 jeffrey.chang
553 * [WPD00003826]Initial import for Linux port
554 * improve none-glue code portability
556 * 03 28 2010 jeffrey.chang
557 * [WPD00003826]Initial import for Linux port
558 * rWlanInfo is modified before data is indicated to OS
560 * 03 28 2010 jeffrey.chang
561 * [WPD00003826]Initial import for Linux port
562 * rWlanInfo is modified before data is indicated to OS
565 * [WPD00001943]Create WiFi test driver framework on WinXP
566 * add a temporary flag for integration with CMD/EVENT v0.9.
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
574 * 03 24 2010 jeffrey.chang
575 * [WPD00003826]Initial import for Linux port
576 * initial import for Linux port
579 * [WPD00001943]Create WiFi test driver framework on WinXP
583 * [WPD00001943]Create WiFi test driver framework on WinXP
584 * generate information for OID_GEN_RCV_OK & OID_GEN_XMIT_OK
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
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
597 * [WPD00001943]Create WiFi test driver framework on WinXP
598 * correct fgSetQuery/fgNeedResp check
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
605 * [WPD00001943]Create WiFi test driver framework on WinXP
606 * code clean: removing unused variables and structure definitions
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
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
619 * [WPD00001943]Create WiFi test driver framework on WinXP
620 * add mutex to avoid multiple access to qmTxQueue simultaneously.
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
628 * [WPD00001943]Create WiFi test driver framework on WinXP
629 * correct behavior to prevent duplicated RX handling for RX0_DONE and RX1_DONE
631 * 02 24 2010 tehuang.liu
632 * [WPD00001943]Create WiFi test driver framework on WinXP
633 * Updated API interfaces for qmHandleEventRxAddBa() and qmHandleEventRxDelBa()
636 * [WPD00001943]Create WiFi test driver framework on WinXP
637 * implement host-side firmware download logic
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
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
655 * [WPD00003816][MT6620 Wi-Fi] Adding the security support
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
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
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
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
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
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
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
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
792 /*******************************************************************************
793 * C O M P I L E R F L A G S
794 ********************************************************************************
797 /*******************************************************************************
798 * E X T E R N A L R E F E R E N C E S
799 ********************************************************************************
806 #include <linux/limits.h>
809 /*******************************************************************************
811 ********************************************************************************
813 #define RX_RESPONSE_TIMEOUT (1000)
815 /*******************************************************************************
817 ********************************************************************************
820 /*******************************************************************************
821 * P U B L I C D A T A
822 ********************************************************************************
825 /*******************************************************************************
826 * P R I V A T E D A T A
827 ********************************************************************************
830 #if CFG_MGMT_FRAME_HANDLING
831 static PROCESS_RX_MGT_FUNCTION apfnProcessRxMgtFrame[MAX_NUM_OF_FC_SUBTYPES] = {
833 aaaFsmRunEventRxAssoc, /* subtype 0000: Association request */
835 NULL, /* subtype 0000: Association request */
836 #endif /* CFG_SUPPORT_AAA */
837 saaFsmRunEventRxAssoc, /* subtype 0001: Association response */
839 aaaFsmRunEventRxAssoc, /* subtype 0010: Reassociation request */
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 */
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 */
864 /*******************************************************************************
866 ********************************************************************************
869 /*******************************************************************************
870 * F U N C T I O N D E C L A R A T I O N S
871 ********************************************************************************
874 /*******************************************************************************
876 ********************************************************************************
878 /*----------------------------------------------------------------------------*/
880 * @brief Initialize the RFBs
882 * @param prAdapter Pointer to the Adapter structure.
886 /*----------------------------------------------------------------------------*/
889 IN P_ADAPTER_T prAdapter
892 P_RX_CTRL_T prRxCtrl;
893 PUINT_8 pucMemHandle;
894 P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
897 DEBUGFUNC("nicRxInitialize");
900 prRxCtrl = &prAdapter->rRxCtrl;
902 //4 <0> Clear allocated memory.
903 kalMemZero((PVOID) prRxCtrl->pucRxCached, prRxCtrl->u4RxCachedSize);
905 //4 <1> Initialize the RFB lists
906 QUEUE_INITIALIZE(&prRxCtrl->rFreeSwRfbList);
907 QUEUE_INITIALIZE(&prRxCtrl->rReceivedRfbList);
908 QUEUE_INITIALIZE(&prRxCtrl->rIndicatedRfbList);
910 pucMemHandle = prRxCtrl->pucRxCached;
911 for (i = CFG_RX_MAX_PKT_NUM; i != 0; i--) {
912 prSwRfb = (P_SW_RFB_T)pucMemHandle;
914 nicRxSetupRFB(prAdapter, prSwRfb);
915 nicRxReturnRFB(prAdapter, prSwRfb);
917 pucMemHandle += ALIGN_4(sizeof(SW_RFB_T));
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);
924 //4 <2> Clear all RX counters
925 RX_RESET_ALL_CNTS(prRxCtrl);
928 prRxCtrl->pucRxCoalescingBufPtr = prAdapter->pucCoalescingBufCached;
930 HAL_CFG_MAX_HIF_RX_LEN_NUM(prAdapter, CFG_SDIO_MAX_RX_AGG_NUM);
934 HAL_CFG_MAX_HIF_RX_LEN_NUM(prAdapter, 1);
938 #if CFG_HIF_STATISTICS
939 prRxCtrl->u4TotalRxAccessNum = 0;
940 prRxCtrl->u4TotalRxPacketNum = 0;
943 #if CFG_HIF_RX_STARVATION_WARNING
944 prRxCtrl->u4QueuedCnt = 0;
945 prRxCtrl->u4DequeuedCnt = 0;
949 } /* end of nicRxInitialize() */
953 /*----------------------------------------------------------------------------*/
955 * @brief Initialize HIF RX control registers explicitly
957 * @param prAdapter Pointer to the Adapter structure.
961 /*----------------------------------------------------------------------------*/
963 nicRxPostInitialize (
964 IN P_ADAPTER_T prAdapter
967 P_RX_CTRL_T prRxCtrl;
968 DEBUGFUNC("nicRxPostInitialize");
971 prRxCtrl = &prAdapter->rRxCtrl;
974 HAL_CFG_MAX_HIF_RX_LEN_NUM(prAdapter, CFG_SDIO_MAX_RX_AGG_NUM);
976 HAL_CFG_MAX_HIF_RX_LEN_NUM(prAdapter, 1);
979 } /* end of nicRxPostInitialize() */
983 /*----------------------------------------------------------------------------*/
985 * @brief Uninitialize the RFBs
987 * @param prAdapter Pointer to the Adapter structure.
991 /*----------------------------------------------------------------------------*/
994 IN P_ADAPTER_T prAdapter
997 P_RX_CTRL_T prRxCtrl;
998 P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
999 KAL_SPIN_LOCK_DECLARATION();
1002 prRxCtrl = &prAdapter->rRxCtrl;
1005 nicRxFlush(prAdapter);
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);
1012 if (prSwRfb->pvPacket) {
1013 kalPacketFree(prAdapter->prGlueInfo, prSwRfb->pvPacket);
1015 prSwRfb->pvPacket = NULL;
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);
1027 if (prSwRfb->pvPacket) {
1028 kalPacketFree(prAdapter->prGlueInfo, prSwRfb->pvPacket);
1030 prSwRfb->pvPacket = NULL;
1038 } /* end of nicRxUninitialize() */
1041 /*----------------------------------------------------------------------------*/
1045 * @param prAdapter pointer to the Adapter handler
1046 * @param prSWRfb specify the RFB to receive rx data
1051 /*----------------------------------------------------------------------------*/
1054 IN P_ADAPTER_T prAdapter,
1055 IN OUT P_SW_RFB_T prSwRfb
1058 P_HIF_RX_HEADER_T prHifRxHdr;
1060 UINT_32 u4PktLen = 0;
1061 UINT_32 u4MacHeaderLen;
1062 UINT_32 u4HeaderOffset;
1064 DEBUGFUNC("nicRxFillRFB");
1069 prHifRxHdr = prSwRfb->prHifRxHdr;
1072 u4PktLen= prHifRxHdr->u2PacketLen;
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;
1078 //DBGLOG(RX, TRACE, ("u4HeaderOffset = %d, u4MacHeaderLen = %d\n",
1079 // u4HeaderOffset, u4MacHeaderLen));
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));
1085 //DBGLOG(RX, TRACE, ("Dump Rx packet, u2PacketLen = %d\n", prSwRfb->u2PacketLen));
1086 //DBGLOG_MEM8(RX, TRACE, prSwRfb->pvHeader, prSwRfb->u2PacketLen);
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"));
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"));
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"));
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));
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"));
1119 #if CFG_TCP_IP_CHKSUM_OFFLOAD || CFG_TCP_IP_CHKSUM_OFFLOAD_NDIS_60
1120 /*----------------------------------------------------------------------------*/
1122 * @brief Fill checksum status in RFB
1124 * @param prAdapter pointer to the Adapter handler
1125 * @param prSWRfb the RFB to receive rx data
1126 * @param u4TcpUdpIpCksStatus specify the Checksum status
1131 /*----------------------------------------------------------------------------*/
1133 nicRxFillChksumStatus(
1134 IN P_ADAPTER_T prAdapter,
1135 IN OUT P_SW_RFB_T prSwRfb,
1136 IN UINT_32 u4TcpUdpIpCksStatus
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;
1149 prSwRfb->aeCSUM[CSUM_TYPE_IPV4] = CSUM_RES_SUCCESS;
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;
1157 prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_SUCCESS;
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;
1165 prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_SUCCESS;
1169 prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_NONE;
1170 prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_NONE;
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;
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;
1182 prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_SUCCESS;
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;
1190 prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_SUCCESS;
1194 prSwRfb->aeCSUM[CSUM_TYPE_UDP] = CSUM_RES_NONE;
1195 prSwRfb->aeCSUM[CSUM_TYPE_TCP] = CSUM_RES_NONE;
1199 prSwRfb->aeCSUM[CSUM_TYPE_IPV4] = CSUM_RES_NONE;
1200 prSwRfb->aeCSUM[CSUM_TYPE_IPV6] = CSUM_RES_NONE;
1205 #endif /* CFG_TCP_IP_CHKSUM_OFFLOAD */
1208 /*----------------------------------------------------------------------------*/
1210 * @brief Process packet doesn't need to do buffer reordering
1212 * @param prAdapter pointer to the Adapter handler
1213 * @param prSWRfb the RFB to receive rx data
1218 /*----------------------------------------------------------------------------*/
1220 nicRxProcessPktWithoutReorder (
1221 IN P_ADAPTER_T prAdapter,
1222 IN P_SW_RFB_T prSwRfb
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;
1231 DEBUGFUNC("nicRxProcessPktWithoutReorder");
1232 //DBGLOG(RX, TRACE, ("\n"));
1237 prRxCtrl = &prAdapter->rRxCtrl;
1240 prTxCtrl = &prAdapter->rTxCtrl;
1243 u4CurrentRxBufferCount = prRxCtrl->rFreeSwRfbList.u4NumElem;
1244 /* QM USED = $A, AVAILABLE COUNT = $B, INDICATED TO OS = $C
1245 * TOTAL = $A + $B + $C
1248 * -------------------------------------------------------
1249 * $A + $B < THRESHOLD := $A + $B + $C < THRESHOLD + $C := $TOTAL - THRESHOLD < $C
1250 * => $C used too much, retain
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
1258 fgIsRetained = (((u4CurrentRxBufferCount +
1259 qmGetRxReorderQueuedBufferCount(prAdapter) +
1260 prTxCtrl->i4PendingFwdFrameCount) < CFG_RX_RETAINED_PKT_THRESHOLD) ?
1263 //DBGLOG(RX, INFO, ("fgIsRetained = %d\n", fgIsRetained));
1265 if (kalProcessRxPacket(prAdapter->prGlueInfo,
1268 (UINT_32)prSwRfb->u2PacketLen,
1270 prSwRfb->aeCSUM) != WLAN_STATUS_SUCCESS) {
1271 DBGLOG(RX, ERROR, ("kalProcessRxPacket return value != WLAN_STATUS_SUCCESS\n"));
1274 nicRxReturnRFB(prAdapter, prSwRfb);
1278 prStaRec = cnmGetStaRecByIndex(prAdapter, prSwRfb->ucStaRecIdx);
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);
1287 #if CFG_ENABLE_BT_OVER_WIFI
1288 if (prStaRec->ucNetTypeIndex == NETWORK_TYPE_BOW_INDEX) {
1289 GLUE_SET_PKT_FLAG_PAL(prSwRfb->pvPacket);
1293 prRxCtrl->apvIndPacket[prRxCtrl->ucNumIndPacket] = prSwRfb->pvPacket;
1294 prRxCtrl->ucNumIndPacket++;
1298 prRxCtrl->apvRetainedPacket[prRxCtrl->ucNumRetainedPacket] = prSwRfb->pvPacket;
1299 prRxCtrl->ucNumRetainedPacket++;
1300 /* TODO : error handling of nicRxSetupRFB */
1301 nicRxSetupRFB(prAdapter, prSwRfb);
1302 nicRxReturnRFB(prAdapter, prSwRfb);
1305 prSwRfb->pvPacket = NULL;
1306 nicRxReturnRFB(prAdapter, prSwRfb);
1311 /*----------------------------------------------------------------------------*/
1313 * @brief Process forwarding data packet
1315 * @param prAdapter pointer to the Adapter handler
1316 * @param prSWRfb the RFB to receive rx data
1321 /*----------------------------------------------------------------------------*/
1323 nicRxProcessForwardPkt (
1324 IN P_ADAPTER_T prAdapter,
1325 IN P_SW_RFB_T prSwRfb
1328 P_MSDU_INFO_T prMsduInfo, prRetMsduInfoList;
1329 P_TX_CTRL_T prTxCtrl;
1330 P_RX_CTRL_T prRxCtrl;
1331 KAL_SPIN_LOCK_DECLARATION();
1333 DEBUGFUNC("nicRxProcessForwardPkt");
1338 prTxCtrl = &prAdapter->rTxCtrl;
1339 prRxCtrl = &prAdapter->rRxCtrl;
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);
1345 if(prMsduInfo && kalProcessRxPacket(prAdapter->prGlueInfo,
1348 (UINT_32)prSwRfb->u2PacketLen,
1349 prRxCtrl->rFreeSwRfbList.u4NumElem < CFG_RX_RETAINED_PKT_THRESHOLD ? TRUE : FALSE,
1350 prSwRfb->aeCSUM) == WLAN_STATUS_SUCCESS) {
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);
1358 // release RX buffer (to rIndicatedRfbList)
1359 prSwRfb->pvPacket = NULL;
1360 nicRxReturnRFB(prAdapter, prSwRfb);
1362 // increase forward frame counter
1363 GLUE_INC_REF_CNT(prTxCtrl->i4PendingFwdFrameCount);
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);
1370 if(prRetMsduInfoList != NULL) { // TX queue refuses queuing the packet
1371 nicTxFreeMsduInfoPacket(prAdapter, prRetMsduInfoList);
1372 nicTxReturnMsduInfo(prAdapter, prRetMsduInfoList);
1374 /* indicate service thread for sending */
1375 if(prTxCtrl->i4PendingFwdFrameCount > 0) {
1376 kalSetEvent(prAdapter->prGlueInfo);
1379 else { // no TX resource
1380 nicRxReturnRFB(prAdapter, prSwRfb);
1387 /*----------------------------------------------------------------------------*/
1389 * @brief Process broadcast data packet for both host and forwarding
1391 * @param prAdapter pointer to the Adapter handler
1392 * @param prSWRfb the RFB to receive rx data
1397 /*----------------------------------------------------------------------------*/
1399 nicRxProcessGOBroadcastPkt (
1400 IN P_ADAPTER_T prAdapter,
1401 IN P_SW_RFB_T prSwRfb
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;
1409 KAL_SPIN_LOCK_DECLARATION();
1411 DEBUGFUNC("nicRxProcessGOBroadcastPkt");
1416 prTxCtrl = &prAdapter->rTxCtrl;
1417 prRxCtrl = &prAdapter->rRxCtrl;
1419 prHifRxHdr = prSwRfb->prHifRxHdr;
1422 ASSERT(CFG_NUM_OF_QM_RX_PKT_NUM >= 16);
1424 if( prRxCtrl->rFreeSwRfbList.u4NumElem
1425 >= (CFG_RX_MAX_PKT_NUM - (CFG_NUM_OF_QM_RX_PKT_NUM - 16 /* Reserved for others */) ) ) {
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);
1432 if(prSwRfbDuplicated){
1433 kalMemCopy(prSwRfbDuplicated->pucRecvBuff,
1434 prSwRfb->pucRecvBuff,
1435 ALIGN_4(prHifRxHdr->u2PacketLen + HIF_RX_HW_APPENDED_LEN));
1437 prSwRfbDuplicated->ucPacketType = HIF_RX_PKT_TYPE_DATA;
1438 prSwRfbDuplicated->ucStaRecIdx = (UINT_8)(prHifRxHdr->ucStaRecIdx);
1439 nicRxFillRFB(prAdapter, prSwRfbDuplicated);
1441 /* 2. Modify eDst */
1442 prSwRfbDuplicated->eDst = RX_PKT_DESTINATION_FORWARD;
1445 nicRxProcessForwardPkt(prAdapter, prSwRfbDuplicated);
1449 DBGLOG(RX, WARN, ("Stop to forward BMC packet due to less free Sw Rfb %u\n", prRxCtrl->rFreeSwRfbList.u4NumElem));
1452 /* 3. Indicate to host */
1453 prSwRfb->eDst = RX_PKT_DESTINATION_HOST;
1454 nicRxProcessPktWithoutReorder(prAdapter, prSwRfb);
1460 /*----------------------------------------------------------------------------*/
1462 * @brief Process HIF data packet
1464 * @param prAdapter pointer to the Adapter handler
1465 * @param prSWRfb the RFB to receive rx data
1470 /*----------------------------------------------------------------------------*/
1472 nicRxProcessDataPacket (
1473 IN P_ADAPTER_T prAdapter,
1474 IN OUT P_SW_RFB_T prSwRfb
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;
1482 DEBUGFUNC("nicRxProcessDataPacket");
1483 //DBGLOG(INIT, TRACE, ("\n"));
1488 prHifRxHdr = prSwRfb->prHifRxHdr;
1489 prRxCtrl = &prAdapter->rRxCtrl;
1491 nicRxFillRFB(prAdapter, prSwRfb);
1493 #if 1 /* Check 1x Pkt */
1494 if (prSwRfb->u2PacketLen > 14) {
1495 PUINT_8 pc = (PUINT_8)prSwRfb->pvHeader;
1496 UINT_16 u2Etype = 0;
1498 u2Etype = (pc[ETH_TYPE_LEN_OFFSET] << 8) | (pc[ETH_TYPE_LEN_OFFSET + 1]);
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));
1505 if (u2Etype == ETH_P_1X) {
1506 DBGLOG(RSN, INFO, ("R1X len=%d\n", prSwRfb->u2PacketLen));
1509 else if (u2Etype == ETH_P_PRE_1X) {
1510 DBGLOG(RSN, INFO, ("Pre R1X len=%d\n", prSwRfb->u2PacketLen));
1515 #if CFG_TCP_IP_CHKSUM_OFFLOAD || CFG_TCP_IP_CHKSUM_OFFLOAD_NDIS_60
1517 UINT_32 u4TcpUdpIpCksStatus;
1519 u4TcpUdpIpCksStatus = *((PUINT_32)((UINT_32)prHifRxHdr +
1520 (UINT_32)(ALIGN_4(prHifRxHdr->u2PacketLen))));
1521 nicRxFillChksumStatus(prAdapter, prSwRfb, u4TcpUdpIpCksStatus);
1524 #endif /* CFG_TCP_IP_CHKSUM_OFFLOAD */
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++;
1533 if((prRetSwRfb = qmHandleRxPackets(prAdapter, prSwRfb)) != NULL) {
1536 prNextSwRfb = (P_SW_RFB_T)QUEUE_GET_NEXT_ENTRY((P_QUE_ENTRY_T)prRetSwRfb);
1538 switch(prRetSwRfb->eDst) {
1539 case RX_PKT_DESTINATION_HOST:
1540 nicRxProcessPktWithoutReorder(prAdapter, prRetSwRfb);
1543 case RX_PKT_DESTINATION_FORWARD:
1544 nicRxProcessForwardPkt(prAdapter, prRetSwRfb);
1547 case RX_PKT_DESTINATION_HOST_WITH_FORWARD:
1548 nicRxProcessGOBroadcastPkt(prAdapter, prRetSwRfb);
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);
1560 #if CFG_HIF_RX_STARVATION_WARNING
1561 prRxCtrl->u4DequeuedCnt++;
1563 prRetSwRfb = prNextSwRfb;
1564 } while(prRetSwRfb);
1568 nicRxReturnRFB(prAdapter, prSwRfb);
1569 RX_INC_CNT(prRxCtrl, RX_CLASS_ERR_DROP_COUNT);
1570 RX_INC_CNT(prRxCtrl, RX_DROP_TOTAL_COUNT);
1575 /*----------------------------------------------------------------------------*/
1577 * @brief Process HIF event packet
1579 * @param prAdapter pointer to the Adapter handler
1580 * @param prSWRfb the RFB to receive rx data
1585 /*----------------------------------------------------------------------------*/
1587 nicRxProcessEventPacket (
1588 IN P_ADAPTER_T prAdapter,
1589 IN OUT P_SW_RFB_T prSwRfb
1592 P_CMD_INFO_T prCmdInfo;
1593 P_MSDU_INFO_T prMsduInfo;
1594 P_WIFI_EVENT_T prEvent;
1595 P_GLUE_INFO_T prGlueInfo;
1597 DEBUGFUNC("nicRxProcessEventPacket");
1598 //DBGLOG(INIT, TRACE, ("\n"));
1603 prEvent = (P_WIFI_EVENT_T) prSwRfb->pucRecvBuff;
1604 prGlueInfo = prAdapter->prGlueInfo;
1607 switch(prEvent->ucEID) {
1608 case EVENT_ID_CMD_RESULT:
1609 prCmdInfo = nicGetPendingCmdInfo(prAdapter, prEvent->ucSeqNum);
1611 if(prCmdInfo != NULL) {
1612 P_EVENT_CMD_RESULT prCmdResult;
1613 prCmdResult = (P_EVENT_CMD_RESULT) ((PUINT_8)prEvent + EVENT_HDR_SIZE);
1615 /* CMD_RESULT should be only in response to Set commands */
1616 ASSERT(prCmdInfo->fgSetQuery == FALSE || prCmdInfo->fgNeedResp == TRUE);
1618 if(prCmdResult->ucStatus == 0) { // success
1619 if(prCmdInfo->pfCmdDoneHandler) {
1620 prCmdInfo->pfCmdDoneHandler(prAdapter, prCmdInfo, prEvent->aucBuffer);
1622 else if(prCmdInfo->fgIsOid == TRUE) {
1623 kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_SUCCESS);
1626 else if(prCmdResult->ucStatus == 1) { // reject
1627 if(prCmdInfo->fgIsOid == TRUE)
1628 kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_FAILURE);
1630 else if(prCmdResult->ucStatus == 2) { // unknown CMD
1631 if(prCmdInfo->fgIsOid == TRUE)
1632 kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_NOT_SUPPORTED);
1636 cmdBufFreeCmdInfo(prAdapter, prCmdInfo);
1642 case EVENT_ID_CONNECTION_STATUS:
1645 P_EVENT_CONNECTION_STATUS prConnectionStatus;
1646 prConnectionStatus = (P_EVENT_CONNECTION_STATUS) (prEvent->aucBuffer);
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) {
1652 kalIndicateStatusAndComplete(prGlueInfo,
1653 WLAN_STATUS_MEDIA_DISCONNECT,
1657 prAdapter->rWlanInfo.u4SysTime = kalGetTimeTick();
1660 else if(prConnectionStatus->ucMediaStatus == PARAM_MEDIA_STATE_CONNECTED) { // connected
1661 prAdapter->rWlanInfo.u4SysTime = kalGetTimeTick();
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);
1670 kalMemCopy(prAdapter->rWlanInfo.rCurrBssId.arMacAddress,
1671 prConnectionStatus->aucBssid,
1674 prAdapter->rWlanInfo.rCurrBssId.u4Privacy
1675 = prConnectionStatus->ucEncryptStatus; // @FIXME
1676 prAdapter->rWlanInfo.rCurrBssId.rRssi
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;
1689 switch(prConnectionStatus->ucInfraMode) {
1691 prAdapter->rWlanInfo.rCurrBssId.eOpMode = NET_TYPE_IBSS;
1694 prAdapter->rWlanInfo.rCurrBssId.eOpMode = NET_TYPE_INFRA;
1698 prAdapter->rWlanInfo.rCurrBssId.eOpMode = NET_TYPE_AUTO_SWITCH;
1701 // always indicate to OS according to MSDN (re-association/roaming)
1702 kalIndicateStatusAndComplete(prGlueInfo,
1703 WLAN_STATUS_MEDIA_CONNECT,
1710 case EVENT_ID_SCAN_RESULT:
1715 case EVENT_ID_RX_ADDBA:
1716 /* The FW indicates that an RX BA agreement will be established */
1717 qmHandleEventRxAddBa(prAdapter, prEvent);
1720 case EVENT_ID_RX_DELBA:
1721 /* The FW indicates that an RX BA agreement has been deleted */
1722 qmHandleEventRxDelBa(prAdapter, prEvent);
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);
1730 if (prLqEx->ucIsLQ0Rdy) {
1731 nicUpdateLinkQuality(prAdapter, NETWORK_TYPE_AIS_INDEX, (P_EVENT_LINK_QUALITY)prLqEx);
1733 if (prLqEx->ucIsLQ1Rdy) {
1734 nicUpdateLinkQuality(prAdapter, NETWORK_TYPE_P2P_INDEX, (P_EVENT_LINK_QUALITY)prLqEx);
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"));
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));
1745 nicUpdateLinkQuality(prAdapter, NETWORK_TYPE_AIS_INDEX, (P_EVENT_LINK_QUALITY)(prEvent->aucBuffer));
1748 /* command response handling */
1749 prCmdInfo = nicGetPendingCmdInfo(prAdapter, prEvent->ucSeqNum);
1751 if(prCmdInfo != NULL) {
1752 if (prCmdInfo->pfCmdDoneHandler) {
1753 prCmdInfo->pfCmdDoneHandler(prAdapter, prCmdInfo, prEvent->aucBuffer);
1755 else if(prCmdInfo->fgIsOid) {
1756 kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_SUCCESS);
1760 cmdBufFreeCmdInfo(prAdapter, prCmdInfo);
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;
1768 kalIndicateStatusAndComplete(prGlueInfo,
1769 WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
1770 (PVOID) &(prAdapter->rWlanInfo.rRssiTriggerValue), sizeof(PARAM_RSSI));
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;
1776 kalIndicateStatusAndComplete(prGlueInfo,
1777 WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
1778 (PVOID) &(prAdapter->rWlanInfo.rRssiTriggerValue), sizeof(PARAM_RSSI));
1784 case EVENT_ID_MIC_ERR_INFO:
1786 P_EVENT_MIC_ERR_INFO prMicError;
1787 //P_PARAM_AUTH_EVENT_T prAuthEvent;
1788 P_STA_RECORD_T prStaRec;
1790 DBGLOG(RSN, EVENT, ("EVENT_ID_MIC_ERR_INFO\n"));
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);
1799 rsnTkipHandleMICFailure(prAdapter, prStaRec, (BOOLEAN)prMicError->u4Flags);
1802 DBGLOG(RSN, INFO, ("No STA rec!!\n"));
1805 prAuthEvent = (P_PARAM_AUTH_EVENT_T)prAdapter->aucIndicationEventBuffer;
1807 /* Status type: Authentication Event */
1808 prAuthEvent->rStatus.eStatusType = ENUM_STATUS_TYPE_AUTHENTICATION;
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);
1816 if (prMicError->u4Flags != 0) {
1817 prAuthEvent->arRequest[0].u4Flags = PARAM_AUTH_REQUEST_GROUP_ERROR;
1820 prAuthEvent->arRequest[0].u4Flags = PARAM_AUTH_REQUEST_PAIRWISE_ERROR;
1823 kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
1824 WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
1826 sizeof(PARAM_STATUS_INDICATION_T) + sizeof(PARAM_AUTH_REQUEST_T));
1831 case EVENT_ID_ASSOC_INFO:
1833 P_EVENT_ASSOC_INFO prAssocInfo;
1834 prAssocInfo = (P_EVENT_ASSOC_INFO)(prEvent->aucBuffer);
1836 kalHandleAssocInfo(prAdapter->prGlueInfo, prAssocInfo);
1840 case EVENT_ID_802_11_PMKID:
1842 P_PARAM_AUTH_EVENT_T prAuthEvent;
1844 UINT_32 u4LenOfUsedBuffer;
1846 prAuthEvent = (P_PARAM_AUTH_EVENT_T)prAdapter->aucIndicationEventBuffer;
1848 prAuthEvent->rStatus.eStatusType = ENUM_STATUS_TYPE_CANDIDATE_LIST;
1850 u4LenOfUsedBuffer = (UINT_32)(prEvent->u2PacketLen - 8);
1852 prAuthEvent->arRequest[0].u4Length = u4LenOfUsedBuffer;
1854 cp = (PUINT_8)&prAuthEvent->arRequest[0];
1856 /* Status type: PMKID Candidatelist Event */
1857 kalMemCopy(cp, (P_EVENT_PMKID_CANDIDATE_LIST_T)(prEvent->aucBuffer), prEvent->u2PacketLen - 8);
1859 kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
1860 WLAN_STATUS_MEDIA_SPECIFIC_INDICATION,
1862 sizeof(PARAM_STATUS_INDICATION_T) + u4LenOfUsedBuffer);
1867 case EVENT_ID_ACTIVATE_STA_REC_T:
1869 P_EVENT_ACTIVATE_STA_REC_T prActivateStaRec;
1870 prActivateStaRec = (P_EVENT_ACTIVATE_STA_REC_T)(prEvent->aucBuffer);
1872 DbgPrint("RX EVENT: EVENT_ID_ACTIVATE_STA_REC_T Index:%d, MAC:["MACSTR"]\n",
1873 prActivateStaRec->ucStaRecIdx,
1874 MAC2STR(prActivateStaRec->aucMacAddr));
1876 qmActivateStaRec(prAdapter,
1877 (UINT_32)prActivateStaRec->ucStaRecIdx,
1878 ((prActivateStaRec->fgIsQoS) ? TRUE: FALSE),
1879 prActivateStaRec->ucNetworkTypeIndex,
1880 ((prActivateStaRec->fgIsAP) ? TRUE: FALSE),
1881 prActivateStaRec->aucMacAddr);
1886 case EVENT_ID_DEACTIVATE_STA_REC_T:
1888 P_EVENT_DEACTIVATE_STA_REC_T prDeactivateStaRec;
1889 prDeactivateStaRec = (P_EVENT_DEACTIVATE_STA_REC_T)(prEvent->aucBuffer);
1891 DbgPrint("RX EVENT: EVENT_ID_DEACTIVATE_STA_REC_T Index:%d, MAC:["MACSTR"]\n",
1892 prDeactivateStaRec->ucStaRecIdx);
1894 qmDeactivateStaRec(prAdapter,
1895 prDeactivateStaRec->ucStaRecIdx);
1900 case EVENT_ID_SCAN_DONE:
1901 scnEventScanDone(prAdapter, (P_EVENT_SCAN_DONE)(prEvent->aucBuffer));
1904 case EVENT_ID_TX_DONE:
1906 P_EVENT_TX_DONE_T prTxDone;
1907 prTxDone = (P_EVENT_TX_DONE_T)(prEvent->aucBuffer);
1909 DBGLOG(INIT, TRACE,("EVENT_ID_TX_DONE PacketSeq:%u ucStatus: %u SN: %u\n",
1910 prTxDone->ucPacketSeq, prTxDone->ucStatus, prTxDone->u2SequenceNumber));
1912 /* call related TX Done Handler */
1913 prMsduInfo = nicGetPendingTxMsduInfo(prAdapter, prTxDone->ucPacketSeq);
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));
1919 wnmReportTimingMeas(prAdapter, prMsduInfo->ucStaRecIndex,
1920 prTxDone->au4Reserved1, prTxDone->au4Reserved1 + prTxDone->au4Reserved2);
1924 prMsduInfo->pfTxDoneHandler(prAdapter, prMsduInfo, (ENUM_TX_RESULT_CODE_T)(prTxDone->ucStatus));
1926 cnmMgtPktFree(prAdapter, prMsduInfo);
1931 case EVENT_ID_SLEEPY_NOTIFY:
1933 P_EVENT_SLEEPY_NOTIFY prEventSleepyNotify;
1934 prEventSleepyNotify = (P_EVENT_SLEEPY_NOTIFY)(prEvent->aucBuffer);
1936 //DBGLOG(RX, INFO, ("ucSleepyState = %d\n", prEventSleepyNotify->ucSleepyState));
1938 prAdapter->fgWiFiInSleepyState = (BOOLEAN)(prEventSleepyNotify->ucSleepyState);
1941 case EVENT_ID_BT_OVER_WIFI:
1942 #if CFG_ENABLE_BT_OVER_WIFI
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;
1950 prEventBtOverWifi = (P_EVENT_BT_OVER_WIFI)(prEvent->aucBuffer);
1952 // construct event header
1953 prBowEvent = (P_AMPC_EVENT)aucTmp;
1955 if(prEventBtOverWifi->ucLinkStatus == 0) {
1957 prBowEvent->rHeader.ucEventId = BOW_EVENT_ID_LINK_CONNECTED;
1958 prBowEvent->rHeader.ucSeqNumber = 0;
1959 prBowEvent->rHeader.u2PayloadLength = sizeof(BOW_LINK_CONNECTED);
1962 prBowLinkConnected = (P_BOW_LINK_CONNECTED)(prBowEvent->aucPayload);
1963 prBowLinkConnected->rChannel.ucChannelNum = prEventBtOverWifi->ucSelectedChannel;
1964 kalMemZero(prBowLinkConnected->aucPeerAddress, MAC_ADDR_LEN); //@FIXME
1966 kalIndicateBOWEvent(prAdapter->prGlueInfo, prBowEvent);
1970 prBowEvent->rHeader.ucEventId = BOW_EVENT_ID_LINK_DISCONNECTED;
1971 prBowEvent->rHeader.ucSeqNumber = 0;
1972 prBowEvent->rHeader.u2PayloadLength = sizeof(BOW_LINK_DISCONNECTED);
1975 prBowLinkDisconnected = (P_BOW_LINK_DISCONNECTED)(prBowEvent->aucPayload);
1976 prBowLinkDisconnected->ucReason = 0; //@FIXME
1977 kalMemZero(prBowLinkDisconnected->aucPeerAddress, MAC_ADDR_LEN); //@FIXME
1979 kalIndicateBOWEvent(prAdapter->prGlueInfo, prBowEvent);
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));
1990 /* command response handling */
1991 prCmdInfo = nicGetPendingCmdInfo(prAdapter, prEvent->ucSeqNum);
1993 if(prCmdInfo != NULL) {
1994 if (prCmdInfo->pfCmdDoneHandler) {
1995 prCmdInfo->pfCmdDoneHandler(prAdapter, prCmdInfo, prEvent->aucBuffer);
1997 else if(prCmdInfo->fgIsOid) {
1998 kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_SUCCESS);
2002 cmdBufFreeCmdInfo(prAdapter, prCmdInfo);
2007 case EVENT_ID_CH_PRIVILEGE:
2008 cnmChMngrHandleChEvent(prAdapter, prEvent);
2011 case EVENT_ID_BSS_ABSENCE_PRESENCE:
2012 qmHandleEventBssAbsencePresence(prAdapter, prEvent);
2015 case EVENT_ID_STA_CHANGE_PS_MODE:
2016 qmHandleEventStaChangePsMode(prAdapter, prEvent);
2018 #if CFG_ENABLE_WIFI_DIRECT
2019 case EVENT_ID_STA_UPDATE_FREE_QUOTA:
2020 qmHandleEventStaUpdateFreeQuota(prAdapter, prEvent);
2023 case EVENT_ID_BSS_BEACON_TIMEOUT:
2024 DBGLOG(INIT, INFO,("EVENT_ID_BSS_BEACON_TIMEOUT\n"));
2026 if (prAdapter->fgDisBcnLostDetection == FALSE) {
2027 P_EVENT_BSS_BEACON_TIMEOUT_T prEventBssBeaconTimeout;
2028 prEventBssBeaconTimeout = (P_EVENT_BSS_BEACON_TIMEOUT_T)(prEvent->aucBuffer);
2030 if(prEventBssBeaconTimeout->ucNetTypeIndex == NETWORK_TYPE_AIS_INDEX) {
2031 aisBssBeaconTimeout(prAdapter);
2033 #if CFG_ENABLE_WIFI_DIRECT
2034 else if((prAdapter->fgIsP2PRegistered) &&
2035 (prEventBssBeaconTimeout->ucNetTypeIndex == NETWORK_TYPE_P2P_INDEX)) {
2037 p2pFsmRunEventBeaconTimeout(prAdapter);
2040 #if CFG_ENABLE_BT_OVER_WIFI
2041 else if(prEventBssBeaconTimeout->ucNetTypeIndex == NETWORK_TYPE_BOW_INDEX) {
2045 DBGLOG(RX, ERROR, ("EVENT_ID_BSS_BEACON_TIMEOUT: (ucNetTypeIdx = %d)\n",
2046 prEventBssBeaconTimeout->ucNetTypeIndex));
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);
2057 if (prEventUpdateNoaParam->ucNetTypeIndex == NETWORK_TYPE_P2P_INDEX) {
2058 p2pProcessEvent_UpdateNOAParam(prAdapter,
2059 prEventUpdateNoaParam->ucNetTypeIndex,
2060 prEventUpdateNoaParam);
2070 case EVENT_ID_STA_AGING_TIMEOUT:
2071 #if CFG_ENABLE_WIFI_DIRECT
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;
2078 prEventStaAgingTimeout = (P_EVENT_STA_AGING_TIMEOUT_T)(prEvent->aucBuffer);
2079 prStaRec = cnmGetStaRecByIndex(prAdapter, prEventStaAgingTimeout->ucStaRecIdx);
2080 if (prStaRec == NULL) {
2084 DBGLOG(INIT, INFO,("EVENT_ID_STA_AGING_TIMEOUT %u " MACSTR "\n",
2085 prEventStaAgingTimeout->ucStaRecIdx, MAC2STR(prStaRec->aucMacAddr)));
2087 prBssInfo = &(prAdapter->rWifiVar.arBssInfo[prStaRec->ucNetTypeIndex]);
2089 bssRemoveStaRecFromClientList(prAdapter, prBssInfo, prStaRec);
2091 /* Call False Auth */
2092 if (prAdapter->fgIsP2PRegistered) {
2093 p2pFuncDisconnect(prAdapter, prStaRec, TRUE, REASON_CODE_DISASSOC_INACTIVITY);
2097 } /* gDisStaAgingTimeoutDetection */
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);
2111 case EVENT_ID_ROAMING_STATUS:
2112 #if CFG_SUPPORT_ROAMING
2114 P_ROAMING_PARAM_T prParam;
2116 prParam = (P_ROAMING_PARAM_T)(prEvent->aucBuffer);
2117 roamingFsmProcessEvent(prAdapter, prParam);
2119 #endif /* CFG_SUPPORT_ROAMING */
2121 case EVENT_ID_SEND_DEAUTH:
2124 P_WLAN_MAC_HEADER_T prWlanMacHeader;
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)));
2131 /* receive packets without StaRec */
2132 prSwRfb->pvHeader = (P_WLAN_MAC_HEADER_T)&prEvent->aucBuffer[0];
2133 if (WLAN_STATUS_SUCCESS == authSendDeauthFrame(prAdapter,
2136 REASON_CODE_CLASS_3_ERR,
2137 (PFN_TX_DONE_HANDLER)NULL)) {
2138 DBGLOG(RX, INFO, ("Send Deauth Error\n"));
2142 #if CFG_SUPPORT_RDD_TEST_MODE
2143 case EVENT_ID_UPDATE_RDD_STATUS:
2145 P_EVENT_RDD_STATUS_T prEventRddStatus;
2147 prEventRddStatus = (P_EVENT_RDD_STATUS_T) (prEvent->aucBuffer);
2149 prAdapter->ucRddStatus = prEventRddStatus->ucRddStatus;
2155 #if CFG_SUPPORT_BCM && CFG_SUPPORT_BCM_BWCS
2156 case EVENT_ID_UPDATE_BWCS_STATUS:
2158 P_PTA_IPC_T prEventBwcsStatus;
2160 prEventBwcsStatus = (P_PTA_IPC_T) (prEvent->aucBuffer);
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]);
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]);
2175 kalIndicateStatusAndComplete(prAdapter->prGlueInfo,
2176 WLAN_STATUS_BWCS_UPDATE,
2177 (PVOID) prEventBwcsStatus,
2183 case EVENT_ID_UPDATE_BCM_DEBUG:
2185 P_PTA_IPC_T prEventBwcsStatus;
2187 prEventBwcsStatus = (P_PTA_IPC_T) (prEvent->aucBuffer);
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]);
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]);
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:
2213 prCmdInfo = nicGetPendingCmdInfo(prAdapter, prEvent->ucSeqNum);
2215 if(prCmdInfo != NULL) {
2216 if (prCmdInfo->pfCmdDoneHandler) {
2217 prCmdInfo->pfCmdDoneHandler(prAdapter, prCmdInfo, prEvent->aucBuffer);
2219 else if(prCmdInfo->fgIsOid) {
2220 kalOidComplete(prAdapter->prGlueInfo, prCmdInfo->fgSetQuery, 0, WLAN_STATUS_SUCCESS);
2224 cmdBufFreeCmdInfo(prAdapter, prCmdInfo);
2230 nicRxReturnRFB(prAdapter, prSwRfb);
2234 /*----------------------------------------------------------------------------*/
2236 * @brief nicRxProcessMgmtPacket is used to dispatch management frames
2237 * to corresponding modules
2239 * @param prAdapter Pointer to the Adapter structure.
2240 * @param prSWRfb the RFB to receive rx data
2244 /*----------------------------------------------------------------------------*/
2246 nicRxProcessMgmtPacket (
2247 IN P_ADAPTER_T prAdapter,
2248 IN OUT P_SW_RFB_T prSwRfb
2252 #if CFG_SUPPORT_802_11W
2253 BOOL fgMfgDrop = FALSE;
2258 nicRxFillRFB(prAdapter, prSwRfb);
2260 ucSubtype = (*(PUINT_8)(prSwRfb->pvHeader) & MASK_FC_SUBTYPE )>> OFFSET_OF_FC_SUBTYPE;
2262 #if CFG_RX_PKTS_DUMP
2264 P_HIF_RX_HEADER_T prHifRxHdr;
2265 UINT_16 u2TxFrameCtrl;
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) {
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,
2277 HIF_RX_HDR_GET_SN(prHifRxHdr), /* The new SN of the frame */
2278 prSwRfb->ucPacketType,
2280 HIF_RX_HDR_GET_80211_FLAG(prHifRxHdr)));
2282 DBGLOG_MEM8(SW4, TRACE, (PUINT_8)prSwRfb->pvHeader, prSwRfb->u2PacketLen);
2288 if(prAdapter->fgTestMode == FALSE) {
2289 #if CFG_MGMT_FRAME_HANDLING
2290 #if CFG_SUPPORT_802_11W
2291 fgMfgDrop = rsnCheckRxMgmt(prAdapter, prSwRfb, ucSubtype);
2294 LOG_FUNC("QM RX MGT: Drop Unprotected Mgmt frame!!!\n");
2296 nicRxReturnRFB(prAdapter, prSwRfb);
2297 RX_INC_CNT(prRxCtrl, RX_DROP_TOTAL_COUNT);
2302 if(apfnProcessRxMgtFrame[ucSubtype]) {
2303 switch(apfnProcessRxMgtFrame[ucSubtype](prAdapter, prSwRfb)){
2304 case WLAN_STATUS_PENDING:
2306 case WLAN_STATUS_SUCCESS:
2307 case WLAN_STATUS_FAILURE:
2311 DBGLOG(RX, WARN, ("Unexpected MMPDU(0x%02X) returned with abnormal status\n", ucSubtype));
2318 nicRxReturnRFB(prAdapter, prSwRfb);
2321 /*----------------------------------------------------------------------------*/
2323 * @brief nicProcessRFBs is used to process RFBs in the rReceivedRFBList queue.
2325 * @param prAdapter Pointer to the Adapter structure.
2329 /*----------------------------------------------------------------------------*/
2332 IN P_ADAPTER_T prAdapter
2335 P_RX_CTRL_T prRxCtrl;
2336 P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
2337 KAL_SPIN_LOCK_DECLARATION();
2339 DEBUGFUNC("nicRxProcessRFBs");
2343 prRxCtrl = &prAdapter->rRxCtrl;
2346 prRxCtrl->ucNumIndPacket = 0;
2347 prRxCtrl->ucNumRetainedPacket = 0;
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);
2355 switch(prSwRfb->ucPacketType){
2356 case HIF_RX_PKT_TYPE_DATA:
2357 nicRxProcessDataPacket(prAdapter, prSwRfb);
2360 case HIF_RX_PKT_TYPE_EVENT:
2361 nicRxProcessEventPacket(prAdapter, prSwRfb);
2364 case HIF_RX_PKT_TYPE_TX_LOOPBACK:
2365 DBGLOG(RX, ERROR, ("ucPacketType = %d\n", prSwRfb->ucPacketType));
2368 case HIF_RX_PKT_TYPE_MANAGEMENT:
2369 nicRxProcessMgmtPacket(prAdapter, prSwRfb);
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));
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);
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);
2393 kalRxIndicatePkts(prAdapter->prGlueInfo, prRxCtrl->apvIndPacket, (UINT_32)prRxCtrl->ucNumIndPacket);
2397 } /* end of nicRxProcessRFBs() */
2400 #if !CFG_SDIO_INTR_ENHANCE
2401 /*----------------------------------------------------------------------------*/
2403 * @brief Read the rx data from data port and setup RFB
2405 * @param prAdapter pointer to the Adapter handler
2406 * @param prSWRfb the RFB to receive rx data
2408 * @retval WLAN_STATUS_SUCCESS: SUCCESS
2409 * @retval WLAN_STATUS_FAILURE: FAILURE
2412 /*----------------------------------------------------------------------------*/
2415 IN P_ADAPTER_T prAdapter,
2416 IN OUT P_SW_RFB_T prSwRfb
2419 P_RX_CTRL_T prRxCtrl;
2421 P_HIF_RX_HEADER_T prHifRxHdr;
2422 UINT_32 u4PktLen = 0, u4ReadBytes;
2423 WLAN_STATUS u4Status = WLAN_STATUS_SUCCESS;
2424 BOOL fgResult = TRUE;
2428 DEBUGFUNC("nicRxReadBuffer");
2433 prRxCtrl = &prAdapter->rRxCtrl;
2436 pucBuf = prSwRfb->pucRecvBuff;
2437 prHifRxHdr = prSwRfb->prHifRxHdr;
2439 DBGLOG(RX, TRACE, ("pucBuf= 0x%x, prHifRxHdr= 0x%x\n", pucBuf, prHifRxHdr));
2442 /* Read the RFB DW length and packet length */
2443 HAL_MCR_RD(prAdapter, MCR_WRPLR, &u4RegValue);
2445 DBGLOG(RX, ERROR, ("Read RX Packet Lentgh Error\n"));
2446 return WLAN_STATUS_FAILURE;
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;
2455 u4PktLen = u4RegValue & BITS(0, 15);
2461 u4PktLen = (u4RegValue & BITS(16, 31)) >> 16;
2464 DBGLOG(RX, TRACE, ("RX%d: u4PktLen = %d\n", rxNum, u4PktLen));
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);
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));
2476 dumpMemory8((PUINT_8)prHifRxHdr, (prHifRxHdr->u2PacketLen > 4096) ? 4096 : prHifRxHdr->u2PacketLen);
2480 /* u4PktLen is byte unit, not inlude HW appended DW */
2482 prSwRfb->ucPacketType = (UINT_8)(prHifRxHdr->u2PacketType & HIF_RX_HDR_PACKET_TYPE_MASK);
2483 DBGLOG(RX, TRACE, ("ucPacketType = %d\n", prSwRfb->ucPacketType));
2485 prSwRfb->ucStaRecIdx = (UINT_8)(prHifRxHdr->ucStaRecIdx);
2487 /* fgResult will be updated in MACRO */
2489 return WLAN_STATUS_FAILURE;
2492 DBGLOG(RX, TRACE, ("Dump RX buffer, length = 0x%x\n", u4ReadBytes));
2493 DBGLOG_MEM8(RX, TRACE, pucBuf, u4ReadBytes);
2500 /*----------------------------------------------------------------------------*/
2502 * @brief Read frames from the data port, fill RFB
2503 * and put each frame into the rReceivedRFBList queue.
2505 * @param prAdapter Pointer to the Adapter structure.
2509 /*----------------------------------------------------------------------------*/
2512 IN P_ADAPTER_T prAdapter
2515 P_RX_CTRL_T prRxCtrl;
2516 P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
2517 P_HIF_RX_HEADER_T prHifRxHdr;
2519 UINT_32 u4HwAppendDW;
2521 KAL_SPIN_LOCK_DECLARATION();
2523 DEBUGFUNC("nicRxReceiveRFBs");
2527 prRxCtrl = &prAdapter->rRxCtrl;
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);
2536 DBGLOG(RX, TRACE, ("No More RFB\n"));
2541 if (nicRxReadBuffer(prAdapter, prSwRfb) == WLAN_STATUS_FAILURE) {
2542 DBGLOG(RX, TRACE, ("halRxFillRFB failed\n"));
2543 nicRxReturnRFB(prAdapter, prSwRfb);
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);
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));
2558 // while (RX_STATUS_TEST_MORE_FLAG(u4HwAppendDW));
2563 } /* end of nicReceiveRFBs() */
2566 /*----------------------------------------------------------------------------*/
2568 * @brief Read frames from the data port, fill RFB
2569 * and put each frame into the rReceivedRFBList queue.
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.
2578 /*----------------------------------------------------------------------------*/
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
2588 P_RX_CTRL_T prRxCtrl;
2590 P_HIF_RX_HEADER_T prHifRxHdr;
2591 UINT_32 u4PktLen = 0;
2592 WLAN_STATUS u4Status = WLAN_STATUS_FAILURE;
2593 BOOL fgResult = TRUE;
2595 DEBUGFUNC("nicRxEnhanceReadBuffer");
2600 prRxCtrl = &prAdapter->rRxCtrl;
2603 pucBuf = prSwRfb->pucRecvBuff;
2606 prHifRxHdr = prSwRfb->prHifRxHdr;
2609 //DBGLOG(RX, TRACE, ("u2RxLength = %d\n", u2RxLength));
2612 //4 <1> Read RFB frame from MCR_WRDR0, include HW appended DW
2613 HAL_READ_RX_PORT(prAdapter,
2615 ALIGN_4(u2RxLength + HIF_RX_HW_APPENDED_LEN),
2617 CFG_RX_MAX_PKT_SIZE);
2620 DBGLOG(RX, ERROR, ("Read RX Packet Lentgh Error\n"));
2624 u4PktLen = (UINT_32)(prHifRxHdr->u2PacketLen);
2625 //DBGLOG(RX, TRACE, ("u4PktLen = %d\n", u4PktLen));
2627 prSwRfb->ucPacketType = (UINT_8)(prHifRxHdr->u2PacketType & HIF_RX_HDR_PACKET_TYPE_MASK);
2628 //DBGLOG(RX, TRACE, ("ucPacketType = %d\n", prSwRfb->ucPacketType));
2630 prSwRfb->ucStaRecIdx = (UINT_8)(prHifRxHdr->ucStaRecIdx);
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));
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));
2646 u4Status = WLAN_STATUS_SUCCESS;
2650 DBGLOG_MEM8(RX, TRACE, pucBuf, ALIGN_4(u2RxLength + HIF_RX_HW_APPENDED_LEN));
2655 /*----------------------------------------------------------------------------*/
2657 * @brief Read frames from the data port for SDIO
2658 * I/F, fill RFB and put each frame into the rReceivedRFBList queue.
2660 * @param prAdapter Pointer to the Adapter structure.
2664 /*----------------------------------------------------------------------------*/
2666 nicRxSDIOReceiveRFBs (
2667 IN P_ADAPTER_T prAdapter
2670 P_SDIO_CTRL_T prSDIOCtrl;
2671 P_RX_CTRL_T prRxCtrl;
2672 P_SW_RFB_T prSwRfb = (P_SW_RFB_T)NULL;
2674 UINT_16 u2RxPktNum, u2RxLength = 0, u2Tmp = 0;
2675 KAL_SPIN_LOCK_DECLARATION();
2677 DEBUGFUNC("nicRxSDIOReceiveRFBs");
2681 prSDIOCtrl = prAdapter->prSDIOCtrl;
2684 prRxCtrl = &prAdapter->rRxCtrl;
2687 for (rxNum = 0 ; rxNum < 2 ; rxNum++) {
2688 u2RxPktNum = (rxNum == 0 ? prSDIOCtrl->rRxInfo.u.u2NumValidRx0Len : prSDIOCtrl->rRxInfo.u.u2NumValidRx1Len);
2690 if(u2RxPktNum == 0) {
2694 for (i = 0; i < u2RxPktNum; i++) {
2696 HAL_READ_RX_LENGTH(prAdapter, &u2RxLength, &u2Tmp);
2698 else if(rxNum == 1) {
2699 HAL_READ_RX_LENGTH(prAdapter, &u2Tmp, &u2RxLength);
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);
2712 DBGLOG(RX, TRACE, ("No More RFB\n"));
2717 if (nicRxEnhanceReadBuffer(prAdapter, rxNum, u2RxLength, prSwRfb) == WLAN_STATUS_FAILURE) {
2718 DBGLOG(RX, TRACE, ("nicRxEnhanceRxReadBuffer failed\n"));
2719 nicRxReturnRFB(prAdapter, prSwRfb);
2723 //prSDIOCtrl->au4RxLength[i] = 0;
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);
2732 prSDIOCtrl->rRxInfo.u.u2NumValidRx0Len = 0;
2733 prSDIOCtrl->rRxInfo.u.u2NumValidRx1Len = 0;
2736 }/* end of nicRxSDIOReceiveRFBs() */
2738 #endif /* CFG_SDIO_INTR_ENHANCE */
2743 /*----------------------------------------------------------------------------*/
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.
2748 * @param prAdapter Pointer to the Adapter structure.
2752 /*----------------------------------------------------------------------------*/
2754 nicRxSDIOAggReceiveRFBs (
2755 IN P_ADAPTER_T prAdapter
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;
2764 UINT_32 u4RxAggCount = 0, u4RxAggLength = 0;
2765 UINT_32 u4RxAvailAggLen, u4CurrAvailFreeRfbCnt;
2767 P_HIF_RX_HEADER_T prHifRxHdr;
2768 BOOL fgResult = TRUE;
2769 BOOLEAN fgIsRxEnhanceMode;
2771 #if CFG_SDIO_RX_ENHANCE
2772 UINT_32 u4MaxLoopCount = CFG_MAX_RX_ENHANCE_LOOP_COUNT;
2775 KAL_SPIN_LOCK_DECLARATION();
2777 DEBUGFUNC("nicRxSDIOAggReceiveRFBs");
2780 prEnhDataStr = prAdapter->prSDIOCtrl;
2781 prRxCtrl = &prAdapter->rRxCtrl;
2782 prSDIOCtrl = prAdapter->prSDIOCtrl;
2784 #if CFG_SDIO_RX_ENHANCE
2785 fgIsRxEnhanceMode = TRUE;
2787 fgIsRxEnhanceMode = FALSE;
2791 #if CFG_SDIO_RX_ENHANCE
2792 /* to limit maximum loop for RX */
2794 if (u4MaxLoopCount == 0) {
2799 if(prEnhDataStr->rRxInfo.u.u2NumValidRx0Len == 0 &&
2800 prEnhDataStr->rRxInfo.u.u2NumValidRx1Len == 0) {
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 // if this assertion happened, it is most likely a F/W bug
2808 ASSERT(u2RxPktNum <= 16);
2810 if (u2RxPktNum > 16)
2816 #if CFG_HIF_STATISTICS
2817 prRxCtrl->u4TotalRxAccessNum++;
2818 prRxCtrl->u4TotalRxPacketNum += u2RxPktNum;
2821 u4CurrAvailFreeRfbCnt = prRxCtrl->rFreeSwRfbList.u4NumElem;
2823 // if SwRfb is not enough, abort reading this time
2824 if(u4CurrAvailFreeRfbCnt < u2RxPktNum) {
2825 #if CFG_HIF_RX_STARVATION_WARNING
2826 DbgPrint("FreeRfb is not enough: %d available, need %d\n", u4CurrAvailFreeRfbCnt, u2RxPktNum);
2827 DbgPrint("Queued Count: %d / Dequeud Count: %d\n", prRxCtrl->u4QueuedCnt, prRxCtrl->u4DequeuedCnt);
2832 #if CFG_SDIO_RX_ENHANCE
2833 u4RxAvailAggLen = CFG_RX_COALESCING_BUFFER_SIZE - (sizeof(ENHANCE_MODE_DATA_STRUCT_T) + 4/* extra HW padding */);
2835 u4RxAvailAggLen = CFG_RX_COALESCING_BUFFER_SIZE;
2839 for (i = 0; i < u2RxPktNum ; i++) {
2840 u4RxLength = (rxNum == 0 ?
2841 (UINT_32)prEnhDataStr->rRxInfo.u.au2Rx0Len[i] :
2842 (UINT_32)prEnhDataStr->rRxInfo.u.au2Rx1Len[i]);
2849 if (ALIGN_4(u4RxLength + HIF_RX_HW_APPENDED_LEN) < u4RxAvailAggLen) {
2850 if (u4RxAggCount < u4CurrAvailFreeRfbCnt) {
2851 u4RxAvailAggLen -= ALIGN_4(u4RxLength + HIF_RX_HW_APPENDED_LEN);
2855 // no FreeSwRfb for rx packet
2861 // CFG_RX_COALESCING_BUFFER_SIZE is not large enough
2867 u4RxAggLength = (CFG_RX_COALESCING_BUFFER_SIZE - u4RxAvailAggLen);
2868 //DBGLOG(RX, INFO, ("u4RxAggCount = %d, u4RxAggLength = %d\n",
2869 // u4RxAggCount, u4RxAggLength));
2871 HAL_READ_RX_PORT(prAdapter,
2874 prRxCtrl->pucRxCoalescingBufPtr,
2875 CFG_RX_COALESCING_BUFFER_SIZE);
2877 DBGLOG(RX, ERROR, ("Read RX Agg Packet Error\n"));
2881 pucSrcAddr = prRxCtrl->pucRxCoalescingBufPtr;
2882 for (i = 0; i < u4RxAggCount; i++) {
2883 UINT_16 u2PktLength;
2885 u2PktLength = (rxNum == 0 ?
2886 prEnhDataStr->rRxInfo.u.au2Rx0Len[i] :
2887 prEnhDataStr->rRxInfo.u.au2Rx1Len[i]);
2889 KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2890 QUEUE_REMOVE_HEAD(&prRxCtrl->rFreeSwRfbList, prSwRfb, P_SW_RFB_T);
2891 KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2894 kalMemCopy(prSwRfb->pucRecvBuff, pucSrcAddr,
2895 ALIGN_4(u2PktLength + HIF_RX_HW_APPENDED_LEN));
2897 prHifRxHdr = prSwRfb->prHifRxHdr;
2900 prSwRfb->ucPacketType = (UINT_8)(prHifRxHdr->u2PacketType & HIF_RX_HDR_PACKET_TYPE_MASK);
2901 //DBGLOG(RX, TRACE, ("ucPacketType = %d\n", prSwRfb->ucPacketType));
2903 prSwRfb->ucStaRecIdx = (UINT_8)(prHifRxHdr->ucStaRecIdx);
2905 KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2906 QUEUE_INSERT_TAIL(&prRxCtrl->rReceivedRfbList, &prSwRfb->rQueEntry);
2907 RX_INC_CNT(prRxCtrl, RX_MPDU_TOTAL_COUNT);
2908 KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
2910 pucSrcAddr += ALIGN_4(u2PktLength + HIF_RX_HW_APPENDED_LEN);
2911 //prEnhDataStr->au4RxLength[i] = 0;
2914 #if CFG_SDIO_RX_ENHANCE
2915 kalMemCopy(prAdapter->prSDIOCtrl, (pucSrcAddr + 4), sizeof(ENHANCE_MODE_DATA_STRUCT_T));
2917 /* do the same thing what nicSDIOReadIntStatus() does */
2918 if((prSDIOCtrl->u4WHISR & WHISR_TX_DONE_INT) == 0 &&
2919 (prSDIOCtrl->rTxInfo.au4WTSR[0] | prSDIOCtrl->rTxInfo.au4WTSR[1])) {
2920 prSDIOCtrl->u4WHISR |= WHISR_TX_DONE_INT;
2923 if((prSDIOCtrl->u4WHISR & BIT(31)) == 0 &&
2924 HAL_GET_MAILBOX_READ_CLEAR(prAdapter) == TRUE &&
2925 (prSDIOCtrl->u4RcvMailbox0 != 0 || prSDIOCtrl->u4RcvMailbox1 != 0)) {
2926 prSDIOCtrl->u4WHISR |= BIT(31);
2929 /* dispatch to interrupt handler with RX bits masked */
2930 nicProcessIST_impl(prAdapter, prSDIOCtrl->u4WHISR & (~(WHISR_RX0_DONE_INT | WHISR_RX1_DONE_INT)));
2934 #if !CFG_SDIO_RX_ENHANCE
2935 prEnhDataStr->rRxInfo.u.u2NumValidRx0Len = 0;
2936 prEnhDataStr->rRxInfo.u.u2NumValidRx1Len = 0;
2939 while ((prEnhDataStr->rRxInfo.u.u2NumValidRx0Len
2940 || prEnhDataStr->rRxInfo.u.u2NumValidRx1Len)
2941 && fgIsRxEnhanceMode);
2945 #endif /* CFG_SDIO_RX_AGG */
2948 /*----------------------------------------------------------------------------*/
2950 * @brief Setup a RFB and allocate the os packet to the RFB
2952 * @param prAdapter Pointer to the Adapter structure.
2953 * @param prSwRfb Pointer to the RFB
2955 * @retval WLAN_STATUS_SUCCESS
2956 * @retval WLAN_STATUS_RESOURCES
2958 /*----------------------------------------------------------------------------*/
2961 IN P_ADAPTER_T prAdapter,
2962 IN P_SW_RFB_T prSwRfb
2966 PUINT_8 pucRecvBuff;
2971 if (!prSwRfb->pvPacket) {
2972 kalMemZero(prSwRfb, sizeof(SW_RFB_T));
2973 pvPacket = kalPacketAlloc(prAdapter->prGlueInfo, CFG_RX_MAX_PKT_SIZE,
2975 if (pvPacket == NULL) {
2976 return WLAN_STATUS_RESOURCES;
2979 prSwRfb->pvPacket = pvPacket;
2980 prSwRfb->pucRecvBuff= (PVOID)pucRecvBuff;
2983 kalMemZero(((PUINT_8)prSwRfb + OFFSET_OF(SW_RFB_T, prHifRxHdr)),
2984 (sizeof(SW_RFB_T)-OFFSET_OF(SW_RFB_T, prHifRxHdr)));
2987 prSwRfb->prHifRxHdr = (P_HIF_RX_HEADER_T)(prSwRfb->pucRecvBuff);
2989 return WLAN_STATUS_SUCCESS;
2991 } /* end of nicRxSetupRFB() */
2994 /*----------------------------------------------------------------------------*/
2996 * @brief This routine is called to put a RFB back onto the "RFB with Buffer" list
2997 * or "RFB without buffer" list according to pvPacket.
2999 * @param prAdapter Pointer to the Adapter structure.
3000 * @param prSwRfb Pointer to the RFB
3004 /*----------------------------------------------------------------------------*/
3007 IN P_ADAPTER_T prAdapter,
3008 IN P_SW_RFB_T prSwRfb
3011 P_RX_CTRL_T prRxCtrl;
3012 P_QUE_ENTRY_T prQueEntry;
3013 KAL_SPIN_LOCK_DECLARATION();
3017 prRxCtrl = &prAdapter->rRxCtrl;
3018 prQueEntry = &prSwRfb->rQueEntry;
3022 /* The processing on this RFB is done, so put it back on the tail of
3024 KAL_ACQUIRE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
3026 if (prSwRfb->pvPacket) {
3027 QUEUE_INSERT_TAIL(&prRxCtrl->rFreeSwRfbList, prQueEntry);
3030 QUEUE_INSERT_TAIL(&prRxCtrl->rIndicatedRfbList, prQueEntry);
3033 KAL_RELEASE_SPIN_LOCK(prAdapter, SPIN_LOCK_RX_QUE);
3035 } /* end of nicRxReturnRFB() */
3037 /*----------------------------------------------------------------------------*/
3039 * @brief Process rx interrupt. When the rx
3040 * Interrupt is asserted, it means there are frames in queue.
3042 * @param prAdapter Pointer to the Adapter structure.
3046 /*----------------------------------------------------------------------------*/
3048 nicProcessRxInterrupt (
3049 IN P_ADAPTER_T prAdapter
3054 #if CFG_SDIO_INTR_ENHANCE
3056 nicRxSDIOAggReceiveRFBs(prAdapter);
3058 nicRxSDIOReceiveRFBs(prAdapter);
3061 nicRxReceiveRFBs(prAdapter);
3062 #endif /* CFG_SDIO_INTR_ENHANCE */
3064 nicRxProcessRFBs(prAdapter);
3068 } /* end of nicProcessRxInterrupt() */
3071 #if CFG_TCP_IP_CHKSUM_OFFLOAD
3072 /*----------------------------------------------------------------------------*/
3074 * @brief Used to update IP/TCP/UDP checksum statistics of RX Module.
3076 * @param prAdapter Pointer to the Adapter structure.
3077 * @param aeCSUM The array of checksum result.
3081 /*----------------------------------------------------------------------------*/
3083 nicRxUpdateCSUMStatistics (
3084 IN P_ADAPTER_T prAdapter,
3085 IN const ENUM_CSUM_RESULT_T aeCSUM[]
3088 P_RX_CTRL_T prRxCtrl;
3093 prRxCtrl = &prAdapter->rRxCtrl;
3096 if ((aeCSUM[CSUM_TYPE_IPV4] == CSUM_RES_SUCCESS) ||
3097 (aeCSUM[CSUM_TYPE_IPV6] == CSUM_RES_SUCCESS)) {
3099 RX_INC_CNT(prRxCtrl, RX_CSUM_IP_SUCCESS_COUNT);
3101 else if ((aeCSUM[CSUM_TYPE_IPV4] == CSUM_RES_FAILED) ||
3102 (aeCSUM[CSUM_TYPE_IPV6] == CSUM_RES_FAILED)) {
3104 RX_INC_CNT(prRxCtrl, RX_CSUM_IP_FAILED_COUNT);
3106 else if ((aeCSUM[CSUM_TYPE_IPV4] == CSUM_RES_NONE) &&
3107 (aeCSUM[CSUM_TYPE_IPV6] == CSUM_RES_NONE)) {
3109 RX_INC_CNT(prRxCtrl, RX_CSUM_UNKNOWN_L3_PKT_COUNT);
3115 if (aeCSUM[CSUM_TYPE_TCP] == CSUM_RES_SUCCESS) {
3116 RX_INC_CNT(prRxCtrl, RX_CSUM_TCP_SUCCESS_COUNT);
3118 else if (aeCSUM[CSUM_TYPE_TCP] == CSUM_RES_FAILED) {
3119 RX_INC_CNT(prRxCtrl, RX_CSUM_TCP_FAILED_COUNT);
3121 else if (aeCSUM[CSUM_TYPE_UDP] == CSUM_RES_SUCCESS) {
3122 RX_INC_CNT(prRxCtrl, RX_CSUM_UDP_SUCCESS_COUNT);
3124 else if (aeCSUM[CSUM_TYPE_UDP] == CSUM_RES_FAILED) {
3125 RX_INC_CNT(prRxCtrl, RX_CSUM_UDP_FAILED_COUNT);
3127 else if ((aeCSUM[CSUM_TYPE_UDP] == CSUM_RES_NONE) &&
3128 (aeCSUM[CSUM_TYPE_TCP] == CSUM_RES_NONE)) {
3130 RX_INC_CNT(prRxCtrl, RX_CSUM_UNKNOWN_L4_PKT_COUNT);
3137 } /* end of nicRxUpdateCSUMStatistics() */
3138 #endif /* CFG_TCP_IP_CHKSUM_OFFLOAD */
3141 /*----------------------------------------------------------------------------*/
3143 * @brief This function is used to query current status of RX Module.
3145 * @param prAdapter Pointer to the Adapter structure.
3146 * @param pucBuffer Pointer to the message buffer.
3147 * @param pu4Count Pointer to the buffer of message length count.
3151 /*----------------------------------------------------------------------------*/
3154 IN P_ADAPTER_T prAdapter,
3155 IN PUINT_8 pucBuffer,
3156 OUT PUINT_32 pu4Count
3159 P_RX_CTRL_T prRxCtrl;
3160 PUINT_8 pucCurrBuf = pucBuffer;
3164 prRxCtrl = &prAdapter->rRxCtrl;
3167 //if (pucBuffer) {} /* For Windows, we'll print directly instead of sprintf() */
3170 SPRINTF(pucCurrBuf, ("\n\nRX CTRL STATUS:"));
3171 SPRINTF(pucCurrBuf, ("\n==============="));
3172 SPRINTF(pucCurrBuf, ("\nFREE RFB w/i BUF LIST :%9ld", prRxCtrl->rFreeSwRfbList.u4NumElem));
3173 SPRINTF(pucCurrBuf, ("\nFREE RFB w/o BUF LIST :%9ld", prRxCtrl->rIndicatedRfbList.u4NumElem));
3174 SPRINTF(pucCurrBuf, ("\nRECEIVED RFB LIST :%9ld", prRxCtrl->rReceivedRfbList.u4NumElem));
3176 SPRINTF(pucCurrBuf, ("\n\n"));
3178 //*pu4Count = (UINT_32)((UINT_32)pucCurrBuf - (UINT_32)pucBuffer);
3181 } /* end of nicRxQueryStatus() */
3184 /*----------------------------------------------------------------------------*/
3186 * @brief Clear RX related counters
3188 * @param prAdapter Pointer of Adapter Data Structure
3192 /*----------------------------------------------------------------------------*/
3194 nicRxClearStatistics (
3195 IN P_ADAPTER_T prAdapter
3198 P_RX_CTRL_T prRxCtrl;
3201 prRxCtrl = &prAdapter->rRxCtrl;
3204 RX_RESET_ALL_CNTS(prRxCtrl);
3209 /*----------------------------------------------------------------------------*/
3211 * @brief This function is used to query current statistics of RX Module.
3213 * @param prAdapter Pointer to the Adapter structure.
3214 * @param pucBuffer Pointer to the message buffer.
3215 * @param pu4Count Pointer to the buffer of message length count.
3219 /*----------------------------------------------------------------------------*/
3221 nicRxQueryStatistics (
3222 IN P_ADAPTER_T prAdapter,
3223 IN PUINT_8 pucBuffer,
3224 OUT PUINT_32 pu4Count
3227 P_RX_CTRL_T prRxCtrl;
3228 PUINT_8 pucCurrBuf = pucBuffer;
3231 prRxCtrl = &prAdapter->rRxCtrl;
3234 //if (pucBuffer) {} /* For Windows, we'll print directly instead of sprintf() */
3237 #define SPRINTF_RX_COUNTER(eCounter) \
3238 SPRINTF(pucCurrBuf, ("%-30s : %ld\n", #eCounter, (UINT_32)prRxCtrl->au8Statistics[eCounter]))
3240 SPRINTF_RX_COUNTER(RX_MPDU_TOTAL_COUNT);
3241 SPRINTF_RX_COUNTER(RX_SIZE_ERR_DROP_COUNT);
3242 SPRINTF_RX_COUNTER(RX_DATA_INDICATION_COUNT);
3243 SPRINTF_RX_COUNTER(RX_DATA_RETURNED_COUNT);
3244 SPRINTF_RX_COUNTER(RX_DATA_RETAINED_COUNT);
3246 #if CFG_TCP_IP_CHKSUM_OFFLOAD || CFG_TCP_IP_CHKSUM_OFFLOAD_NDIS_60
3247 SPRINTF_RX_COUNTER(RX_CSUM_TCP_FAILED_COUNT);
3248 SPRINTF_RX_COUNTER(RX_CSUM_UDP_FAILED_COUNT);
3249 SPRINTF_RX_COUNTER(RX_CSUM_IP_FAILED_COUNT);
3250 SPRINTF_RX_COUNTER(RX_CSUM_TCP_SUCCESS_COUNT);
3251 SPRINTF_RX_COUNTER(RX_CSUM_UDP_SUCCESS_COUNT);
3252 SPRINTF_RX_COUNTER(RX_CSUM_IP_SUCCESS_COUNT);
3253 SPRINTF_RX_COUNTER(RX_CSUM_UNKNOWN_L4_PKT_COUNT);
3254 SPRINTF_RX_COUNTER(RX_CSUM_UNKNOWN_L3_PKT_COUNT);
3255 SPRINTF_RX_COUNTER(RX_IP_V6_PKT_CCOUNT);
3258 //*pu4Count = (UINT_32)(pucCurrBuf - pucBuffer);
3260 nicRxClearStatistics(prAdapter);
3265 /*----------------------------------------------------------------------------*/
3267 * @brief Read the Response data from data port
3269 * @param prAdapter pointer to the Adapter handler
3270 * @param pucRspBuffer pointer to the Response buffer
3272 * @retval WLAN_STATUS_SUCCESS: Response packet has been read
3273 * @retval WLAN_STATUS_FAILURE: Read Response packet timeout or error occurred
3276 /*----------------------------------------------------------------------------*/
3279 IN P_ADAPTER_T prAdapter,
3280 IN UINT_8 ucPortIdx,
3281 OUT PUINT_8 pucRspBuffer,
3282 IN UINT_32 u4MaxRespBufferLen,
3283 OUT PUINT_32 pu4Length
3286 UINT_32 u4Value = 0, u4PktLen = 0, i = 0;
3287 WLAN_STATUS u4Status = WLAN_STATUS_SUCCESS;
3288 BOOL fgResult = TRUE;
3289 UINT_32 u4Time, u4Current;
3291 DEBUGFUNC("nicRxWaitResponse");
3294 ASSERT(pucRspBuffer);
3295 ASSERT(ucPortIdx < 2);
3297 u4Time = (UINT_32)kalGetTimeTick();
3300 /* Read the packet length */
3301 HAL_MCR_RD(prAdapter, MCR_WRPLR, &u4Value);
3304 DBGLOG(RX, ERROR, ("Read Response Packet Error\n"));
3305 return WLAN_STATUS_FAILURE;
3308 if(ucPortIdx == 0) {
3309 u4PktLen = u4Value & 0xFFFF;
3312 u4PktLen = (u4Value >> 16) & 0xFFFF;
3315 DBGLOG(RX, TRACE, ("i = %d, u4PktLen = %d\n", i, u4PktLen));
3317 if (u4PktLen == 0) {
3318 /* timeout exceeding check */
3319 u4Current = (UINT_32)kalGetTimeTick();
3321 if((u4Current > u4Time) && ((u4Current - u4Time) > RX_RESPONSE_TIMEOUT)) {
3322 return WLAN_STATUS_FAILURE;
3324 else if(u4Current < u4Time && ((u4Current + (0xFFFFFFFF - u4Time)) > RX_RESPONSE_TIMEOUT)) {
3325 return WLAN_STATUS_FAILURE;
3328 /* Response packet is not ready */
3333 else if (u4PktLen > u4MaxRespBufferLen) {
3334 DBGLOG(RX, WARN, ("Not enough Event Buffer: required length = 0x%x, available buffer length = %d\n",
3335 u4PktLen, u4MaxRespBufferLen));
3337 return WLAN_STATUS_FAILURE;
3340 HAL_PORT_RD(prAdapter,
3341 ucPortIdx == 0 ? MCR_WRDR0 : MCR_WRDR1,
3344 u4MaxRespBufferLen);
3346 /* fgResult will be updated in MACRO */
3348 DBGLOG(RX, ERROR, ("Read Response Packet Error\n"));
3349 return WLAN_STATUS_FAILURE;
3352 DBGLOG(RX, TRACE, ("Dump Response buffer, length = 0x%x\n",
3354 DBGLOG_MEM8(RX, TRACE, pucRspBuffer, u4PktLen);
3356 *pu4Length = u4PktLen;
3364 /*----------------------------------------------------------------------------*/
3366 * @brief Set filter to enable Promiscuous Mode
3368 * @param prAdapter Pointer to the Adapter structure.
3372 /*----------------------------------------------------------------------------*/
3374 nicRxEnablePromiscuousMode (
3375 IN P_ADAPTER_T prAdapter
3381 } /* end of nicRxEnablePromiscuousMode() */
3384 /*----------------------------------------------------------------------------*/
3386 * @brief Set filter to disable Promiscuous Mode
3388 * @param prAdapter Pointer to the Adapter structure.
3392 /*----------------------------------------------------------------------------*/
3394 nicRxDisablePromiscuousMode (
3395 IN P_ADAPTER_T prAdapter
3401 } /* end of nicRxDisablePromiscuousMode() */
3404 /*----------------------------------------------------------------------------*/
3406 * @brief this function flushes all packets queued in reordering module
3408 * @param prAdapter Pointer to the Adapter structure.
3410 * @retval WLAN_STATUS_SUCCESS Flushed successfully
3412 /*----------------------------------------------------------------------------*/
3415 IN P_ADAPTER_T prAdapter
3422 if((prSwRfb = qmFlushRxQueues(prAdapter)) != NULL) {
3424 P_SW_RFB_T prNextSwRfb;
3427 prNextSwRfb = (P_SW_RFB_T)QUEUE_GET_NEXT_ENTRY((P_QUE_ENTRY_T)prSwRfb);
3430 nicRxReturnRFB(prAdapter, prSwRfb);
3432 prSwRfb = prNextSwRfb;
3436 return WLAN_STATUS_SUCCESS;
3440 /*----------------------------------------------------------------------------*/
3448 /*----------------------------------------------------------------------------*/
3450 nicRxProcessActionFrame (
3451 IN P_ADAPTER_T prAdapter,
3452 IN P_SW_RFB_T prSwRfb
3455 P_WLAN_ACTION_FRAME prActFrame;
3460 if (prSwRfb->u2PacketLen < sizeof(WLAN_ACTION_FRAME) - 1) {
3461 return WLAN_STATUS_INVALID_PACKET;
3463 prActFrame = (P_WLAN_ACTION_FRAME) prSwRfb->pvHeader;
3465 switch (prActFrame->ucCategory) {
3466 case CATEGORY_PUBLIC_ACTION:
3468 #if CFG_ENABLE_WIFI_DIRECT
3469 if (prAdapter->fgIsP2PRegistered) {
3470 rlmProcessPublicAction(prAdapter, prSwRfb);
3472 p2pFuncValidateRxActionFrame(
3473 prAdapter, prSwRfb);
3479 case CATEGORY_HT_ACTION:
3480 #if CFG_ENABLE_WIFI_DIRECT
3481 if (prAdapter->fgIsP2PRegistered) {
3482 rlmProcessHtAction(prAdapter, prSwRfb);
3486 case CATEGORY_VENDOR_SPECIFIC_ACTION:
3487 #if CFG_ENABLE_WIFI_DIRECT
3488 if (prAdapter->fgIsP2PRegistered) {
3489 p2pFuncValidateRxActionFrame(prAdapter, prSwRfb);
3493 #if CFG_SUPPORT_802_11W
3494 case CATEGORY_SA_QUERT_ACTION:
3496 P_HIF_RX_HEADER_T prHifRxHdr;
3498 prHifRxHdr = prSwRfb->prHifRxHdr;
3500 if ((HIF_RX_HDR_GET_NETWORK_IDX(prHifRxHdr) == NETWORK_TYPE_AIS_INDEX) &&
3501 prAdapter->rWifiVar.rAisSpecificBssInfo.fgMgmtProtection /* Use MFP */
3503 if (!(prHifRxHdr->ucReserved & CONTROL_FLAG_UC_MGMT_NO_ENC)) {
3504 /* MFP test plan 5.3.3.4 */
3505 rsnSaQueryAction(prAdapter, prSwRfb);
3508 DBGLOG(RSN, TRACE, ("Un-Protected SA Query, do nothing\n"));
3514 #if CFG_SUPPORT_802_11V
3515 case CATEGORY_WNM_ACTION:
3517 wnmWNMAction(prAdapter, prSwRfb);
3523 } /* end of switch case */
3525 return WLAN_STATUS_SUCCESS;