dp_rx_err.c 91 KB

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