dp_rx.c 94 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427
  1. /*
  2. * Copyright (c) 2016-2020 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_peer.h"
  22. #include "hal_rx.h"
  23. #include "hal_api.h"
  24. #include "qdf_nbuf.h"
  25. #ifdef MESH_MODE_SUPPORT
  26. #include "if_meta_hdr.h"
  27. #endif
  28. #include "dp_internal.h"
  29. #include "dp_rx_mon.h"
  30. #include "dp_ipa.h"
  31. #ifdef FEATURE_WDS
  32. #include "dp_txrx_wds.h"
  33. #endif
  34. #include "dp_hist.h"
  35. #include "dp_rx_buffer_pool.h"
  36. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  37. #ifdef ATH_RX_PRI_SAVE
  38. #define DP_RX_TID_SAVE(_nbuf, _tid) \
  39. (qdf_nbuf_set_priority(_nbuf, _tid))
  40. #else
  41. #define DP_RX_TID_SAVE(_nbuf, _tid)
  42. #endif
  43. #ifdef DP_RX_DISABLE_NDI_MDNS_FORWARDING
  44. static inline
  45. bool dp_rx_check_ndi_mdns_fwding(struct dp_peer *ta_peer, qdf_nbuf_t nbuf)
  46. {
  47. if (ta_peer->vdev->opmode == wlan_op_mode_ndi &&
  48. qdf_nbuf_is_ipv6_mdns_pkt(nbuf)) {
  49. DP_STATS_INC(ta_peer, rx.intra_bss.mdns_no_fwd, 1);
  50. return false;
  51. }
  52. return true;
  53. }
  54. #else
  55. static inline
  56. bool dp_rx_check_ndi_mdns_fwding(struct dp_peer *ta_peer, qdf_nbuf_t nbuf)
  57. {
  58. return true;
  59. }
  60. #endif
  61. static inline bool dp_rx_check_ap_bridge(struct dp_vdev *vdev)
  62. {
  63. return vdev->ap_bridge_enabled;
  64. }
  65. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  66. #ifdef DUP_RX_DESC_WAR
  67. void dp_rx_dump_info_and_assert(struct dp_soc *soc,
  68. hal_ring_handle_t hal_ring,
  69. hal_ring_desc_t ring_desc,
  70. struct dp_rx_desc *rx_desc)
  71. {
  72. void *hal_soc = soc->hal_soc;
  73. hal_srng_dump_ring_desc(hal_soc, hal_ring, ring_desc);
  74. dp_rx_desc_dump(rx_desc);
  75. }
  76. #else
  77. void dp_rx_dump_info_and_assert(struct dp_soc *soc,
  78. hal_ring_handle_t hal_ring_hdl,
  79. hal_ring_desc_t ring_desc,
  80. struct dp_rx_desc *rx_desc)
  81. {
  82. hal_soc_handle_t hal_soc = soc->hal_soc;
  83. dp_rx_desc_dump(rx_desc);
  84. hal_srng_dump_ring_desc(hal_soc, hal_ring_hdl, ring_desc);
  85. hal_srng_dump_ring(hal_soc, hal_ring_hdl);
  86. qdf_assert_always(0);
  87. }
  88. #endif
  89. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  90. #ifdef RX_DESC_SANITY_WAR
  91. static inline
  92. QDF_STATUS dp_rx_desc_sanity(struct dp_soc *soc, hal_soc_handle_t hal_soc,
  93. hal_ring_handle_t hal_ring_hdl,
  94. hal_ring_desc_t ring_desc,
  95. struct dp_rx_desc *rx_desc)
  96. {
  97. uint8_t return_buffer_manager;
  98. if (qdf_unlikely(!rx_desc)) {
  99. /*
  100. * This is an unlikely case where the cookie obtained
  101. * from the ring_desc is invalid and hence we are not
  102. * able to find the corresponding rx_desc
  103. */
  104. goto fail;
  105. }
  106. return_buffer_manager = hal_rx_ret_buf_manager_get(ring_desc);
  107. if (qdf_unlikely(!(return_buffer_manager == HAL_RX_BUF_RBM_SW1_BM ||
  108. return_buffer_manager == HAL_RX_BUF_RBM_SW3_BM))) {
  109. goto fail;
  110. }
  111. return QDF_STATUS_SUCCESS;
  112. fail:
  113. DP_STATS_INC(soc, rx.err.invalid_cookie, 1);
  114. dp_err("Ring Desc:");
  115. hal_srng_dump_ring_desc(hal_soc, hal_ring_hdl,
  116. ring_desc);
  117. return QDF_STATUS_E_NULL_VALUE;
  118. }
  119. #else
  120. static inline
  121. QDF_STATUS dp_rx_desc_sanity(struct dp_soc *soc, hal_soc_handle_t hal_soc,
  122. hal_ring_handle_t hal_ring_hdl,
  123. hal_ring_desc_t ring_desc,
  124. struct dp_rx_desc *rx_desc)
  125. {
  126. return QDF_STATUS_SUCCESS;
  127. }
  128. #endif
  129. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  130. /**
  131. * dp_pdev_frag_alloc_and_map() - Allocate frag for desc buffer and map
  132. *
  133. * @dp_soc: struct dp_soc *
  134. * @nbuf_frag_info_t: nbuf frag info
  135. * @dp_pdev: struct dp_pdev *
  136. * @rx_desc_pool: Rx desc pool
  137. *
  138. * Return: QDF_STATUS
  139. */
  140. #ifdef DP_RX_MON_MEM_FRAG
  141. static inline QDF_STATUS
  142. dp_pdev_frag_alloc_and_map(struct dp_soc *dp_soc,
  143. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  144. struct dp_pdev *dp_pdev,
  145. struct rx_desc_pool *rx_desc_pool)
  146. {
  147. QDF_STATUS ret = QDF_STATUS_E_FAILURE;
  148. (nbuf_frag_info_t->virt_addr).vaddr =
  149. qdf_frag_alloc(rx_desc_pool->buf_size);
  150. if (!((nbuf_frag_info_t->virt_addr).vaddr)) {
  151. dp_err("Frag alloc failed");
  152. DP_STATS_INC(dp_pdev, replenish.frag_alloc_fail, 1);
  153. return QDF_STATUS_E_NOMEM;
  154. }
  155. ret = qdf_mem_map_page(dp_soc->osdev,
  156. (nbuf_frag_info_t->virt_addr).vaddr,
  157. QDF_DMA_FROM_DEVICE,
  158. rx_desc_pool->buf_size,
  159. &nbuf_frag_info_t->paddr);
  160. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  161. qdf_frag_free((nbuf_frag_info_t->virt_addr).vaddr);
  162. dp_err("Frag map failed");
  163. DP_STATS_INC(dp_pdev, replenish.map_err, 1);
  164. return QDF_STATUS_E_FAULT;
  165. }
  166. return QDF_STATUS_SUCCESS;
  167. }
  168. #else
  169. static inline QDF_STATUS
  170. dp_pdev_frag_alloc_and_map(struct dp_soc *dp_soc,
  171. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  172. struct dp_pdev *dp_pdev,
  173. struct rx_desc_pool *rx_desc_pool)
  174. {
  175. return QDF_STATUS_SUCCESS;
  176. }
  177. #endif /* DP_RX_MON_MEM_FRAG */
  178. /**
  179. * dp_pdev_nbuf_alloc_and_map() - Allocate nbuf for desc buffer and map
  180. *
  181. * @dp_soc: struct dp_soc *
  182. * @mac_id: Mac id
  183. * @num_entries_avail: num_entries_avail
  184. * @nbuf_frag_info_t: nbuf frag info
  185. * @dp_pdev: struct dp_pdev *
  186. * @rx_desc_pool: Rx desc pool
  187. *
  188. * Return: QDF_STATUS
  189. */
  190. static inline QDF_STATUS
  191. dp_pdev_nbuf_alloc_and_map_replenish(struct dp_soc *dp_soc,
  192. uint32_t mac_id,
  193. uint32_t num_entries_avail,
  194. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  195. struct dp_pdev *dp_pdev,
  196. struct rx_desc_pool *rx_desc_pool)
  197. {
  198. QDF_STATUS ret = QDF_STATUS_E_FAILURE;
  199. (nbuf_frag_info_t->virt_addr).nbuf =
  200. dp_rx_buffer_pool_nbuf_alloc(dp_soc,
  201. mac_id,
  202. rx_desc_pool,
  203. num_entries_avail);
  204. if (!((nbuf_frag_info_t->virt_addr).nbuf)) {
  205. dp_err("nbuf alloc failed");
  206. DP_STATS_INC(dp_pdev, replenish.nbuf_alloc_fail, 1);
  207. return QDF_STATUS_E_NOMEM;
  208. }
  209. ret = qdf_nbuf_map_nbytes_single(dp_soc->osdev,
  210. (nbuf_frag_info_t->virt_addr).nbuf,
  211. QDF_DMA_FROM_DEVICE,
  212. rx_desc_pool->buf_size);
  213. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  214. dp_rx_buffer_pool_nbuf_free(dp_soc,
  215. (nbuf_frag_info_t->virt_addr).nbuf, mac_id);
  216. dp_err("nbuf map failed");
  217. DP_STATS_INC(dp_pdev, replenish.map_err, 1);
  218. return QDF_STATUS_E_FAULT;
  219. }
  220. nbuf_frag_info_t->paddr =
  221. qdf_nbuf_get_frag_paddr((nbuf_frag_info_t->virt_addr).nbuf, 0);
  222. dp_ipa_handle_rx_buf_smmu_mapping(dp_soc,
  223. (qdf_nbuf_t)((nbuf_frag_info_t->virt_addr).nbuf),
  224. rx_desc_pool->buf_size,
  225. true);
  226. ret = check_x86_paddr(dp_soc, &((nbuf_frag_info_t->virt_addr).nbuf),
  227. &nbuf_frag_info_t->paddr,
  228. rx_desc_pool);
  229. if (ret == QDF_STATUS_E_FAILURE) {
  230. qdf_nbuf_unmap_nbytes_single(dp_soc->osdev,
  231. (nbuf_frag_info_t->virt_addr).nbuf,
  232. QDF_DMA_FROM_DEVICE,
  233. rx_desc_pool->buf_size);
  234. DP_STATS_INC(dp_pdev, replenish.x86_fail, 1);
  235. return QDF_STATUS_E_ADDRNOTAVAIL;
  236. }
  237. return QDF_STATUS_SUCCESS;
  238. }
  239. /*
  240. * dp_rx_buffers_replenish() - replenish rxdma ring with rx nbufs
  241. * called during dp rx initialization
  242. * and at the end of dp_rx_process.
  243. *
  244. * @soc: core txrx main context
  245. * @mac_id: mac_id which is one of 3 mac_ids
  246. * @dp_rxdma_srng: dp rxdma circular ring
  247. * @rx_desc_pool: Pointer to free Rx descriptor pool
  248. * @num_req_buffers: number of buffer to be replenished
  249. * @desc_list: list of descs if called from dp_rx_process
  250. * or NULL during dp rx initialization or out of buffer
  251. * interrupt.
  252. * @tail: tail of descs list
  253. * @func_name: name of the caller function
  254. * Return: return success or failure
  255. */
  256. QDF_STATUS __dp_rx_buffers_replenish(struct dp_soc *dp_soc, uint32_t mac_id,
  257. struct dp_srng *dp_rxdma_srng,
  258. struct rx_desc_pool *rx_desc_pool,
  259. uint32_t num_req_buffers,
  260. union dp_rx_desc_list_elem_t **desc_list,
  261. union dp_rx_desc_list_elem_t **tail,
  262. const char *func_name)
  263. {
  264. uint32_t num_alloc_desc;
  265. uint16_t num_desc_to_free = 0;
  266. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(dp_soc, mac_id);
  267. uint32_t num_entries_avail;
  268. uint32_t count;
  269. int sync_hw_ptr = 1;
  270. struct dp_rx_nbuf_frag_info nbuf_frag_info = {0};
  271. void *rxdma_ring_entry;
  272. union dp_rx_desc_list_elem_t *next;
  273. QDF_STATUS ret;
  274. void *rxdma_srng;
  275. rxdma_srng = dp_rxdma_srng->hal_srng;
  276. if (!rxdma_srng) {
  277. dp_rx_debug("%pK: rxdma srng not initialized", dp_soc);
  278. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  279. return QDF_STATUS_E_FAILURE;
  280. }
  281. dp_rx_debug("%pK: requested %d buffers for replenish",
  282. dp_soc, num_req_buffers);
  283. hal_srng_access_start(dp_soc->hal_soc, rxdma_srng);
  284. num_entries_avail = hal_srng_src_num_avail(dp_soc->hal_soc,
  285. rxdma_srng,
  286. sync_hw_ptr);
  287. dp_rx_debug("%pK: no of available entries in rxdma ring: %d",
  288. dp_soc, num_entries_avail);
  289. if (!(*desc_list) && (num_entries_avail >
  290. ((dp_rxdma_srng->num_entries * 3) / 4))) {
  291. num_req_buffers = num_entries_avail;
  292. } else if (num_entries_avail < num_req_buffers) {
  293. num_desc_to_free = num_req_buffers - num_entries_avail;
  294. num_req_buffers = num_entries_avail;
  295. }
  296. if (qdf_unlikely(!num_req_buffers)) {
  297. num_desc_to_free = num_req_buffers;
  298. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  299. goto free_descs;
  300. }
  301. /*
  302. * if desc_list is NULL, allocate the descs from freelist
  303. */
  304. if (!(*desc_list)) {
  305. num_alloc_desc = dp_rx_get_free_desc_list(dp_soc, mac_id,
  306. rx_desc_pool,
  307. num_req_buffers,
  308. desc_list,
  309. tail);
  310. if (!num_alloc_desc) {
  311. dp_rx_err("%pK: no free rx_descs in freelist", dp_soc);
  312. DP_STATS_INC(dp_pdev, err.desc_alloc_fail,
  313. num_req_buffers);
  314. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  315. return QDF_STATUS_E_NOMEM;
  316. }
  317. dp_rx_debug("%pK: %d rx desc allocated", dp_soc, num_alloc_desc);
  318. num_req_buffers = num_alloc_desc;
  319. }
  320. count = 0;
  321. while (count < num_req_buffers) {
  322. /* Flag is set while pdev rx_desc_pool initialization */
  323. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  324. ret = dp_pdev_frag_alloc_and_map(dp_soc,
  325. &nbuf_frag_info,
  326. dp_pdev,
  327. rx_desc_pool);
  328. else
  329. ret = dp_pdev_nbuf_alloc_and_map_replenish(dp_soc,
  330. mac_id,
  331. num_entries_avail, &nbuf_frag_info,
  332. dp_pdev, rx_desc_pool);
  333. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  334. if (qdf_unlikely(ret == QDF_STATUS_E_FAULT))
  335. continue;
  336. break;
  337. }
  338. count++;
  339. rxdma_ring_entry = hal_srng_src_get_next(dp_soc->hal_soc,
  340. rxdma_srng);
  341. qdf_assert_always(rxdma_ring_entry);
  342. next = (*desc_list)->next;
  343. /* Flag is set while pdev rx_desc_pool initialization */
  344. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  345. dp_rx_desc_frag_prep(&((*desc_list)->rx_desc),
  346. &nbuf_frag_info);
  347. else
  348. dp_rx_desc_prep(&((*desc_list)->rx_desc),
  349. &nbuf_frag_info);
  350. /* rx_desc.in_use should be zero at this time*/
  351. qdf_assert_always((*desc_list)->rx_desc.in_use == 0);
  352. (*desc_list)->rx_desc.in_use = 1;
  353. (*desc_list)->rx_desc.in_err_state = 0;
  354. dp_rx_desc_update_dbg_info(&(*desc_list)->rx_desc,
  355. func_name, RX_DESC_REPLENISHED);
  356. dp_verbose_debug("rx_netbuf=%pK, paddr=0x%llx, cookie=%d",
  357. nbuf_frag_info.virt_addr.nbuf,
  358. (unsigned long long)(nbuf_frag_info.paddr),
  359. (*desc_list)->rx_desc.cookie);
  360. hal_rxdma_buff_addr_info_set(rxdma_ring_entry,
  361. nbuf_frag_info.paddr,
  362. (*desc_list)->rx_desc.cookie,
  363. rx_desc_pool->owner);
  364. *desc_list = next;
  365. }
  366. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  367. dp_verbose_debug("replenished buffers %d, rx desc added back to free list %u",
  368. count, num_desc_to_free);
  369. /* No need to count the number of bytes received during replenish.
  370. * Therefore set replenish.pkts.bytes as 0.
  371. */
  372. DP_STATS_INC_PKT(dp_pdev, replenish.pkts, count, 0);
  373. free_descs:
  374. DP_STATS_INC(dp_pdev, buf_freelist, num_desc_to_free);
  375. /*
  376. * add any available free desc back to the free list
  377. */
  378. if (*desc_list)
  379. dp_rx_add_desc_list_to_free_list(dp_soc, desc_list, tail,
  380. mac_id, rx_desc_pool);
  381. return QDF_STATUS_SUCCESS;
  382. }
  383. /*
  384. * dp_rx_deliver_raw() - process RAW mode pkts and hand over the
  385. * pkts to RAW mode simulation to
  386. * decapsulate the pkt.
  387. *
  388. * @vdev: vdev on which RAW mode is enabled
  389. * @nbuf_list: list of RAW pkts to process
  390. * @peer: peer object from which the pkt is rx
  391. *
  392. * Return: void
  393. */
  394. void
  395. dp_rx_deliver_raw(struct dp_vdev *vdev, qdf_nbuf_t nbuf_list,
  396. struct dp_peer *peer)
  397. {
  398. qdf_nbuf_t deliver_list_head = NULL;
  399. qdf_nbuf_t deliver_list_tail = NULL;
  400. qdf_nbuf_t nbuf;
  401. nbuf = nbuf_list;
  402. while (nbuf) {
  403. qdf_nbuf_t next = qdf_nbuf_next(nbuf);
  404. DP_RX_LIST_APPEND(deliver_list_head, deliver_list_tail, nbuf);
  405. DP_STATS_INC(vdev->pdev, rx_raw_pkts, 1);
  406. DP_STATS_INC_PKT(peer, rx.raw, 1, qdf_nbuf_len(nbuf));
  407. /*
  408. * reset the chfrag_start and chfrag_end bits in nbuf cb
  409. * as this is a non-amsdu pkt and RAW mode simulation expects
  410. * these bit s to be 0 for non-amsdu pkt.
  411. */
  412. if (qdf_nbuf_is_rx_chfrag_start(nbuf) &&
  413. qdf_nbuf_is_rx_chfrag_end(nbuf)) {
  414. qdf_nbuf_set_rx_chfrag_start(nbuf, 0);
  415. qdf_nbuf_set_rx_chfrag_end(nbuf, 0);
  416. }
  417. nbuf = next;
  418. }
  419. vdev->osif_rsim_rx_decap(vdev->osif_vdev, &deliver_list_head,
  420. &deliver_list_tail, peer->mac_addr.raw);
  421. vdev->osif_rx(vdev->osif_vdev, deliver_list_head);
  422. }
  423. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  424. #ifndef FEATURE_WDS
  425. static void
  426. dp_rx_da_learn(struct dp_soc *soc,
  427. uint8_t *rx_tlv_hdr,
  428. struct dp_peer *ta_peer,
  429. qdf_nbuf_t nbuf)
  430. {
  431. }
  432. #endif
  433. /*
  434. * dp_rx_intrabss_fwd() - Implements the Intra-BSS forwarding logic
  435. *
  436. * @soc: core txrx main context
  437. * @ta_peer : source peer entry
  438. * @rx_tlv_hdr : start address of rx tlvs
  439. * @nbuf : nbuf that has to be intrabss forwarded
  440. *
  441. * Return: bool: true if it is forwarded else false
  442. */
  443. static bool
  444. dp_rx_intrabss_fwd(struct dp_soc *soc,
  445. struct dp_peer *ta_peer,
  446. uint8_t *rx_tlv_hdr,
  447. qdf_nbuf_t nbuf,
  448. struct hal_rx_msdu_metadata msdu_metadata)
  449. {
  450. uint16_t len;
  451. uint8_t is_frag;
  452. uint16_t da_peer_id = HTT_INVALID_PEER;
  453. struct dp_peer *da_peer = NULL;
  454. bool is_da_bss_peer = false;
  455. struct dp_ast_entry *ast_entry;
  456. qdf_nbuf_t nbuf_copy;
  457. uint8_t tid = qdf_nbuf_get_tid_val(nbuf);
  458. uint8_t ring_id = QDF_NBUF_CB_RX_CTX_ID(nbuf);
  459. struct cdp_tid_rx_stats *tid_stats = &ta_peer->vdev->pdev->stats.
  460. tid_stats.tid_rx_stats[ring_id][tid];
  461. /* check if the destination peer is available in peer table
  462. * and also check if the source peer and destination peer
  463. * belong to the same vap and destination peer is not bss peer.
  464. */
  465. if ((qdf_nbuf_is_da_valid(nbuf) && !qdf_nbuf_is_da_mcbc(nbuf))) {
  466. ast_entry = soc->ast_table[msdu_metadata.da_idx];
  467. if (!ast_entry)
  468. return false;
  469. if (ast_entry->type == CDP_TXRX_AST_TYPE_DA) {
  470. ast_entry->is_active = TRUE;
  471. return false;
  472. }
  473. da_peer_id = ast_entry->peer_id;
  474. if (da_peer_id == HTT_INVALID_PEER)
  475. return false;
  476. /* TA peer cannot be same as peer(DA) on which AST is present
  477. * this indicates a change in topology and that AST entries
  478. * are yet to be updated.
  479. */
  480. if (da_peer_id == ta_peer->peer_id)
  481. return false;
  482. if (ast_entry->vdev_id != ta_peer->vdev->vdev_id)
  483. return false;
  484. da_peer = dp_peer_get_ref_by_id(soc, da_peer_id,
  485. DP_MOD_ID_RX);
  486. if (!da_peer)
  487. return false;
  488. is_da_bss_peer = da_peer->bss_peer;
  489. dp_peer_unref_delete(da_peer, DP_MOD_ID_RX);
  490. if (!is_da_bss_peer) {
  491. len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  492. is_frag = qdf_nbuf_is_frag(nbuf);
  493. memset(nbuf->cb, 0x0, sizeof(nbuf->cb));
  494. /* If the source or destination peer in the isolation
  495. * list then dont forward instead push to bridge stack.
  496. */
  497. if (dp_get_peer_isolation(ta_peer) ||
  498. dp_get_peer_isolation(da_peer))
  499. return false;
  500. /* linearize the nbuf just before we send to
  501. * dp_tx_send()
  502. */
  503. if (qdf_unlikely(is_frag)) {
  504. if (qdf_nbuf_linearize(nbuf) == -ENOMEM)
  505. return false;
  506. nbuf = qdf_nbuf_unshare(nbuf);
  507. if (!nbuf) {
  508. DP_STATS_INC_PKT(ta_peer,
  509. rx.intra_bss.fail,
  510. 1,
  511. len);
  512. /* return true even though the pkt is
  513. * not forwarded. Basically skb_unshare
  514. * failed and we want to continue with
  515. * next nbuf.
  516. */
  517. tid_stats->fail_cnt[INTRABSS_DROP]++;
  518. return true;
  519. }
  520. }
  521. if (!dp_tx_send((struct cdp_soc_t *)soc,
  522. ta_peer->vdev->vdev_id, nbuf)) {
  523. DP_STATS_INC_PKT(ta_peer, rx.intra_bss.pkts, 1,
  524. len);
  525. return true;
  526. } else {
  527. DP_STATS_INC_PKT(ta_peer, rx.intra_bss.fail, 1,
  528. len);
  529. tid_stats->fail_cnt[INTRABSS_DROP]++;
  530. return false;
  531. }
  532. }
  533. }
  534. /* if it is a broadcast pkt (eg: ARP) and it is not its own
  535. * source, then clone the pkt and send the cloned pkt for
  536. * intra BSS forwarding and original pkt up the network stack
  537. * Note: how do we handle multicast pkts. do we forward
  538. * all multicast pkts as is or let a higher layer module
  539. * like igmpsnoop decide whether to forward or not with
  540. * Mcast enhancement.
  541. */
  542. else if (qdf_unlikely((qdf_nbuf_is_da_mcbc(nbuf) &&
  543. !ta_peer->bss_peer))) {
  544. if (!dp_rx_check_ndi_mdns_fwding(ta_peer, nbuf))
  545. goto end;
  546. /* If the source peer in the isolation list
  547. * then dont forward instead push to bridge stack
  548. */
  549. if (dp_get_peer_isolation(ta_peer))
  550. goto end;
  551. nbuf_copy = qdf_nbuf_copy(nbuf);
  552. if (!nbuf_copy)
  553. goto end;
  554. len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  555. memset(nbuf_copy->cb, 0x0, sizeof(nbuf_copy->cb));
  556. /* Set cb->ftype to intrabss FWD */
  557. qdf_nbuf_set_tx_ftype(nbuf_copy, CB_FTYPE_INTRABSS_FWD);
  558. if (dp_tx_send((struct cdp_soc_t *)soc,
  559. ta_peer->vdev->vdev_id, nbuf_copy)) {
  560. DP_STATS_INC_PKT(ta_peer, rx.intra_bss.fail, 1, len);
  561. tid_stats->fail_cnt[INTRABSS_DROP]++;
  562. qdf_nbuf_free(nbuf_copy);
  563. } else {
  564. DP_STATS_INC_PKT(ta_peer, rx.intra_bss.pkts, 1, len);
  565. tid_stats->intrabss_cnt++;
  566. }
  567. }
  568. end:
  569. /* return false as we have to still send the original pkt
  570. * up the stack
  571. */
  572. return false;
  573. }
  574. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  575. #ifdef MESH_MODE_SUPPORT
  576. /**
  577. * dp_rx_fill_mesh_stats() - Fills the mesh per packet receive stats
  578. *
  579. * @vdev: DP Virtual device handle
  580. * @nbuf: Buffer pointer
  581. * @rx_tlv_hdr: start of rx tlv header
  582. * @peer: pointer to peer
  583. *
  584. * This function allocated memory for mesh receive stats and fill the
  585. * required stats. Stores the memory address in skb cb.
  586. *
  587. * Return: void
  588. */
  589. void dp_rx_fill_mesh_stats(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  590. uint8_t *rx_tlv_hdr, struct dp_peer *peer)
  591. {
  592. struct mesh_recv_hdr_s *rx_info = NULL;
  593. uint32_t pkt_type;
  594. uint32_t nss;
  595. uint32_t rate_mcs;
  596. uint32_t bw;
  597. uint8_t primary_chan_num;
  598. uint32_t center_chan_freq;
  599. struct dp_soc *soc;
  600. /* fill recv mesh stats */
  601. rx_info = qdf_mem_malloc(sizeof(struct mesh_recv_hdr_s));
  602. /* upper layers are resposible to free this memory */
  603. if (!rx_info) {
  604. dp_rx_err("%pK: Memory allocation failed for mesh rx stats",
  605. vdev->pdev->soc);
  606. DP_STATS_INC(vdev->pdev, mesh_mem_alloc, 1);
  607. return;
  608. }
  609. rx_info->rs_flags = MESH_RXHDR_VER1;
  610. if (qdf_nbuf_is_rx_chfrag_start(nbuf))
  611. rx_info->rs_flags |= MESH_RX_FIRST_MSDU;
  612. if (qdf_nbuf_is_rx_chfrag_end(nbuf))
  613. rx_info->rs_flags |= MESH_RX_LAST_MSDU;
  614. if (hal_rx_attn_msdu_get_is_decrypted(rx_tlv_hdr)) {
  615. rx_info->rs_flags |= MESH_RX_DECRYPTED;
  616. rx_info->rs_keyix = hal_rx_msdu_get_keyid(rx_tlv_hdr);
  617. if (vdev->osif_get_key)
  618. vdev->osif_get_key(vdev->osif_vdev,
  619. &rx_info->rs_decryptkey[0],
  620. &peer->mac_addr.raw[0],
  621. rx_info->rs_keyix);
  622. }
  623. rx_info->rs_rssi = peer->stats.rx.rssi;
  624. soc = vdev->pdev->soc;
  625. primary_chan_num = hal_rx_msdu_start_get_freq(rx_tlv_hdr);
  626. center_chan_freq = hal_rx_msdu_start_get_freq(rx_tlv_hdr) >> 16;
  627. if (soc->cdp_soc.ol_ops && soc->cdp_soc.ol_ops->freq_to_band) {
  628. rx_info->rs_band = soc->cdp_soc.ol_ops->freq_to_band(
  629. soc->ctrl_psoc,
  630. vdev->pdev->pdev_id,
  631. center_chan_freq);
  632. }
  633. rx_info->rs_channel = primary_chan_num;
  634. pkt_type = hal_rx_msdu_start_get_pkt_type(rx_tlv_hdr);
  635. rate_mcs = hal_rx_msdu_start_rate_mcs_get(rx_tlv_hdr);
  636. bw = hal_rx_msdu_start_bw_get(rx_tlv_hdr);
  637. nss = hal_rx_msdu_start_nss_get(vdev->pdev->soc->hal_soc, rx_tlv_hdr);
  638. rx_info->rs_ratephy1 = rate_mcs | (nss << 0x8) | (pkt_type << 16) |
  639. (bw << 24);
  640. qdf_nbuf_set_rx_fctx_type(nbuf, (void *)rx_info, CB_FTYPE_MESH_RX_INFO);
  641. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_INFO_MED,
  642. FL("Mesh rx stats: flags %x, rssi %x, chn %x, rate %x, kix %x"),
  643. rx_info->rs_flags,
  644. rx_info->rs_rssi,
  645. rx_info->rs_channel,
  646. rx_info->rs_ratephy1,
  647. rx_info->rs_keyix);
  648. }
  649. /**
  650. * dp_rx_filter_mesh_packets() - Filters mesh unwanted packets
  651. *
  652. * @vdev: DP Virtual device handle
  653. * @nbuf: Buffer pointer
  654. * @rx_tlv_hdr: start of rx tlv header
  655. *
  656. * This checks if the received packet is matching any filter out
  657. * catogery and and drop the packet if it matches.
  658. *
  659. * Return: status(0 indicates drop, 1 indicate to no drop)
  660. */
  661. QDF_STATUS dp_rx_filter_mesh_packets(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  662. uint8_t *rx_tlv_hdr)
  663. {
  664. union dp_align_mac_addr mac_addr;
  665. struct dp_soc *soc = vdev->pdev->soc;
  666. if (qdf_unlikely(vdev->mesh_rx_filter)) {
  667. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_FROMDS)
  668. if (hal_rx_mpdu_get_fr_ds(soc->hal_soc,
  669. rx_tlv_hdr))
  670. return QDF_STATUS_SUCCESS;
  671. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_TODS)
  672. if (hal_rx_mpdu_get_to_ds(soc->hal_soc,
  673. rx_tlv_hdr))
  674. return QDF_STATUS_SUCCESS;
  675. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_NODS)
  676. if (!hal_rx_mpdu_get_fr_ds(soc->hal_soc,
  677. rx_tlv_hdr) &&
  678. !hal_rx_mpdu_get_to_ds(soc->hal_soc,
  679. rx_tlv_hdr))
  680. return QDF_STATUS_SUCCESS;
  681. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_RA) {
  682. if (hal_rx_mpdu_get_addr1(soc->hal_soc,
  683. rx_tlv_hdr,
  684. &mac_addr.raw[0]))
  685. return QDF_STATUS_E_FAILURE;
  686. if (!qdf_mem_cmp(&mac_addr.raw[0],
  687. &vdev->mac_addr.raw[0],
  688. QDF_MAC_ADDR_SIZE))
  689. return QDF_STATUS_SUCCESS;
  690. }
  691. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_TA) {
  692. if (hal_rx_mpdu_get_addr2(soc->hal_soc,
  693. rx_tlv_hdr,
  694. &mac_addr.raw[0]))
  695. return QDF_STATUS_E_FAILURE;
  696. if (!qdf_mem_cmp(&mac_addr.raw[0],
  697. &vdev->mac_addr.raw[0],
  698. QDF_MAC_ADDR_SIZE))
  699. return QDF_STATUS_SUCCESS;
  700. }
  701. }
  702. return QDF_STATUS_E_FAILURE;
  703. }
  704. #else
  705. void dp_rx_fill_mesh_stats(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  706. uint8_t *rx_tlv_hdr, struct dp_peer *peer)
  707. {
  708. }
  709. QDF_STATUS dp_rx_filter_mesh_packets(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  710. uint8_t *rx_tlv_hdr)
  711. {
  712. return QDF_STATUS_E_FAILURE;
  713. }
  714. #endif
  715. #ifdef FEATURE_NAC_RSSI
  716. /**
  717. * dp_rx_nac_filter(): Function to perform filtering of non-associated
  718. * clients
  719. * @pdev: DP pdev handle
  720. * @rx_pkt_hdr: Rx packet Header
  721. *
  722. * return: dp_vdev*
  723. */
  724. static
  725. struct dp_vdev *dp_rx_nac_filter(struct dp_pdev *pdev,
  726. uint8_t *rx_pkt_hdr)
  727. {
  728. struct ieee80211_frame *wh;
  729. struct dp_neighbour_peer *peer = NULL;
  730. wh = (struct ieee80211_frame *)rx_pkt_hdr;
  731. if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) != IEEE80211_FC1_DIR_TODS)
  732. return NULL;
  733. qdf_spin_lock_bh(&pdev->neighbour_peer_mutex);
  734. TAILQ_FOREACH(peer, &pdev->neighbour_peers_list,
  735. neighbour_peer_list_elem) {
  736. if (qdf_mem_cmp(&peer->neighbour_peers_macaddr.raw[0],
  737. wh->i_addr2, QDF_MAC_ADDR_SIZE) == 0) {
  738. dp_rx_debug("%pK: NAC configuration matched for mac-%2x:%2x:%2x:%2x:%2x:%2x",
  739. pdev->soc,
  740. peer->neighbour_peers_macaddr.raw[0],
  741. peer->neighbour_peers_macaddr.raw[1],
  742. peer->neighbour_peers_macaddr.raw[2],
  743. peer->neighbour_peers_macaddr.raw[3],
  744. peer->neighbour_peers_macaddr.raw[4],
  745. peer->neighbour_peers_macaddr.raw[5]);
  746. qdf_spin_unlock_bh(&pdev->neighbour_peer_mutex);
  747. return pdev->monitor_vdev;
  748. }
  749. }
  750. qdf_spin_unlock_bh(&pdev->neighbour_peer_mutex);
  751. return NULL;
  752. }
  753. /**
  754. * dp_rx_process_invalid_peer(): Function to pass invalid peer list to umac
  755. * @soc: DP SOC handle
  756. * @mpdu: mpdu for which peer is invalid
  757. * @mac_id: mac_id which is one of 3 mac_ids(Assuming mac_id and
  758. * pool_id has same mapping)
  759. *
  760. * return: integer type
  761. */
  762. uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu,
  763. uint8_t mac_id)
  764. {
  765. struct dp_invalid_peer_msg msg;
  766. struct dp_vdev *vdev = NULL;
  767. struct dp_pdev *pdev = NULL;
  768. struct ieee80211_frame *wh;
  769. qdf_nbuf_t curr_nbuf, next_nbuf;
  770. uint8_t *rx_tlv_hdr = qdf_nbuf_data(mpdu);
  771. uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(rx_tlv_hdr);
  772. rx_pkt_hdr = hal_rx_pkt_hdr_get(rx_tlv_hdr);
  773. if (!HAL_IS_DECAP_FORMAT_RAW(soc->hal_soc, rx_tlv_hdr)) {
  774. dp_rx_debug("%pK: Drop decapped frames", soc);
  775. goto free;
  776. }
  777. wh = (struct ieee80211_frame *)rx_pkt_hdr;
  778. if (!DP_FRAME_IS_DATA(wh)) {
  779. dp_rx_debug("%pK: NAWDS valid only for data frames", soc);
  780. goto free;
  781. }
  782. if (qdf_nbuf_len(mpdu) < sizeof(struct ieee80211_frame)) {
  783. dp_rx_err("%pK: Invalid nbuf length", soc);
  784. goto free;
  785. }
  786. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  787. if (!pdev || qdf_unlikely(pdev->is_pdev_down)) {
  788. dp_rx_err("%pK: PDEV %s", soc, !pdev ? "not found" : "down");
  789. goto free;
  790. }
  791. if (pdev->filter_neighbour_peers) {
  792. /* Next Hop scenario not yet handle */
  793. vdev = dp_rx_nac_filter(pdev, rx_pkt_hdr);
  794. if (vdev) {
  795. dp_rx_mon_deliver(soc, pdev->pdev_id,
  796. pdev->invalid_peer_head_msdu,
  797. pdev->invalid_peer_tail_msdu);
  798. pdev->invalid_peer_head_msdu = NULL;
  799. pdev->invalid_peer_tail_msdu = NULL;
  800. return 0;
  801. }
  802. }
  803. TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) {
  804. if (qdf_mem_cmp(wh->i_addr1, vdev->mac_addr.raw,
  805. QDF_MAC_ADDR_SIZE) == 0) {
  806. goto out;
  807. }
  808. }
  809. if (!vdev) {
  810. dp_rx_err("%pK: VDEV not found", soc);
  811. goto free;
  812. }
  813. out:
  814. msg.wh = wh;
  815. qdf_nbuf_pull_head(mpdu, RX_PKT_TLVS_LEN);
  816. msg.nbuf = mpdu;
  817. msg.vdev_id = vdev->vdev_id;
  818. /*
  819. * NOTE: Only valid for HKv1.
  820. * If smart monitor mode is enabled on RE, we are getting invalid
  821. * peer frames with RA as STA mac of RE and the TA not matching
  822. * with any NAC list or the the BSSID.Such frames need to dropped
  823. * in order to avoid HM_WDS false addition.
  824. */
  825. if (pdev->soc->cdp_soc.ol_ops->rx_invalid_peer) {
  826. if (!soc->hw_nac_monitor_support &&
  827. pdev->filter_neighbour_peers &&
  828. vdev->opmode == wlan_op_mode_sta) {
  829. dp_rx_warn("%pK: Drop inv peer pkts with STA RA:%pm",
  830. soc, wh->i_addr1);
  831. goto free;
  832. }
  833. pdev->soc->cdp_soc.ol_ops->rx_invalid_peer(
  834. (struct cdp_ctrl_objmgr_psoc *)soc->ctrl_psoc,
  835. pdev->pdev_id, &msg);
  836. }
  837. free:
  838. /* Drop and free packet */
  839. curr_nbuf = mpdu;
  840. while (curr_nbuf) {
  841. next_nbuf = qdf_nbuf_next(curr_nbuf);
  842. qdf_nbuf_free(curr_nbuf);
  843. curr_nbuf = next_nbuf;
  844. }
  845. return 0;
  846. }
  847. /**
  848. * dp_rx_process_invalid_peer_wrapper(): Function to wrap invalid peer handler
  849. * @soc: DP SOC handle
  850. * @mpdu: mpdu for which peer is invalid
  851. * @mpdu_done: if an mpdu is completed
  852. * @mac_id: mac_id which is one of 3 mac_ids(Assuming mac_id and
  853. * pool_id has same mapping)
  854. *
  855. * return: integer type
  856. */
  857. void dp_rx_process_invalid_peer_wrapper(struct dp_soc *soc,
  858. qdf_nbuf_t mpdu, bool mpdu_done,
  859. uint8_t mac_id)
  860. {
  861. /* Only trigger the process when mpdu is completed */
  862. if (mpdu_done)
  863. dp_rx_process_invalid_peer(soc, mpdu, mac_id);
  864. }
  865. #else
  866. uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu,
  867. uint8_t mac_id)
  868. {
  869. qdf_nbuf_t curr_nbuf, next_nbuf;
  870. struct dp_pdev *pdev;
  871. struct dp_vdev *vdev = NULL;
  872. struct ieee80211_frame *wh;
  873. uint8_t *rx_tlv_hdr = qdf_nbuf_data(mpdu);
  874. uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(rx_tlv_hdr);
  875. wh = (struct ieee80211_frame *)rx_pkt_hdr;
  876. if (!DP_FRAME_IS_DATA(wh)) {
  877. QDF_TRACE_ERROR_RL(QDF_MODULE_ID_DP,
  878. "only for data frames");
  879. goto free;
  880. }
  881. if (qdf_nbuf_len(mpdu) < sizeof(struct ieee80211_frame)) {
  882. dp_rx_err("%pK: Invalid nbuf length", soc);
  883. goto free;
  884. }
  885. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  886. if (!pdev) {
  887. dp_rx_err("%pK: PDEV not found", soc);
  888. goto free;
  889. }
  890. qdf_spin_lock_bh(&pdev->vdev_list_lock);
  891. DP_PDEV_ITERATE_VDEV_LIST(pdev, vdev) {
  892. if (qdf_mem_cmp(wh->i_addr1, vdev->mac_addr.raw,
  893. QDF_MAC_ADDR_SIZE) == 0) {
  894. qdf_spin_unlock_bh(&pdev->vdev_list_lock);
  895. goto out;
  896. }
  897. }
  898. qdf_spin_unlock_bh(&pdev->vdev_list_lock);
  899. if (!vdev) {
  900. dp_rx_err("%pK: VDEV not found", soc);
  901. goto free;
  902. }
  903. out:
  904. if (soc->cdp_soc.ol_ops->rx_invalid_peer)
  905. soc->cdp_soc.ol_ops->rx_invalid_peer(vdev->vdev_id, wh);
  906. free:
  907. /* reset the head and tail pointers */
  908. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  909. if (pdev) {
  910. pdev->invalid_peer_head_msdu = NULL;
  911. pdev->invalid_peer_tail_msdu = NULL;
  912. }
  913. /* Drop and free packet */
  914. curr_nbuf = mpdu;
  915. while (curr_nbuf) {
  916. next_nbuf = qdf_nbuf_next(curr_nbuf);
  917. qdf_nbuf_free(curr_nbuf);
  918. curr_nbuf = next_nbuf;
  919. }
  920. /* Reset the head and tail pointers */
  921. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  922. if (pdev) {
  923. pdev->invalid_peer_head_msdu = NULL;
  924. pdev->invalid_peer_tail_msdu = NULL;
  925. }
  926. return 0;
  927. }
  928. void dp_rx_process_invalid_peer_wrapper(struct dp_soc *soc,
  929. qdf_nbuf_t mpdu, bool mpdu_done,
  930. uint8_t mac_id)
  931. {
  932. /* Process the nbuf */
  933. dp_rx_process_invalid_peer(soc, mpdu, mac_id);
  934. }
  935. #endif
  936. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  937. #ifdef RECEIVE_OFFLOAD
  938. /**
  939. * dp_rx_print_offload_info() - Print offload info from RX TLV
  940. * @soc: dp soc handle
  941. * @rx_tlv: RX TLV for which offload information is to be printed
  942. *
  943. * Return: None
  944. */
  945. static void dp_rx_print_offload_info(struct dp_soc *soc, uint8_t *rx_tlv)
  946. {
  947. dp_verbose_debug("----------------------RX DESC LRO/GRO----------------------");
  948. dp_verbose_debug("lro_eligible 0x%x", HAL_RX_TLV_GET_LRO_ELIGIBLE(rx_tlv));
  949. dp_verbose_debug("pure_ack 0x%x", HAL_RX_TLV_GET_TCP_PURE_ACK(rx_tlv));
  950. dp_verbose_debug("chksum 0x%x", hal_rx_tlv_get_tcp_chksum(soc->hal_soc,
  951. rx_tlv));
  952. dp_verbose_debug("TCP seq num 0x%x", HAL_RX_TLV_GET_TCP_SEQ(rx_tlv));
  953. dp_verbose_debug("TCP ack num 0x%x", HAL_RX_TLV_GET_TCP_ACK(rx_tlv));
  954. dp_verbose_debug("TCP window 0x%x", HAL_RX_TLV_GET_TCP_WIN(rx_tlv));
  955. dp_verbose_debug("TCP protocol 0x%x", HAL_RX_TLV_GET_TCP_PROTO(rx_tlv));
  956. dp_verbose_debug("TCP offset 0x%x", HAL_RX_TLV_GET_TCP_OFFSET(rx_tlv));
  957. dp_verbose_debug("toeplitz 0x%x", HAL_RX_TLV_GET_FLOW_ID_TOEPLITZ(rx_tlv));
  958. dp_verbose_debug("---------------------------------------------------------");
  959. }
  960. /**
  961. * dp_rx_fill_gro_info() - Fill GRO info from RX TLV into skb->cb
  962. * @soc: DP SOC handle
  963. * @rx_tlv: RX TLV received for the msdu
  964. * @msdu: msdu for which GRO info needs to be filled
  965. * @rx_ol_pkt_cnt: counter to be incremented for GRO eligible packets
  966. *
  967. * Return: None
  968. */
  969. static
  970. void dp_rx_fill_gro_info(struct dp_soc *soc, uint8_t *rx_tlv,
  971. qdf_nbuf_t msdu, uint32_t *rx_ol_pkt_cnt)
  972. {
  973. if (!wlan_cfg_is_gro_enabled(soc->wlan_cfg_ctx))
  974. return;
  975. /* Filling up RX offload info only for TCP packets */
  976. if (!HAL_RX_TLV_GET_TCP_PROTO(rx_tlv))
  977. return;
  978. *rx_ol_pkt_cnt = *rx_ol_pkt_cnt + 1;
  979. QDF_NBUF_CB_RX_LRO_ELIGIBLE(msdu) =
  980. HAL_RX_TLV_GET_LRO_ELIGIBLE(rx_tlv);
  981. QDF_NBUF_CB_RX_TCP_PURE_ACK(msdu) =
  982. HAL_RX_TLV_GET_TCP_PURE_ACK(rx_tlv);
  983. QDF_NBUF_CB_RX_TCP_CHKSUM(msdu) =
  984. hal_rx_tlv_get_tcp_chksum(soc->hal_soc,
  985. rx_tlv);
  986. QDF_NBUF_CB_RX_TCP_SEQ_NUM(msdu) =
  987. HAL_RX_TLV_GET_TCP_SEQ(rx_tlv);
  988. QDF_NBUF_CB_RX_TCP_ACK_NUM(msdu) =
  989. HAL_RX_TLV_GET_TCP_ACK(rx_tlv);
  990. QDF_NBUF_CB_RX_TCP_WIN(msdu) =
  991. HAL_RX_TLV_GET_TCP_WIN(rx_tlv);
  992. QDF_NBUF_CB_RX_TCP_PROTO(msdu) =
  993. HAL_RX_TLV_GET_TCP_PROTO(rx_tlv);
  994. QDF_NBUF_CB_RX_IPV6_PROTO(msdu) =
  995. HAL_RX_TLV_GET_IPV6(rx_tlv);
  996. QDF_NBUF_CB_RX_TCP_OFFSET(msdu) =
  997. HAL_RX_TLV_GET_TCP_OFFSET(rx_tlv);
  998. QDF_NBUF_CB_RX_FLOW_ID(msdu) =
  999. HAL_RX_TLV_GET_FLOW_ID_TOEPLITZ(rx_tlv);
  1000. dp_rx_print_offload_info(soc, rx_tlv);
  1001. }
  1002. #else
  1003. static void dp_rx_fill_gro_info(struct dp_soc *soc, uint8_t *rx_tlv,
  1004. qdf_nbuf_t msdu, uint32_t *rx_ol_pkt_cnt)
  1005. {
  1006. }
  1007. #endif /* RECEIVE_OFFLOAD */
  1008. /**
  1009. * dp_rx_adjust_nbuf_len() - set appropriate msdu length in nbuf.
  1010. *
  1011. * @nbuf: pointer to msdu.
  1012. * @mpdu_len: mpdu length
  1013. *
  1014. * Return: returns true if nbuf is last msdu of mpdu else retuns false.
  1015. */
  1016. static inline bool dp_rx_adjust_nbuf_len(qdf_nbuf_t nbuf, uint16_t *mpdu_len)
  1017. {
  1018. bool last_nbuf;
  1019. if (*mpdu_len > (RX_DATA_BUFFER_SIZE - RX_PKT_TLVS_LEN)) {
  1020. qdf_nbuf_set_pktlen(nbuf, RX_DATA_BUFFER_SIZE);
  1021. last_nbuf = false;
  1022. } else {
  1023. qdf_nbuf_set_pktlen(nbuf, (*mpdu_len + RX_PKT_TLVS_LEN));
  1024. last_nbuf = true;
  1025. }
  1026. *mpdu_len -= (RX_DATA_BUFFER_SIZE - RX_PKT_TLVS_LEN);
  1027. return last_nbuf;
  1028. }
  1029. /**
  1030. * dp_rx_sg_create() - create a frag_list for MSDUs which are spread across
  1031. * multiple nbufs.
  1032. * @soc: DP SOC handle
  1033. * @nbuf: pointer to the first msdu of an amsdu.
  1034. *
  1035. * This function implements the creation of RX frag_list for cases
  1036. * where an MSDU is spread across multiple nbufs.
  1037. *
  1038. * Return: returns the head nbuf which contains complete frag_list.
  1039. */
  1040. qdf_nbuf_t dp_rx_sg_create(struct dp_soc *soc, qdf_nbuf_t nbuf)
  1041. {
  1042. qdf_nbuf_t parent, frag_list, next = NULL;
  1043. uint16_t frag_list_len = 0;
  1044. uint16_t mpdu_len;
  1045. bool last_nbuf;
  1046. /*
  1047. * Use msdu len got from REO entry descriptor instead since
  1048. * there is case the RX PKT TLV is corrupted while msdu_len
  1049. * from REO descriptor is right for non-raw RX scatter msdu.
  1050. */
  1051. mpdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  1052. /*
  1053. * this is a case where the complete msdu fits in one single nbuf.
  1054. * in this case HW sets both start and end bit and we only need to
  1055. * reset these bits for RAW mode simulator to decap the pkt
  1056. */
  1057. if (qdf_nbuf_is_rx_chfrag_start(nbuf) &&
  1058. qdf_nbuf_is_rx_chfrag_end(nbuf)) {
  1059. qdf_nbuf_set_pktlen(nbuf, mpdu_len + RX_PKT_TLVS_LEN);
  1060. qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN);
  1061. return nbuf;
  1062. }
  1063. /*
  1064. * This is a case where we have multiple msdus (A-MSDU) spread across
  1065. * multiple nbufs. here we create a fraglist out of these nbufs.
  1066. *
  1067. * the moment we encounter a nbuf with continuation bit set we
  1068. * know for sure we have an MSDU which is spread across multiple
  1069. * nbufs. We loop through and reap nbufs till we reach last nbuf.
  1070. */
  1071. parent = nbuf;
  1072. frag_list = nbuf->next;
  1073. nbuf = nbuf->next;
  1074. /*
  1075. * set the start bit in the first nbuf we encounter with continuation
  1076. * bit set. This has the proper mpdu length set as it is the first
  1077. * msdu of the mpdu. this becomes the parent nbuf and the subsequent
  1078. * nbufs will form the frag_list of the parent nbuf.
  1079. */
  1080. qdf_nbuf_set_rx_chfrag_start(parent, 1);
  1081. last_nbuf = dp_rx_adjust_nbuf_len(parent, &mpdu_len);
  1082. /*
  1083. * HW issue: MSDU cont bit is set but reported MPDU length can fit
  1084. * in to single buffer
  1085. *
  1086. * Increment error stats and avoid SG list creation
  1087. */
  1088. if (last_nbuf) {
  1089. DP_STATS_INC(soc, rx.err.msdu_continuation_err, 1);
  1090. qdf_nbuf_pull_head(parent, RX_PKT_TLVS_LEN);
  1091. return parent;
  1092. }
  1093. /*
  1094. * this is where we set the length of the fragments which are
  1095. * associated to the parent nbuf. We iterate through the frag_list
  1096. * till we hit the last_nbuf of the list.
  1097. */
  1098. do {
  1099. last_nbuf = dp_rx_adjust_nbuf_len(nbuf, &mpdu_len);
  1100. qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN);
  1101. frag_list_len += qdf_nbuf_len(nbuf);
  1102. if (last_nbuf) {
  1103. next = nbuf->next;
  1104. nbuf->next = NULL;
  1105. break;
  1106. }
  1107. nbuf = nbuf->next;
  1108. } while (!last_nbuf);
  1109. qdf_nbuf_set_rx_chfrag_start(nbuf, 0);
  1110. qdf_nbuf_append_ext_list(parent, frag_list, frag_list_len);
  1111. parent->next = next;
  1112. qdf_nbuf_pull_head(parent, RX_PKT_TLVS_LEN);
  1113. return parent;
  1114. }
  1115. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  1116. #ifdef QCA_PEER_EXT_STATS
  1117. /*
  1118. * dp_rx_compute_tid_delay - Computer per TID delay stats
  1119. * @peer: DP soc context
  1120. * @nbuf: NBuffer
  1121. *
  1122. * Return: Void
  1123. */
  1124. void dp_rx_compute_tid_delay(struct cdp_delay_tid_stats *stats,
  1125. qdf_nbuf_t nbuf)
  1126. {
  1127. struct cdp_delay_rx_stats *rx_delay = &stats->rx_delay;
  1128. uint32_t to_stack = qdf_nbuf_get_timedelta_ms(nbuf);
  1129. dp_hist_update_stats(&rx_delay->to_stack_delay, to_stack);
  1130. }
  1131. #endif /* QCA_PEER_EXT_STATS */
  1132. /**
  1133. * dp_rx_compute_delay() - Compute and fill in all timestamps
  1134. * to pass in correct fields
  1135. *
  1136. * @vdev: pdev handle
  1137. * @tx_desc: tx descriptor
  1138. * @tid: tid value
  1139. * Return: none
  1140. */
  1141. void dp_rx_compute_delay(struct dp_vdev *vdev, qdf_nbuf_t nbuf)
  1142. {
  1143. uint8_t ring_id = QDF_NBUF_CB_RX_CTX_ID(nbuf);
  1144. int64_t current_ts = qdf_ktime_to_ms(qdf_ktime_get());
  1145. uint32_t to_stack = qdf_nbuf_get_timedelta_ms(nbuf);
  1146. uint8_t tid = qdf_nbuf_get_tid_val(nbuf);
  1147. uint32_t interframe_delay =
  1148. (uint32_t)(current_ts - vdev->prev_rx_deliver_tstamp);
  1149. dp_update_delay_stats(vdev->pdev, to_stack, tid,
  1150. CDP_DELAY_STATS_REAP_STACK, ring_id);
  1151. /*
  1152. * Update interframe delay stats calculated at deliver_data_ol point.
  1153. * Value of vdev->prev_rx_deliver_tstamp will be 0 for 1st frame, so
  1154. * interframe delay will not be calculate correctly for 1st frame.
  1155. * On the other side, this will help in avoiding extra per packet check
  1156. * of vdev->prev_rx_deliver_tstamp.
  1157. */
  1158. dp_update_delay_stats(vdev->pdev, interframe_delay, tid,
  1159. CDP_DELAY_STATS_RX_INTERFRAME, ring_id);
  1160. vdev->prev_rx_deliver_tstamp = current_ts;
  1161. }
  1162. /**
  1163. * dp_rx_drop_nbuf_list() - drop an nbuf list
  1164. * @pdev: dp pdev reference
  1165. * @buf_list: buffer list to be dropepd
  1166. *
  1167. * Return: int (number of bufs dropped)
  1168. */
  1169. static inline int dp_rx_drop_nbuf_list(struct dp_pdev *pdev,
  1170. qdf_nbuf_t buf_list)
  1171. {
  1172. struct cdp_tid_rx_stats *stats = NULL;
  1173. uint8_t tid = 0, ring_id = 0;
  1174. int num_dropped = 0;
  1175. qdf_nbuf_t buf, next_buf;
  1176. buf = buf_list;
  1177. while (buf) {
  1178. ring_id = QDF_NBUF_CB_RX_CTX_ID(buf);
  1179. next_buf = qdf_nbuf_queue_next(buf);
  1180. tid = qdf_nbuf_get_tid_val(buf);
  1181. if (qdf_likely(pdev)) {
  1182. stats = &pdev->stats.tid_stats.tid_rx_stats[ring_id][tid];
  1183. stats->fail_cnt[INVALID_PEER_VDEV]++;
  1184. stats->delivered_to_stack--;
  1185. }
  1186. qdf_nbuf_free(buf);
  1187. buf = next_buf;
  1188. num_dropped++;
  1189. }
  1190. return num_dropped;
  1191. }
  1192. #ifdef QCA_SUPPORT_WDS_EXTENDED
  1193. /**
  1194. * dp_rx_wds_ext() - Make different lists for 4-address and 3-address frames
  1195. * @nbuf_head: skb list head
  1196. * @vdev: vdev
  1197. * @peer: peer
  1198. * @peer_id: peer id of new received frame
  1199. * @vdev_id: vdev_id of new received frame
  1200. *
  1201. * Return: true if peer_ids are different.
  1202. */
  1203. static inline bool
  1204. dp_rx_is_list_ready(qdf_nbuf_t nbuf_head,
  1205. struct dp_vdev *vdev,
  1206. struct dp_peer *peer,
  1207. uint16_t peer_id,
  1208. uint8_t vdev_id)
  1209. {
  1210. if (nbuf_head && peer && (peer->peer_id != peer_id))
  1211. return true;
  1212. return false;
  1213. }
  1214. /**
  1215. * dp_rx_deliver_to_stack_ext() - Deliver to netdev per sta
  1216. * @soc: core txrx main context
  1217. * @vdev: vdev
  1218. * @peer: peer
  1219. * @nbuf_head: skb list head
  1220. *
  1221. * Return: true if packet is delivered to netdev per STA.
  1222. */
  1223. static inline bool
  1224. dp_rx_deliver_to_stack_ext(struct dp_soc *soc, struct dp_vdev *vdev,
  1225. struct dp_peer *peer, qdf_nbuf_t nbuf_head)
  1226. {
  1227. /*
  1228. * When extended WDS is disabled, frames are sent to AP netdevice.
  1229. */
  1230. if (qdf_likely(!vdev->wds_ext_enabled))
  1231. return false;
  1232. /*
  1233. * There can be 2 cases:
  1234. * 1. Send frame to parent netdev if its not for netdev per STA
  1235. * 2. If frame is meant for netdev per STA:
  1236. * a. Send frame to appropriate netdev using registered fp.
  1237. * b. If fp is NULL, drop the frames.
  1238. */
  1239. if (!peer->wds_ext.init)
  1240. return false;
  1241. if (peer->osif_rx)
  1242. peer->osif_rx(peer->wds_ext.osif_peer, nbuf_head);
  1243. else
  1244. dp_rx_drop_nbuf_list(vdev->pdev, nbuf_head);
  1245. return true;
  1246. }
  1247. #else
  1248. static inline bool
  1249. dp_rx_is_list_ready(qdf_nbuf_t nbuf_head,
  1250. struct dp_vdev *vdev,
  1251. struct dp_peer *peer,
  1252. uint16_t peer_id,
  1253. uint8_t vdev_id)
  1254. {
  1255. if (nbuf_head && vdev && (vdev->vdev_id != vdev_id))
  1256. return true;
  1257. return false;
  1258. }
  1259. static inline bool
  1260. dp_rx_deliver_to_stack_ext(struct dp_soc *soc, struct dp_vdev *vdev,
  1261. struct dp_peer *peer, qdf_nbuf_t nbuf_head)
  1262. {
  1263. return false;
  1264. }
  1265. #endif
  1266. #ifdef PEER_CACHE_RX_PKTS
  1267. /**
  1268. * dp_rx_flush_rx_cached() - flush cached rx frames
  1269. * @peer: peer
  1270. * @drop: flag to drop frames or forward to net stack
  1271. *
  1272. * Return: None
  1273. */
  1274. void dp_rx_flush_rx_cached(struct dp_peer *peer, bool drop)
  1275. {
  1276. struct dp_peer_cached_bufq *bufqi;
  1277. struct dp_rx_cached_buf *cache_buf = NULL;
  1278. ol_txrx_rx_fp data_rx = NULL;
  1279. int num_buff_elem;
  1280. QDF_STATUS status;
  1281. if (qdf_atomic_inc_return(&peer->flush_in_progress) > 1) {
  1282. qdf_atomic_dec(&peer->flush_in_progress);
  1283. return;
  1284. }
  1285. qdf_spin_lock_bh(&peer->peer_info_lock);
  1286. if (peer->state >= OL_TXRX_PEER_STATE_CONN && peer->vdev->osif_rx)
  1287. data_rx = peer->vdev->osif_rx;
  1288. else
  1289. drop = true;
  1290. qdf_spin_unlock_bh(&peer->peer_info_lock);
  1291. bufqi = &peer->bufq_info;
  1292. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1293. qdf_list_remove_front(&bufqi->cached_bufq,
  1294. (qdf_list_node_t **)&cache_buf);
  1295. while (cache_buf) {
  1296. num_buff_elem = QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(
  1297. cache_buf->buf);
  1298. bufqi->entries -= num_buff_elem;
  1299. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1300. if (drop) {
  1301. bufqi->dropped = dp_rx_drop_nbuf_list(peer->vdev->pdev,
  1302. cache_buf->buf);
  1303. } else {
  1304. /* Flush the cached frames to OSIF DEV */
  1305. status = data_rx(peer->vdev->osif_vdev, cache_buf->buf);
  1306. if (status != QDF_STATUS_SUCCESS)
  1307. bufqi->dropped = dp_rx_drop_nbuf_list(
  1308. peer->vdev->pdev,
  1309. cache_buf->buf);
  1310. }
  1311. qdf_mem_free(cache_buf);
  1312. cache_buf = NULL;
  1313. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1314. qdf_list_remove_front(&bufqi->cached_bufq,
  1315. (qdf_list_node_t **)&cache_buf);
  1316. }
  1317. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1318. qdf_atomic_dec(&peer->flush_in_progress);
  1319. }
  1320. /**
  1321. * dp_rx_enqueue_rx() - cache rx frames
  1322. * @peer: peer
  1323. * @rx_buf_list: cache buffer list
  1324. *
  1325. * Return: None
  1326. */
  1327. static QDF_STATUS
  1328. dp_rx_enqueue_rx(struct dp_peer *peer, qdf_nbuf_t rx_buf_list)
  1329. {
  1330. struct dp_rx_cached_buf *cache_buf;
  1331. struct dp_peer_cached_bufq *bufqi = &peer->bufq_info;
  1332. int num_buff_elem;
  1333. dp_debug_rl("bufq->curr %d bufq->drops %d", bufqi->entries,
  1334. bufqi->dropped);
  1335. if (!peer->valid) {
  1336. bufqi->dropped = dp_rx_drop_nbuf_list(peer->vdev->pdev,
  1337. rx_buf_list);
  1338. return QDF_STATUS_E_INVAL;
  1339. }
  1340. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1341. if (bufqi->entries >= bufqi->thresh) {
  1342. bufqi->dropped = dp_rx_drop_nbuf_list(peer->vdev->pdev,
  1343. rx_buf_list);
  1344. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1345. return QDF_STATUS_E_RESOURCES;
  1346. }
  1347. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1348. num_buff_elem = QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(rx_buf_list);
  1349. cache_buf = qdf_mem_malloc_atomic(sizeof(*cache_buf));
  1350. if (!cache_buf) {
  1351. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1352. "Failed to allocate buf to cache rx frames");
  1353. bufqi->dropped = dp_rx_drop_nbuf_list(peer->vdev->pdev,
  1354. rx_buf_list);
  1355. return QDF_STATUS_E_NOMEM;
  1356. }
  1357. cache_buf->buf = rx_buf_list;
  1358. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1359. qdf_list_insert_back(&bufqi->cached_bufq,
  1360. &cache_buf->node);
  1361. bufqi->entries += num_buff_elem;
  1362. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1363. return QDF_STATUS_SUCCESS;
  1364. }
  1365. static inline
  1366. bool dp_rx_is_peer_cache_bufq_supported(void)
  1367. {
  1368. return true;
  1369. }
  1370. #else
  1371. static inline
  1372. bool dp_rx_is_peer_cache_bufq_supported(void)
  1373. {
  1374. return false;
  1375. }
  1376. static inline QDF_STATUS
  1377. dp_rx_enqueue_rx(struct dp_peer *peer, qdf_nbuf_t rx_buf_list)
  1378. {
  1379. return QDF_STATUS_SUCCESS;
  1380. }
  1381. #endif
  1382. #ifndef DELIVERY_TO_STACK_STATUS_CHECK
  1383. /**
  1384. * dp_rx_check_delivery_to_stack() - Deliver pkts to network
  1385. * using the appropriate call back functions.
  1386. * @soc: soc
  1387. * @vdev: vdev
  1388. * @peer: peer
  1389. * @nbuf_head: skb list head
  1390. * @nbuf_tail: skb list tail
  1391. *
  1392. * Return: None
  1393. */
  1394. static void dp_rx_check_delivery_to_stack(struct dp_soc *soc,
  1395. struct dp_vdev *vdev,
  1396. struct dp_peer *peer,
  1397. qdf_nbuf_t nbuf_head)
  1398. {
  1399. if (qdf_unlikely(dp_rx_deliver_to_stack_ext(soc, vdev,
  1400. peer, nbuf_head)))
  1401. return;
  1402. /* Function pointer initialized only when FISA is enabled */
  1403. if (vdev->osif_fisa_rx)
  1404. /* on failure send it via regular path */
  1405. vdev->osif_fisa_rx(soc, vdev, nbuf_head);
  1406. else
  1407. vdev->osif_rx(vdev->osif_vdev, nbuf_head);
  1408. }
  1409. #else
  1410. /**
  1411. * dp_rx_check_delivery_to_stack() - Deliver pkts to network
  1412. * using the appropriate call back functions.
  1413. * @soc: soc
  1414. * @vdev: vdev
  1415. * @peer: peer
  1416. * @nbuf_head: skb list head
  1417. * @nbuf_tail: skb list tail
  1418. *
  1419. * Check the return status of the call back function and drop
  1420. * the packets if the return status indicates a failure.
  1421. *
  1422. * Return: None
  1423. */
  1424. static void dp_rx_check_delivery_to_stack(struct dp_soc *soc,
  1425. struct dp_vdev *vdev,
  1426. struct dp_peer *peer,
  1427. qdf_nbuf_t nbuf_head)
  1428. {
  1429. int num_nbuf = 0;
  1430. QDF_STATUS ret_val = QDF_STATUS_E_FAILURE;
  1431. /* Function pointer initialized only when FISA is enabled */
  1432. if (vdev->osif_fisa_rx)
  1433. /* on failure send it via regular path */
  1434. ret_val = vdev->osif_fisa_rx(soc, vdev, nbuf_head);
  1435. else if (vdev->osif_rx)
  1436. ret_val = vdev->osif_rx(vdev->osif_vdev, nbuf_head);
  1437. if (!QDF_IS_STATUS_SUCCESS(ret_val)) {
  1438. num_nbuf = dp_rx_drop_nbuf_list(vdev->pdev, nbuf_head);
  1439. DP_STATS_INC(soc, rx.err.rejected, num_nbuf);
  1440. if (peer)
  1441. DP_STATS_DEC(peer, rx.to_stack.num, num_nbuf);
  1442. }
  1443. }
  1444. #endif /* ifdef DELIVERY_TO_STACK_STATUS_CHECK */
  1445. void dp_rx_deliver_to_stack(struct dp_soc *soc,
  1446. struct dp_vdev *vdev,
  1447. struct dp_peer *peer,
  1448. qdf_nbuf_t nbuf_head,
  1449. qdf_nbuf_t nbuf_tail)
  1450. {
  1451. int num_nbuf = 0;
  1452. if (qdf_unlikely(!vdev || vdev->delete.pending)) {
  1453. num_nbuf = dp_rx_drop_nbuf_list(NULL, nbuf_head);
  1454. /*
  1455. * This is a special case where vdev is invalid,
  1456. * so we cannot know the pdev to which this packet
  1457. * belonged. Hence we update the soc rx error stats.
  1458. */
  1459. DP_STATS_INC(soc, rx.err.invalid_vdev, num_nbuf);
  1460. return;
  1461. }
  1462. /*
  1463. * highly unlikely to have a vdev without a registered rx
  1464. * callback function. if so let us free the nbuf_list.
  1465. */
  1466. if (qdf_unlikely(!vdev->osif_rx)) {
  1467. if (peer && dp_rx_is_peer_cache_bufq_supported()) {
  1468. dp_rx_enqueue_rx(peer, nbuf_head);
  1469. } else {
  1470. num_nbuf = dp_rx_drop_nbuf_list(vdev->pdev,
  1471. nbuf_head);
  1472. DP_STATS_DEC(peer, rx.to_stack.num, num_nbuf);
  1473. }
  1474. return;
  1475. }
  1476. if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw) ||
  1477. (vdev->rx_decap_type == htt_cmn_pkt_type_native_wifi)) {
  1478. vdev->osif_rsim_rx_decap(vdev->osif_vdev, &nbuf_head,
  1479. &nbuf_tail, peer->mac_addr.raw);
  1480. }
  1481. dp_rx_check_delivery_to_stack(soc, vdev, peer, nbuf_head);
  1482. }
  1483. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  1484. /**
  1485. * dp_rx_cksum_offload() - set the nbuf checksum as defined by hardware.
  1486. * @nbuf: pointer to the first msdu of an amsdu.
  1487. * @rx_tlv_hdr: pointer to the start of RX TLV headers.
  1488. *
  1489. * The ipsumed field of the skb is set based on whether HW validated the
  1490. * IP/TCP/UDP checksum.
  1491. *
  1492. * Return: void
  1493. */
  1494. static inline void dp_rx_cksum_offload(struct dp_pdev *pdev,
  1495. qdf_nbuf_t nbuf,
  1496. uint8_t *rx_tlv_hdr)
  1497. {
  1498. qdf_nbuf_rx_cksum_t cksum = {0};
  1499. bool ip_csum_err = hal_rx_attn_ip_cksum_fail_get(rx_tlv_hdr);
  1500. bool tcp_udp_csum_er = hal_rx_attn_tcp_udp_cksum_fail_get(rx_tlv_hdr);
  1501. if (qdf_likely(!ip_csum_err && !tcp_udp_csum_er)) {
  1502. cksum.l4_result = QDF_NBUF_RX_CKSUM_TCP_UDP_UNNECESSARY;
  1503. qdf_nbuf_set_rx_cksum(nbuf, &cksum);
  1504. } else {
  1505. DP_STATS_INCC(pdev, err.ip_csum_err, 1, ip_csum_err);
  1506. DP_STATS_INCC(pdev, err.tcp_udp_csum_err, 1, tcp_udp_csum_er);
  1507. }
  1508. }
  1509. #ifdef VDEV_PEER_PROTOCOL_COUNT
  1510. #define dp_rx_msdu_stats_update_prot_cnts(vdev_hdl, nbuf, peer) \
  1511. { \
  1512. qdf_nbuf_t nbuf_local; \
  1513. struct dp_peer *peer_local; \
  1514. struct dp_vdev *vdev_local = vdev_hdl; \
  1515. do { \
  1516. if (qdf_likely(!((vdev_local)->peer_protocol_count_track))) \
  1517. break; \
  1518. nbuf_local = nbuf; \
  1519. peer_local = peer; \
  1520. if (qdf_unlikely(qdf_nbuf_is_frag((nbuf_local)))) \
  1521. break; \
  1522. else if (qdf_unlikely(qdf_nbuf_is_raw_frame((nbuf_local)))) \
  1523. break; \
  1524. dp_vdev_peer_stats_update_protocol_cnt((vdev_local), \
  1525. (nbuf_local), \
  1526. (peer_local), 0, 1); \
  1527. } while (0); \
  1528. }
  1529. #else
  1530. #define dp_rx_msdu_stats_update_prot_cnts(vdev_hdl, nbuf, peer)
  1531. #endif
  1532. /**
  1533. * dp_rx_msdu_stats_update() - update per msdu stats.
  1534. * @soc: core txrx main context
  1535. * @nbuf: pointer to the first msdu of an amsdu.
  1536. * @rx_tlv_hdr: pointer to the start of RX TLV headers.
  1537. * @peer: pointer to the peer object.
  1538. * @ring_id: reo dest ring number on which pkt is reaped.
  1539. * @tid_stats: per tid rx stats.
  1540. *
  1541. * update all the per msdu stats for that nbuf.
  1542. * Return: void
  1543. */
  1544. static void dp_rx_msdu_stats_update(struct dp_soc *soc,
  1545. qdf_nbuf_t nbuf,
  1546. uint8_t *rx_tlv_hdr,
  1547. struct dp_peer *peer,
  1548. uint8_t ring_id,
  1549. struct cdp_tid_rx_stats *tid_stats)
  1550. {
  1551. bool is_ampdu, is_not_amsdu;
  1552. uint32_t sgi, mcs, tid, nss, bw, reception_type, pkt_type;
  1553. struct dp_vdev *vdev = peer->vdev;
  1554. qdf_ether_header_t *eh;
  1555. uint16_t msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  1556. dp_rx_msdu_stats_update_prot_cnts(vdev, nbuf, peer);
  1557. is_not_amsdu = qdf_nbuf_is_rx_chfrag_start(nbuf) &
  1558. qdf_nbuf_is_rx_chfrag_end(nbuf);
  1559. DP_STATS_INC_PKT(peer, rx.rcvd_reo[ring_id], 1, msdu_len);
  1560. DP_STATS_INCC(peer, rx.non_amsdu_cnt, 1, is_not_amsdu);
  1561. DP_STATS_INCC(peer, rx.amsdu_cnt, 1, !is_not_amsdu);
  1562. DP_STATS_INCC(peer, rx.rx_retries, 1, qdf_nbuf_is_rx_retry_flag(nbuf));
  1563. tid_stats->msdu_cnt++;
  1564. if (qdf_unlikely(qdf_nbuf_is_da_mcbc(nbuf) &&
  1565. (vdev->rx_decap_type == htt_cmn_pkt_type_ethernet))) {
  1566. eh = (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
  1567. DP_STATS_INC_PKT(peer, rx.multicast, 1, msdu_len);
  1568. tid_stats->mcast_msdu_cnt++;
  1569. if (QDF_IS_ADDR_BROADCAST(eh->ether_dhost)) {
  1570. DP_STATS_INC_PKT(peer, rx.bcast, 1, msdu_len);
  1571. tid_stats->bcast_msdu_cnt++;
  1572. }
  1573. }
  1574. /*
  1575. * currently we can return from here as we have similar stats
  1576. * updated at per ppdu level instead of msdu level
  1577. */
  1578. if (!soc->process_rx_status)
  1579. return;
  1580. is_ampdu = hal_rx_mpdu_info_ampdu_flag_get(rx_tlv_hdr);
  1581. DP_STATS_INCC(peer, rx.ampdu_cnt, 1, is_ampdu);
  1582. DP_STATS_INCC(peer, rx.non_ampdu_cnt, 1, !(is_ampdu));
  1583. sgi = hal_rx_msdu_start_sgi_get(rx_tlv_hdr);
  1584. mcs = hal_rx_msdu_start_rate_mcs_get(rx_tlv_hdr);
  1585. tid = qdf_nbuf_get_tid_val(nbuf);
  1586. bw = hal_rx_msdu_start_bw_get(rx_tlv_hdr);
  1587. reception_type = hal_rx_msdu_start_reception_type_get(soc->hal_soc,
  1588. rx_tlv_hdr);
  1589. nss = hal_rx_msdu_start_nss_get(soc->hal_soc, rx_tlv_hdr);
  1590. pkt_type = hal_rx_msdu_start_get_pkt_type(rx_tlv_hdr);
  1591. DP_STATS_INCC(peer, rx.rx_mpdu_cnt[mcs], 1,
  1592. ((mcs < MAX_MCS) && QDF_NBUF_CB_RX_CHFRAG_START(nbuf)));
  1593. DP_STATS_INCC(peer, rx.rx_mpdu_cnt[MAX_MCS - 1], 1,
  1594. ((mcs >= MAX_MCS) && QDF_NBUF_CB_RX_CHFRAG_START(nbuf)));
  1595. DP_STATS_INC(peer, rx.bw[bw], 1);
  1596. /*
  1597. * only if nss > 0 and pkt_type is 11N/AC/AX,
  1598. * then increase index [nss - 1] in array counter.
  1599. */
  1600. if (nss > 0 && (pkt_type == DOT11_N ||
  1601. pkt_type == DOT11_AC ||
  1602. pkt_type == DOT11_AX))
  1603. DP_STATS_INC(peer, rx.nss[nss - 1], 1);
  1604. DP_STATS_INC(peer, rx.sgi_count[sgi], 1);
  1605. DP_STATS_INCC(peer, rx.err.mic_err, 1,
  1606. hal_rx_mpdu_end_mic_err_get(rx_tlv_hdr));
  1607. DP_STATS_INCC(peer, rx.err.decrypt_err, 1,
  1608. hal_rx_mpdu_end_decrypt_err_get(rx_tlv_hdr));
  1609. DP_STATS_INC(peer, rx.wme_ac_type[TID_TO_WME_AC(tid)], 1);
  1610. DP_STATS_INC(peer, rx.reception_type[reception_type], 1);
  1611. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS - 1], 1,
  1612. ((mcs >= MAX_MCS_11A) && (pkt_type == DOT11_A)));
  1613. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1,
  1614. ((mcs <= MAX_MCS_11A) && (pkt_type == DOT11_A)));
  1615. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS - 1], 1,
  1616. ((mcs >= MAX_MCS_11B) && (pkt_type == DOT11_B)));
  1617. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1,
  1618. ((mcs <= MAX_MCS_11B) && (pkt_type == DOT11_B)));
  1619. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS - 1], 1,
  1620. ((mcs >= MAX_MCS_11A) && (pkt_type == DOT11_N)));
  1621. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1,
  1622. ((mcs <= MAX_MCS_11A) && (pkt_type == DOT11_N)));
  1623. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS - 1], 1,
  1624. ((mcs >= MAX_MCS_11AC) && (pkt_type == DOT11_AC)));
  1625. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1,
  1626. ((mcs <= MAX_MCS_11AC) && (pkt_type == DOT11_AC)));
  1627. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS - 1], 1,
  1628. ((mcs >= MAX_MCS) && (pkt_type == DOT11_AX)));
  1629. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1,
  1630. ((mcs < MAX_MCS) && (pkt_type == DOT11_AX)));
  1631. if ((soc->process_rx_status) &&
  1632. hal_rx_attn_first_mpdu_get(rx_tlv_hdr)) {
  1633. #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE
  1634. if (!vdev->pdev)
  1635. return;
  1636. dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, vdev->pdev->soc,
  1637. &peer->stats, peer->peer_id,
  1638. UPDATE_PEER_STATS,
  1639. vdev->pdev->pdev_id);
  1640. #endif
  1641. }
  1642. }
  1643. static inline bool is_sa_da_idx_valid(struct dp_soc *soc,
  1644. uint8_t *rx_tlv_hdr,
  1645. qdf_nbuf_t nbuf,
  1646. struct hal_rx_msdu_metadata msdu_info)
  1647. {
  1648. if ((qdf_nbuf_is_sa_valid(nbuf) &&
  1649. (msdu_info.sa_idx > wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx))) ||
  1650. (!qdf_nbuf_is_da_mcbc(nbuf) &&
  1651. qdf_nbuf_is_da_valid(nbuf) &&
  1652. (msdu_info.da_idx > wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx))))
  1653. return false;
  1654. return true;
  1655. }
  1656. #ifndef WDS_VENDOR_EXTENSION
  1657. int dp_wds_rx_policy_check(uint8_t *rx_tlv_hdr,
  1658. struct dp_vdev *vdev,
  1659. struct dp_peer *peer)
  1660. {
  1661. return 1;
  1662. }
  1663. #endif
  1664. #ifdef RX_DESC_DEBUG_CHECK
  1665. /**
  1666. * dp_rx_desc_nbuf_sanity_check - Add sanity check to catch REO rx_desc paddr
  1667. * corruption
  1668. *
  1669. * @ring_desc: REO ring descriptor
  1670. * @rx_desc: Rx descriptor
  1671. *
  1672. * Return: NONE
  1673. */
  1674. static inline
  1675. QDF_STATUS dp_rx_desc_nbuf_sanity_check(hal_ring_desc_t ring_desc,
  1676. struct dp_rx_desc *rx_desc)
  1677. {
  1678. struct hal_buf_info hbi;
  1679. hal_rx_reo_buf_paddr_get(ring_desc, &hbi);
  1680. /* Sanity check for possible buffer paddr corruption */
  1681. if (dp_rx_desc_paddr_sanity_check(rx_desc, (&hbi)->paddr))
  1682. return QDF_STATUS_SUCCESS;
  1683. return QDF_STATUS_E_FAILURE;
  1684. }
  1685. #else
  1686. static inline
  1687. QDF_STATUS dp_rx_desc_nbuf_sanity_check(hal_ring_desc_t ring_desc,
  1688. struct dp_rx_desc *rx_desc)
  1689. {
  1690. return QDF_STATUS_SUCCESS;
  1691. }
  1692. #endif
  1693. #ifdef WLAN_FEATURE_RX_SOFTIRQ_TIME_LIMIT
  1694. static inline
  1695. bool dp_rx_reap_loop_pkt_limit_hit(struct dp_soc *soc, int num_reaped)
  1696. {
  1697. bool limit_hit = false;
  1698. struct wlan_cfg_dp_soc_ctxt *cfg = soc->wlan_cfg_ctx;
  1699. limit_hit =
  1700. (num_reaped >= cfg->rx_reap_loop_pkt_limit) ? true : false;
  1701. if (limit_hit)
  1702. DP_STATS_INC(soc, rx.reap_loop_pkt_limit_hit, 1)
  1703. return limit_hit;
  1704. }
  1705. static inline bool dp_rx_enable_eol_data_check(struct dp_soc *soc)
  1706. {
  1707. return soc->wlan_cfg_ctx->rx_enable_eol_data_check;
  1708. }
  1709. #else
  1710. static inline
  1711. bool dp_rx_reap_loop_pkt_limit_hit(struct dp_soc *soc, int num_reaped)
  1712. {
  1713. return false;
  1714. }
  1715. static inline bool dp_rx_enable_eol_data_check(struct dp_soc *soc)
  1716. {
  1717. return false;
  1718. }
  1719. #endif /* WLAN_FEATURE_RX_SOFTIRQ_TIME_LIMIT */
  1720. #ifdef DP_RX_PKT_NO_PEER_DELIVER
  1721. /**
  1722. * dp_rx_deliver_to_stack_no_peer() - try deliver rx data even if
  1723. * no corresbonding peer found
  1724. * @soc: core txrx main context
  1725. * @nbuf: pkt skb pointer
  1726. *
  1727. * This function will try to deliver some RX special frames to stack
  1728. * even there is no peer matched found. for instance, LFR case, some
  1729. * eapol data will be sent to host before peer_map done.
  1730. *
  1731. * Return: None
  1732. */
  1733. static
  1734. void dp_rx_deliver_to_stack_no_peer(struct dp_soc *soc, qdf_nbuf_t nbuf)
  1735. {
  1736. uint16_t peer_id;
  1737. uint8_t vdev_id;
  1738. struct dp_vdev *vdev = NULL;
  1739. uint32_t l2_hdr_offset = 0;
  1740. uint16_t msdu_len = 0;
  1741. uint32_t pkt_len = 0;
  1742. uint8_t *rx_tlv_hdr;
  1743. uint32_t frame_mask = FRAME_MASK_IPV4_ARP | FRAME_MASK_IPV4_DHCP |
  1744. FRAME_MASK_IPV4_EAPOL | FRAME_MASK_IPV6_DHCP;
  1745. peer_id = QDF_NBUF_CB_RX_PEER_ID(nbuf);
  1746. if (peer_id > soc->max_peers)
  1747. goto deliver_fail;
  1748. vdev_id = QDF_NBUF_CB_RX_VDEV_ID(nbuf);
  1749. vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_RX);
  1750. if (!vdev || vdev->delete.pending || !vdev->osif_rx)
  1751. goto deliver_fail;
  1752. if (qdf_unlikely(qdf_nbuf_is_frag(nbuf)))
  1753. goto deliver_fail;
  1754. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  1755. l2_hdr_offset =
  1756. hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc, rx_tlv_hdr);
  1757. msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  1758. pkt_len = msdu_len + l2_hdr_offset + RX_PKT_TLVS_LEN;
  1759. QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(nbuf) = 1;
  1760. qdf_nbuf_set_pktlen(nbuf, pkt_len);
  1761. qdf_nbuf_pull_head(nbuf,
  1762. RX_PKT_TLVS_LEN +
  1763. l2_hdr_offset);
  1764. if (dp_rx_is_special_frame(nbuf, frame_mask)) {
  1765. qdf_nbuf_set_exc_frame(nbuf, 1);
  1766. if (QDF_STATUS_SUCCESS !=
  1767. vdev->osif_rx(vdev->osif_vdev, nbuf))
  1768. goto deliver_fail;
  1769. DP_STATS_INC(soc, rx.err.pkt_delivered_no_peer, 1);
  1770. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_RX);
  1771. return;
  1772. }
  1773. deliver_fail:
  1774. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  1775. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  1776. qdf_nbuf_free(nbuf);
  1777. if (vdev)
  1778. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_RX);
  1779. }
  1780. #else
  1781. static inline
  1782. void dp_rx_deliver_to_stack_no_peer(struct dp_soc *soc, qdf_nbuf_t nbuf)
  1783. {
  1784. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  1785. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  1786. qdf_nbuf_free(nbuf);
  1787. }
  1788. #endif
  1789. /**
  1790. * dp_rx_srng_get_num_pending() - get number of pending entries
  1791. * @hal_soc: hal soc opaque pointer
  1792. * @hal_ring: opaque pointer to the HAL Rx Ring
  1793. * @num_entries: number of entries in the hal_ring.
  1794. * @near_full: pointer to a boolean. This is set if ring is near full.
  1795. *
  1796. * The function returns the number of entries in a destination ring which are
  1797. * yet to be reaped. The function also checks if the ring is near full.
  1798. * If more than half of the ring needs to be reaped, the ring is considered
  1799. * approaching full.
  1800. * The function useses hal_srng_dst_num_valid_locked to get the number of valid
  1801. * entries. It should not be called within a SRNG lock. HW pointer value is
  1802. * synced into cached_hp.
  1803. *
  1804. * Return: Number of pending entries if any
  1805. */
  1806. static
  1807. uint32_t dp_rx_srng_get_num_pending(hal_soc_handle_t hal_soc,
  1808. hal_ring_handle_t hal_ring_hdl,
  1809. uint32_t num_entries,
  1810. bool *near_full)
  1811. {
  1812. uint32_t num_pending = 0;
  1813. num_pending = hal_srng_dst_num_valid_locked(hal_soc,
  1814. hal_ring_hdl,
  1815. true);
  1816. if (num_entries && (num_pending >= num_entries >> 1))
  1817. *near_full = true;
  1818. else
  1819. *near_full = false;
  1820. return num_pending;
  1821. }
  1822. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  1823. #ifdef WLAN_SUPPORT_RX_FISA
  1824. void dp_rx_skip_tlvs(qdf_nbuf_t nbuf, uint32_t l3_padding)
  1825. {
  1826. QDF_NBUF_CB_RX_PACKET_L3_HDR_PAD(nbuf) = l3_padding;
  1827. qdf_nbuf_pull_head(nbuf, l3_padding + RX_PKT_TLVS_LEN);
  1828. }
  1829. /**
  1830. * dp_rx_set_hdr_pad() - set l3 padding in nbuf cb
  1831. * @nbuf: pkt skb pointer
  1832. * @l3_padding: l3 padding
  1833. *
  1834. * Return: None
  1835. */
  1836. static inline
  1837. void dp_rx_set_hdr_pad(qdf_nbuf_t nbuf, uint32_t l3_padding)
  1838. {
  1839. QDF_NBUF_CB_RX_PACKET_L3_HDR_PAD(nbuf) = l3_padding;
  1840. }
  1841. #else
  1842. void dp_rx_skip_tlvs(qdf_nbuf_t nbuf, uint32_t l3_padding)
  1843. {
  1844. qdf_nbuf_pull_head(nbuf, l3_padding + RX_PKT_TLVS_LEN);
  1845. }
  1846. static inline
  1847. void dp_rx_set_hdr_pad(qdf_nbuf_t nbuf, uint32_t l3_padding)
  1848. {
  1849. }
  1850. #endif
  1851. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  1852. #ifdef DP_RX_DROP_RAW_FRM
  1853. /**
  1854. * dp_rx_is_raw_frame_dropped() - if raw frame nbuf, free and drop
  1855. * @nbuf: pkt skb pointer
  1856. *
  1857. * Return: true - raw frame, dropped
  1858. * false - not raw frame, do nothing
  1859. */
  1860. static inline
  1861. bool dp_rx_is_raw_frame_dropped(qdf_nbuf_t nbuf)
  1862. {
  1863. if (qdf_nbuf_is_raw_frame(nbuf)) {
  1864. qdf_nbuf_free(nbuf);
  1865. return true;
  1866. }
  1867. return false;
  1868. }
  1869. #else
  1870. static inline
  1871. bool dp_rx_is_raw_frame_dropped(qdf_nbuf_t nbuf)
  1872. {
  1873. return false;
  1874. }
  1875. #endif
  1876. #ifdef WLAN_FEATURE_DP_RX_RING_HISTORY
  1877. /**
  1878. * dp_rx_ring_record_entry() - Record an entry into the rx ring history.
  1879. * @soc: Datapath soc structure
  1880. * @ring_num: REO ring number
  1881. * @ring_desc: REO ring descriptor
  1882. *
  1883. * Returns: None
  1884. */
  1885. static inline void
  1886. dp_rx_ring_record_entry(struct dp_soc *soc, uint8_t ring_num,
  1887. hal_ring_desc_t ring_desc)
  1888. {
  1889. struct dp_buf_info_record *record;
  1890. uint8_t rbm;
  1891. struct hal_buf_info hbi;
  1892. uint32_t idx;
  1893. if (qdf_unlikely(!soc->rx_ring_history[ring_num]))
  1894. return;
  1895. hal_rx_reo_buf_paddr_get(ring_desc, &hbi);
  1896. rbm = hal_rx_ret_buf_manager_get(ring_desc);
  1897. idx = dp_history_get_next_index(&soc->rx_ring_history[ring_num]->index,
  1898. DP_RX_HIST_MAX);
  1899. /* No NULL check needed for record since its an array */
  1900. record = &soc->rx_ring_history[ring_num]->entry[idx];
  1901. record->timestamp = qdf_get_log_timestamp();
  1902. record->hbi.paddr = hbi.paddr;
  1903. record->hbi.sw_cookie = hbi.sw_cookie;
  1904. record->hbi.rbm = rbm;
  1905. }
  1906. #else
  1907. static inline void
  1908. dp_rx_ring_record_entry(struct dp_soc *soc, uint8_t ring_num,
  1909. hal_ring_desc_t ring_desc)
  1910. {
  1911. }
  1912. #endif
  1913. #ifdef WLAN_DP_FEATURE_SW_LATENCY_MGR
  1914. /**
  1915. * dp_rx_update_stats() - Update soc level rx packet count
  1916. * @soc: DP soc handle
  1917. * @nbuf: nbuf received
  1918. *
  1919. * Returns: none
  1920. */
  1921. static inline void dp_rx_update_stats(struct dp_soc *soc,
  1922. qdf_nbuf_t nbuf)
  1923. {
  1924. DP_STATS_INC_PKT(soc, rx.ingress, 1,
  1925. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  1926. }
  1927. #else
  1928. static inline void dp_rx_update_stats(struct dp_soc *soc,
  1929. qdf_nbuf_t nbuf)
  1930. {
  1931. }
  1932. #endif
  1933. #ifdef WLAN_FEATURE_PKT_CAPTURE_LITHIUM
  1934. /**
  1935. * dp_rx_deliver_to_pkt_capture() - deliver rx packet to packet capture
  1936. * @soc : dp_soc handle
  1937. * @pdev: dp_pdev handle
  1938. * @peer_id: peer_id of the peer for which completion came
  1939. * @ppdu_id: ppdu_id
  1940. * @netbuf: Buffer pointer
  1941. *
  1942. * This function is used to deliver rx packet to packet capture
  1943. */
  1944. void dp_rx_deliver_to_pkt_capture(struct dp_soc *soc, struct dp_pdev *pdev,
  1945. uint16_t peer_id, uint32_t ppdu_id,
  1946. qdf_nbuf_t netbuf)
  1947. {
  1948. dp_wdi_event_handler(WDI_EVENT_PKT_CAPTURE_RX_DATA, soc, netbuf,
  1949. peer_id, WDI_NO_VAL, pdev->pdev_id);
  1950. }
  1951. #endif
  1952. /**
  1953. * dp_rx_process() - Brain of the Rx processing functionality
  1954. * Called from the bottom half (tasklet/NET_RX_SOFTIRQ)
  1955. * @int_ctx: per interrupt context
  1956. * @hal_ring: opaque pointer to the HAL Rx Ring, which will be serviced
  1957. * @reo_ring_num: ring number (0, 1, 2 or 3) of the reo ring.
  1958. * @quota: No. of units (packets) that can be serviced in one shot.
  1959. *
  1960. * This function implements the core of Rx functionality. This is
  1961. * expected to handle only non-error frames.
  1962. *
  1963. * Return: uint32_t: No. of elements processed
  1964. */
  1965. uint32_t dp_rx_process(struct dp_intr *int_ctx, hal_ring_handle_t hal_ring_hdl,
  1966. uint8_t reo_ring_num, uint32_t quota)
  1967. {
  1968. hal_ring_desc_t ring_desc;
  1969. hal_soc_handle_t hal_soc;
  1970. struct dp_rx_desc *rx_desc = NULL;
  1971. qdf_nbuf_t nbuf, next;
  1972. bool near_full;
  1973. union dp_rx_desc_list_elem_t *head[MAX_PDEV_CNT];
  1974. union dp_rx_desc_list_elem_t *tail[MAX_PDEV_CNT];
  1975. uint32_t num_pending;
  1976. uint32_t rx_bufs_used = 0, rx_buf_cookie;
  1977. uint16_t msdu_len = 0;
  1978. uint16_t peer_id;
  1979. uint8_t vdev_id;
  1980. struct dp_peer *peer;
  1981. struct dp_vdev *vdev;
  1982. uint32_t pkt_len = 0;
  1983. struct hal_rx_mpdu_desc_info mpdu_desc_info;
  1984. struct hal_rx_msdu_desc_info msdu_desc_info;
  1985. enum hal_reo_error_status error;
  1986. uint32_t peer_mdata;
  1987. uint8_t *rx_tlv_hdr;
  1988. uint32_t rx_bufs_reaped[MAX_PDEV_CNT];
  1989. uint8_t mac_id = 0;
  1990. struct dp_pdev *rx_pdev;
  1991. struct dp_srng *dp_rxdma_srng;
  1992. struct rx_desc_pool *rx_desc_pool;
  1993. struct dp_soc *soc = int_ctx->soc;
  1994. uint8_t ring_id = 0;
  1995. uint8_t core_id = 0;
  1996. struct cdp_tid_rx_stats *tid_stats;
  1997. qdf_nbuf_t nbuf_head;
  1998. qdf_nbuf_t nbuf_tail;
  1999. qdf_nbuf_t deliver_list_head;
  2000. qdf_nbuf_t deliver_list_tail;
  2001. uint32_t num_rx_bufs_reaped = 0;
  2002. uint32_t intr_id;
  2003. struct hif_opaque_softc *scn;
  2004. int32_t tid = 0;
  2005. bool is_prev_msdu_last = true;
  2006. uint32_t num_entries_avail = 0;
  2007. uint32_t rx_ol_pkt_cnt = 0;
  2008. uint32_t num_entries = 0;
  2009. struct hal_rx_msdu_metadata msdu_metadata;
  2010. QDF_STATUS status;
  2011. qdf_nbuf_t ebuf_head;
  2012. qdf_nbuf_t ebuf_tail;
  2013. DP_HIST_INIT();
  2014. qdf_assert_always(soc && hal_ring_hdl);
  2015. hal_soc = soc->hal_soc;
  2016. qdf_assert_always(hal_soc);
  2017. scn = soc->hif_handle;
  2018. hif_pm_runtime_mark_dp_rx_busy(scn);
  2019. intr_id = int_ctx->dp_intr_id;
  2020. num_entries = hal_srng_get_num_entries(hal_soc, hal_ring_hdl);
  2021. more_data:
  2022. /* reset local variables here to be re-used in the function */
  2023. nbuf_head = NULL;
  2024. nbuf_tail = NULL;
  2025. deliver_list_head = NULL;
  2026. deliver_list_tail = NULL;
  2027. peer = NULL;
  2028. vdev = NULL;
  2029. num_rx_bufs_reaped = 0;
  2030. ebuf_head = NULL;
  2031. ebuf_tail = NULL;
  2032. qdf_mem_zero(rx_bufs_reaped, sizeof(rx_bufs_reaped));
  2033. qdf_mem_zero(&mpdu_desc_info, sizeof(mpdu_desc_info));
  2034. qdf_mem_zero(&msdu_desc_info, sizeof(msdu_desc_info));
  2035. qdf_mem_zero(head, sizeof(head));
  2036. qdf_mem_zero(tail, sizeof(tail));
  2037. if (qdf_unlikely(dp_rx_srng_access_start(int_ctx, soc, hal_ring_hdl))) {
  2038. /*
  2039. * Need API to convert from hal_ring pointer to
  2040. * Ring Type / Ring Id combo
  2041. */
  2042. DP_STATS_INC(soc, rx.err.hal_ring_access_fail, 1);
  2043. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  2044. FL("HAL RING Access Failed -- %pK"), hal_ring_hdl);
  2045. goto done;
  2046. }
  2047. /*
  2048. * start reaping the buffers from reo ring and queue
  2049. * them in per vdev queue.
  2050. * Process the received pkts in a different per vdev loop.
  2051. */
  2052. while (qdf_likely(quota &&
  2053. (ring_desc = hal_srng_dst_peek(hal_soc,
  2054. hal_ring_hdl)))) {
  2055. error = HAL_RX_ERROR_STATUS_GET(ring_desc);
  2056. ring_id = hal_srng_ring_id_get(hal_ring_hdl);
  2057. if (qdf_unlikely(error == HAL_REO_ERROR_DETECTED)) {
  2058. dp_rx_err("%pK: HAL RING 0x%pK:error %d",
  2059. soc, hal_ring_hdl, error);
  2060. DP_STATS_INC(soc, rx.err.hal_reo_error[ring_id], 1);
  2061. /* Don't know how to deal with this -- assert */
  2062. qdf_assert(0);
  2063. }
  2064. dp_rx_ring_record_entry(soc, reo_ring_num, ring_desc);
  2065. rx_buf_cookie = HAL_RX_REO_BUF_COOKIE_GET(ring_desc);
  2066. status = dp_rx_cookie_check_and_invalidate(ring_desc);
  2067. if (qdf_unlikely(QDF_IS_STATUS_ERROR(status))) {
  2068. DP_STATS_INC(soc, rx.err.stale_cookie, 1);
  2069. break;
  2070. }
  2071. rx_desc = dp_rx_cookie_2_va_rxdma_buf(soc, rx_buf_cookie);
  2072. status = dp_rx_desc_sanity(soc, hal_soc, hal_ring_hdl,
  2073. ring_desc, rx_desc);
  2074. if (QDF_IS_STATUS_ERROR(status)) {
  2075. if (qdf_unlikely(rx_desc && rx_desc->nbuf)) {
  2076. qdf_assert_always(rx_desc->unmapped);
  2077. dp_ipa_handle_rx_buf_smmu_mapping(
  2078. soc,
  2079. rx_desc->nbuf,
  2080. RX_DATA_BUFFER_SIZE,
  2081. false);
  2082. qdf_nbuf_unmap_nbytes_single(
  2083. soc->osdev,
  2084. rx_desc->nbuf,
  2085. QDF_DMA_FROM_DEVICE,
  2086. RX_DATA_BUFFER_SIZE);
  2087. rx_desc->unmapped = 1;
  2088. dp_rx_buffer_pool_nbuf_free(soc, rx_desc->nbuf,
  2089. rx_desc->pool_id);
  2090. dp_rx_add_to_free_desc_list(
  2091. &head[rx_desc->pool_id],
  2092. &tail[rx_desc->pool_id],
  2093. rx_desc);
  2094. }
  2095. hal_srng_dst_get_next(hal_soc, hal_ring_hdl);
  2096. continue;
  2097. }
  2098. /*
  2099. * this is a unlikely scenario where the host is reaping
  2100. * a descriptor which it already reaped just a while ago
  2101. * but is yet to replenish it back to HW.
  2102. * In this case host will dump the last 128 descriptors
  2103. * including the software descriptor rx_desc and assert.
  2104. */
  2105. if (qdf_unlikely(!rx_desc->in_use)) {
  2106. DP_STATS_INC(soc, rx.err.hal_reo_dest_dup, 1);
  2107. dp_info_rl("Reaping rx_desc not in use!");
  2108. dp_rx_dump_info_and_assert(soc, hal_ring_hdl,
  2109. ring_desc, rx_desc);
  2110. /* ignore duplicate RX desc and continue to process */
  2111. /* Pop out the descriptor */
  2112. hal_srng_dst_get_next(hal_soc, hal_ring_hdl);
  2113. continue;
  2114. }
  2115. status = dp_rx_desc_nbuf_sanity_check(ring_desc, rx_desc);
  2116. if (qdf_unlikely(QDF_IS_STATUS_ERROR(status))) {
  2117. DP_STATS_INC(soc, rx.err.nbuf_sanity_fail, 1);
  2118. dp_info_rl("Nbuf sanity check failure!");
  2119. dp_rx_dump_info_and_assert(soc, hal_ring_hdl,
  2120. ring_desc, rx_desc);
  2121. rx_desc->in_err_state = 1;
  2122. hal_srng_dst_get_next(hal_soc, hal_ring_hdl);
  2123. continue;
  2124. }
  2125. if (qdf_unlikely(!dp_rx_desc_check_magic(rx_desc))) {
  2126. dp_err("Invalid rx_desc cookie=%d", rx_buf_cookie);
  2127. DP_STATS_INC(soc, rx.err.rx_desc_invalid_magic, 1);
  2128. dp_rx_dump_info_and_assert(soc, hal_ring_hdl,
  2129. ring_desc, rx_desc);
  2130. }
  2131. /* Get MPDU DESC info */
  2132. hal_rx_mpdu_desc_info_get(ring_desc, &mpdu_desc_info);
  2133. /* Get MSDU DESC info */
  2134. hal_rx_msdu_desc_info_get(ring_desc, &msdu_desc_info);
  2135. if (qdf_unlikely(msdu_desc_info.msdu_flags &
  2136. HAL_MSDU_F_MSDU_CONTINUATION)) {
  2137. /* previous msdu has end bit set, so current one is
  2138. * the new MPDU
  2139. */
  2140. if (is_prev_msdu_last) {
  2141. /* Get number of entries available in HW ring */
  2142. num_entries_avail =
  2143. hal_srng_dst_num_valid(hal_soc,
  2144. hal_ring_hdl, 1);
  2145. /* For new MPDU check if we can read complete
  2146. * MPDU by comparing the number of buffers
  2147. * available and number of buffers needed to
  2148. * reap this MPDU
  2149. */
  2150. if (((msdu_desc_info.msdu_len /
  2151. (RX_DATA_BUFFER_SIZE - RX_PKT_TLVS_LEN) +
  2152. 1)) > num_entries_avail) {
  2153. DP_STATS_INC(
  2154. soc,
  2155. rx.msdu_scatter_wait_break,
  2156. 1);
  2157. break;
  2158. }
  2159. is_prev_msdu_last = false;
  2160. }
  2161. }
  2162. core_id = smp_processor_id();
  2163. DP_STATS_INC(soc, rx.ring_packets[core_id][ring_id], 1);
  2164. if (mpdu_desc_info.mpdu_flags & HAL_MPDU_F_RETRY_BIT)
  2165. qdf_nbuf_set_rx_retry_flag(rx_desc->nbuf, 1);
  2166. if (qdf_unlikely(mpdu_desc_info.mpdu_flags &
  2167. HAL_MPDU_F_RAW_AMPDU))
  2168. qdf_nbuf_set_raw_frame(rx_desc->nbuf, 1);
  2169. if (!is_prev_msdu_last &&
  2170. msdu_desc_info.msdu_flags & HAL_MSDU_F_LAST_MSDU_IN_MPDU)
  2171. is_prev_msdu_last = true;
  2172. /* Pop out the descriptor*/
  2173. hal_srng_dst_get_next(hal_soc, hal_ring_hdl);
  2174. rx_bufs_reaped[rx_desc->pool_id]++;
  2175. peer_mdata = mpdu_desc_info.peer_meta_data;
  2176. QDF_NBUF_CB_RX_PEER_ID(rx_desc->nbuf) =
  2177. DP_PEER_METADATA_PEER_ID_GET(peer_mdata);
  2178. QDF_NBUF_CB_RX_VDEV_ID(rx_desc->nbuf) =
  2179. DP_PEER_METADATA_VDEV_ID_GET(peer_mdata);
  2180. /*
  2181. * save msdu flags first, last and continuation msdu in
  2182. * nbuf->cb, also save mcbc, is_da_valid, is_sa_valid and
  2183. * length to nbuf->cb. This ensures the info required for
  2184. * per pkt processing is always in the same cache line.
  2185. * This helps in improving throughput for smaller pkt
  2186. * sizes.
  2187. */
  2188. if (msdu_desc_info.msdu_flags & HAL_MSDU_F_FIRST_MSDU_IN_MPDU)
  2189. qdf_nbuf_set_rx_chfrag_start(rx_desc->nbuf, 1);
  2190. if (msdu_desc_info.msdu_flags & HAL_MSDU_F_MSDU_CONTINUATION)
  2191. qdf_nbuf_set_rx_chfrag_cont(rx_desc->nbuf, 1);
  2192. if (msdu_desc_info.msdu_flags & HAL_MSDU_F_LAST_MSDU_IN_MPDU)
  2193. qdf_nbuf_set_rx_chfrag_end(rx_desc->nbuf, 1);
  2194. if (msdu_desc_info.msdu_flags & HAL_MSDU_F_DA_IS_MCBC)
  2195. qdf_nbuf_set_da_mcbc(rx_desc->nbuf, 1);
  2196. if (msdu_desc_info.msdu_flags & HAL_MSDU_F_DA_IS_VALID)
  2197. qdf_nbuf_set_da_valid(rx_desc->nbuf, 1);
  2198. if (msdu_desc_info.msdu_flags & HAL_MSDU_F_SA_IS_VALID)
  2199. qdf_nbuf_set_sa_valid(rx_desc->nbuf, 1);
  2200. qdf_nbuf_set_tid_val(rx_desc->nbuf,
  2201. HAL_RX_REO_QUEUE_NUMBER_GET(ring_desc));
  2202. qdf_nbuf_set_rx_reo_dest_ind(
  2203. rx_desc->nbuf,
  2204. HAL_RX_REO_MSDU_REO_DST_IND_GET(ring_desc));
  2205. QDF_NBUF_CB_RX_PKT_LEN(rx_desc->nbuf) = msdu_desc_info.msdu_len;
  2206. QDF_NBUF_CB_RX_CTX_ID(rx_desc->nbuf) = reo_ring_num;
  2207. /*
  2208. * move unmap after scattered msdu waiting break logic
  2209. * in case double skb unmap happened.
  2210. */
  2211. rx_desc_pool = &soc->rx_desc_buf[rx_desc->pool_id];
  2212. dp_ipa_handle_rx_buf_smmu_mapping(soc, rx_desc->nbuf,
  2213. rx_desc_pool->buf_size,
  2214. false);
  2215. qdf_nbuf_unmap_nbytes_single(soc->osdev, rx_desc->nbuf,
  2216. QDF_DMA_FROM_DEVICE,
  2217. rx_desc_pool->buf_size);
  2218. rx_desc->unmapped = 1;
  2219. DP_RX_PROCESS_NBUF(soc, nbuf_head, nbuf_tail, ebuf_head,
  2220. ebuf_tail, rx_desc);
  2221. /*
  2222. * if continuation bit is set then we have MSDU spread
  2223. * across multiple buffers, let us not decrement quota
  2224. * till we reap all buffers of that MSDU.
  2225. */
  2226. if (qdf_likely(!qdf_nbuf_is_rx_chfrag_cont(rx_desc->nbuf)))
  2227. quota -= 1;
  2228. dp_rx_add_to_free_desc_list(&head[rx_desc->pool_id],
  2229. &tail[rx_desc->pool_id],
  2230. rx_desc);
  2231. num_rx_bufs_reaped++;
  2232. /*
  2233. * only if complete msdu is received for scatter case,
  2234. * then allow break.
  2235. */
  2236. if (is_prev_msdu_last &&
  2237. dp_rx_reap_loop_pkt_limit_hit(soc, num_rx_bufs_reaped))
  2238. break;
  2239. }
  2240. done:
  2241. dp_rx_srng_access_end(int_ctx, soc, hal_ring_hdl);
  2242. for (mac_id = 0; mac_id < MAX_PDEV_CNT; mac_id++) {
  2243. /*
  2244. * continue with next mac_id if no pkts were reaped
  2245. * from that pool
  2246. */
  2247. if (!rx_bufs_reaped[mac_id])
  2248. continue;
  2249. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_id];
  2250. rx_desc_pool = &soc->rx_desc_buf[mac_id];
  2251. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  2252. rx_desc_pool, rx_bufs_reaped[mac_id],
  2253. &head[mac_id], &tail[mac_id]);
  2254. }
  2255. dp_verbose_debug("replenished %u\n", rx_bufs_reaped[0]);
  2256. /* Peer can be NULL is case of LFR */
  2257. if (qdf_likely(peer))
  2258. vdev = NULL;
  2259. /*
  2260. * BIG loop where each nbuf is dequeued from global queue,
  2261. * processed and queued back on a per vdev basis. These nbufs
  2262. * are sent to stack as and when we run out of nbufs
  2263. * or a new nbuf dequeued from global queue has a different
  2264. * vdev when compared to previous nbuf.
  2265. */
  2266. nbuf = nbuf_head;
  2267. while (nbuf) {
  2268. next = nbuf->next;
  2269. if (qdf_unlikely(dp_rx_is_raw_frame_dropped(nbuf))) {
  2270. nbuf = next;
  2271. DP_STATS_INC(soc, rx.err.raw_frm_drop, 1);
  2272. continue;
  2273. }
  2274. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  2275. vdev_id = QDF_NBUF_CB_RX_VDEV_ID(nbuf);
  2276. peer_id = QDF_NBUF_CB_RX_PEER_ID(nbuf);
  2277. if (dp_rx_is_list_ready(deliver_list_head, vdev, peer,
  2278. peer_id, vdev_id)) {
  2279. dp_rx_deliver_to_stack(soc, vdev, peer,
  2280. deliver_list_head,
  2281. deliver_list_tail);
  2282. deliver_list_head = NULL;
  2283. deliver_list_tail = NULL;
  2284. }
  2285. /* Get TID from struct cb->tid_val, save to tid */
  2286. if (qdf_nbuf_is_rx_chfrag_start(nbuf))
  2287. tid = qdf_nbuf_get_tid_val(nbuf);
  2288. if (qdf_unlikely(!peer)) {
  2289. peer = dp_peer_get_ref_by_id(soc, peer_id,
  2290. DP_MOD_ID_RX);
  2291. } else if (peer && peer->peer_id != peer_id) {
  2292. dp_peer_unref_delete(peer, DP_MOD_ID_RX);
  2293. peer = dp_peer_get_ref_by_id(soc, peer_id,
  2294. DP_MOD_ID_RX);
  2295. }
  2296. if (peer) {
  2297. QDF_NBUF_CB_DP_TRACE_PRINT(nbuf) = false;
  2298. qdf_dp_trace_set_track(nbuf, QDF_RX);
  2299. QDF_NBUF_CB_RX_DP_TRACE(nbuf) = 1;
  2300. QDF_NBUF_CB_RX_PACKET_TRACK(nbuf) =
  2301. QDF_NBUF_RX_PKT_DATA_TRACK;
  2302. }
  2303. rx_bufs_used++;
  2304. if (qdf_likely(peer)) {
  2305. vdev = peer->vdev;
  2306. /*
  2307. * In encryption mode, all data packets except
  2308. * EAPOL frames should be dropped when peer is not
  2309. * authenticated. Thie feature is enabled for all peers
  2310. * under this vdev when peer_authorize flag is set.
  2311. */
  2312. if (qdf_unlikely(vdev->peer_authorize)) {
  2313. if (qdf_unlikely(vdev->sec_type != cdp_sec_type_none)) {
  2314. /*
  2315. * Allow only EAPOL frames
  2316. */
  2317. if (qdf_unlikely(!peer->authorize &&
  2318. !qdf_nbuf_is_ipv4_eapol_pkt(nbuf))) {
  2319. qdf_nbuf_free(nbuf);
  2320. nbuf = next;
  2321. DP_STATS_INC(soc, rx.err.peer_unauth_rx_pkt_drop, 1);
  2322. continue;
  2323. }
  2324. }
  2325. }
  2326. } else {
  2327. nbuf->next = NULL;
  2328. dp_rx_deliver_to_stack_no_peer(soc, nbuf);
  2329. nbuf = next;
  2330. continue;
  2331. }
  2332. if (qdf_unlikely(!vdev)) {
  2333. qdf_nbuf_free(nbuf);
  2334. nbuf = next;
  2335. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  2336. continue;
  2337. }
  2338. /* when hlos tid override is enabled, save tid in
  2339. * skb->priority
  2340. */
  2341. if (qdf_unlikely(vdev->skip_sw_tid_classification &
  2342. DP_TXRX_HLOS_TID_OVERRIDE_ENABLED))
  2343. qdf_nbuf_set_priority(nbuf, tid);
  2344. rx_pdev = vdev->pdev;
  2345. DP_RX_TID_SAVE(nbuf, tid);
  2346. if (qdf_unlikely(rx_pdev->delay_stats_flag) ||
  2347. qdf_unlikely(wlan_cfg_is_peer_ext_stats_enabled(
  2348. soc->wlan_cfg_ctx)))
  2349. qdf_nbuf_set_timestamp(nbuf);
  2350. ring_id = QDF_NBUF_CB_RX_CTX_ID(nbuf);
  2351. tid_stats =
  2352. &rx_pdev->stats.tid_stats.tid_rx_stats[ring_id][tid];
  2353. /*
  2354. * Check if DMA completed -- msdu_done is the last bit
  2355. * to be written
  2356. */
  2357. if (qdf_unlikely(!qdf_nbuf_is_rx_chfrag_cont(nbuf) &&
  2358. !hal_rx_attn_msdu_done_get(rx_tlv_hdr))) {
  2359. dp_err("MSDU DONE failure");
  2360. DP_STATS_INC(soc, rx.err.msdu_done_fail, 1);
  2361. hal_rx_dump_pkt_tlvs(hal_soc, rx_tlv_hdr,
  2362. QDF_TRACE_LEVEL_INFO);
  2363. tid_stats->fail_cnt[MSDU_DONE_FAILURE]++;
  2364. qdf_nbuf_free(nbuf);
  2365. qdf_assert(0);
  2366. nbuf = next;
  2367. continue;
  2368. }
  2369. DP_HIST_PACKET_COUNT_INC(vdev->pdev->pdev_id);
  2370. /*
  2371. * First IF condition:
  2372. * 802.11 Fragmented pkts are reinjected to REO
  2373. * HW block as SG pkts and for these pkts we only
  2374. * need to pull the RX TLVS header length.
  2375. * Second IF condition:
  2376. * The below condition happens when an MSDU is spread
  2377. * across multiple buffers. This can happen in two cases
  2378. * 1. The nbuf size is smaller then the received msdu.
  2379. * ex: we have set the nbuf size to 2048 during
  2380. * nbuf_alloc. but we received an msdu which is
  2381. * 2304 bytes in size then this msdu is spread
  2382. * across 2 nbufs.
  2383. *
  2384. * 2. AMSDUs when RAW mode is enabled.
  2385. * ex: 1st MSDU is in 1st nbuf and 2nd MSDU is spread
  2386. * across 1st nbuf and 2nd nbuf and last MSDU is
  2387. * spread across 2nd nbuf and 3rd nbuf.
  2388. *
  2389. * for these scenarios let us create a skb frag_list and
  2390. * append these buffers till the last MSDU of the AMSDU
  2391. * Third condition:
  2392. * This is the most likely case, we receive 802.3 pkts
  2393. * decapsulated by HW, here we need to set the pkt length.
  2394. */
  2395. hal_rx_msdu_metadata_get(hal_soc, rx_tlv_hdr, &msdu_metadata);
  2396. if (qdf_unlikely(qdf_nbuf_is_frag(nbuf))) {
  2397. bool is_mcbc, is_sa_vld, is_da_vld;
  2398. is_mcbc = hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
  2399. rx_tlv_hdr);
  2400. is_sa_vld =
  2401. hal_rx_msdu_end_sa_is_valid_get(soc->hal_soc,
  2402. rx_tlv_hdr);
  2403. is_da_vld =
  2404. hal_rx_msdu_end_da_is_valid_get(soc->hal_soc,
  2405. rx_tlv_hdr);
  2406. qdf_nbuf_set_da_mcbc(nbuf, is_mcbc);
  2407. qdf_nbuf_set_da_valid(nbuf, is_da_vld);
  2408. qdf_nbuf_set_sa_valid(nbuf, is_sa_vld);
  2409. qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN);
  2410. } else if (qdf_nbuf_is_rx_chfrag_cont(nbuf)) {
  2411. msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  2412. nbuf = dp_rx_sg_create(soc, nbuf);
  2413. next = nbuf->next;
  2414. if (qdf_nbuf_is_raw_frame(nbuf)) {
  2415. DP_STATS_INC(vdev->pdev, rx_raw_pkts, 1);
  2416. DP_STATS_INC_PKT(peer, rx.raw, 1, msdu_len);
  2417. } else {
  2418. qdf_nbuf_free(nbuf);
  2419. DP_STATS_INC(soc, rx.err.scatter_msdu, 1);
  2420. dp_info_rl("scatter msdu len %d, dropped",
  2421. msdu_len);
  2422. nbuf = next;
  2423. continue;
  2424. }
  2425. } else {
  2426. msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  2427. pkt_len = msdu_len +
  2428. msdu_metadata.l3_hdr_pad +
  2429. RX_PKT_TLVS_LEN;
  2430. qdf_nbuf_set_pktlen(nbuf, pkt_len);
  2431. dp_rx_skip_tlvs(nbuf, msdu_metadata.l3_hdr_pad);
  2432. }
  2433. /*
  2434. * process frame for mulitpass phrase processing
  2435. */
  2436. if (qdf_unlikely(vdev->multipass_en)) {
  2437. if (dp_rx_multipass_process(peer, nbuf, tid) == false) {
  2438. DP_STATS_INC(peer, rx.multipass_rx_pkt_drop, 1);
  2439. qdf_nbuf_free(nbuf);
  2440. nbuf = next;
  2441. continue;
  2442. }
  2443. }
  2444. if (!dp_wds_rx_policy_check(rx_tlv_hdr, vdev, peer)) {
  2445. dp_rx_err("%pK: Policy Check Drop pkt", soc);
  2446. tid_stats->fail_cnt[POLICY_CHECK_DROP]++;
  2447. /* Drop & free packet */
  2448. qdf_nbuf_free(nbuf);
  2449. /* Statistics */
  2450. nbuf = next;
  2451. continue;
  2452. }
  2453. if (qdf_unlikely(peer && (peer->nawds_enabled) &&
  2454. (qdf_nbuf_is_da_mcbc(nbuf)) &&
  2455. (hal_rx_get_mpdu_mac_ad4_valid(soc->hal_soc,
  2456. rx_tlv_hdr) ==
  2457. false))) {
  2458. tid_stats->fail_cnt[NAWDS_MCAST_DROP]++;
  2459. DP_STATS_INC(peer, rx.nawds_mcast_drop, 1);
  2460. qdf_nbuf_free(nbuf);
  2461. nbuf = next;
  2462. continue;
  2463. }
  2464. if (soc->process_rx_status)
  2465. dp_rx_cksum_offload(vdev->pdev, nbuf, rx_tlv_hdr);
  2466. /* Update the protocol tag in SKB based on CCE metadata */
  2467. dp_rx_update_protocol_tag(soc, vdev, nbuf, rx_tlv_hdr,
  2468. reo_ring_num, false, true);
  2469. /* Update the flow tag in SKB based on FSE metadata */
  2470. dp_rx_update_flow_tag(soc, vdev, nbuf, rx_tlv_hdr, true);
  2471. dp_rx_msdu_stats_update(soc, nbuf, rx_tlv_hdr, peer,
  2472. ring_id, tid_stats);
  2473. if (qdf_unlikely(vdev->mesh_vdev)) {
  2474. if (dp_rx_filter_mesh_packets(vdev, nbuf, rx_tlv_hdr)
  2475. == QDF_STATUS_SUCCESS) {
  2476. dp_rx_info("%pK: mesh pkt filtered", soc);
  2477. tid_stats->fail_cnt[MESH_FILTER_DROP]++;
  2478. DP_STATS_INC(vdev->pdev, dropped.mesh_filter,
  2479. 1);
  2480. qdf_nbuf_free(nbuf);
  2481. nbuf = next;
  2482. continue;
  2483. }
  2484. dp_rx_fill_mesh_stats(vdev, nbuf, rx_tlv_hdr, peer);
  2485. }
  2486. if (qdf_likely(vdev->rx_decap_type ==
  2487. htt_cmn_pkt_type_ethernet) &&
  2488. qdf_likely(!vdev->mesh_vdev)) {
  2489. /* WDS Destination Address Learning */
  2490. dp_rx_da_learn(soc, rx_tlv_hdr, peer, nbuf);
  2491. /* Due to HW issue, sometimes we see that the sa_idx
  2492. * and da_idx are invalid with sa_valid and da_valid
  2493. * bits set
  2494. *
  2495. * in this case we also see that value of
  2496. * sa_sw_peer_id is set as 0
  2497. *
  2498. * Drop the packet if sa_idx and da_idx OOB or
  2499. * sa_sw_peerid is 0
  2500. */
  2501. if (!is_sa_da_idx_valid(soc, rx_tlv_hdr, nbuf,
  2502. msdu_metadata)) {
  2503. qdf_nbuf_free(nbuf);
  2504. nbuf = next;
  2505. DP_STATS_INC(soc, rx.err.invalid_sa_da_idx, 1);
  2506. continue;
  2507. }
  2508. /* WDS Source Port Learning */
  2509. if (qdf_likely(vdev->wds_enabled))
  2510. dp_rx_wds_srcport_learn(soc,
  2511. rx_tlv_hdr,
  2512. peer,
  2513. nbuf,
  2514. msdu_metadata);
  2515. /* Intrabss-fwd */
  2516. if (dp_rx_check_ap_bridge(vdev))
  2517. if (dp_rx_intrabss_fwd(soc,
  2518. peer,
  2519. rx_tlv_hdr,
  2520. nbuf,
  2521. msdu_metadata)) {
  2522. nbuf = next;
  2523. tid_stats->intrabss_cnt++;
  2524. continue; /* Get next desc */
  2525. }
  2526. }
  2527. dp_rx_fill_gro_info(soc, rx_tlv_hdr, nbuf, &rx_ol_pkt_cnt);
  2528. dp_rx_update_stats(soc, nbuf);
  2529. DP_RX_LIST_APPEND(deliver_list_head,
  2530. deliver_list_tail,
  2531. nbuf);
  2532. DP_STATS_INC_PKT(peer, rx.to_stack, 1,
  2533. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  2534. if (qdf_unlikely(peer->in_twt))
  2535. DP_STATS_INC_PKT(peer, rx.to_stack_twt, 1,
  2536. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  2537. tid_stats->delivered_to_stack++;
  2538. nbuf = next;
  2539. }
  2540. if (qdf_likely(deliver_list_head)) {
  2541. if (qdf_likely(peer)) {
  2542. dp_rx_deliver_to_pkt_capture(soc, vdev->pdev, peer_id,
  2543. 0, deliver_list_head);
  2544. dp_rx_deliver_to_stack(soc, vdev, peer,
  2545. deliver_list_head,
  2546. deliver_list_tail);
  2547. }
  2548. else {
  2549. nbuf = deliver_list_head;
  2550. while (nbuf) {
  2551. next = nbuf->next;
  2552. nbuf->next = NULL;
  2553. dp_rx_deliver_to_stack_no_peer(soc, nbuf);
  2554. nbuf = next;
  2555. }
  2556. }
  2557. }
  2558. if (qdf_likely(peer))
  2559. dp_peer_unref_delete(peer, DP_MOD_ID_RX);
  2560. if (dp_rx_enable_eol_data_check(soc) && rx_bufs_used) {
  2561. if (quota) {
  2562. num_pending =
  2563. dp_rx_srng_get_num_pending(hal_soc,
  2564. hal_ring_hdl,
  2565. num_entries,
  2566. &near_full);
  2567. if (num_pending) {
  2568. DP_STATS_INC(soc, rx.hp_oos2, 1);
  2569. if (!hif_exec_should_yield(scn, intr_id))
  2570. goto more_data;
  2571. if (qdf_unlikely(near_full)) {
  2572. DP_STATS_INC(soc, rx.near_full, 1);
  2573. goto more_data;
  2574. }
  2575. }
  2576. }
  2577. if (vdev && vdev->osif_fisa_flush)
  2578. vdev->osif_fisa_flush(soc, reo_ring_num);
  2579. if (vdev && vdev->osif_gro_flush && rx_ol_pkt_cnt) {
  2580. vdev->osif_gro_flush(vdev->osif_vdev,
  2581. reo_ring_num);
  2582. }
  2583. }
  2584. /* Update histogram statistics by looping through pdev's */
  2585. DP_RX_HIST_STATS_PER_PDEV();
  2586. return rx_bufs_used; /* Assume no scale factor for now */
  2587. }
  2588. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  2589. QDF_STATUS dp_rx_vdev_detach(struct dp_vdev *vdev)
  2590. {
  2591. QDF_STATUS ret;
  2592. if (vdev->osif_rx_flush) {
  2593. ret = vdev->osif_rx_flush(vdev->osif_vdev, vdev->vdev_id);
  2594. if (!QDF_IS_STATUS_SUCCESS(ret)) {
  2595. dp_err("Failed to flush rx pkts for vdev %d\n",
  2596. vdev->vdev_id);
  2597. return ret;
  2598. }
  2599. }
  2600. return QDF_STATUS_SUCCESS;
  2601. }
  2602. static QDF_STATUS
  2603. dp_pdev_nbuf_alloc_and_map(struct dp_soc *dp_soc,
  2604. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  2605. struct dp_pdev *dp_pdev,
  2606. struct rx_desc_pool *rx_desc_pool)
  2607. {
  2608. QDF_STATUS ret = QDF_STATUS_E_FAILURE;
  2609. (nbuf_frag_info_t->virt_addr).nbuf =
  2610. qdf_nbuf_alloc(dp_soc->osdev, rx_desc_pool->buf_size,
  2611. RX_BUFFER_RESERVATION,
  2612. rx_desc_pool->buf_alignment, FALSE);
  2613. if (!((nbuf_frag_info_t->virt_addr).nbuf)) {
  2614. dp_err("nbuf alloc failed");
  2615. DP_STATS_INC(dp_pdev, replenish.nbuf_alloc_fail, 1);
  2616. return ret;
  2617. }
  2618. ret = qdf_nbuf_map_nbytes_single(dp_soc->osdev,
  2619. (nbuf_frag_info_t->virt_addr).nbuf,
  2620. QDF_DMA_FROM_DEVICE,
  2621. rx_desc_pool->buf_size);
  2622. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  2623. qdf_nbuf_free((nbuf_frag_info_t->virt_addr).nbuf);
  2624. dp_err("nbuf map failed");
  2625. DP_STATS_INC(dp_pdev, replenish.map_err, 1);
  2626. return ret;
  2627. }
  2628. nbuf_frag_info_t->paddr =
  2629. qdf_nbuf_get_frag_paddr((nbuf_frag_info_t->virt_addr).nbuf, 0);
  2630. ret = check_x86_paddr(dp_soc, &((nbuf_frag_info_t->virt_addr).nbuf),
  2631. &nbuf_frag_info_t->paddr,
  2632. rx_desc_pool);
  2633. if (ret == QDF_STATUS_E_FAILURE) {
  2634. qdf_nbuf_unmap_nbytes_single(dp_soc->osdev,
  2635. (nbuf_frag_info_t->virt_addr).nbuf,
  2636. QDF_DMA_FROM_DEVICE,
  2637. rx_desc_pool->buf_size);
  2638. qdf_nbuf_free((nbuf_frag_info_t->virt_addr).nbuf);
  2639. dp_err("nbuf check x86 failed");
  2640. DP_STATS_INC(dp_pdev, replenish.x86_fail, 1);
  2641. return ret;
  2642. }
  2643. return QDF_STATUS_SUCCESS;
  2644. }
  2645. QDF_STATUS
  2646. dp_pdev_rx_buffers_attach(struct dp_soc *dp_soc, uint32_t mac_id,
  2647. struct dp_srng *dp_rxdma_srng,
  2648. struct rx_desc_pool *rx_desc_pool,
  2649. uint32_t num_req_buffers)
  2650. {
  2651. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(dp_soc, mac_id);
  2652. hal_ring_handle_t rxdma_srng = dp_rxdma_srng->hal_srng;
  2653. union dp_rx_desc_list_elem_t *next;
  2654. void *rxdma_ring_entry;
  2655. qdf_dma_addr_t paddr;
  2656. struct dp_rx_nbuf_frag_info *nf_info;
  2657. uint32_t nr_descs, nr_nbuf = 0, nr_nbuf_total = 0;
  2658. uint32_t buffer_index, nbuf_ptrs_per_page;
  2659. qdf_nbuf_t nbuf;
  2660. QDF_STATUS ret;
  2661. int page_idx, total_pages;
  2662. union dp_rx_desc_list_elem_t *desc_list = NULL;
  2663. union dp_rx_desc_list_elem_t *tail = NULL;
  2664. int sync_hw_ptr = 1;
  2665. uint32_t num_entries_avail;
  2666. if (qdf_unlikely(!rxdma_srng)) {
  2667. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  2668. return QDF_STATUS_E_FAILURE;
  2669. }
  2670. dp_debug("requested %u RX buffers for driver attach", num_req_buffers);
  2671. hal_srng_access_start(dp_soc->hal_soc, rxdma_srng);
  2672. num_entries_avail = hal_srng_src_num_avail(dp_soc->hal_soc,
  2673. rxdma_srng,
  2674. sync_hw_ptr);
  2675. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  2676. if (!num_entries_avail) {
  2677. dp_err("Num of available entries is zero, nothing to do");
  2678. return QDF_STATUS_E_NOMEM;
  2679. }
  2680. if (num_entries_avail < num_req_buffers)
  2681. num_req_buffers = num_entries_avail;
  2682. nr_descs = dp_rx_get_free_desc_list(dp_soc, mac_id, rx_desc_pool,
  2683. num_req_buffers, &desc_list, &tail);
  2684. if (!nr_descs) {
  2685. dp_err("no free rx_descs in freelist");
  2686. DP_STATS_INC(dp_pdev, err.desc_alloc_fail, num_req_buffers);
  2687. return QDF_STATUS_E_NOMEM;
  2688. }
  2689. dp_debug("got %u RX descs for driver attach", nr_descs);
  2690. /*
  2691. * Try to allocate pointers to the nbuf one page at a time.
  2692. * Take pointers that can fit in one page of memory and
  2693. * iterate through the total descriptors that need to be
  2694. * allocated in order of pages. Reuse the pointers that
  2695. * have been allocated to fit in one page across each
  2696. * iteration to index into the nbuf.
  2697. */
  2698. total_pages = (nr_descs * sizeof(*nf_info)) / PAGE_SIZE;
  2699. /*
  2700. * Add an extra page to store the remainder if any
  2701. */
  2702. if ((nr_descs * sizeof(*nf_info)) % PAGE_SIZE)
  2703. total_pages++;
  2704. nf_info = qdf_mem_malloc(PAGE_SIZE);
  2705. if (!nf_info) {
  2706. dp_err("failed to allocate nbuf array");
  2707. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  2708. QDF_BUG(0);
  2709. return QDF_STATUS_E_NOMEM;
  2710. }
  2711. nbuf_ptrs_per_page = PAGE_SIZE / sizeof(*nf_info);
  2712. for (page_idx = 0; page_idx < total_pages; page_idx++) {
  2713. qdf_mem_zero(nf_info, PAGE_SIZE);
  2714. for (nr_nbuf = 0; nr_nbuf < nbuf_ptrs_per_page; nr_nbuf++) {
  2715. /*
  2716. * The last page of buffer pointers may not be required
  2717. * completely based on the number of descriptors. Below
  2718. * check will ensure we are allocating only the
  2719. * required number of descriptors.
  2720. */
  2721. if (nr_nbuf_total >= nr_descs)
  2722. break;
  2723. /* Flag is set while pdev rx_desc_pool initialization */
  2724. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  2725. ret = dp_pdev_frag_alloc_and_map(dp_soc,
  2726. &nf_info[nr_nbuf], dp_pdev,
  2727. rx_desc_pool);
  2728. else
  2729. ret = dp_pdev_nbuf_alloc_and_map(dp_soc,
  2730. &nf_info[nr_nbuf], dp_pdev,
  2731. rx_desc_pool);
  2732. if (QDF_IS_STATUS_ERROR(ret))
  2733. break;
  2734. nr_nbuf_total++;
  2735. }
  2736. hal_srng_access_start(dp_soc->hal_soc, rxdma_srng);
  2737. for (buffer_index = 0; buffer_index < nr_nbuf; buffer_index++) {
  2738. rxdma_ring_entry =
  2739. hal_srng_src_get_next(dp_soc->hal_soc,
  2740. rxdma_srng);
  2741. qdf_assert_always(rxdma_ring_entry);
  2742. next = desc_list->next;
  2743. paddr = nf_info[buffer_index].paddr;
  2744. nbuf = nf_info[buffer_index].virt_addr.nbuf;
  2745. /* Flag is set while pdev rx_desc_pool initialization */
  2746. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  2747. dp_rx_desc_frag_prep(&desc_list->rx_desc,
  2748. &nf_info[buffer_index]);
  2749. else
  2750. dp_rx_desc_prep(&desc_list->rx_desc,
  2751. &nf_info[buffer_index]);
  2752. desc_list->rx_desc.in_use = 1;
  2753. dp_rx_desc_alloc_dbg_info(&desc_list->rx_desc);
  2754. dp_rx_desc_update_dbg_info(&desc_list->rx_desc,
  2755. __func__,
  2756. RX_DESC_REPLENISHED);
  2757. hal_rxdma_buff_addr_info_set(rxdma_ring_entry, paddr,
  2758. desc_list->rx_desc.cookie,
  2759. rx_desc_pool->owner);
  2760. dp_ipa_handle_rx_buf_smmu_mapping(
  2761. dp_soc, nbuf,
  2762. rx_desc_pool->buf_size,
  2763. true);
  2764. desc_list = next;
  2765. }
  2766. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  2767. }
  2768. dp_info("filled %u RX buffers for driver attach", nr_nbuf_total);
  2769. qdf_mem_free(nf_info);
  2770. if (!nr_nbuf_total) {
  2771. dp_err("No nbuf's allocated");
  2772. QDF_BUG(0);
  2773. return QDF_STATUS_E_RESOURCES;
  2774. }
  2775. /* No need to count the number of bytes received during replenish.
  2776. * Therefore set replenish.pkts.bytes as 0.
  2777. */
  2778. DP_STATS_INC_PKT(dp_pdev, replenish.pkts, nr_nbuf, 0);
  2779. return QDF_STATUS_SUCCESS;
  2780. }
  2781. /**
  2782. * dp_rx_enable_mon_dest_frag() - Enable frag processing for
  2783. * monitor destination ring via frag.
  2784. *
  2785. * Enable this flag only for monitor destination buffer processing
  2786. * if DP_RX_MON_MEM_FRAG feature is enabled.
  2787. * If flag is set then frag based function will be called for alloc,
  2788. * map, prep desc and free ops for desc buffer else normal nbuf based
  2789. * function will be called.
  2790. *
  2791. * @rx_desc_pool: Rx desc pool
  2792. * @is_mon_dest_desc: Is it for monitor dest buffer
  2793. *
  2794. * Return: None
  2795. */
  2796. #ifdef DP_RX_MON_MEM_FRAG
  2797. void dp_rx_enable_mon_dest_frag(struct rx_desc_pool *rx_desc_pool,
  2798. bool is_mon_dest_desc)
  2799. {
  2800. rx_desc_pool->rx_mon_dest_frag_enable = is_mon_dest_desc;
  2801. if (is_mon_dest_desc)
  2802. dp_alert("Feature DP_RX_MON_MEM_FRAG for mon_dest is enabled");
  2803. }
  2804. #else
  2805. void dp_rx_enable_mon_dest_frag(struct rx_desc_pool *rx_desc_pool,
  2806. bool is_mon_dest_desc)
  2807. {
  2808. rx_desc_pool->rx_mon_dest_frag_enable = false;
  2809. if (is_mon_dest_desc)
  2810. dp_alert("Feature DP_RX_MON_MEM_FRAG for mon_dest is disabled");
  2811. }
  2812. #endif
  2813. /*
  2814. * dp_rx_pdev_desc_pool_alloc() - allocate memory for software rx descriptor
  2815. * pool
  2816. *
  2817. * @pdev: core txrx pdev context
  2818. *
  2819. * Return: QDF_STATUS - QDF_STATUS_SUCCESS
  2820. * QDF_STATUS_E_NOMEM
  2821. */
  2822. QDF_STATUS
  2823. dp_rx_pdev_desc_pool_alloc(struct dp_pdev *pdev)
  2824. {
  2825. struct dp_soc *soc = pdev->soc;
  2826. uint32_t rxdma_entries;
  2827. uint32_t rx_sw_desc_num;
  2828. struct dp_srng *dp_rxdma_srng;
  2829. struct rx_desc_pool *rx_desc_pool;
  2830. uint32_t status = QDF_STATUS_SUCCESS;
  2831. int mac_for_pdev;
  2832. mac_for_pdev = pdev->lmac_id;
  2833. if (wlan_cfg_get_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx)) {
  2834. dp_rx_info("%pK: nss-wifi<4> skip Rx refil %d",
  2835. soc, mac_for_pdev);
  2836. return status;
  2837. }
  2838. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_for_pdev];
  2839. rxdma_entries = dp_rxdma_srng->num_entries;
  2840. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2841. rx_sw_desc_num = wlan_cfg_get_dp_soc_rx_sw_desc_num(soc->wlan_cfg_ctx);
  2842. rx_desc_pool->desc_type = DP_RX_DESC_BUF_TYPE;
  2843. status = dp_rx_desc_pool_alloc(soc,
  2844. rx_sw_desc_num,
  2845. rx_desc_pool);
  2846. if (status != QDF_STATUS_SUCCESS)
  2847. return status;
  2848. return status;
  2849. }
  2850. /*
  2851. * dp_rx_pdev_desc_pool_free() - free software rx descriptor pool
  2852. *
  2853. * @pdev: core txrx pdev context
  2854. */
  2855. void dp_rx_pdev_desc_pool_free(struct dp_pdev *pdev)
  2856. {
  2857. int mac_for_pdev = pdev->lmac_id;
  2858. struct dp_soc *soc = pdev->soc;
  2859. struct rx_desc_pool *rx_desc_pool;
  2860. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2861. dp_rx_desc_pool_free(soc, rx_desc_pool);
  2862. }
  2863. /*
  2864. * dp_rx_pdev_desc_pool_init() - initialize software rx descriptors
  2865. *
  2866. * @pdev: core txrx pdev context
  2867. *
  2868. * Return: QDF_STATUS - QDF_STATUS_SUCCESS
  2869. * QDF_STATUS_E_NOMEM
  2870. */
  2871. QDF_STATUS dp_rx_pdev_desc_pool_init(struct dp_pdev *pdev)
  2872. {
  2873. int mac_for_pdev = pdev->lmac_id;
  2874. struct dp_soc *soc = pdev->soc;
  2875. uint32_t rxdma_entries;
  2876. uint32_t rx_sw_desc_num;
  2877. struct dp_srng *dp_rxdma_srng;
  2878. struct rx_desc_pool *rx_desc_pool;
  2879. if (wlan_cfg_get_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx)) {
  2880. /**
  2881. * If NSS is enabled, rx_desc_pool is already filled.
  2882. * Hence, just disable desc_pool frag flag.
  2883. */
  2884. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2885. dp_rx_enable_mon_dest_frag(rx_desc_pool, false);
  2886. dp_rx_info("%pK: nss-wifi<4> skip Rx refil %d",
  2887. soc, mac_for_pdev);
  2888. return QDF_STATUS_SUCCESS;
  2889. }
  2890. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2891. if (dp_rx_desc_pool_is_allocated(rx_desc_pool) == QDF_STATUS_E_NOMEM)
  2892. return QDF_STATUS_E_NOMEM;
  2893. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_for_pdev];
  2894. rxdma_entries = dp_rxdma_srng->num_entries;
  2895. soc->process_rx_status = CONFIG_PROCESS_RX_STATUS;
  2896. rx_sw_desc_num =
  2897. wlan_cfg_get_dp_soc_rx_sw_desc_num(soc->wlan_cfg_ctx);
  2898. rx_desc_pool->owner = DP_WBM2SW_RBM;
  2899. rx_desc_pool->buf_size = RX_DATA_BUFFER_SIZE;
  2900. rx_desc_pool->buf_alignment = RX_DATA_BUFFER_ALIGNMENT;
  2901. /* Disable monitor dest processing via frag */
  2902. dp_rx_enable_mon_dest_frag(rx_desc_pool, false);
  2903. dp_rx_desc_pool_init(soc, mac_for_pdev,
  2904. rx_sw_desc_num, rx_desc_pool);
  2905. return QDF_STATUS_SUCCESS;
  2906. }
  2907. /*
  2908. * dp_rx_pdev_desc_pool_deinit() - de-initialize software rx descriptor pools
  2909. * @pdev: core txrx pdev context
  2910. *
  2911. * This function resets the freelist of rx descriptors and destroys locks
  2912. * associated with this list of descriptors.
  2913. */
  2914. void dp_rx_pdev_desc_pool_deinit(struct dp_pdev *pdev)
  2915. {
  2916. int mac_for_pdev = pdev->lmac_id;
  2917. struct dp_soc *soc = pdev->soc;
  2918. struct rx_desc_pool *rx_desc_pool;
  2919. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2920. dp_rx_desc_pool_deinit(soc, rx_desc_pool);
  2921. }
  2922. /*
  2923. * dp_rx_pdev_buffers_alloc() - Allocate nbufs (skbs) and replenish RxDMA ring
  2924. *
  2925. * @pdev: core txrx pdev context
  2926. *
  2927. * Return: QDF_STATUS - QDF_STATUS_SUCCESS
  2928. * QDF_STATUS_E_NOMEM
  2929. */
  2930. QDF_STATUS
  2931. dp_rx_pdev_buffers_alloc(struct dp_pdev *pdev)
  2932. {
  2933. int mac_for_pdev = pdev->lmac_id;
  2934. struct dp_soc *soc = pdev->soc;
  2935. struct dp_srng *dp_rxdma_srng;
  2936. struct rx_desc_pool *rx_desc_pool;
  2937. uint32_t rxdma_entries;
  2938. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_for_pdev];
  2939. rxdma_entries = dp_rxdma_srng->num_entries;
  2940. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2941. /* Initialize RX buffer pool which will be
  2942. * used during low memory conditions
  2943. */
  2944. dp_rx_buffer_pool_init(soc, mac_for_pdev);
  2945. return dp_pdev_rx_buffers_attach(soc, mac_for_pdev, dp_rxdma_srng,
  2946. rx_desc_pool, rxdma_entries - 1);
  2947. }
  2948. /*
  2949. * dp_rx_pdev_buffers_free - Free nbufs (skbs)
  2950. *
  2951. * @pdev: core txrx pdev context
  2952. */
  2953. void
  2954. dp_rx_pdev_buffers_free(struct dp_pdev *pdev)
  2955. {
  2956. int mac_for_pdev = pdev->lmac_id;
  2957. struct dp_soc *soc = pdev->soc;
  2958. struct rx_desc_pool *rx_desc_pool;
  2959. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2960. dp_rx_desc_nbuf_free(soc, rx_desc_pool);
  2961. dp_rx_buffer_pool_deinit(soc, mac_for_pdev);
  2962. }
  2963. #ifdef DP_RX_SPECIAL_FRAME_NEED
  2964. bool dp_rx_deliver_special_frame(struct dp_soc *soc, struct dp_peer *peer,
  2965. qdf_nbuf_t nbuf, uint32_t frame_mask,
  2966. uint8_t *rx_tlv_hdr)
  2967. {
  2968. uint32_t l2_hdr_offset = 0;
  2969. uint16_t msdu_len = 0;
  2970. uint32_t skip_len;
  2971. l2_hdr_offset =
  2972. hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc, rx_tlv_hdr);
  2973. if (qdf_unlikely(qdf_nbuf_is_frag(nbuf))) {
  2974. skip_len = l2_hdr_offset;
  2975. } else {
  2976. msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  2977. skip_len = l2_hdr_offset + RX_PKT_TLVS_LEN;
  2978. qdf_nbuf_set_pktlen(nbuf, msdu_len + skip_len);
  2979. }
  2980. QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(nbuf) = 1;
  2981. dp_rx_set_hdr_pad(nbuf, l2_hdr_offset);
  2982. qdf_nbuf_pull_head(nbuf, skip_len);
  2983. if (dp_rx_is_special_frame(nbuf, frame_mask)) {
  2984. qdf_nbuf_set_exc_frame(nbuf, 1);
  2985. dp_rx_deliver_to_stack(soc, peer->vdev, peer,
  2986. nbuf, NULL);
  2987. return true;
  2988. }
  2989. return false;
  2990. }
  2991. #endif