dp_rx_err.c 87 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193
  1. /*
  2. * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
  3. * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
  4. *
  5. * Permission to use, copy, modify, and/or distribute this software for
  6. * any purpose with or without fee is hereby granted, provided that the
  7. * above copyright notice and this permission notice appear in all
  8. * copies.
  9. *
  10. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  11. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  13. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  14. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  15. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  16. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17. * PERFORMANCE OF THIS SOFTWARE.
  18. */
  19. #include "hal_hw_headers.h"
  20. #include "dp_types.h"
  21. #include "dp_rx.h"
  22. #include "dp_tx.h"
  23. #include "dp_peer.h"
  24. #include "dp_internal.h"
  25. #include "hal_api.h"
  26. #include "qdf_trace.h"
  27. #include "qdf_nbuf.h"
  28. #include "dp_rx_defrag.h"
  29. #include "dp_ipa.h"
  30. #ifdef WIFI_MONITOR_SUPPORT
  31. #include "dp_htt.h"
  32. #include <dp_mon.h>
  33. #endif
  34. #ifdef FEATURE_WDS
  35. #include "dp_txrx_wds.h"
  36. #endif
  37. #include <enet.h> /* LLC_SNAP_HDR_LEN */
  38. #include "qdf_net_types.h"
  39. #include "dp_rx_buffer_pool.h"
  40. #define dp_rx_err_alert(params...) QDF_TRACE_FATAL(QDF_MODULE_ID_DP_RX_ERROR, params)
  41. #define dp_rx_err_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_DP_RX_ERROR, params)
  42. #define dp_rx_err_info(params...) \
  43. __QDF_TRACE_FL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_DP_RX_ERROR, ## params)
  44. #define dp_rx_err_info_rl(params...) \
  45. __QDF_TRACE_RL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_DP_RX_ERROR, ## params)
  46. #define dp_rx_err_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_DP_RX_ERROR, params)
  47. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  48. /* Max regular Rx packet routing error */
  49. #define DP_MAX_REG_RX_ROUTING_ERRS_THRESHOLD 20
  50. #define DP_MAX_REG_RX_ROUTING_ERRS_IN_TIMEOUT 10
  51. #define DP_RX_ERR_ROUTE_TIMEOUT_US (5 * 1000 * 1000) /* micro seconds */
  52. #ifdef FEATURE_MEC
  53. bool dp_rx_mcast_echo_check(struct dp_soc *soc,
  54. struct dp_txrx_peer *txrx_peer,
  55. uint8_t *rx_tlv_hdr,
  56. qdf_nbuf_t nbuf)
  57. {
  58. struct dp_vdev *vdev = txrx_peer->vdev;
  59. struct dp_pdev *pdev = vdev->pdev;
  60. struct dp_mec_entry *mecentry = NULL;
  61. struct dp_ast_entry *ase = NULL;
  62. uint16_t sa_idx = 0;
  63. uint8_t *data;
  64. /*
  65. * Multicast Echo Check is required only if vdev is STA and
  66. * received pkt is a multicast/broadcast pkt. otherwise
  67. * skip the MEC check.
  68. */
  69. if (vdev->opmode != wlan_op_mode_sta)
  70. return false;
  71. if (!hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc, rx_tlv_hdr))
  72. return false;
  73. data = qdf_nbuf_data(nbuf);
  74. /*
  75. * if the received pkts src mac addr matches with vdev
  76. * mac address then drop the pkt as it is looped back
  77. */
  78. if (!(qdf_mem_cmp(&data[QDF_MAC_ADDR_SIZE],
  79. vdev->mac_addr.raw,
  80. QDF_MAC_ADDR_SIZE)))
  81. return true;
  82. /*
  83. * In case of qwrap isolation mode, donot drop loopback packets.
  84. * In isolation mode, all packets from the wired stations need to go
  85. * to rootap and loop back to reach the wireless stations and
  86. * vice-versa.
  87. */
  88. if (qdf_unlikely(vdev->isolation_vdev))
  89. return false;
  90. /*
  91. * if the received pkts src mac addr matches with the
  92. * wired PCs MAC addr which is behind the STA or with
  93. * wireless STAs MAC addr which are behind the Repeater,
  94. * then drop the pkt as it is looped back
  95. */
  96. if (hal_rx_msdu_end_sa_is_valid_get(soc->hal_soc, rx_tlv_hdr)) {
  97. sa_idx = hal_rx_msdu_end_sa_idx_get(soc->hal_soc, rx_tlv_hdr);
  98. if ((sa_idx < 0) ||
  99. (sa_idx >= wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx))) {
  100. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  101. "invalid sa_idx: %d", sa_idx);
  102. qdf_assert_always(0);
  103. }
  104. qdf_spin_lock_bh(&soc->ast_lock);
  105. ase = soc->ast_table[sa_idx];
  106. /*
  107. * this check was not needed since MEC is not dependent on AST,
  108. * but if we dont have this check SON has some issues in
  109. * dual backhaul scenario. in APS SON mode, client connected
  110. * to RE 2G and sends multicast packets. the RE sends it to CAP
  111. * over 5G backhaul. the CAP loopback it on 2G to RE.
  112. * On receiving in 2G STA vap, we assume that client has roamed
  113. * and kickout the client.
  114. */
  115. if (ase && (ase->peer_id != txrx_peer->peer_id)) {
  116. qdf_spin_unlock_bh(&soc->ast_lock);
  117. goto drop;
  118. }
  119. qdf_spin_unlock_bh(&soc->ast_lock);
  120. }
  121. qdf_spin_lock_bh(&soc->mec_lock);
  122. mecentry = dp_peer_mec_hash_find_by_pdevid(soc, pdev->pdev_id,
  123. &data[QDF_MAC_ADDR_SIZE]);
  124. if (!mecentry) {
  125. qdf_spin_unlock_bh(&soc->mec_lock);
  126. return false;
  127. }
  128. qdf_spin_unlock_bh(&soc->mec_lock);
  129. drop:
  130. dp_rx_err_info("%pK: received pkt with same src mac " QDF_MAC_ADDR_FMT,
  131. soc, QDF_MAC_ADDR_REF(&data[QDF_MAC_ADDR_SIZE]));
  132. return true;
  133. }
  134. #endif
  135. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  136. void dp_rx_link_desc_refill_duplicate_check(
  137. struct dp_soc *soc,
  138. struct hal_buf_info *buf_info,
  139. hal_buff_addrinfo_t ring_buf_info)
  140. {
  141. struct hal_buf_info current_link_desc_buf_info = { 0 };
  142. /* do duplicate link desc address check */
  143. hal_rx_buffer_addr_info_get_paddr(ring_buf_info,
  144. &current_link_desc_buf_info);
  145. /*
  146. * TODO - Check if the hal soc api call can be removed
  147. * since the cookie is just used for print.
  148. * buffer_addr_info is the first element of ring_desc
  149. */
  150. hal_rx_buf_cookie_rbm_get(soc->hal_soc,
  151. (uint32_t *)ring_buf_info,
  152. &current_link_desc_buf_info);
  153. if (qdf_unlikely(current_link_desc_buf_info.paddr ==
  154. buf_info->paddr)) {
  155. dp_info_rl("duplicate link desc addr: %llu, cookie: 0x%x",
  156. current_link_desc_buf_info.paddr,
  157. current_link_desc_buf_info.sw_cookie);
  158. DP_STATS_INC(soc, rx.err.dup_refill_link_desc, 1);
  159. }
  160. *buf_info = current_link_desc_buf_info;
  161. }
  162. QDF_STATUS
  163. dp_rx_link_desc_return_by_addr(struct dp_soc *soc,
  164. hal_buff_addrinfo_t link_desc_addr,
  165. uint8_t bm_action)
  166. {
  167. struct dp_srng *wbm_desc_rel_ring = &soc->wbm_desc_rel_ring;
  168. hal_ring_handle_t wbm_rel_srng = wbm_desc_rel_ring->hal_srng;
  169. hal_soc_handle_t hal_soc = soc->hal_soc;
  170. QDF_STATUS status = QDF_STATUS_E_FAILURE;
  171. void *src_srng_desc;
  172. if (!wbm_rel_srng) {
  173. dp_rx_err_err("%pK: WBM RELEASE RING not initialized", soc);
  174. return status;
  175. }
  176. /* do duplicate link desc address check */
  177. dp_rx_link_desc_refill_duplicate_check(
  178. soc,
  179. &soc->last_op_info.wbm_rel_link_desc,
  180. link_desc_addr);
  181. if (qdf_unlikely(hal_srng_access_start(hal_soc, wbm_rel_srng))) {
  182. /* TODO */
  183. /*
  184. * Need API to convert from hal_ring pointer to
  185. * Ring Type / Ring Id combo
  186. */
  187. dp_rx_err_err("%pK: HAL RING Access For WBM Release SRNG Failed - %pK",
  188. soc, wbm_rel_srng);
  189. DP_STATS_INC(soc, rx.err.hal_ring_access_fail, 1);
  190. goto done;
  191. }
  192. src_srng_desc = hal_srng_src_get_next(hal_soc, wbm_rel_srng);
  193. if (qdf_likely(src_srng_desc)) {
  194. /* Return link descriptor through WBM ring (SW2WBM)*/
  195. hal_rx_msdu_link_desc_set(hal_soc,
  196. src_srng_desc, link_desc_addr, bm_action);
  197. status = QDF_STATUS_SUCCESS;
  198. } else {
  199. struct hal_srng *srng = (struct hal_srng *)wbm_rel_srng;
  200. DP_STATS_INC(soc, rx.err.hal_ring_access_full_fail, 1);
  201. dp_info_rl("WBM Release Ring (Id %d) Full(Fail CNT %u)",
  202. srng->ring_id,
  203. soc->stats.rx.err.hal_ring_access_full_fail);
  204. dp_info_rl("HP 0x%x Reap HP 0x%x TP 0x%x Cached TP 0x%x",
  205. *srng->u.src_ring.hp_addr,
  206. srng->u.src_ring.reap_hp,
  207. *srng->u.src_ring.tp_addr,
  208. srng->u.src_ring.cached_tp);
  209. QDF_BUG(0);
  210. }
  211. done:
  212. hal_srng_access_end(hal_soc, wbm_rel_srng);
  213. return status;
  214. }
  215. qdf_export_symbol(dp_rx_link_desc_return_by_addr);
  216. QDF_STATUS
  217. dp_rx_link_desc_return(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  218. uint8_t bm_action)
  219. {
  220. void *buf_addr_info = HAL_RX_REO_BUF_ADDR_INFO_GET(ring_desc);
  221. return dp_rx_link_desc_return_by_addr(soc, buf_addr_info, bm_action);
  222. }
  223. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  224. /**
  225. * dp_rx_msdus_drop() - Drops all MSDU's per MPDU
  226. *
  227. * @soc: core txrx main context
  228. * @ring_desc: opaque pointer to the REO error ring descriptor
  229. * @mpdu_desc_info: MPDU descriptor information from ring descriptor
  230. * @mac_id: mac ID
  231. * @quota: No. of units (packets) that can be serviced in one shot.
  232. *
  233. * This function is used to drop all MSDU in an MPDU
  234. *
  235. * Return: uint32_t: No. of elements processed
  236. */
  237. static uint32_t
  238. dp_rx_msdus_drop(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  239. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  240. uint8_t *mac_id,
  241. uint32_t quota)
  242. {
  243. uint32_t rx_bufs_used = 0;
  244. void *link_desc_va;
  245. struct hal_buf_info buf_info;
  246. struct dp_pdev *pdev;
  247. struct hal_rx_msdu_list msdu_list; /* MSDU's per MPDU */
  248. int i;
  249. uint8_t *rx_tlv_hdr;
  250. uint32_t tid;
  251. struct rx_desc_pool *rx_desc_pool;
  252. struct dp_rx_desc *rx_desc;
  253. /* First field in REO Dst ring Desc is buffer_addr_info */
  254. void *buf_addr_info = ring_desc;
  255. struct buffer_addr_info cur_link_desc_addr_info = { 0 };
  256. struct buffer_addr_info next_link_desc_addr_info = { 0 };
  257. hal_rx_reo_buf_paddr_get(soc->hal_soc, ring_desc, &buf_info);
  258. /* buffer_addr_info is the first element of ring_desc */
  259. hal_rx_buf_cookie_rbm_get(soc->hal_soc,
  260. (uint32_t *)ring_desc,
  261. &buf_info);
  262. link_desc_va = dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  263. if (!link_desc_va) {
  264. dp_rx_err_debug("link desc va is null, soc %pk", soc);
  265. return rx_bufs_used;
  266. }
  267. more_msdu_link_desc:
  268. /* No UNMAP required -- this is "malloc_consistent" memory */
  269. hal_rx_msdu_list_get(soc->hal_soc, link_desc_va, &msdu_list,
  270. &mpdu_desc_info->msdu_count);
  271. for (i = 0; (i < mpdu_desc_info->msdu_count); i++) {
  272. rx_desc = soc->arch_ops.dp_rx_desc_cookie_2_va(
  273. soc, msdu_list.sw_cookie[i]);
  274. qdf_assert_always(rx_desc);
  275. /* all buffers from a MSDU link link belong to same pdev */
  276. *mac_id = rx_desc->pool_id;
  277. pdev = dp_get_pdev_for_lmac_id(soc, rx_desc->pool_id);
  278. if (!pdev) {
  279. dp_rx_err_debug("%pK: pdev is null for pool_id = %d",
  280. soc, rx_desc->pool_id);
  281. return rx_bufs_used;
  282. }
  283. if (!dp_rx_desc_check_magic(rx_desc)) {
  284. dp_rx_err_err("%pK: Invalid rx_desc cookie=%d",
  285. soc, msdu_list.sw_cookie[i]);
  286. return rx_bufs_used;
  287. }
  288. rx_desc_pool = &soc->rx_desc_buf[rx_desc->pool_id];
  289. dp_ipa_rx_buf_smmu_mapping_lock(soc);
  290. dp_rx_nbuf_unmap_pool(soc, rx_desc_pool, rx_desc->nbuf);
  291. rx_desc->unmapped = 1;
  292. dp_ipa_rx_buf_smmu_mapping_unlock(soc);
  293. rx_desc->rx_buf_start = qdf_nbuf_data(rx_desc->nbuf);
  294. rx_bufs_used++;
  295. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc,
  296. rx_desc->rx_buf_start);
  297. dp_rx_err_err("%pK: Packet received with PN error for tid :%d",
  298. soc, tid);
  299. rx_tlv_hdr = qdf_nbuf_data(rx_desc->nbuf);
  300. if (hal_rx_encryption_info_valid(soc->hal_soc, rx_tlv_hdr))
  301. hal_rx_print_pn(soc->hal_soc, rx_tlv_hdr);
  302. dp_rx_err_send_pktlog(soc, pdev, mpdu_desc_info,
  303. rx_desc->nbuf,
  304. QDF_TX_RX_STATUS_DROP, true);
  305. /* Just free the buffers */
  306. dp_rx_buffer_pool_nbuf_free(soc, rx_desc->nbuf, *mac_id);
  307. dp_rx_add_to_free_desc_list(&pdev->free_list_head,
  308. &pdev->free_list_tail, rx_desc);
  309. }
  310. /*
  311. * If the msdu's are spread across multiple link-descriptors,
  312. * we cannot depend solely on the msdu_count(e.g., if msdu is
  313. * spread across multiple buffers).Hence, it is
  314. * necessary to check the next link_descriptor and release
  315. * all the msdu's that are part of it.
  316. */
  317. hal_rx_get_next_msdu_link_desc_buf_addr_info(
  318. link_desc_va,
  319. &next_link_desc_addr_info);
  320. if (hal_rx_is_buf_addr_info_valid(
  321. &next_link_desc_addr_info)) {
  322. /* Clear the next link desc info for the current link_desc */
  323. hal_rx_clear_next_msdu_link_desc_buf_addr_info(link_desc_va);
  324. dp_rx_link_desc_return_by_addr(soc, buf_addr_info,
  325. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  326. hal_rx_buffer_addr_info_get_paddr(
  327. &next_link_desc_addr_info,
  328. &buf_info);
  329. /* buffer_addr_info is the first element of ring_desc */
  330. hal_rx_buf_cookie_rbm_get(soc->hal_soc,
  331. (uint32_t *)&next_link_desc_addr_info,
  332. &buf_info);
  333. cur_link_desc_addr_info = next_link_desc_addr_info;
  334. buf_addr_info = &cur_link_desc_addr_info;
  335. link_desc_va =
  336. dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  337. goto more_msdu_link_desc;
  338. }
  339. quota--;
  340. dp_rx_link_desc_return_by_addr(soc, buf_addr_info,
  341. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  342. return rx_bufs_used;
  343. }
  344. /**
  345. * dp_rx_pn_error_handle() - Handles PN check errors
  346. *
  347. * @soc: core txrx main context
  348. * @ring_desc: opaque pointer to the REO error ring descriptor
  349. * @mpdu_desc_info: MPDU descriptor information from ring descriptor
  350. * @mac_id: mac ID
  351. * @quota: No. of units (packets) that can be serviced in one shot.
  352. *
  353. * This function implements PN error handling
  354. * If the peer is configured to ignore the PN check errors
  355. * or if DP feels, that this frame is still OK, the frame can be
  356. * re-injected back to REO to use some of the other features
  357. * of REO e.g. duplicate detection/routing to other cores
  358. *
  359. * Return: uint32_t: No. of elements processed
  360. */
  361. static uint32_t
  362. dp_rx_pn_error_handle(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  363. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  364. uint8_t *mac_id,
  365. uint32_t quota)
  366. {
  367. uint16_t peer_id;
  368. uint32_t rx_bufs_used = 0;
  369. struct dp_txrx_peer *txrx_peer;
  370. bool peer_pn_policy = false;
  371. dp_txrx_ref_handle txrx_ref_handle = NULL;
  372. peer_id = dp_rx_peer_metadata_peer_id_get(soc,
  373. mpdu_desc_info->peer_meta_data);
  374. txrx_peer = dp_tgt_txrx_peer_get_ref_by_id(soc, peer_id,
  375. &txrx_ref_handle,
  376. DP_MOD_ID_RX_ERR);
  377. if (qdf_likely(txrx_peer)) {
  378. /*
  379. * TODO: Check for peer specific policies & set peer_pn_policy
  380. */
  381. dp_err_rl("discard rx due to PN error for peer %pK",
  382. txrx_peer);
  383. dp_txrx_peer_unref_delete(txrx_ref_handle, DP_MOD_ID_RX_ERR);
  384. }
  385. dp_rx_err_err("%pK: Packet received with PN error", soc);
  386. /* No peer PN policy -- definitely drop */
  387. if (!peer_pn_policy)
  388. rx_bufs_used = dp_rx_msdus_drop(soc, ring_desc,
  389. mpdu_desc_info,
  390. mac_id, quota);
  391. return rx_bufs_used;
  392. }
  393. #ifdef DP_RX_DELIVER_ALL_OOR_FRAMES
  394. /**
  395. * dp_rx_deliver_oor_frame() - deliver OOR frames to stack
  396. * @soc: Datapath soc handler
  397. * @txrx_peer: pointer to DP peer
  398. * @nbuf: pointer to the skb of RX frame
  399. * @frame_mask: the mask for special frame needed
  400. * @rx_tlv_hdr: start of rx tlv header
  401. *
  402. * note: Msdu_len must have been stored in QDF_NBUF_CB_RX_PKT_LEN(nbuf) and
  403. * single nbuf is expected.
  404. *
  405. * return: true - nbuf has been delivered to stack, false - not.
  406. */
  407. static bool
  408. dp_rx_deliver_oor_frame(struct dp_soc *soc,
  409. struct dp_txrx_peer *txrx_peer,
  410. qdf_nbuf_t nbuf, uint32_t frame_mask,
  411. uint8_t *rx_tlv_hdr)
  412. {
  413. uint32_t l2_hdr_offset = 0;
  414. uint16_t msdu_len = 0;
  415. uint32_t skip_len;
  416. l2_hdr_offset =
  417. hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc, rx_tlv_hdr);
  418. if (qdf_unlikely(qdf_nbuf_is_frag(nbuf))) {
  419. skip_len = l2_hdr_offset;
  420. } else {
  421. msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  422. skip_len = l2_hdr_offset + soc->rx_pkt_tlv_size;
  423. qdf_nbuf_set_pktlen(nbuf, msdu_len + skip_len);
  424. }
  425. QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(nbuf) = 1;
  426. dp_rx_set_hdr_pad(nbuf, l2_hdr_offset);
  427. qdf_nbuf_pull_head(nbuf, skip_len);
  428. qdf_nbuf_set_exc_frame(nbuf, 1);
  429. dp_info_rl("OOR frame, mpdu sn 0x%x",
  430. hal_rx_get_rx_sequence(soc->hal_soc, rx_tlv_hdr));
  431. dp_rx_deliver_to_stack(soc, txrx_peer->vdev, txrx_peer, nbuf, NULL);
  432. return true;
  433. }
  434. #else
  435. static bool
  436. dp_rx_deliver_oor_frame(struct dp_soc *soc,
  437. struct dp_txrx_peer *txrx_peer,
  438. qdf_nbuf_t nbuf, uint32_t frame_mask,
  439. uint8_t *rx_tlv_hdr)
  440. {
  441. return dp_rx_deliver_special_frame(soc, txrx_peer, nbuf, frame_mask,
  442. rx_tlv_hdr);
  443. }
  444. #endif
  445. /**
  446. * dp_rx_oor_handle() - Handles the msdu which is OOR error
  447. *
  448. * @soc: core txrx main context
  449. * @nbuf: pointer to msdu skb
  450. * @peer_id: dp peer ID
  451. * @rx_tlv_hdr: start of rx tlv header
  452. *
  453. * This function process the msdu delivered from REO2TCL
  454. * ring with error type OOR
  455. *
  456. * Return: None
  457. */
  458. static void
  459. dp_rx_oor_handle(struct dp_soc *soc,
  460. qdf_nbuf_t nbuf,
  461. uint16_t peer_id,
  462. uint8_t *rx_tlv_hdr)
  463. {
  464. uint32_t frame_mask = wlan_cfg_get_special_frame_cfg(soc->wlan_cfg_ctx);
  465. struct dp_txrx_peer *txrx_peer = NULL;
  466. dp_txrx_ref_handle txrx_ref_handle = NULL;
  467. txrx_peer = dp_tgt_txrx_peer_get_ref_by_id(soc, peer_id,
  468. &txrx_ref_handle,
  469. DP_MOD_ID_RX_ERR);
  470. if (!txrx_peer) {
  471. dp_info_rl("peer not found");
  472. goto free_nbuf;
  473. }
  474. if (dp_rx_deliver_oor_frame(soc, txrx_peer, nbuf, frame_mask,
  475. rx_tlv_hdr)) {
  476. DP_STATS_INC(soc, rx.err.reo_err_oor_to_stack, 1);
  477. dp_txrx_peer_unref_delete(txrx_ref_handle, DP_MOD_ID_RX_ERR);
  478. return;
  479. }
  480. free_nbuf:
  481. if (txrx_peer)
  482. dp_txrx_peer_unref_delete(txrx_ref_handle, DP_MOD_ID_RX_ERR);
  483. DP_STATS_INC(soc, rx.err.reo_err_oor_drop, 1);
  484. dp_rx_nbuf_free(nbuf);
  485. }
  486. /**
  487. * dp_rx_err_nbuf_pn_check() - Check if the PN number of this current packet
  488. * is a monotonous increment of packet number
  489. * from the previous successfully re-ordered
  490. * frame.
  491. * @soc: Datapath SOC handle
  492. * @ring_desc: REO ring descriptor
  493. * @nbuf: Current packet
  494. *
  495. * Return: QDF_STATUS_SUCCESS, if the pn check passes, else QDF_STATUS_E_FAILURE
  496. */
  497. static inline QDF_STATUS
  498. dp_rx_err_nbuf_pn_check(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  499. qdf_nbuf_t nbuf)
  500. {
  501. uint64_t prev_pn, curr_pn[2];
  502. if (!hal_rx_encryption_info_valid(soc->hal_soc, qdf_nbuf_data(nbuf)))
  503. return QDF_STATUS_SUCCESS;
  504. hal_rx_reo_prev_pn_get(soc->hal_soc, ring_desc, &prev_pn);
  505. hal_rx_tlv_get_pn_num(soc->hal_soc, qdf_nbuf_data(nbuf), curr_pn);
  506. if (curr_pn[0] > prev_pn)
  507. return QDF_STATUS_SUCCESS;
  508. return QDF_STATUS_E_FAILURE;
  509. }
  510. #ifdef WLAN_SKIP_BAR_UPDATE
  511. static
  512. void dp_rx_err_handle_bar(struct dp_soc *soc,
  513. struct dp_peer *peer,
  514. qdf_nbuf_t nbuf)
  515. {
  516. dp_info_rl("BAR update to H.W is skipped");
  517. DP_STATS_INC(soc, rx.err.bar_handle_fail_count, 1);
  518. }
  519. #else
  520. static
  521. void dp_rx_err_handle_bar(struct dp_soc *soc,
  522. struct dp_peer *peer,
  523. qdf_nbuf_t nbuf)
  524. {
  525. uint8_t *rx_tlv_hdr;
  526. unsigned char type, subtype;
  527. uint16_t start_seq_num;
  528. uint32_t tid;
  529. QDF_STATUS status;
  530. struct ieee80211_frame_bar *bar;
  531. /*
  532. * 1. Is this a BAR frame. If not Discard it.
  533. * 2. If it is, get the peer id, tid, ssn
  534. * 2a Do a tid update
  535. */
  536. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  537. bar = (struct ieee80211_frame_bar *)(rx_tlv_hdr + soc->rx_pkt_tlv_size);
  538. type = bar->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
  539. subtype = bar->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
  540. if (!(type == IEEE80211_FC0_TYPE_CTL &&
  541. subtype == QDF_IEEE80211_FC0_SUBTYPE_BAR)) {
  542. dp_err_rl("Not a BAR frame!");
  543. return;
  544. }
  545. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc, rx_tlv_hdr);
  546. qdf_assert_always(tid < DP_MAX_TIDS);
  547. start_seq_num = le16toh(bar->i_seq) >> IEEE80211_SEQ_SEQ_SHIFT;
  548. dp_info_rl("tid %u window_size %u start_seq_num %u",
  549. tid, peer->rx_tid[tid].ba_win_size, start_seq_num);
  550. status = dp_rx_tid_update_wifi3(peer, tid,
  551. peer->rx_tid[tid].ba_win_size,
  552. start_seq_num,
  553. true);
  554. if (status != QDF_STATUS_SUCCESS) {
  555. dp_err_rl("failed to handle bar frame update rx tid");
  556. DP_STATS_INC(soc, rx.err.bar_handle_fail_count, 1);
  557. } else {
  558. DP_STATS_INC(soc, rx.err.ssn_update_count, 1);
  559. }
  560. }
  561. #endif
  562. /**
  563. * _dp_rx_bar_frame_handle(): Core of the BAR frame handling
  564. * @soc: Datapath SoC handle
  565. * @nbuf: packet being processed
  566. * @mpdu_desc_info: mpdu desc info for the current packet
  567. * @tid: tid on which the packet arrived
  568. * @err_status: Flag to indicate if REO encountered an error while routing this
  569. * frame
  570. * @error_code: REO error code
  571. *
  572. * Return: None
  573. */
  574. static void
  575. _dp_rx_bar_frame_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
  576. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  577. uint32_t tid, uint8_t err_status, uint32_t error_code)
  578. {
  579. uint16_t peer_id;
  580. struct dp_peer *peer;
  581. peer_id = dp_rx_peer_metadata_peer_id_get(soc,
  582. mpdu_desc_info->peer_meta_data);
  583. peer = dp_peer_get_tgt_peer_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
  584. if (!peer)
  585. return;
  586. dp_info_rl("BAR frame: "
  587. " peer_id = %d"
  588. " tid = %u"
  589. " SSN = %d"
  590. " error status = %d",
  591. peer->peer_id,
  592. tid,
  593. mpdu_desc_info->mpdu_seq,
  594. err_status);
  595. if (err_status == HAL_REO_ERROR_DETECTED) {
  596. switch (error_code) {
  597. case HAL_REO_ERR_BAR_FRAME_2K_JUMP:
  598. case HAL_REO_ERR_BAR_FRAME_OOR:
  599. dp_rx_err_handle_bar(soc, peer, nbuf);
  600. DP_STATS_INC(soc, rx.err.reo_error[error_code], 1);
  601. break;
  602. default:
  603. DP_STATS_INC(soc, rx.bar_frame, 1);
  604. }
  605. }
  606. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  607. }
  608. /**
  609. * dp_rx_bar_frame_handle() - Function to handle err BAR frames
  610. * @soc: core DP main context
  611. * @ring_desc: Hal ring desc
  612. * @rx_desc: dp rx desc
  613. * @mpdu_desc_info: mpdu desc info
  614. * @err_status: error status
  615. * @err_code: error code
  616. *
  617. * Handle the error BAR frames received. Ensure the SOC level
  618. * stats are updated based on the REO error code. The BAR frames
  619. * are further processed by updating the Rx tids with the start
  620. * sequence number (SSN) and BA window size. Desc is returned
  621. * to the free desc list
  622. *
  623. * Return: none
  624. */
  625. static void
  626. dp_rx_bar_frame_handle(struct dp_soc *soc,
  627. hal_ring_desc_t ring_desc,
  628. struct dp_rx_desc *rx_desc,
  629. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  630. uint8_t err_status,
  631. uint32_t err_code)
  632. {
  633. qdf_nbuf_t nbuf;
  634. struct dp_pdev *pdev;
  635. struct rx_desc_pool *rx_desc_pool;
  636. uint8_t *rx_tlv_hdr;
  637. uint32_t tid;
  638. nbuf = rx_desc->nbuf;
  639. rx_desc_pool = &soc->rx_desc_buf[rx_desc->pool_id];
  640. dp_ipa_rx_buf_smmu_mapping_lock(soc);
  641. dp_rx_nbuf_unmap_pool(soc, rx_desc_pool, nbuf);
  642. rx_desc->unmapped = 1;
  643. dp_ipa_rx_buf_smmu_mapping_unlock(soc);
  644. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  645. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc,
  646. rx_tlv_hdr);
  647. pdev = dp_get_pdev_for_lmac_id(soc, rx_desc->pool_id);
  648. if (!pdev) {
  649. dp_rx_err_debug("%pK: pdev is null for pool_id = %d",
  650. soc, rx_desc->pool_id);
  651. return;
  652. }
  653. _dp_rx_bar_frame_handle(soc, nbuf, mpdu_desc_info, tid, err_status,
  654. err_code);
  655. dp_rx_err_send_pktlog(soc, pdev, mpdu_desc_info, nbuf,
  656. QDF_TX_RX_STATUS_DROP, true);
  657. dp_rx_link_desc_return(soc, ring_desc,
  658. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  659. dp_rx_buffer_pool_nbuf_free(soc, rx_desc->nbuf,
  660. rx_desc->pool_id);
  661. dp_rx_add_to_free_desc_list(&pdev->free_list_head,
  662. &pdev->free_list_tail,
  663. rx_desc);
  664. }
  665. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  666. void dp_2k_jump_handle(struct dp_soc *soc, qdf_nbuf_t nbuf, uint8_t *rx_tlv_hdr,
  667. uint16_t peer_id, uint8_t tid)
  668. {
  669. struct dp_peer *peer = NULL;
  670. struct dp_rx_tid *rx_tid = NULL;
  671. uint32_t frame_mask = FRAME_MASK_IPV4_ARP;
  672. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
  673. if (!peer) {
  674. dp_rx_err_info_rl("%pK: peer not found", soc);
  675. goto free_nbuf;
  676. }
  677. if (tid >= DP_MAX_TIDS) {
  678. dp_info_rl("invalid tid");
  679. goto nbuf_deliver;
  680. }
  681. rx_tid = &peer->rx_tid[tid];
  682. qdf_spin_lock_bh(&rx_tid->tid_lock);
  683. /* only if BA session is active, allow send Delba */
  684. if (rx_tid->ba_status != DP_RX_BA_ACTIVE) {
  685. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  686. goto nbuf_deliver;
  687. }
  688. if (!rx_tid->delba_tx_status) {
  689. rx_tid->delba_tx_retry++;
  690. rx_tid->delba_tx_status = 1;
  691. rx_tid->delba_rcode =
  692. IEEE80211_REASON_QOS_SETUP_REQUIRED;
  693. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  694. if (soc->cdp_soc.ol_ops->send_delba) {
  695. DP_STATS_INC(soc, rx.err.rx_2k_jump_delba_sent,
  696. 1);
  697. soc->cdp_soc.ol_ops->send_delba(
  698. peer->vdev->pdev->soc->ctrl_psoc,
  699. peer->vdev->vdev_id,
  700. peer->mac_addr.raw,
  701. tid,
  702. rx_tid->delba_rcode,
  703. CDP_DELBA_2K_JUMP);
  704. }
  705. } else {
  706. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  707. }
  708. nbuf_deliver:
  709. if (dp_rx_deliver_special_frame(soc, peer->txrx_peer, nbuf, frame_mask,
  710. rx_tlv_hdr)) {
  711. DP_STATS_INC(soc, rx.err.rx_2k_jump_to_stack, 1);
  712. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  713. return;
  714. }
  715. free_nbuf:
  716. if (peer)
  717. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  718. DP_STATS_INC(soc, rx.err.rx_2k_jump_drop, 1);
  719. dp_rx_nbuf_free(nbuf);
  720. }
  721. #if defined(QCA_WIFI_QCA6390) || defined(QCA_WIFI_QCA6490) || \
  722. defined(QCA_WIFI_QCA6750) || defined(QCA_WIFI_KIWI)
  723. bool
  724. dp_rx_null_q_handle_invalid_peer_id_exception(struct dp_soc *soc,
  725. uint8_t pool_id,
  726. uint8_t *rx_tlv_hdr,
  727. qdf_nbuf_t nbuf)
  728. {
  729. struct dp_peer *peer = NULL;
  730. uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(soc->hal_soc, rx_tlv_hdr);
  731. struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, pool_id);
  732. struct ieee80211_frame *wh = (struct ieee80211_frame *)rx_pkt_hdr;
  733. if (!pdev) {
  734. dp_rx_err_debug("%pK: pdev is null for pool_id = %d",
  735. soc, pool_id);
  736. return false;
  737. }
  738. /*
  739. * WAR- In certain types of packets if peer_id is not correct then
  740. * driver may not be able find. Try finding peer by addr_2 of
  741. * received MPDU
  742. */
  743. if (wh)
  744. peer = dp_peer_find_hash_find(soc, wh->i_addr2, 0,
  745. DP_VDEV_ALL, DP_MOD_ID_RX_ERR);
  746. if (peer) {
  747. dp_verbose_debug("MPDU sw_peer_id & ast_idx is corrupted");
  748. hal_rx_dump_pkt_tlvs(soc->hal_soc, rx_tlv_hdr,
  749. QDF_TRACE_LEVEL_DEBUG);
  750. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer_id,
  751. 1, qdf_nbuf_len(nbuf));
  752. dp_rx_nbuf_free(nbuf);
  753. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  754. return true;
  755. }
  756. return false;
  757. }
  758. #else
  759. bool
  760. dp_rx_null_q_handle_invalid_peer_id_exception(struct dp_soc *soc,
  761. uint8_t pool_id,
  762. uint8_t *rx_tlv_hdr,
  763. qdf_nbuf_t nbuf)
  764. {
  765. return false;
  766. }
  767. #endif
  768. bool dp_rx_check_pkt_len(struct dp_soc *soc, uint32_t pkt_len)
  769. {
  770. if (qdf_unlikely(pkt_len > RX_DATA_BUFFER_SIZE)) {
  771. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_pkt_len,
  772. 1, pkt_len);
  773. return true;
  774. } else {
  775. return false;
  776. }
  777. }
  778. #ifdef QCA_SUPPORT_EAPOL_OVER_CONTROL_PORT
  779. void
  780. dp_rx_deliver_to_osif_stack(struct dp_soc *soc,
  781. struct dp_vdev *vdev,
  782. struct dp_txrx_peer *txrx_peer,
  783. qdf_nbuf_t nbuf,
  784. qdf_nbuf_t tail,
  785. bool is_eapol)
  786. {
  787. if (is_eapol && soc->eapol_over_control_port)
  788. dp_rx_eapol_deliver_to_stack(soc, vdev, txrx_peer, nbuf, NULL);
  789. else
  790. dp_rx_deliver_to_stack(soc, vdev, txrx_peer, nbuf, NULL);
  791. }
  792. #else
  793. void
  794. dp_rx_deliver_to_osif_stack(struct dp_soc *soc,
  795. struct dp_vdev *vdev,
  796. struct dp_txrx_peer *txrx_peer,
  797. qdf_nbuf_t nbuf,
  798. qdf_nbuf_t tail,
  799. bool is_eapol)
  800. {
  801. dp_rx_deliver_to_stack(soc, vdev, txrx_peer, nbuf, NULL);
  802. }
  803. #endif
  804. #ifdef WLAN_FEATURE_11BE_MLO
  805. int dp_rx_err_match_dhost(qdf_ether_header_t *eh, struct dp_vdev *vdev)
  806. {
  807. return ((qdf_mem_cmp(eh->ether_dhost, &vdev->mac_addr.raw[0],
  808. QDF_MAC_ADDR_SIZE) == 0) ||
  809. (qdf_mem_cmp(eh->ether_dhost, &vdev->mld_mac_addr.raw[0],
  810. QDF_MAC_ADDR_SIZE) == 0));
  811. }
  812. #else
  813. int dp_rx_err_match_dhost(qdf_ether_header_t *eh, struct dp_vdev *vdev)
  814. {
  815. return (qdf_mem_cmp(eh->ether_dhost, &vdev->mac_addr.raw[0],
  816. QDF_MAC_ADDR_SIZE) == 0);
  817. }
  818. #endif
  819. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  820. bool
  821. dp_rx_err_drop_3addr_mcast(struct dp_vdev *vdev, uint8_t *rx_tlv_hdr)
  822. {
  823. struct dp_soc *soc = vdev->pdev->soc;
  824. if (!vdev->drop_3addr_mcast)
  825. return false;
  826. if (vdev->opmode != wlan_op_mode_sta)
  827. return false;
  828. if (hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc, rx_tlv_hdr))
  829. return true;
  830. return false;
  831. }
  832. /**
  833. * dp_rx_err_is_pn_check_needed() - Check if the packet number check is needed
  834. * for this frame received in REO error ring.
  835. * @soc: Datapath SOC handle
  836. * @error: REO error detected or not
  837. * @error_code: Error code in case of REO error
  838. *
  839. * Return: true if pn check if needed in software,
  840. * false, if pn check if not needed.
  841. */
  842. static inline bool
  843. dp_rx_err_is_pn_check_needed(struct dp_soc *soc, uint8_t error,
  844. uint32_t error_code)
  845. {
  846. return (soc->features.pn_in_reo_dest &&
  847. (error == HAL_REO_ERROR_DETECTED &&
  848. (hal_rx_reo_is_2k_jump(error_code) ||
  849. hal_rx_reo_is_oor_error(error_code) ||
  850. hal_rx_reo_is_bar_oor_2k_jump(error_code))));
  851. }
  852. #ifdef DP_WAR_INVALID_FIRST_MSDU_FLAG
  853. static inline void
  854. dp_rx_err_populate_mpdu_desc_info(struct dp_soc *soc, qdf_nbuf_t nbuf,
  855. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  856. bool first_msdu_in_mpdu_processed)
  857. {
  858. if (first_msdu_in_mpdu_processed) {
  859. /*
  860. * This is the 2nd indication of first_msdu in the same mpdu.
  861. * Skip re-parsing the mdpu_desc_info and use the cached one,
  862. * since this msdu is most probably from the current mpdu
  863. * which is being processed
  864. */
  865. } else {
  866. hal_rx_tlv_populate_mpdu_desc_info(soc->hal_soc,
  867. qdf_nbuf_data(nbuf),
  868. mpdu_desc_info);
  869. }
  870. }
  871. #else
  872. static inline void
  873. dp_rx_err_populate_mpdu_desc_info(struct dp_soc *soc, qdf_nbuf_t nbuf,
  874. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  875. bool first_msdu_in_mpdu_processed)
  876. {
  877. hal_rx_tlv_populate_mpdu_desc_info(soc->hal_soc, qdf_nbuf_data(nbuf),
  878. mpdu_desc_info);
  879. }
  880. #endif
  881. /**
  882. * dp_rx_reo_err_entry_process() - Handles for REO error entry processing
  883. *
  884. * @soc: core txrx main context
  885. * @ring_desc: opaque pointer to the REO error ring descriptor
  886. * @mpdu_desc_info: pointer to mpdu level description info
  887. * @link_desc_va: pointer to msdu_link_desc virtual address
  888. * @err_code: reo error code fetched from ring entry
  889. *
  890. * Function to handle msdus fetched from msdu link desc, currently
  891. * support REO error NULL queue, 2K jump, OOR.
  892. *
  893. * Return: msdu count processed
  894. */
  895. static uint32_t
  896. dp_rx_reo_err_entry_process(struct dp_soc *soc,
  897. void *ring_desc,
  898. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  899. void *link_desc_va,
  900. enum hal_reo_error_code err_code)
  901. {
  902. uint32_t rx_bufs_used = 0;
  903. struct dp_pdev *pdev;
  904. int i;
  905. uint8_t *rx_tlv_hdr_first;
  906. uint8_t *rx_tlv_hdr_last;
  907. uint32_t tid = DP_MAX_TIDS;
  908. uint16_t peer_id;
  909. struct dp_rx_desc *rx_desc;
  910. struct rx_desc_pool *rx_desc_pool;
  911. qdf_nbuf_t nbuf;
  912. qdf_nbuf_t next_nbuf;
  913. struct hal_buf_info buf_info;
  914. struct hal_rx_msdu_list msdu_list;
  915. uint16_t num_msdus;
  916. struct buffer_addr_info cur_link_desc_addr_info = { 0 };
  917. struct buffer_addr_info next_link_desc_addr_info = { 0 };
  918. /* First field in REO Dst ring Desc is buffer_addr_info */
  919. void *buf_addr_info = ring_desc;
  920. qdf_nbuf_t head_nbuf = NULL;
  921. qdf_nbuf_t tail_nbuf = NULL;
  922. uint16_t msdu_processed = 0;
  923. QDF_STATUS status;
  924. bool ret, is_pn_check_needed;
  925. uint8_t rx_desc_pool_id;
  926. struct dp_txrx_peer *txrx_peer = NULL;
  927. dp_txrx_ref_handle txrx_ref_handle = NULL;
  928. hal_ring_handle_t hal_ring_hdl = soc->reo_exception_ring.hal_srng;
  929. bool first_msdu_in_mpdu_processed = false;
  930. bool msdu_dropped = false;
  931. uint8_t link_id = 0;
  932. peer_id = dp_rx_peer_metadata_peer_id_get(soc,
  933. mpdu_desc_info->peer_meta_data);
  934. is_pn_check_needed = dp_rx_err_is_pn_check_needed(soc,
  935. HAL_REO_ERROR_DETECTED,
  936. err_code);
  937. more_msdu_link_desc:
  938. hal_rx_msdu_list_get(soc->hal_soc, link_desc_va, &msdu_list,
  939. &num_msdus);
  940. for (i = 0; i < num_msdus; i++) {
  941. rx_desc = soc->arch_ops.dp_rx_desc_cookie_2_va(
  942. soc,
  943. msdu_list.sw_cookie[i]);
  944. qdf_assert_always(rx_desc);
  945. nbuf = rx_desc->nbuf;
  946. /*
  947. * this is a unlikely scenario where the host is reaping
  948. * a descriptor which it already reaped just a while ago
  949. * but is yet to replenish it back to HW.
  950. * In this case host will dump the last 128 descriptors
  951. * including the software descriptor rx_desc and assert.
  952. */
  953. if (qdf_unlikely(!rx_desc->in_use) ||
  954. qdf_unlikely(!nbuf)) {
  955. DP_STATS_INC(soc, rx.err.hal_reo_dest_dup, 1);
  956. dp_info_rl("Reaping rx_desc not in use!");
  957. dp_rx_dump_info_and_assert(soc, hal_ring_hdl,
  958. ring_desc, rx_desc);
  959. /* ignore duplicate RX desc and continue to process */
  960. /* Pop out the descriptor */
  961. msdu_dropped = true;
  962. continue;
  963. }
  964. ret = dp_rx_desc_paddr_sanity_check(rx_desc,
  965. msdu_list.paddr[i]);
  966. if (!ret) {
  967. DP_STATS_INC(soc, rx.err.nbuf_sanity_fail, 1);
  968. rx_desc->in_err_state = 1;
  969. msdu_dropped = true;
  970. continue;
  971. }
  972. rx_desc_pool_id = rx_desc->pool_id;
  973. /* all buffers from a MSDU link belong to same pdev */
  974. pdev = dp_get_pdev_for_lmac_id(soc, rx_desc_pool_id);
  975. rx_desc_pool = &soc->rx_desc_buf[rx_desc_pool_id];
  976. dp_ipa_rx_buf_smmu_mapping_lock(soc);
  977. dp_rx_nbuf_unmap_pool(soc, rx_desc_pool, nbuf);
  978. rx_desc->unmapped = 1;
  979. dp_ipa_rx_buf_smmu_mapping_unlock(soc);
  980. QDF_NBUF_CB_RX_PKT_LEN(nbuf) = msdu_list.msdu_info[i].msdu_len;
  981. rx_bufs_used++;
  982. dp_rx_add_to_free_desc_list(&pdev->free_list_head,
  983. &pdev->free_list_tail, rx_desc);
  984. DP_RX_LIST_APPEND(head_nbuf, tail_nbuf, nbuf);
  985. if (qdf_unlikely(msdu_list.msdu_info[i].msdu_flags &
  986. HAL_MSDU_F_MSDU_CONTINUATION)) {
  987. qdf_nbuf_set_rx_chfrag_cont(nbuf, 1);
  988. continue;
  989. }
  990. if (dp_rx_buffer_pool_refill(soc, head_nbuf,
  991. rx_desc_pool_id)) {
  992. /* MSDU queued back to the pool */
  993. msdu_dropped = true;
  994. head_nbuf = NULL;
  995. goto process_next_msdu;
  996. }
  997. if (is_pn_check_needed) {
  998. if (msdu_list.msdu_info[i].msdu_flags &
  999. HAL_MSDU_F_FIRST_MSDU_IN_MPDU) {
  1000. dp_rx_err_populate_mpdu_desc_info(soc, nbuf,
  1001. mpdu_desc_info,
  1002. first_msdu_in_mpdu_processed);
  1003. first_msdu_in_mpdu_processed = true;
  1004. } else {
  1005. if (!first_msdu_in_mpdu_processed) {
  1006. /*
  1007. * If no msdu in this mpdu was dropped
  1008. * due to failed sanity checks, then
  1009. * its not expected to hit this
  1010. * condition. Hence we assert here.
  1011. */
  1012. if (!msdu_dropped)
  1013. qdf_assert_always(0);
  1014. /*
  1015. * We do not have valid mpdu_desc_info
  1016. * to process this nbuf, hence drop it.
  1017. * TODO - Increment stats
  1018. */
  1019. goto process_next_msdu;
  1020. }
  1021. /*
  1022. * DO NOTHING -
  1023. * Continue using the same mpdu_desc_info
  1024. * details populated from the first msdu in
  1025. * the mpdu.
  1026. */
  1027. }
  1028. status = dp_rx_err_nbuf_pn_check(soc, ring_desc, nbuf);
  1029. if (QDF_IS_STATUS_ERROR(status)) {
  1030. DP_STATS_INC(soc, rx.err.pn_in_dest_check_fail,
  1031. 1);
  1032. goto process_next_msdu;
  1033. }
  1034. peer_id = dp_rx_peer_metadata_peer_id_get(soc,
  1035. mpdu_desc_info->peer_meta_data);
  1036. if (mpdu_desc_info->bar_frame)
  1037. _dp_rx_bar_frame_handle(soc, nbuf,
  1038. mpdu_desc_info, tid,
  1039. HAL_REO_ERROR_DETECTED,
  1040. err_code);
  1041. }
  1042. rx_tlv_hdr_first = qdf_nbuf_data(head_nbuf);
  1043. rx_tlv_hdr_last = qdf_nbuf_data(tail_nbuf);
  1044. if (qdf_unlikely(head_nbuf != tail_nbuf)) {
  1045. /*
  1046. * For SG case, only the length of last skb is valid
  1047. * as HW only populate the msdu_len for last msdu
  1048. * in rx link descriptor, use the length from
  1049. * last skb to overwrite the head skb for further
  1050. * SG processing.
  1051. */
  1052. QDF_NBUF_CB_RX_PKT_LEN(head_nbuf) =
  1053. QDF_NBUF_CB_RX_PKT_LEN(tail_nbuf);
  1054. nbuf = dp_rx_sg_create(soc, head_nbuf);
  1055. qdf_nbuf_set_is_frag(nbuf, 1);
  1056. DP_STATS_INC(soc, rx.err.reo_err_oor_sg_count, 1);
  1057. }
  1058. head_nbuf = NULL;
  1059. switch (err_code) {
  1060. case HAL_REO_ERR_REGULAR_FRAME_2K_JUMP:
  1061. case HAL_REO_ERR_2K_ERROR_HANDLING_FLAG_SET:
  1062. case HAL_REO_ERR_BAR_FRAME_2K_JUMP:
  1063. /*
  1064. * only first msdu, mpdu start description tlv valid?
  1065. * and use it for following msdu.
  1066. */
  1067. if (hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  1068. rx_tlv_hdr_last))
  1069. tid = hal_rx_mpdu_start_tid_get(
  1070. soc->hal_soc,
  1071. rx_tlv_hdr_first);
  1072. dp_2k_jump_handle(soc, nbuf, rx_tlv_hdr_last,
  1073. peer_id, tid);
  1074. break;
  1075. case HAL_REO_ERR_REGULAR_FRAME_OOR:
  1076. case HAL_REO_ERR_BAR_FRAME_OOR:
  1077. dp_rx_oor_handle(soc, nbuf, peer_id, rx_tlv_hdr_last);
  1078. break;
  1079. case HAL_REO_ERR_QUEUE_DESC_ADDR_0:
  1080. txrx_peer = dp_tgt_txrx_peer_get_ref_by_id(
  1081. soc, peer_id,
  1082. &txrx_ref_handle,
  1083. DP_MOD_ID_RX_ERR);
  1084. if (!txrx_peer)
  1085. dp_info_rl("txrx_peer is null peer_id %u",
  1086. peer_id);
  1087. soc->arch_ops.dp_rx_null_q_desc_handle(soc, nbuf,
  1088. rx_tlv_hdr_last,
  1089. rx_desc_pool_id,
  1090. txrx_peer,
  1091. TRUE,
  1092. link_id);
  1093. if (txrx_peer)
  1094. dp_txrx_peer_unref_delete(txrx_ref_handle,
  1095. DP_MOD_ID_RX_ERR);
  1096. break;
  1097. default:
  1098. dp_err_rl("Non-support error code %d", err_code);
  1099. dp_rx_nbuf_free(nbuf);
  1100. }
  1101. process_next_msdu:
  1102. nbuf = head_nbuf;
  1103. while (nbuf) {
  1104. next_nbuf = qdf_nbuf_next(nbuf);
  1105. dp_rx_nbuf_free(nbuf);
  1106. nbuf = next_nbuf;
  1107. }
  1108. msdu_processed++;
  1109. head_nbuf = NULL;
  1110. tail_nbuf = NULL;
  1111. }
  1112. /*
  1113. * If the msdu's are spread across multiple link-descriptors,
  1114. * we cannot depend solely on the msdu_count(e.g., if msdu is
  1115. * spread across multiple buffers).Hence, it is
  1116. * necessary to check the next link_descriptor and release
  1117. * all the msdu's that are part of it.
  1118. */
  1119. hal_rx_get_next_msdu_link_desc_buf_addr_info(
  1120. link_desc_va,
  1121. &next_link_desc_addr_info);
  1122. if (hal_rx_is_buf_addr_info_valid(
  1123. &next_link_desc_addr_info)) {
  1124. /* Clear the next link desc info for the current link_desc */
  1125. hal_rx_clear_next_msdu_link_desc_buf_addr_info(link_desc_va);
  1126. dp_rx_link_desc_return_by_addr(
  1127. soc,
  1128. buf_addr_info,
  1129. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  1130. hal_rx_buffer_addr_info_get_paddr(
  1131. &next_link_desc_addr_info,
  1132. &buf_info);
  1133. /* buffer_addr_info is the first element of ring_desc */
  1134. hal_rx_buf_cookie_rbm_get(soc->hal_soc,
  1135. (uint32_t *)&next_link_desc_addr_info,
  1136. &buf_info);
  1137. link_desc_va =
  1138. dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  1139. cur_link_desc_addr_info = next_link_desc_addr_info;
  1140. buf_addr_info = &cur_link_desc_addr_info;
  1141. goto more_msdu_link_desc;
  1142. }
  1143. dp_rx_link_desc_return_by_addr(soc, buf_addr_info,
  1144. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  1145. if (qdf_unlikely(msdu_processed != mpdu_desc_info->msdu_count))
  1146. DP_STATS_INC(soc, rx.err.msdu_count_mismatch, 1);
  1147. return rx_bufs_used;
  1148. }
  1149. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  1150. void
  1151. dp_rx_process_rxdma_err(struct dp_soc *soc, qdf_nbuf_t nbuf,
  1152. uint8_t *rx_tlv_hdr, struct dp_txrx_peer *txrx_peer,
  1153. uint8_t err_code, uint8_t mac_id, uint8_t link_id)
  1154. {
  1155. uint32_t pkt_len, l2_hdr_offset;
  1156. uint16_t msdu_len;
  1157. struct dp_vdev *vdev;
  1158. qdf_ether_header_t *eh;
  1159. bool is_broadcast;
  1160. /*
  1161. * Check if DMA completed -- msdu_done is the last bit
  1162. * to be written
  1163. */
  1164. if (!hal_rx_attn_msdu_done_get(soc->hal_soc, rx_tlv_hdr)) {
  1165. dp_err_rl("MSDU DONE failure");
  1166. hal_rx_dump_pkt_tlvs(soc->hal_soc, rx_tlv_hdr,
  1167. QDF_TRACE_LEVEL_INFO);
  1168. qdf_assert(0);
  1169. }
  1170. l2_hdr_offset = hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc,
  1171. rx_tlv_hdr);
  1172. msdu_len = hal_rx_msdu_start_msdu_len_get(soc->hal_soc, rx_tlv_hdr);
  1173. pkt_len = msdu_len + l2_hdr_offset + soc->rx_pkt_tlv_size;
  1174. if (dp_rx_check_pkt_len(soc, pkt_len)) {
  1175. /* Drop & free packet */
  1176. dp_rx_nbuf_free(nbuf);
  1177. return;
  1178. }
  1179. /* Set length in nbuf */
  1180. qdf_nbuf_set_pktlen(nbuf, pkt_len);
  1181. qdf_nbuf_set_next(nbuf, NULL);
  1182. qdf_nbuf_set_rx_chfrag_start(nbuf, 1);
  1183. qdf_nbuf_set_rx_chfrag_end(nbuf, 1);
  1184. if (!txrx_peer) {
  1185. QDF_TRACE_ERROR_RL(QDF_MODULE_ID_DP, "txrx_peer is NULL");
  1186. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  1187. qdf_nbuf_len(nbuf));
  1188. /* Trigger invalid peer handler wrapper */
  1189. dp_rx_process_invalid_peer_wrapper(soc, nbuf, true, mac_id);
  1190. return;
  1191. }
  1192. vdev = txrx_peer->vdev;
  1193. if (!vdev) {
  1194. dp_rx_err_info_rl("%pK: INVALID vdev %pK OR osif_rx", soc,
  1195. vdev);
  1196. /* Drop & free packet */
  1197. dp_rx_nbuf_free(nbuf);
  1198. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  1199. return;
  1200. }
  1201. /*
  1202. * Advance the packet start pointer by total size of
  1203. * pre-header TLV's
  1204. */
  1205. dp_rx_skip_tlvs(soc, nbuf, l2_hdr_offset);
  1206. if (err_code == HAL_RXDMA_ERR_WIFI_PARSE) {
  1207. uint8_t *pkt_type;
  1208. pkt_type = qdf_nbuf_data(nbuf) + (2 * QDF_MAC_ADDR_SIZE);
  1209. if (*(uint16_t *)pkt_type == htons(QDF_ETH_TYPE_8021Q)) {
  1210. if (*(uint16_t *)(pkt_type + DP_SKIP_VLAN) ==
  1211. htons(QDF_LLC_STP)) {
  1212. DP_STATS_INC(vdev->pdev, vlan_tag_stp_cnt, 1);
  1213. goto process_mesh;
  1214. } else {
  1215. goto process_rx;
  1216. }
  1217. }
  1218. }
  1219. if (vdev->rx_decap_type == htt_cmn_pkt_type_raw)
  1220. goto process_mesh;
  1221. /*
  1222. * WAPI cert AP sends rekey frames as unencrypted.
  1223. * Thus RXDMA will report unencrypted frame error.
  1224. * To pass WAPI cert case, SW needs to pass unencrypted
  1225. * rekey frame to stack.
  1226. */
  1227. if (qdf_nbuf_is_ipv4_wapi_pkt(nbuf)) {
  1228. goto process_rx;
  1229. }
  1230. /*
  1231. * In dynamic WEP case rekey frames are not encrypted
  1232. * similar to WAPI. Allow EAPOL when 8021+wep is enabled and
  1233. * key install is already done
  1234. */
  1235. if ((vdev->sec_type == cdp_sec_type_wep104) &&
  1236. (qdf_nbuf_is_ipv4_eapol_pkt(nbuf)))
  1237. goto process_rx;
  1238. process_mesh:
  1239. if (!vdev->mesh_vdev && err_code == HAL_RXDMA_ERR_UNENCRYPTED) {
  1240. dp_rx_nbuf_free(nbuf);
  1241. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  1242. return;
  1243. }
  1244. if (vdev->mesh_vdev) {
  1245. if (dp_rx_filter_mesh_packets(vdev, nbuf, rx_tlv_hdr)
  1246. == QDF_STATUS_SUCCESS) {
  1247. dp_rx_err_info("%pK: mesh pkt filtered", soc);
  1248. DP_STATS_INC(vdev->pdev, dropped.mesh_filter, 1);
  1249. dp_rx_nbuf_free(nbuf);
  1250. return;
  1251. }
  1252. dp_rx_fill_mesh_stats(vdev, nbuf, rx_tlv_hdr, txrx_peer);
  1253. }
  1254. process_rx:
  1255. if (qdf_unlikely(hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
  1256. rx_tlv_hdr) &&
  1257. (vdev->rx_decap_type ==
  1258. htt_cmn_pkt_type_ethernet))) {
  1259. eh = (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
  1260. is_broadcast = (QDF_IS_ADDR_BROADCAST
  1261. (eh->ether_dhost)) ? 1 : 0 ;
  1262. DP_PEER_PER_PKT_STATS_INC_PKT(txrx_peer, rx.multicast, 1,
  1263. qdf_nbuf_len(nbuf), link_id);
  1264. if (is_broadcast) {
  1265. DP_PEER_PER_PKT_STATS_INC_PKT(txrx_peer, rx.bcast, 1,
  1266. qdf_nbuf_len(nbuf),
  1267. link_id);
  1268. }
  1269. } else {
  1270. DP_PEER_PER_PKT_STATS_INC_PKT(txrx_peer, rx.unicast, 1,
  1271. qdf_nbuf_len(nbuf),
  1272. link_id);
  1273. }
  1274. if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw)) {
  1275. dp_rx_deliver_raw(vdev, nbuf, txrx_peer, link_id);
  1276. } else {
  1277. /* Update the protocol tag in SKB based on CCE metadata */
  1278. dp_rx_update_protocol_tag(soc, vdev, nbuf, rx_tlv_hdr,
  1279. EXCEPTION_DEST_RING_ID, true, true);
  1280. /* Update the flow tag in SKB based on FSE metadata */
  1281. dp_rx_update_flow_tag(soc, vdev, nbuf, rx_tlv_hdr, true);
  1282. DP_PEER_STATS_FLAT_INC(txrx_peer, to_stack.num, 1);
  1283. qdf_nbuf_set_exc_frame(nbuf, 1);
  1284. dp_rx_deliver_to_osif_stack(soc, vdev, txrx_peer, nbuf, NULL,
  1285. qdf_nbuf_is_ipv4_eapol_pkt(nbuf));
  1286. }
  1287. return;
  1288. }
  1289. void dp_rx_process_mic_error(struct dp_soc *soc, qdf_nbuf_t nbuf,
  1290. uint8_t *rx_tlv_hdr,
  1291. struct dp_txrx_peer *txrx_peer)
  1292. {
  1293. struct dp_vdev *vdev = NULL;
  1294. struct dp_pdev *pdev = NULL;
  1295. struct ol_if_ops *tops = NULL;
  1296. uint16_t rx_seq, fragno;
  1297. uint8_t is_raw;
  1298. unsigned int tid;
  1299. QDF_STATUS status;
  1300. struct cdp_rx_mic_err_info mic_failure_info;
  1301. if (!hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  1302. rx_tlv_hdr))
  1303. return;
  1304. if (!txrx_peer) {
  1305. dp_info_rl("txrx_peer not found");
  1306. goto fail;
  1307. }
  1308. vdev = txrx_peer->vdev;
  1309. if (!vdev) {
  1310. dp_info_rl("VDEV not found");
  1311. goto fail;
  1312. }
  1313. pdev = vdev->pdev;
  1314. if (!pdev) {
  1315. dp_info_rl("PDEV not found");
  1316. goto fail;
  1317. }
  1318. is_raw = HAL_IS_DECAP_FORMAT_RAW(soc->hal_soc, qdf_nbuf_data(nbuf));
  1319. if (is_raw) {
  1320. fragno = dp_rx_frag_get_mpdu_frag_number(soc,
  1321. qdf_nbuf_data(nbuf));
  1322. /* Can get only last fragment */
  1323. if (fragno) {
  1324. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc,
  1325. qdf_nbuf_data(nbuf));
  1326. rx_seq = hal_rx_get_rx_sequence(soc->hal_soc,
  1327. qdf_nbuf_data(nbuf));
  1328. status = dp_rx_defrag_add_last_frag(soc, txrx_peer,
  1329. tid, rx_seq, nbuf);
  1330. dp_info_rl("Frag pkt seq# %d frag# %d consumed "
  1331. "status %d !", rx_seq, fragno, status);
  1332. return;
  1333. }
  1334. }
  1335. if (hal_rx_mpdu_get_addr1(soc->hal_soc, qdf_nbuf_data(nbuf),
  1336. &mic_failure_info.da_mac_addr.bytes[0])) {
  1337. dp_err_rl("Failed to get da_mac_addr");
  1338. goto fail;
  1339. }
  1340. if (hal_rx_mpdu_get_addr2(soc->hal_soc, qdf_nbuf_data(nbuf),
  1341. &mic_failure_info.ta_mac_addr.bytes[0])) {
  1342. dp_err_rl("Failed to get ta_mac_addr");
  1343. goto fail;
  1344. }
  1345. mic_failure_info.key_id = 0;
  1346. mic_failure_info.multicast =
  1347. IEEE80211_IS_MULTICAST(mic_failure_info.da_mac_addr.bytes);
  1348. qdf_mem_zero(mic_failure_info.tsc, MIC_SEQ_CTR_SIZE);
  1349. mic_failure_info.frame_type = cdp_rx_frame_type_802_11;
  1350. mic_failure_info.data = NULL;
  1351. mic_failure_info.vdev_id = vdev->vdev_id;
  1352. tops = pdev->soc->cdp_soc.ol_ops;
  1353. if (tops->rx_mic_error)
  1354. tops->rx_mic_error(soc->ctrl_psoc, pdev->pdev_id,
  1355. &mic_failure_info);
  1356. fail:
  1357. dp_rx_nbuf_free(nbuf);
  1358. return;
  1359. }
  1360. #if defined(WLAN_FEATURE_11BE_MLO) && defined(WLAN_MLO_MULTI_CHIP) && \
  1361. defined(WLAN_MCAST_MLO)
  1362. static bool dp_rx_igmp_handler(struct dp_soc *soc,
  1363. struct dp_vdev *vdev,
  1364. struct dp_txrx_peer *peer,
  1365. qdf_nbuf_t nbuf,
  1366. uint8_t link_id)
  1367. {
  1368. if (soc->arch_ops.dp_rx_mcast_handler) {
  1369. if (soc->arch_ops.dp_rx_mcast_handler(soc, vdev, peer,
  1370. nbuf, link_id))
  1371. return true;
  1372. }
  1373. return false;
  1374. }
  1375. #else
  1376. static bool dp_rx_igmp_handler(struct dp_soc *soc,
  1377. struct dp_vdev *vdev,
  1378. struct dp_txrx_peer *peer,
  1379. qdf_nbuf_t nbuf,
  1380. uint8_t link_id)
  1381. {
  1382. return false;
  1383. }
  1384. #endif
  1385. /**
  1386. * dp_rx_err_route_hdl() - Function to send EAPOL frames to stack
  1387. * Free any other packet which comes in
  1388. * this path.
  1389. *
  1390. * @soc: core DP main context
  1391. * @nbuf: buffer pointer
  1392. * @txrx_peer: txrx peer handle
  1393. * @rx_tlv_hdr: start of rx tlv header
  1394. * @err_src: rxdma/reo
  1395. * @link_id: link id on which the packet is received
  1396. *
  1397. * This function indicates EAPOL frame received in wbm error ring to stack.
  1398. * Any other frame should be dropped.
  1399. *
  1400. * Return: SUCCESS if delivered to stack
  1401. */
  1402. static void
  1403. dp_rx_err_route_hdl(struct dp_soc *soc, qdf_nbuf_t nbuf,
  1404. struct dp_txrx_peer *txrx_peer, uint8_t *rx_tlv_hdr,
  1405. enum hal_rx_wbm_error_source err_src,
  1406. uint8_t link_id)
  1407. {
  1408. uint32_t pkt_len;
  1409. uint16_t msdu_len;
  1410. struct dp_vdev *vdev;
  1411. struct hal_rx_msdu_metadata msdu_metadata;
  1412. bool is_eapol;
  1413. qdf_nbuf_set_rx_chfrag_start(
  1414. nbuf,
  1415. hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  1416. rx_tlv_hdr));
  1417. qdf_nbuf_set_rx_chfrag_end(nbuf,
  1418. hal_rx_msdu_end_last_msdu_get(soc->hal_soc,
  1419. rx_tlv_hdr));
  1420. qdf_nbuf_set_da_mcbc(nbuf, hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
  1421. rx_tlv_hdr));
  1422. qdf_nbuf_set_da_valid(nbuf,
  1423. hal_rx_msdu_end_da_is_valid_get(soc->hal_soc,
  1424. rx_tlv_hdr));
  1425. qdf_nbuf_set_sa_valid(nbuf,
  1426. hal_rx_msdu_end_sa_is_valid_get(soc->hal_soc,
  1427. rx_tlv_hdr));
  1428. hal_rx_msdu_metadata_get(soc->hal_soc, rx_tlv_hdr, &msdu_metadata);
  1429. msdu_len = hal_rx_msdu_start_msdu_len_get(soc->hal_soc, rx_tlv_hdr);
  1430. pkt_len = msdu_len + msdu_metadata.l3_hdr_pad + soc->rx_pkt_tlv_size;
  1431. if (qdf_likely(!qdf_nbuf_is_frag(nbuf))) {
  1432. if (dp_rx_check_pkt_len(soc, pkt_len))
  1433. goto drop_nbuf;
  1434. /* Set length in nbuf */
  1435. qdf_nbuf_set_pktlen(
  1436. nbuf, qdf_min(pkt_len, (uint32_t)RX_DATA_BUFFER_SIZE));
  1437. qdf_assert_always(nbuf->data == rx_tlv_hdr);
  1438. }
  1439. /*
  1440. * Check if DMA completed -- msdu_done is the last bit
  1441. * to be written
  1442. */
  1443. if (!hal_rx_attn_msdu_done_get(soc->hal_soc, rx_tlv_hdr)) {
  1444. dp_err_rl("MSDU DONE failure");
  1445. hal_rx_dump_pkt_tlvs(soc->hal_soc, rx_tlv_hdr,
  1446. QDF_TRACE_LEVEL_INFO);
  1447. qdf_assert(0);
  1448. }
  1449. if (!txrx_peer)
  1450. goto drop_nbuf;
  1451. vdev = txrx_peer->vdev;
  1452. if (!vdev) {
  1453. dp_err_rl("Null vdev!");
  1454. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  1455. goto drop_nbuf;
  1456. }
  1457. /*
  1458. * Advance the packet start pointer by total size of
  1459. * pre-header TLV's
  1460. */
  1461. if (qdf_nbuf_is_frag(nbuf))
  1462. qdf_nbuf_pull_head(nbuf, soc->rx_pkt_tlv_size);
  1463. else
  1464. qdf_nbuf_pull_head(nbuf, (msdu_metadata.l3_hdr_pad +
  1465. soc->rx_pkt_tlv_size));
  1466. QDF_NBUF_CB_RX_PEER_ID(nbuf) = txrx_peer->peer_id;
  1467. if (dp_rx_igmp_handler(soc, vdev, txrx_peer, nbuf, link_id))
  1468. return;
  1469. dp_vdev_peer_stats_update_protocol_cnt(vdev, nbuf, NULL, 0, 1);
  1470. /*
  1471. * Indicate EAPOL frame to stack only when vap mac address
  1472. * matches the destination address.
  1473. */
  1474. is_eapol = qdf_nbuf_is_ipv4_eapol_pkt(nbuf);
  1475. if (is_eapol || qdf_nbuf_is_ipv4_wapi_pkt(nbuf)) {
  1476. qdf_ether_header_t *eh =
  1477. (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
  1478. if (dp_rx_err_match_dhost(eh, vdev)) {
  1479. DP_STATS_INC_PKT(vdev, rx_i.routed_eapol_pkt, 1,
  1480. qdf_nbuf_len(nbuf));
  1481. /*
  1482. * Update the protocol tag in SKB based on
  1483. * CCE metadata.
  1484. */
  1485. dp_rx_update_protocol_tag(soc, vdev, nbuf, rx_tlv_hdr,
  1486. EXCEPTION_DEST_RING_ID,
  1487. true, true);
  1488. /* Update the flow tag in SKB based on FSE metadata */
  1489. dp_rx_update_flow_tag(soc, vdev, nbuf, rx_tlv_hdr,
  1490. true);
  1491. DP_PEER_TO_STACK_INCC_PKT(txrx_peer, 1,
  1492. qdf_nbuf_len(nbuf),
  1493. vdev->pdev->enhanced_stats_en);
  1494. qdf_nbuf_set_exc_frame(nbuf, 1);
  1495. qdf_nbuf_set_next(nbuf, NULL);
  1496. dp_rx_deliver_to_osif_stack(soc, vdev, txrx_peer, nbuf,
  1497. NULL, is_eapol);
  1498. return;
  1499. }
  1500. }
  1501. drop_nbuf:
  1502. DP_STATS_INCC(soc, rx.reo2rel_route_drop, 1,
  1503. err_src == HAL_RX_WBM_ERR_SRC_REO);
  1504. DP_STATS_INCC(soc, rx.rxdma2rel_route_drop, 1,
  1505. err_src == HAL_RX_WBM_ERR_SRC_RXDMA);
  1506. dp_rx_nbuf_free(nbuf);
  1507. }
  1508. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  1509. #ifdef DP_RX_DESC_COOKIE_INVALIDATE
  1510. /**
  1511. * dp_rx_link_cookie_check() - Validate link desc cookie
  1512. * @ring_desc: ring descriptor
  1513. *
  1514. * Return: qdf status
  1515. */
  1516. static inline QDF_STATUS
  1517. dp_rx_link_cookie_check(hal_ring_desc_t ring_desc)
  1518. {
  1519. if (qdf_unlikely(HAL_RX_REO_BUF_LINK_COOKIE_INVALID_GET(ring_desc)))
  1520. return QDF_STATUS_E_FAILURE;
  1521. return QDF_STATUS_SUCCESS;
  1522. }
  1523. /**
  1524. * dp_rx_link_cookie_invalidate() - Invalidate link desc cookie
  1525. * @ring_desc: ring descriptor
  1526. *
  1527. * Return: None
  1528. */
  1529. static inline void
  1530. dp_rx_link_cookie_invalidate(hal_ring_desc_t ring_desc)
  1531. {
  1532. HAL_RX_REO_BUF_LINK_COOKIE_INVALID_SET(ring_desc);
  1533. }
  1534. #else
  1535. static inline QDF_STATUS
  1536. dp_rx_link_cookie_check(hal_ring_desc_t ring_desc)
  1537. {
  1538. return QDF_STATUS_SUCCESS;
  1539. }
  1540. static inline void
  1541. dp_rx_link_cookie_invalidate(hal_ring_desc_t ring_desc)
  1542. {
  1543. }
  1544. #endif
  1545. #ifdef WLAN_FEATURE_DP_RX_RING_HISTORY
  1546. /**
  1547. * dp_rx_err_ring_record_entry() - Record rx err ring history
  1548. * @soc: Datapath soc structure
  1549. * @paddr: paddr of the buffer in RX err ring
  1550. * @sw_cookie: SW cookie of the buffer in RX err ring
  1551. * @rbm: Return buffer manager of the buffer in RX err ring
  1552. *
  1553. * Return: None
  1554. */
  1555. static inline void
  1556. dp_rx_err_ring_record_entry(struct dp_soc *soc, uint64_t paddr,
  1557. uint32_t sw_cookie, uint8_t rbm)
  1558. {
  1559. struct dp_buf_info_record *record;
  1560. uint32_t idx;
  1561. if (qdf_unlikely(!soc->rx_err_ring_history))
  1562. return;
  1563. idx = dp_history_get_next_index(&soc->rx_err_ring_history->index,
  1564. DP_RX_ERR_HIST_MAX);
  1565. /* No NULL check needed for record since its an array */
  1566. record = &soc->rx_err_ring_history->entry[idx];
  1567. record->timestamp = qdf_get_log_timestamp();
  1568. record->hbi.paddr = paddr;
  1569. record->hbi.sw_cookie = sw_cookie;
  1570. record->hbi.rbm = rbm;
  1571. }
  1572. #else
  1573. static inline void
  1574. dp_rx_err_ring_record_entry(struct dp_soc *soc, uint64_t paddr,
  1575. uint32_t sw_cookie, uint8_t rbm)
  1576. {
  1577. }
  1578. #endif
  1579. #ifdef HANDLE_RX_REROUTE_ERR
  1580. static int dp_rx_err_handle_msdu_buf(struct dp_soc *soc,
  1581. hal_ring_desc_t ring_desc)
  1582. {
  1583. int lmac_id = DP_INVALID_LMAC_ID;
  1584. struct dp_rx_desc *rx_desc;
  1585. struct hal_buf_info hbi;
  1586. struct dp_pdev *pdev;
  1587. struct rx_desc_pool *rx_desc_pool;
  1588. hal_rx_reo_buf_paddr_get(soc->hal_soc, ring_desc, &hbi);
  1589. rx_desc = dp_rx_cookie_2_va_rxdma_buf(soc, hbi.sw_cookie);
  1590. /* sanity */
  1591. if (!rx_desc) {
  1592. DP_STATS_INC(soc, rx.err.reo_err_msdu_buf_invalid_cookie, 1);
  1593. goto assert_return;
  1594. }
  1595. if (!rx_desc->nbuf)
  1596. goto assert_return;
  1597. dp_rx_err_ring_record_entry(soc, hbi.paddr,
  1598. hbi.sw_cookie,
  1599. hal_rx_ret_buf_manager_get(soc->hal_soc,
  1600. ring_desc));
  1601. if (hbi.paddr != qdf_nbuf_get_frag_paddr(rx_desc->nbuf, 0)) {
  1602. DP_STATS_INC(soc, rx.err.nbuf_sanity_fail, 1);
  1603. rx_desc->in_err_state = 1;
  1604. goto assert_return;
  1605. }
  1606. rx_desc_pool = &soc->rx_desc_buf[rx_desc->pool_id];
  1607. /* After this point the rx_desc and nbuf are valid */
  1608. dp_ipa_rx_buf_smmu_mapping_lock(soc);
  1609. qdf_assert_always(!rx_desc->unmapped);
  1610. dp_rx_nbuf_unmap_pool(soc, rx_desc_pool, rx_desc->nbuf);
  1611. rx_desc->unmapped = 1;
  1612. dp_ipa_rx_buf_smmu_mapping_unlock(soc);
  1613. dp_rx_buffer_pool_nbuf_free(soc, rx_desc->nbuf,
  1614. rx_desc->pool_id);
  1615. pdev = dp_get_pdev_for_lmac_id(soc, rx_desc->pool_id);
  1616. lmac_id = rx_desc->pool_id;
  1617. dp_rx_add_to_free_desc_list(&pdev->free_list_head,
  1618. &pdev->free_list_tail,
  1619. rx_desc);
  1620. return lmac_id;
  1621. assert_return:
  1622. qdf_assert(0);
  1623. return lmac_id;
  1624. }
  1625. static int dp_rx_err_exception(struct dp_soc *soc, hal_ring_desc_t ring_desc)
  1626. {
  1627. int ret;
  1628. uint64_t cur_time_stamp;
  1629. DP_STATS_INC(soc, rx.err.reo_err_msdu_buf_rcved, 1);
  1630. /* Recover if overall error count exceeds threshold */
  1631. if (soc->stats.rx.err.reo_err_msdu_buf_rcved >
  1632. DP_MAX_REG_RX_ROUTING_ERRS_THRESHOLD) {
  1633. dp_err("pkt threshold breached! reo_err_msdu_buf_rcved %u first err pkt time_stamp %llu",
  1634. soc->stats.rx.err.reo_err_msdu_buf_rcved,
  1635. soc->rx_route_err_start_pkt_ts);
  1636. qdf_trigger_self_recovery(NULL, QDF_RX_REG_PKT_ROUTE_ERR);
  1637. }
  1638. cur_time_stamp = qdf_get_log_timestamp_usecs();
  1639. if (!soc->rx_route_err_start_pkt_ts)
  1640. soc->rx_route_err_start_pkt_ts = cur_time_stamp;
  1641. /* Recover if threshold number of packets received in threshold time */
  1642. if ((cur_time_stamp - soc->rx_route_err_start_pkt_ts) >
  1643. DP_RX_ERR_ROUTE_TIMEOUT_US) {
  1644. soc->rx_route_err_start_pkt_ts = cur_time_stamp;
  1645. if (soc->rx_route_err_in_window >
  1646. DP_MAX_REG_RX_ROUTING_ERRS_IN_TIMEOUT) {
  1647. qdf_trigger_self_recovery(NULL,
  1648. QDF_RX_REG_PKT_ROUTE_ERR);
  1649. dp_err("rate threshold breached! reo_err_msdu_buf_rcved %u first err pkt time_stamp %llu",
  1650. soc->stats.rx.err.reo_err_msdu_buf_rcved,
  1651. soc->rx_route_err_start_pkt_ts);
  1652. } else {
  1653. soc->rx_route_err_in_window = 1;
  1654. }
  1655. } else {
  1656. soc->rx_route_err_in_window++;
  1657. }
  1658. ret = dp_rx_err_handle_msdu_buf(soc, ring_desc);
  1659. return ret;
  1660. }
  1661. #else /* HANDLE_RX_REROUTE_ERR */
  1662. static int dp_rx_err_exception(struct dp_soc *soc, hal_ring_desc_t ring_desc)
  1663. {
  1664. qdf_assert_always(0);
  1665. return DP_INVALID_LMAC_ID;
  1666. }
  1667. #endif /* HANDLE_RX_REROUTE_ERR */
  1668. #ifdef WLAN_MLO_MULTI_CHIP
  1669. /**
  1670. * dp_idle_link_bm_id_check() - war for HW issue
  1671. *
  1672. * @soc: DP SOC handle
  1673. * @rbm: idle link RBM value
  1674. * @ring_desc: reo error link descriptor
  1675. *
  1676. * This is a war for HW issue where link descriptor
  1677. * of partner soc received due to packets wrongly
  1678. * interpreted as fragments
  1679. *
  1680. * Return: true in case link desc is consumed
  1681. * false in other cases
  1682. */
  1683. static bool dp_idle_link_bm_id_check(struct dp_soc *soc, uint8_t rbm,
  1684. void *ring_desc)
  1685. {
  1686. struct dp_soc *replenish_soc = NULL;
  1687. /* return ok incase of link desc of same soc */
  1688. if (rbm == soc->idle_link_bm_id)
  1689. return false;
  1690. if (soc->arch_ops.dp_soc_get_by_idle_bm_id)
  1691. replenish_soc =
  1692. soc->arch_ops.dp_soc_get_by_idle_bm_id(soc, rbm);
  1693. qdf_assert_always(replenish_soc);
  1694. /*
  1695. * For WIN usecase we should only get fragment packets in
  1696. * this ring as for MLO case fragmentation is not supported
  1697. * we should not see links from other soc.
  1698. *
  1699. * Drop all packets from partner soc and replenish the descriptors
  1700. */
  1701. dp_handle_wbm_internal_error(replenish_soc, ring_desc,
  1702. HAL_WBM_RELEASE_RING_2_DESC_TYPE);
  1703. return true;
  1704. }
  1705. #else
  1706. static bool dp_idle_link_bm_id_check(struct dp_soc *soc, uint8_t rbm,
  1707. void *ring_desc)
  1708. {
  1709. return false;
  1710. }
  1711. #endif
  1712. uint32_t
  1713. dp_rx_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
  1714. hal_ring_handle_t hal_ring_hdl, uint32_t quota)
  1715. {
  1716. hal_ring_desc_t ring_desc;
  1717. hal_soc_handle_t hal_soc;
  1718. uint32_t count = 0;
  1719. uint32_t rx_bufs_used = 0;
  1720. uint32_t rx_bufs_reaped[MAX_PDEV_CNT] = { 0 };
  1721. uint8_t mac_id = 0;
  1722. uint8_t buf_type;
  1723. uint8_t err_status;
  1724. struct hal_rx_mpdu_desc_info mpdu_desc_info;
  1725. struct hal_buf_info hbi;
  1726. struct dp_pdev *dp_pdev;
  1727. struct dp_srng *dp_rxdma_srng;
  1728. struct rx_desc_pool *rx_desc_pool;
  1729. void *link_desc_va;
  1730. struct hal_rx_msdu_list msdu_list; /* MSDU's per MPDU */
  1731. uint16_t num_msdus;
  1732. struct dp_rx_desc *rx_desc = NULL;
  1733. QDF_STATUS status;
  1734. bool ret;
  1735. uint32_t error_code = 0;
  1736. bool sw_pn_check_needed;
  1737. int max_reap_limit = dp_rx_get_loop_pkt_limit(soc);
  1738. int i, rx_bufs_reaped_total;
  1739. /* Debug -- Remove later */
  1740. qdf_assert(soc && hal_ring_hdl);
  1741. hal_soc = soc->hal_soc;
  1742. /* Debug -- Remove later */
  1743. qdf_assert(hal_soc);
  1744. if (qdf_unlikely(dp_srng_access_start(int_ctx, soc, hal_ring_hdl))) {
  1745. /* TODO */
  1746. /*
  1747. * Need API to convert from hal_ring pointer to
  1748. * Ring Type / Ring Id combo
  1749. */
  1750. DP_STATS_INC(soc, rx.err.hal_ring_access_fail, 1);
  1751. dp_rx_err_err("%pK: HAL RING Access Failed -- %pK", soc,
  1752. hal_ring_hdl);
  1753. goto done;
  1754. }
  1755. while (qdf_likely(quota-- && (ring_desc =
  1756. hal_srng_dst_peek(hal_soc,
  1757. hal_ring_hdl)))) {
  1758. DP_STATS_INC(soc, rx.err_ring_pkts, 1);
  1759. err_status = hal_rx_err_status_get(hal_soc, ring_desc);
  1760. buf_type = hal_rx_reo_buf_type_get(hal_soc, ring_desc);
  1761. if (err_status == HAL_REO_ERROR_DETECTED)
  1762. error_code = hal_rx_get_reo_error_code(hal_soc,
  1763. ring_desc);
  1764. qdf_mem_set(&mpdu_desc_info, sizeof(mpdu_desc_info), 0);
  1765. sw_pn_check_needed = dp_rx_err_is_pn_check_needed(soc,
  1766. err_status,
  1767. error_code);
  1768. if (!sw_pn_check_needed) {
  1769. /*
  1770. * MPDU desc info will be present in the REO desc
  1771. * only in the below scenarios
  1772. * 1) pn_in_dest_disabled: always
  1773. * 2) pn_in_dest enabled: All cases except 2k-jup
  1774. * and OOR errors
  1775. */
  1776. hal_rx_mpdu_desc_info_get(hal_soc, ring_desc,
  1777. &mpdu_desc_info);
  1778. }
  1779. if (HAL_RX_REO_DESC_MSDU_COUNT_GET(ring_desc) == 0)
  1780. goto next_entry;
  1781. /*
  1782. * For REO error ring, only MSDU LINK DESC is expected.
  1783. * Handle HAL_RX_REO_MSDU_BUF_ADDR_TYPE exception case.
  1784. */
  1785. if (qdf_unlikely(buf_type != HAL_RX_REO_MSDU_LINK_DESC_TYPE)) {
  1786. int lmac_id;
  1787. lmac_id = dp_rx_err_exception(soc, ring_desc);
  1788. if (lmac_id >= 0)
  1789. rx_bufs_reaped[lmac_id] += 1;
  1790. goto next_entry;
  1791. }
  1792. hal_rx_buf_cookie_rbm_get(hal_soc, (uint32_t *)ring_desc,
  1793. &hbi);
  1794. /*
  1795. * check for the magic number in the sw cookie
  1796. */
  1797. qdf_assert_always((hbi.sw_cookie >> LINK_DESC_ID_SHIFT) &
  1798. soc->link_desc_id_start);
  1799. if (dp_idle_link_bm_id_check(soc, hbi.rbm, ring_desc)) {
  1800. DP_STATS_INC(soc, rx.err.invalid_link_cookie, 1);
  1801. goto next_entry;
  1802. }
  1803. status = dp_rx_link_cookie_check(ring_desc);
  1804. if (qdf_unlikely(QDF_IS_STATUS_ERROR(status))) {
  1805. DP_STATS_INC(soc, rx.err.invalid_link_cookie, 1);
  1806. break;
  1807. }
  1808. hal_rx_reo_buf_paddr_get(soc->hal_soc, ring_desc, &hbi);
  1809. link_desc_va = dp_rx_cookie_2_link_desc_va(soc, &hbi);
  1810. hal_rx_msdu_list_get(soc->hal_soc, link_desc_va, &msdu_list,
  1811. &num_msdus);
  1812. if (!num_msdus ||
  1813. !dp_rx_is_sw_cookie_valid(soc, msdu_list.sw_cookie[0])) {
  1814. dp_rx_err_info_rl("Invalid MSDU info num_msdus %u cookie: 0x%x",
  1815. num_msdus, msdu_list.sw_cookie[0]);
  1816. dp_rx_link_desc_return(soc, ring_desc,
  1817. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  1818. goto next_entry;
  1819. }
  1820. dp_rx_err_ring_record_entry(soc, msdu_list.paddr[0],
  1821. msdu_list.sw_cookie[0],
  1822. msdu_list.rbm[0]);
  1823. // TODO - BE- Check if the RBM is to be checked for all chips
  1824. if (qdf_unlikely((msdu_list.rbm[0] !=
  1825. dp_rx_get_rx_bm_id(soc)) &&
  1826. (msdu_list.rbm[0] !=
  1827. soc->idle_link_bm_id) &&
  1828. (msdu_list.rbm[0] !=
  1829. dp_rx_get_defrag_bm_id(soc)))) {
  1830. /* TODO */
  1831. /* Call appropriate handler */
  1832. if (!wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) {
  1833. DP_STATS_INC(soc, rx.err.invalid_rbm, 1);
  1834. dp_rx_err_err("%pK: Invalid RBM %d",
  1835. soc, msdu_list.rbm[0]);
  1836. }
  1837. /* Return link descriptor through WBM ring (SW2WBM)*/
  1838. dp_rx_link_desc_return(soc, ring_desc,
  1839. HAL_BM_ACTION_RELEASE_MSDU_LIST);
  1840. goto next_entry;
  1841. }
  1842. rx_desc = soc->arch_ops.dp_rx_desc_cookie_2_va(
  1843. soc,
  1844. msdu_list.sw_cookie[0]);
  1845. qdf_assert_always(rx_desc);
  1846. mac_id = rx_desc->pool_id;
  1847. if (sw_pn_check_needed) {
  1848. goto process_reo_error_code;
  1849. }
  1850. if (mpdu_desc_info.bar_frame) {
  1851. qdf_assert_always(mpdu_desc_info.msdu_count == 1);
  1852. dp_rx_bar_frame_handle(soc, ring_desc, rx_desc,
  1853. &mpdu_desc_info, err_status,
  1854. error_code);
  1855. rx_bufs_reaped[mac_id] += 1;
  1856. goto next_entry;
  1857. }
  1858. if (mpdu_desc_info.mpdu_flags & HAL_MPDU_F_FRAGMENT) {
  1859. /*
  1860. * We only handle one msdu per link desc for fragmented
  1861. * case. We drop the msdus and release the link desc
  1862. * back if there are more than one msdu in link desc.
  1863. */
  1864. if (qdf_unlikely(num_msdus > 1)) {
  1865. count = dp_rx_msdus_drop(soc, ring_desc,
  1866. &mpdu_desc_info,
  1867. &mac_id, quota);
  1868. rx_bufs_reaped[mac_id] += count;
  1869. goto next_entry;
  1870. }
  1871. /*
  1872. * this is a unlikely scenario where the host is reaping
  1873. * a descriptor which it already reaped just a while ago
  1874. * but is yet to replenish it back to HW.
  1875. * In this case host will dump the last 128 descriptors
  1876. * including the software descriptor rx_desc and assert.
  1877. */
  1878. if (qdf_unlikely(!rx_desc->in_use)) {
  1879. DP_STATS_INC(soc, rx.err.hal_reo_dest_dup, 1);
  1880. dp_info_rl("Reaping rx_desc not in use!");
  1881. dp_rx_dump_info_and_assert(soc, hal_ring_hdl,
  1882. ring_desc, rx_desc);
  1883. /* ignore duplicate RX desc and continue */
  1884. /* Pop out the descriptor */
  1885. goto next_entry;
  1886. }
  1887. ret = dp_rx_desc_paddr_sanity_check(rx_desc,
  1888. msdu_list.paddr[0]);
  1889. if (!ret) {
  1890. DP_STATS_INC(soc, rx.err.nbuf_sanity_fail, 1);
  1891. rx_desc->in_err_state = 1;
  1892. goto next_entry;
  1893. }
  1894. count = dp_rx_frag_handle(soc,
  1895. ring_desc, &mpdu_desc_info,
  1896. rx_desc, &mac_id, quota);
  1897. rx_bufs_reaped[mac_id] += count;
  1898. DP_STATS_INC(soc, rx.rx_frags, 1);
  1899. goto next_entry;
  1900. }
  1901. process_reo_error_code:
  1902. /*
  1903. * Expect REO errors to be handled after this point
  1904. */
  1905. qdf_assert_always(err_status == HAL_REO_ERROR_DETECTED);
  1906. dp_info_rl("Got pkt with REO ERROR: %d", error_code);
  1907. switch (error_code) {
  1908. case HAL_REO_ERR_PN_CHECK_FAILED:
  1909. case HAL_REO_ERR_PN_ERROR_HANDLING_FLAG_SET:
  1910. DP_STATS_INC(soc, rx.err.reo_error[error_code], 1);
  1911. dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1912. if (dp_pdev)
  1913. DP_STATS_INC(dp_pdev, err.reo_error, 1);
  1914. count = dp_rx_pn_error_handle(soc,
  1915. ring_desc,
  1916. &mpdu_desc_info, &mac_id,
  1917. quota);
  1918. rx_bufs_reaped[mac_id] += count;
  1919. break;
  1920. case HAL_REO_ERR_REGULAR_FRAME_2K_JUMP:
  1921. case HAL_REO_ERR_2K_ERROR_HANDLING_FLAG_SET:
  1922. case HAL_REO_ERR_BAR_FRAME_2K_JUMP:
  1923. case HAL_REO_ERR_REGULAR_FRAME_OOR:
  1924. case HAL_REO_ERR_BAR_FRAME_OOR:
  1925. case HAL_REO_ERR_QUEUE_DESC_ADDR_0:
  1926. DP_STATS_INC(soc, rx.err.reo_error[error_code], 1);
  1927. dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1928. if (dp_pdev)
  1929. DP_STATS_INC(dp_pdev, err.reo_error, 1);
  1930. count = dp_rx_reo_err_entry_process(
  1931. soc,
  1932. ring_desc,
  1933. &mpdu_desc_info,
  1934. link_desc_va,
  1935. error_code);
  1936. rx_bufs_reaped[mac_id] += count;
  1937. break;
  1938. case HAL_REO_ERR_QUEUE_DESC_INVALID:
  1939. case HAL_REO_ERR_AMPDU_IN_NON_BA:
  1940. case HAL_REO_ERR_NON_BA_DUPLICATE:
  1941. case HAL_REO_ERR_BA_DUPLICATE:
  1942. case HAL_REO_ERR_BAR_FRAME_NO_BA_SESSION:
  1943. case HAL_REO_ERR_BAR_FRAME_SN_EQUALS_SSN:
  1944. case HAL_REO_ERR_QUEUE_DESC_BLOCKED_SET:
  1945. DP_STATS_INC(soc, rx.err.reo_error[error_code], 1);
  1946. count = dp_rx_msdus_drop(soc, ring_desc,
  1947. &mpdu_desc_info,
  1948. &mac_id, quota);
  1949. rx_bufs_reaped[mac_id] += count;
  1950. break;
  1951. default:
  1952. /* Assert if unexpected error type */
  1953. qdf_assert_always(0);
  1954. }
  1955. next_entry:
  1956. dp_rx_link_cookie_invalidate(ring_desc);
  1957. hal_srng_dst_get_next(hal_soc, hal_ring_hdl);
  1958. rx_bufs_reaped_total = 0;
  1959. for (i = 0; i < MAX_PDEV_CNT; i++)
  1960. rx_bufs_reaped_total += rx_bufs_reaped[i];
  1961. if (dp_rx_reap_loop_pkt_limit_hit(soc, rx_bufs_reaped_total,
  1962. max_reap_limit))
  1963. break;
  1964. }
  1965. done:
  1966. dp_srng_access_end(int_ctx, soc, hal_ring_hdl);
  1967. if (soc->rx.flags.defrag_timeout_check) {
  1968. uint32_t now_ms =
  1969. qdf_system_ticks_to_msecs(qdf_system_ticks());
  1970. if (now_ms >= soc->rx.defrag.next_flush_ms)
  1971. dp_rx_defrag_waitlist_flush(soc);
  1972. }
  1973. for (mac_id = 0; mac_id < MAX_PDEV_CNT; mac_id++) {
  1974. if (rx_bufs_reaped[mac_id]) {
  1975. dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1976. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_id];
  1977. rx_desc_pool = &soc->rx_desc_buf[mac_id];
  1978. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  1979. rx_desc_pool,
  1980. rx_bufs_reaped[mac_id],
  1981. &dp_pdev->free_list_head,
  1982. &dp_pdev->free_list_tail,
  1983. false);
  1984. rx_bufs_used += rx_bufs_reaped[mac_id];
  1985. }
  1986. }
  1987. return rx_bufs_used; /* Assume no scale factor for now */
  1988. }
  1989. #ifdef DROP_RXDMA_DECRYPT_ERR
  1990. /**
  1991. * dp_handle_rxdma_decrypt_err() - Check if decrypt err frames can be handled
  1992. *
  1993. * Return: true if rxdma decrypt err frames are handled and false otherwise
  1994. */
  1995. static inline bool dp_handle_rxdma_decrypt_err(void)
  1996. {
  1997. return false;
  1998. }
  1999. #else
  2000. static inline bool dp_handle_rxdma_decrypt_err(void)
  2001. {
  2002. return true;
  2003. }
  2004. #endif
  2005. void dp_rx_wbm_sg_list_last_msdu_war(struct dp_soc *soc)
  2006. {
  2007. if (soc->wbm_sg_last_msdu_war) {
  2008. uint32_t len;
  2009. qdf_nbuf_t temp = soc->wbm_sg_param.wbm_sg_nbuf_tail;
  2010. len = hal_rx_msdu_start_msdu_len_get(soc->hal_soc,
  2011. qdf_nbuf_data(temp));
  2012. temp = soc->wbm_sg_param.wbm_sg_nbuf_head;
  2013. while (temp) {
  2014. QDF_NBUF_CB_RX_PKT_LEN(temp) = len;
  2015. temp = temp->next;
  2016. }
  2017. }
  2018. }
  2019. #ifdef RX_DESC_DEBUG_CHECK
  2020. QDF_STATUS dp_rx_wbm_desc_nbuf_sanity_check(struct dp_soc *soc,
  2021. hal_ring_handle_t hal_ring_hdl,
  2022. hal_ring_desc_t ring_desc,
  2023. struct dp_rx_desc *rx_desc)
  2024. {
  2025. struct hal_buf_info hbi;
  2026. hal_rx_wbm_rel_buf_paddr_get(soc->hal_soc, ring_desc, &hbi);
  2027. /* Sanity check for possible buffer paddr corruption */
  2028. if (dp_rx_desc_paddr_sanity_check(rx_desc, (&hbi)->paddr))
  2029. return QDF_STATUS_SUCCESS;
  2030. hal_srng_dump_ring_desc(soc->hal_soc, hal_ring_hdl, ring_desc);
  2031. return QDF_STATUS_E_FAILURE;
  2032. }
  2033. #else
  2034. QDF_STATUS dp_rx_wbm_desc_nbuf_sanity_check(struct dp_soc *soc,
  2035. hal_ring_handle_t hal_ring_hdl,
  2036. hal_ring_desc_t ring_desc,
  2037. struct dp_rx_desc *rx_desc)
  2038. {
  2039. return QDF_STATUS_SUCCESS;
  2040. }
  2041. #endif
  2042. bool
  2043. dp_rx_is_sg_formation_required(struct hal_wbm_err_desc_info *info)
  2044. {
  2045. /*
  2046. * Currently Null Queue and Unencrypted error handlers has support for
  2047. * SG. Other error handler do not deal with SG buffer.
  2048. */
  2049. if (((info->wbm_err_src == HAL_RX_WBM_ERR_SRC_REO) &&
  2050. (info->reo_err_code == HAL_REO_ERR_QUEUE_DESC_ADDR_0)) ||
  2051. ((info->wbm_err_src == HAL_RX_WBM_ERR_SRC_RXDMA) &&
  2052. (info->rxdma_err_code == HAL_RXDMA_ERR_UNENCRYPTED)))
  2053. return true;
  2054. return false;
  2055. }
  2056. #ifdef QCA_DP_NBUF_FAST_RECYCLE_CHECK
  2057. void dp_rx_err_tlv_invalidate(struct dp_soc *soc,
  2058. qdf_nbuf_t nbuf)
  2059. {
  2060. /*
  2061. * In case of fast recycle TX driver can avoid invalidate
  2062. * of buffer in case of SFE forward. We need to invalidate
  2063. * the TLV headers after writing to this location
  2064. */
  2065. qdf_nbuf_dma_inv_range_no_dsb((void *)nbuf->data,
  2066. (void *)(nbuf->data +
  2067. soc->rx_pkt_tlv_size +
  2068. L3_HEADER_PAD));
  2069. }
  2070. #else
  2071. void dp_rx_err_tlv_invalidate(struct dp_soc *soc,
  2072. qdf_nbuf_t nbuf)
  2073. {
  2074. }
  2075. #endif
  2076. #ifndef CONFIG_NBUF_AP_PLATFORM
  2077. static inline uint16_t
  2078. dp_rx_get_peer_id(struct dp_soc *soc,
  2079. uint8_t *rx_tlv_hdr,
  2080. qdf_nbuf_t nbuf)
  2081. {
  2082. uint32_t peer_mdata = 0;
  2083. peer_mdata = hal_rx_tlv_peer_meta_data_get(soc->hal_soc,
  2084. rx_tlv_hdr);
  2085. return dp_rx_peer_metadata_peer_id_get(soc, peer_mdata);
  2086. }
  2087. static inline void
  2088. dp_rx_get_wbm_err_info_from_nbuf(struct dp_soc *soc,
  2089. qdf_nbuf_t nbuf,
  2090. uint8_t *rx_tlv_hdr,
  2091. union hal_wbm_err_info_u *wbm_err)
  2092. {
  2093. hal_rx_priv_info_get_from_tlv(soc->hal_soc, rx_tlv_hdr,
  2094. (uint8_t *)&wbm_err->info,
  2095. sizeof(union hal_wbm_err_info_u));
  2096. }
  2097. void
  2098. dp_rx_set_wbm_err_info_in_nbuf(struct dp_soc *soc,
  2099. qdf_nbuf_t nbuf,
  2100. union hal_wbm_err_info_u wbm_err)
  2101. {
  2102. hal_rx_priv_info_set_in_tlv(soc->hal_soc,
  2103. qdf_nbuf_data(nbuf),
  2104. (uint8_t *)&wbm_err.info,
  2105. sizeof(union hal_wbm_err_info_u));
  2106. }
  2107. #else
  2108. static inline uint16_t
  2109. dp_rx_get_peer_id(struct dp_soc *soc,
  2110. uint8_t *rx_tlv_hdr,
  2111. qdf_nbuf_t nbuf)
  2112. {
  2113. uint32_t peer_mdata = QDF_NBUF_CB_RX_MPDU_DESC_INFO_2(nbuf);
  2114. return dp_rx_peer_metadata_peer_id_get(soc, peer_mdata);
  2115. }
  2116. static inline void
  2117. dp_rx_get_wbm_err_info_from_nbuf(struct dp_soc *soc,
  2118. qdf_nbuf_t nbuf,
  2119. uint8_t *rx_tlv_hdr,
  2120. union hal_wbm_err_info_u *wbm_err)
  2121. {
  2122. wbm_err->info = QDF_NBUF_CB_RX_ERROR_CODE_INFO(nbuf);
  2123. }
  2124. void
  2125. dp_rx_set_wbm_err_info_in_nbuf(struct dp_soc *soc,
  2126. qdf_nbuf_t nbuf,
  2127. union hal_wbm_err_info_u wbm_err)
  2128. {
  2129. QDF_NBUF_CB_RX_ERROR_CODE_INFO(nbuf) = wbm_err.info;
  2130. }
  2131. #endif /* CONFIG_NBUF_AP_PLATFORM */
  2132. uint32_t
  2133. dp_rx_wbm_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
  2134. hal_ring_handle_t hal_ring_hdl, uint32_t quota)
  2135. {
  2136. hal_soc_handle_t hal_soc;
  2137. uint32_t rx_bufs_used = 0;
  2138. struct dp_pdev *dp_pdev;
  2139. uint8_t *rx_tlv_hdr;
  2140. bool is_tkip_mic_err;
  2141. qdf_nbuf_t nbuf_head = NULL;
  2142. qdf_nbuf_t nbuf, next;
  2143. union hal_wbm_err_info_u wbm_err = { 0 };
  2144. uint8_t pool_id;
  2145. uint8_t tid = 0;
  2146. uint8_t link_id = 0;
  2147. /* Debug -- Remove later */
  2148. qdf_assert(soc && hal_ring_hdl);
  2149. hal_soc = soc->hal_soc;
  2150. /* Debug -- Remove later */
  2151. qdf_assert(hal_soc);
  2152. nbuf_head = soc->arch_ops.dp_rx_wbm_err_reap_desc(int_ctx, soc,
  2153. hal_ring_hdl,
  2154. quota,
  2155. &rx_bufs_used);
  2156. nbuf = nbuf_head;
  2157. while (nbuf) {
  2158. struct dp_txrx_peer *txrx_peer;
  2159. struct dp_peer *peer;
  2160. uint16_t peer_id;
  2161. uint8_t err_code;
  2162. uint8_t *tlv_hdr;
  2163. dp_txrx_ref_handle txrx_ref_handle = NULL;
  2164. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  2165. /*
  2166. * retrieve the wbm desc info from nbuf CB/TLV, so we can
  2167. * handle error cases appropriately
  2168. */
  2169. dp_rx_get_wbm_err_info_from_nbuf(soc, nbuf,
  2170. rx_tlv_hdr,
  2171. &wbm_err);
  2172. peer_id = dp_rx_get_peer_id(soc,
  2173. rx_tlv_hdr,
  2174. nbuf);
  2175. txrx_peer = dp_tgt_txrx_peer_get_ref_by_id(soc, peer_id,
  2176. &txrx_ref_handle,
  2177. DP_MOD_ID_RX_ERR);
  2178. if (!txrx_peer)
  2179. dp_info_rl("peer is null peer_id %u err_src %u, "
  2180. "REO: push_rsn %u err_code %u, "
  2181. "RXDMA: push_rsn %u err_code %u",
  2182. peer_id, wbm_err.info_bit.wbm_err_src,
  2183. wbm_err.info_bit.reo_psh_rsn,
  2184. wbm_err.info_bit.reo_err_code,
  2185. wbm_err.info_bit.rxdma_psh_rsn,
  2186. wbm_err.info_bit.rxdma_err_code);
  2187. /* Set queue_mapping in nbuf to 0 */
  2188. dp_set_rx_queue(nbuf, 0);
  2189. next = nbuf->next;
  2190. /*
  2191. * Form the SG for msdu continued buffers
  2192. * QCN9000 has this support
  2193. */
  2194. if (qdf_nbuf_is_rx_chfrag_cont(nbuf)) {
  2195. nbuf = dp_rx_sg_create(soc, nbuf);
  2196. next = nbuf->next;
  2197. /*
  2198. * SG error handling is not done correctly,
  2199. * drop SG frames for now.
  2200. */
  2201. dp_rx_nbuf_free(nbuf);
  2202. dp_info_rl("scattered msdu dropped");
  2203. nbuf = next;
  2204. if (txrx_peer)
  2205. dp_txrx_peer_unref_delete(txrx_ref_handle,
  2206. DP_MOD_ID_RX_ERR);
  2207. continue;
  2208. }
  2209. dp_rx_nbuf_set_link_id_from_tlv(soc, rx_tlv_hdr, nbuf);
  2210. pool_id = wbm_err.info_bit.pool_id;
  2211. dp_pdev = dp_get_pdev_for_lmac_id(soc, pool_id);
  2212. if (dp_pdev && dp_pdev->link_peer_stats &&
  2213. txrx_peer && txrx_peer->is_mld_peer) {
  2214. link_id = dp_rx_get_stats_arr_idx_from_link_id(
  2215. nbuf,
  2216. txrx_peer);
  2217. } else {
  2218. link_id = 0;
  2219. }
  2220. if (wbm_err.info_bit.wbm_err_src == HAL_RX_WBM_ERR_SRC_REO) {
  2221. if (wbm_err.info_bit.reo_psh_rsn
  2222. == HAL_RX_WBM_REO_PSH_RSN_ERROR) {
  2223. DP_STATS_INC(soc,
  2224. rx.err.reo_error
  2225. [wbm_err.info_bit.reo_err_code], 1);
  2226. /* increment @pdev level */
  2227. if (dp_pdev)
  2228. DP_STATS_INC(dp_pdev, err.reo_error,
  2229. 1);
  2230. switch (wbm_err.info_bit.reo_err_code) {
  2231. /*
  2232. * Handling for packets which have NULL REO
  2233. * queue descriptor
  2234. */
  2235. case HAL_REO_ERR_QUEUE_DESC_ADDR_0:
  2236. pool_id = wbm_err.info_bit.pool_id;
  2237. soc->arch_ops.dp_rx_null_q_desc_handle(
  2238. soc, nbuf,
  2239. rx_tlv_hdr,
  2240. pool_id,
  2241. txrx_peer,
  2242. FALSE,
  2243. link_id);
  2244. break;
  2245. /* TODO */
  2246. /* Add per error code accounting */
  2247. case HAL_REO_ERR_REGULAR_FRAME_2K_JUMP:
  2248. if (txrx_peer)
  2249. DP_PEER_PER_PKT_STATS_INC(txrx_peer,
  2250. rx.err.jump_2k_err,
  2251. 1,
  2252. link_id);
  2253. pool_id = wbm_err.info_bit.pool_id;
  2254. if (hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  2255. rx_tlv_hdr)) {
  2256. tid =
  2257. hal_rx_mpdu_start_tid_get(hal_soc, rx_tlv_hdr);
  2258. }
  2259. QDF_NBUF_CB_RX_PKT_LEN(nbuf) =
  2260. hal_rx_msdu_start_msdu_len_get(
  2261. soc->hal_soc, rx_tlv_hdr);
  2262. nbuf->next = NULL;
  2263. dp_2k_jump_handle(soc, nbuf,
  2264. rx_tlv_hdr,
  2265. peer_id, tid);
  2266. break;
  2267. case HAL_REO_ERR_REGULAR_FRAME_OOR:
  2268. if (txrx_peer)
  2269. DP_PEER_PER_PKT_STATS_INC(txrx_peer,
  2270. rx.err.oor_err,
  2271. 1,
  2272. link_id);
  2273. if (hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  2274. rx_tlv_hdr)) {
  2275. tid =
  2276. hal_rx_mpdu_start_tid_get(hal_soc, rx_tlv_hdr);
  2277. }
  2278. QDF_NBUF_CB_RX_PKT_LEN(nbuf) =
  2279. hal_rx_msdu_start_msdu_len_get(
  2280. soc->hal_soc, rx_tlv_hdr);
  2281. nbuf->next = NULL;
  2282. dp_rx_oor_handle(soc, nbuf,
  2283. peer_id,
  2284. rx_tlv_hdr);
  2285. break;
  2286. case HAL_REO_ERR_BAR_FRAME_2K_JUMP:
  2287. case HAL_REO_ERR_BAR_FRAME_OOR:
  2288. peer = dp_peer_get_tgt_peer_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
  2289. if (peer) {
  2290. dp_rx_err_handle_bar(soc, peer,
  2291. nbuf);
  2292. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  2293. }
  2294. dp_rx_nbuf_free(nbuf);
  2295. break;
  2296. case HAL_REO_ERR_PN_CHECK_FAILED:
  2297. case HAL_REO_ERR_PN_ERROR_HANDLING_FLAG_SET:
  2298. if (txrx_peer)
  2299. DP_PEER_PER_PKT_STATS_INC(txrx_peer,
  2300. rx.err.pn_err,
  2301. 1,
  2302. link_id);
  2303. dp_rx_nbuf_free(nbuf);
  2304. break;
  2305. default:
  2306. dp_info_rl("Got pkt with REO ERROR: %d",
  2307. wbm_err.info_bit.
  2308. reo_err_code);
  2309. dp_rx_nbuf_free(nbuf);
  2310. }
  2311. } else if (wbm_err.info_bit.reo_psh_rsn
  2312. == HAL_RX_WBM_REO_PSH_RSN_ROUTE) {
  2313. dp_rx_err_route_hdl(soc, nbuf, txrx_peer,
  2314. rx_tlv_hdr,
  2315. HAL_RX_WBM_ERR_SRC_REO,
  2316. link_id);
  2317. } else {
  2318. /* should not enter here */
  2319. dp_rx_err_alert("invalid reo push reason %u",
  2320. wbm_err.info_bit.reo_psh_rsn);
  2321. dp_rx_nbuf_free(nbuf);
  2322. qdf_assert_always(0);
  2323. }
  2324. } else if (wbm_err.info_bit.wbm_err_src ==
  2325. HAL_RX_WBM_ERR_SRC_RXDMA) {
  2326. if (wbm_err.info_bit.rxdma_psh_rsn
  2327. == HAL_RX_WBM_RXDMA_PSH_RSN_ERROR) {
  2328. DP_STATS_INC(soc,
  2329. rx.err.rxdma_error
  2330. [wbm_err.info_bit.rxdma_err_code], 1);
  2331. /* increment @pdev level */
  2332. if (dp_pdev)
  2333. DP_STATS_INC(dp_pdev,
  2334. err.rxdma_error, 1);
  2335. switch (wbm_err.info_bit.rxdma_err_code) {
  2336. case HAL_RXDMA_ERR_UNENCRYPTED:
  2337. case HAL_RXDMA_ERR_WIFI_PARSE:
  2338. if (txrx_peer)
  2339. DP_PEER_PER_PKT_STATS_INC(txrx_peer,
  2340. rx.err.rxdma_wifi_parse_err,
  2341. 1,
  2342. link_id);
  2343. pool_id = wbm_err.info_bit.pool_id;
  2344. dp_rx_process_rxdma_err(soc, nbuf,
  2345. rx_tlv_hdr,
  2346. txrx_peer,
  2347. wbm_err.
  2348. info_bit.
  2349. rxdma_err_code,
  2350. pool_id,
  2351. link_id);
  2352. break;
  2353. case HAL_RXDMA_ERR_TKIP_MIC:
  2354. dp_rx_process_mic_error(soc, nbuf,
  2355. rx_tlv_hdr,
  2356. txrx_peer);
  2357. if (txrx_peer)
  2358. DP_PEER_PER_PKT_STATS_INC(txrx_peer,
  2359. rx.err.mic_err,
  2360. 1,
  2361. link_id);
  2362. break;
  2363. case HAL_RXDMA_ERR_DECRYPT:
  2364. /* All the TKIP-MIC failures are treated as Decrypt Errors
  2365. * for QCN9224 Targets
  2366. */
  2367. is_tkip_mic_err = hal_rx_msdu_end_is_tkip_mic_err(hal_soc, rx_tlv_hdr);
  2368. if (is_tkip_mic_err && txrx_peer) {
  2369. dp_rx_process_mic_error(soc, nbuf,
  2370. rx_tlv_hdr,
  2371. txrx_peer);
  2372. DP_PEER_PER_PKT_STATS_INC(txrx_peer,
  2373. rx.err.mic_err,
  2374. 1,
  2375. link_id);
  2376. break;
  2377. }
  2378. if (txrx_peer) {
  2379. DP_PEER_PER_PKT_STATS_INC(txrx_peer,
  2380. rx.err.decrypt_err,
  2381. 1,
  2382. link_id);
  2383. dp_rx_nbuf_free(nbuf);
  2384. break;
  2385. }
  2386. if (!dp_handle_rxdma_decrypt_err()) {
  2387. dp_rx_nbuf_free(nbuf);
  2388. break;
  2389. }
  2390. pool_id = wbm_err.info_bit.pool_id;
  2391. err_code = wbm_err.info_bit.rxdma_err_code;
  2392. tlv_hdr = rx_tlv_hdr;
  2393. dp_rx_process_rxdma_err(soc, nbuf,
  2394. tlv_hdr, NULL,
  2395. err_code,
  2396. pool_id,
  2397. link_id);
  2398. break;
  2399. case HAL_RXDMA_MULTICAST_ECHO:
  2400. if (txrx_peer)
  2401. DP_PEER_PER_PKT_STATS_INC_PKT(txrx_peer,
  2402. rx.mec_drop, 1,
  2403. qdf_nbuf_len(nbuf),
  2404. link_id);
  2405. dp_rx_nbuf_free(nbuf);
  2406. break;
  2407. case HAL_RXDMA_UNAUTHORIZED_WDS:
  2408. pool_id = wbm_err.info_bit.pool_id;
  2409. err_code = wbm_err.info_bit.rxdma_err_code;
  2410. tlv_hdr = rx_tlv_hdr;
  2411. dp_rx_process_rxdma_err(soc, nbuf,
  2412. tlv_hdr,
  2413. txrx_peer,
  2414. err_code,
  2415. pool_id,
  2416. link_id);
  2417. break;
  2418. default:
  2419. dp_rx_nbuf_free(nbuf);
  2420. dp_err_rl("RXDMA error %d",
  2421. wbm_err.info_bit.rxdma_err_code);
  2422. }
  2423. } else if (wbm_err.info_bit.rxdma_psh_rsn
  2424. == HAL_RX_WBM_RXDMA_PSH_RSN_ROUTE) {
  2425. dp_rx_err_route_hdl(soc, nbuf, txrx_peer,
  2426. rx_tlv_hdr,
  2427. HAL_RX_WBM_ERR_SRC_RXDMA,
  2428. link_id);
  2429. } else if (wbm_err.info_bit.rxdma_psh_rsn
  2430. == HAL_RX_WBM_RXDMA_PSH_RSN_FLUSH) {
  2431. dp_rx_err_err("rxdma push reason %u",
  2432. wbm_err.info_bit.rxdma_psh_rsn);
  2433. DP_STATS_INC(soc, rx.err.rx_flush_count, 1);
  2434. dp_rx_nbuf_free(nbuf);
  2435. } else {
  2436. /* should not enter here */
  2437. dp_rx_err_alert("invalid rxdma push reason %u",
  2438. wbm_err.info_bit.rxdma_psh_rsn);
  2439. dp_rx_nbuf_free(nbuf);
  2440. qdf_assert_always(0);
  2441. }
  2442. } else {
  2443. /* Should not come here */
  2444. qdf_assert(0);
  2445. }
  2446. if (txrx_peer)
  2447. dp_txrx_peer_unref_delete(txrx_ref_handle,
  2448. DP_MOD_ID_RX_ERR);
  2449. nbuf = next;
  2450. }
  2451. return rx_bufs_used; /* Assume no scale factor for now */
  2452. }
  2453. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  2454. /**
  2455. * dup_desc_dbg() - dump and assert if duplicate rx desc found
  2456. *
  2457. * @soc: core DP main context
  2458. * @rxdma_dst_ring_desc: void pointer to monitor link descriptor buf addr info
  2459. * @rx_desc: void pointer to rx descriptor
  2460. *
  2461. * Return: void
  2462. */
  2463. static void dup_desc_dbg(struct dp_soc *soc,
  2464. hal_rxdma_desc_t rxdma_dst_ring_desc,
  2465. void *rx_desc)
  2466. {
  2467. DP_STATS_INC(soc, rx.err.hal_rxdma_err_dup, 1);
  2468. dp_rx_dump_info_and_assert(
  2469. soc,
  2470. soc->rx_rel_ring.hal_srng,
  2471. hal_rxdma_desc_to_hal_ring_desc(rxdma_dst_ring_desc),
  2472. rx_desc);
  2473. }
  2474. /**
  2475. * dp_rx_err_mpdu_pop() - extract the MSDU's from link descs
  2476. *
  2477. * @soc: core DP main context
  2478. * @mac_id: mac id which is one of 3 mac_ids
  2479. * @rxdma_dst_ring_desc: void pointer to monitor link descriptor buf addr info
  2480. * @head: head of descs list to be freed
  2481. * @tail: tail of decs list to be freed
  2482. *
  2483. * Return: number of msdu in MPDU to be popped
  2484. */
  2485. static inline uint32_t
  2486. dp_rx_err_mpdu_pop(struct dp_soc *soc, uint32_t mac_id,
  2487. hal_rxdma_desc_t rxdma_dst_ring_desc,
  2488. union dp_rx_desc_list_elem_t **head,
  2489. union dp_rx_desc_list_elem_t **tail)
  2490. {
  2491. void *rx_msdu_link_desc;
  2492. qdf_nbuf_t msdu;
  2493. qdf_nbuf_t last;
  2494. struct hal_rx_msdu_list msdu_list;
  2495. uint16_t num_msdus;
  2496. struct hal_buf_info buf_info;
  2497. uint32_t rx_bufs_used = 0;
  2498. uint32_t msdu_cnt;
  2499. uint32_t i;
  2500. uint8_t push_reason;
  2501. uint8_t rxdma_error_code = 0;
  2502. uint8_t bm_action = HAL_BM_ACTION_PUT_IN_IDLE_LIST;
  2503. struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  2504. uint32_t rx_link_buf_info[HAL_RX_BUFFINFO_NUM_DWORDS];
  2505. hal_rxdma_desc_t ring_desc;
  2506. struct rx_desc_pool *rx_desc_pool;
  2507. if (!pdev) {
  2508. dp_rx_err_debug("%pK: pdev is null for mac_id = %d",
  2509. soc, mac_id);
  2510. return rx_bufs_used;
  2511. }
  2512. msdu = 0;
  2513. last = NULL;
  2514. hal_rx_reo_ent_buf_paddr_get(soc->hal_soc, rxdma_dst_ring_desc,
  2515. &buf_info, &msdu_cnt);
  2516. push_reason =
  2517. hal_rx_reo_ent_rxdma_push_reason_get(rxdma_dst_ring_desc);
  2518. if (push_reason == HAL_RX_WBM_RXDMA_PSH_RSN_ERROR) {
  2519. rxdma_error_code =
  2520. hal_rx_reo_ent_rxdma_error_code_get(rxdma_dst_ring_desc);
  2521. }
  2522. do {
  2523. rx_msdu_link_desc =
  2524. dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  2525. qdf_assert_always(rx_msdu_link_desc);
  2526. hal_rx_msdu_list_get(soc->hal_soc, rx_msdu_link_desc,
  2527. &msdu_list, &num_msdus);
  2528. if (msdu_list.sw_cookie[0] != HAL_RX_COOKIE_SPECIAL) {
  2529. /* if the msdus belongs to NSS offloaded radio &&
  2530. * the rbm is not SW1_BM then return the msdu_link
  2531. * descriptor without freeing the msdus (nbufs). let
  2532. * these buffers be given to NSS completion ring for
  2533. * NSS to free them.
  2534. * else iterate through the msdu link desc list and
  2535. * free each msdu in the list.
  2536. */
  2537. if (msdu_list.rbm[0] !=
  2538. HAL_RX_BUF_RBM_SW3_BM(soc->wbm_sw0_bm_id) &&
  2539. wlan_cfg_get_dp_pdev_nss_enabled(
  2540. pdev->wlan_cfg_ctx))
  2541. bm_action = HAL_BM_ACTION_RELEASE_MSDU_LIST;
  2542. else {
  2543. for (i = 0; i < num_msdus; i++) {
  2544. struct dp_rx_desc *rx_desc =
  2545. soc->arch_ops.
  2546. dp_rx_desc_cookie_2_va(
  2547. soc,
  2548. msdu_list.sw_cookie[i]);
  2549. qdf_assert_always(rx_desc);
  2550. msdu = rx_desc->nbuf;
  2551. /*
  2552. * this is a unlikely scenario
  2553. * where the host is reaping
  2554. * a descriptor which
  2555. * it already reaped just a while ago
  2556. * but is yet to replenish
  2557. * it back to HW.
  2558. * In this case host will dump
  2559. * the last 128 descriptors
  2560. * including the software descriptor
  2561. * rx_desc and assert.
  2562. */
  2563. ring_desc = rxdma_dst_ring_desc;
  2564. if (qdf_unlikely(!rx_desc->in_use)) {
  2565. dup_desc_dbg(soc,
  2566. ring_desc,
  2567. rx_desc);
  2568. continue;
  2569. }
  2570. if (rx_desc->unmapped == 0) {
  2571. rx_desc_pool =
  2572. &soc->rx_desc_buf[rx_desc->pool_id];
  2573. dp_ipa_rx_buf_smmu_mapping_lock(soc);
  2574. dp_rx_nbuf_unmap_pool(soc,
  2575. rx_desc_pool,
  2576. msdu);
  2577. rx_desc->unmapped = 1;
  2578. dp_ipa_rx_buf_smmu_mapping_unlock(soc);
  2579. }
  2580. dp_rx_err_debug("%pK: msdu_nbuf=%pK ",
  2581. soc, msdu);
  2582. dp_rx_buffer_pool_nbuf_free(soc, msdu,
  2583. rx_desc->pool_id);
  2584. rx_bufs_used++;
  2585. dp_rx_add_to_free_desc_list(head,
  2586. tail, rx_desc);
  2587. }
  2588. }
  2589. } else {
  2590. rxdma_error_code = HAL_RXDMA_ERR_WAR;
  2591. }
  2592. /*
  2593. * Store the current link buffer into to the local structure
  2594. * to be used for release purpose.
  2595. */
  2596. hal_rxdma_buff_addr_info_set(soc->hal_soc, rx_link_buf_info,
  2597. buf_info.paddr, buf_info.sw_cookie,
  2598. buf_info.rbm);
  2599. hal_rx_mon_next_link_desc_get(soc->hal_soc, rx_msdu_link_desc,
  2600. &buf_info);
  2601. dp_rx_link_desc_return_by_addr(soc,
  2602. (hal_buff_addrinfo_t)
  2603. rx_link_buf_info,
  2604. bm_action);
  2605. } while (buf_info.paddr);
  2606. DP_STATS_INC(soc, rx.err.rxdma_error[rxdma_error_code], 1);
  2607. if (pdev)
  2608. DP_STATS_INC(pdev, err.rxdma_error, 1);
  2609. if (rxdma_error_code == HAL_RXDMA_ERR_DECRYPT) {
  2610. dp_rx_err_err("%pK: Packet received with Decrypt error", soc);
  2611. }
  2612. return rx_bufs_used;
  2613. }
  2614. uint32_t
  2615. dp_rxdma_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
  2616. uint32_t mac_id, uint32_t quota)
  2617. {
  2618. struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  2619. hal_rxdma_desc_t rxdma_dst_ring_desc;
  2620. hal_soc_handle_t hal_soc;
  2621. void *err_dst_srng;
  2622. union dp_rx_desc_list_elem_t *head = NULL;
  2623. union dp_rx_desc_list_elem_t *tail = NULL;
  2624. struct dp_srng *dp_rxdma_srng;
  2625. struct rx_desc_pool *rx_desc_pool;
  2626. uint32_t work_done = 0;
  2627. uint32_t rx_bufs_used = 0;
  2628. if (!pdev)
  2629. return 0;
  2630. err_dst_srng = soc->rxdma_err_dst_ring[mac_id].hal_srng;
  2631. if (!err_dst_srng) {
  2632. dp_rx_err_err("%pK: HAL Monitor Destination Ring Init Failed -- %pK",
  2633. soc, err_dst_srng);
  2634. return 0;
  2635. }
  2636. hal_soc = soc->hal_soc;
  2637. qdf_assert(hal_soc);
  2638. if (qdf_unlikely(dp_srng_access_start(int_ctx, soc, err_dst_srng))) {
  2639. dp_rx_err_err("%pK: HAL Monitor Destination Ring Init Failed -- %pK",
  2640. soc, err_dst_srng);
  2641. return 0;
  2642. }
  2643. while (qdf_likely(quota-- && (rxdma_dst_ring_desc =
  2644. hal_srng_dst_get_next(hal_soc, err_dst_srng)))) {
  2645. rx_bufs_used += dp_rx_err_mpdu_pop(soc, mac_id,
  2646. rxdma_dst_ring_desc,
  2647. &head, &tail);
  2648. }
  2649. dp_srng_access_end(int_ctx, soc, err_dst_srng);
  2650. if (rx_bufs_used) {
  2651. if (wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx)) {
  2652. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_id];
  2653. rx_desc_pool = &soc->rx_desc_buf[mac_id];
  2654. } else {
  2655. dp_rxdma_srng = &soc->rx_refill_buf_ring[pdev->lmac_id];
  2656. rx_desc_pool = &soc->rx_desc_buf[pdev->lmac_id];
  2657. }
  2658. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  2659. rx_desc_pool, rx_bufs_used, &head, &tail, false);
  2660. work_done += rx_bufs_used;
  2661. }
  2662. return work_done;
  2663. }
  2664. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  2665. static inline void
  2666. dp_wbm_int_err_mpdu_pop(struct dp_soc *soc, uint32_t mac_id,
  2667. hal_rxdma_desc_t rxdma_dst_ring_desc,
  2668. union dp_rx_desc_list_elem_t **head,
  2669. union dp_rx_desc_list_elem_t **tail,
  2670. uint32_t *rx_bufs_used)
  2671. {
  2672. void *rx_msdu_link_desc;
  2673. qdf_nbuf_t msdu;
  2674. qdf_nbuf_t last;
  2675. struct hal_rx_msdu_list msdu_list;
  2676. uint16_t num_msdus;
  2677. struct hal_buf_info buf_info;
  2678. uint32_t msdu_cnt, i;
  2679. uint32_t rx_link_buf_info[HAL_RX_BUFFINFO_NUM_DWORDS];
  2680. struct rx_desc_pool *rx_desc_pool;
  2681. struct dp_rx_desc *rx_desc;
  2682. msdu = 0;
  2683. last = NULL;
  2684. hal_rx_reo_ent_buf_paddr_get(soc->hal_soc, rxdma_dst_ring_desc,
  2685. &buf_info, &msdu_cnt);
  2686. do {
  2687. rx_msdu_link_desc =
  2688. dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  2689. if (!rx_msdu_link_desc) {
  2690. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_NULL_LINK_DESC], 1);
  2691. break;
  2692. }
  2693. hal_rx_msdu_list_get(soc->hal_soc, rx_msdu_link_desc,
  2694. &msdu_list, &num_msdus);
  2695. if (msdu_list.sw_cookie[0] != HAL_RX_COOKIE_SPECIAL) {
  2696. for (i = 0; i < num_msdus; i++) {
  2697. if (!dp_rx_is_sw_cookie_valid(soc, msdu_list.sw_cookie[i])) {
  2698. dp_rx_err_info_rl("Invalid MSDU info cookie: 0x%x",
  2699. msdu_list.sw_cookie[i]);
  2700. continue;
  2701. }
  2702. rx_desc = soc->arch_ops.dp_rx_desc_cookie_2_va(
  2703. soc,
  2704. msdu_list.sw_cookie[i]);
  2705. qdf_assert_always(rx_desc);
  2706. rx_desc_pool =
  2707. &soc->rx_desc_buf[rx_desc->pool_id];
  2708. msdu = rx_desc->nbuf;
  2709. /*
  2710. * this is a unlikely scenario where the host is reaping
  2711. * a descriptor which it already reaped just a while ago
  2712. * but is yet to replenish it back to HW.
  2713. */
  2714. if (qdf_unlikely(!rx_desc->in_use) ||
  2715. qdf_unlikely(!msdu)) {
  2716. dp_rx_err_info_rl("Reaping rx_desc not in use!");
  2717. continue;
  2718. }
  2719. dp_ipa_rx_buf_smmu_mapping_lock(soc);
  2720. dp_rx_nbuf_unmap_pool(soc, rx_desc_pool, msdu);
  2721. rx_desc->unmapped = 1;
  2722. dp_ipa_rx_buf_smmu_mapping_unlock(soc);
  2723. dp_rx_buffer_pool_nbuf_free(soc, msdu,
  2724. rx_desc->pool_id);
  2725. rx_bufs_used[rx_desc->pool_id]++;
  2726. dp_rx_add_to_free_desc_list(head,
  2727. tail, rx_desc);
  2728. }
  2729. }
  2730. /*
  2731. * Store the current link buffer into to the local structure
  2732. * to be used for release purpose.
  2733. */
  2734. hal_rxdma_buff_addr_info_set(soc->hal_soc, rx_link_buf_info,
  2735. buf_info.paddr, buf_info.sw_cookie,
  2736. buf_info.rbm);
  2737. hal_rx_mon_next_link_desc_get(soc->hal_soc, rx_msdu_link_desc,
  2738. &buf_info);
  2739. dp_rx_link_desc_return_by_addr(soc, (hal_buff_addrinfo_t)
  2740. rx_link_buf_info,
  2741. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  2742. } while (buf_info.paddr);
  2743. }
  2744. void
  2745. dp_handle_wbm_internal_error(struct dp_soc *soc, void *hal_desc,
  2746. uint32_t buf_type)
  2747. {
  2748. struct hal_buf_info buf_info = {0};
  2749. struct dp_rx_desc *rx_desc = NULL;
  2750. struct rx_desc_pool *rx_desc_pool;
  2751. uint32_t rx_bufs_reaped[MAX_PDEV_CNT] = {0};
  2752. union dp_rx_desc_list_elem_t *head = NULL;
  2753. union dp_rx_desc_list_elem_t *tail = NULL;
  2754. uint8_t pool_id;
  2755. uint8_t mac_id;
  2756. hal_rx_reo_buf_paddr_get(soc->hal_soc, hal_desc, &buf_info);
  2757. if (!buf_info.paddr) {
  2758. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_NULL_BUFFER], 1);
  2759. return;
  2760. }
  2761. /* buffer_addr_info is the first element of ring_desc */
  2762. hal_rx_buf_cookie_rbm_get(soc->hal_soc, (uint32_t *)hal_desc,
  2763. &buf_info);
  2764. if (buf_type == HAL_WBM_RELEASE_RING_2_BUFFER_TYPE) {
  2765. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_NULL_MSDU_BUFF], 1);
  2766. rx_desc = soc->arch_ops.dp_rx_desc_cookie_2_va(
  2767. soc,
  2768. buf_info.sw_cookie);
  2769. if (rx_desc && rx_desc->nbuf) {
  2770. rx_desc_pool = &soc->rx_desc_buf[rx_desc->pool_id];
  2771. dp_ipa_rx_buf_smmu_mapping_lock(soc);
  2772. dp_rx_nbuf_unmap_pool(soc, rx_desc_pool,
  2773. rx_desc->nbuf);
  2774. rx_desc->unmapped = 1;
  2775. dp_ipa_rx_buf_smmu_mapping_unlock(soc);
  2776. dp_rx_buffer_pool_nbuf_free(soc, rx_desc->nbuf,
  2777. rx_desc->pool_id);
  2778. dp_rx_add_to_free_desc_list(&head,
  2779. &tail,
  2780. rx_desc);
  2781. rx_bufs_reaped[rx_desc->pool_id]++;
  2782. }
  2783. } else if (buf_type == HAL_WBM_RELEASE_RING_2_DESC_TYPE) {
  2784. pool_id = DP_RX_DESC_COOKIE_POOL_ID_GET(buf_info.sw_cookie);
  2785. dp_wbm_int_err_mpdu_pop(soc, pool_id, hal_desc,
  2786. &head, &tail, rx_bufs_reaped);
  2787. }
  2788. for (mac_id = 0; mac_id < MAX_PDEV_CNT; mac_id++) {
  2789. struct rx_desc_pool *rx_desc_pool;
  2790. struct dp_srng *dp_rxdma_srng;
  2791. if (!rx_bufs_reaped[mac_id])
  2792. continue;
  2793. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_BUFF_REAPED], 1);
  2794. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_id];
  2795. rx_desc_pool = &soc->rx_desc_buf[mac_id];
  2796. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  2797. rx_desc_pool,
  2798. rx_bufs_reaped[mac_id],
  2799. &head, &tail, false);
  2800. }
  2801. }
  2802. #endif /* QCA_HOST_MODE_WIFI_DISABLED */