dp_rx.c 97 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543
  1. /*
  2. * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
  3. * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
  4. *
  5. * Permission to use, copy, modify, and/or distribute this software for
  6. * any purpose with or without fee is hereby granted, provided that the
  7. * above copyright notice and this permission notice appear in all
  8. * copies.
  9. *
  10. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  11. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  13. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  14. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  15. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  16. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17. * PERFORMANCE OF THIS SOFTWARE.
  18. */
  19. #include "hal_hw_headers.h"
  20. #include "dp_types.h"
  21. #include "dp_rx.h"
  22. #include "dp_tx.h"
  23. #include "dp_peer.h"
  24. #include "hal_rx.h"
  25. #include "hal_api.h"
  26. #include "qdf_nbuf.h"
  27. #ifdef MESH_MODE_SUPPORT
  28. #include "if_meta_hdr.h"
  29. #endif
  30. #include "dp_internal.h"
  31. #include "dp_ipa.h"
  32. #include "dp_hist.h"
  33. #include "dp_rx_buffer_pool.h"
  34. #ifdef WIFI_MONITOR_SUPPORT
  35. #include "dp_htt.h"
  36. #include <dp_mon.h>
  37. #endif
  38. #ifdef FEATURE_WDS
  39. #include "dp_txrx_wds.h"
  40. #endif
  41. #ifdef DP_RATETABLE_SUPPORT
  42. #include "dp_ratetable.h"
  43. #endif
  44. #include "enet.h"
  45. #ifndef WLAN_SOFTUMAC_SUPPORT /* WLAN_SOFTUMAC_SUPPORT */
  46. #ifdef DUP_RX_DESC_WAR
  47. void dp_rx_dump_info_and_assert(struct dp_soc *soc,
  48. hal_ring_handle_t hal_ring,
  49. hal_ring_desc_t ring_desc,
  50. struct dp_rx_desc *rx_desc)
  51. {
  52. void *hal_soc = soc->hal_soc;
  53. hal_srng_dump_ring_desc(hal_soc, hal_ring, ring_desc);
  54. dp_rx_desc_dump(rx_desc);
  55. }
  56. #else
  57. void dp_rx_dump_info_and_assert(struct dp_soc *soc,
  58. hal_ring_handle_t hal_ring_hdl,
  59. hal_ring_desc_t ring_desc,
  60. struct dp_rx_desc *rx_desc)
  61. {
  62. hal_soc_handle_t hal_soc = soc->hal_soc;
  63. dp_rx_desc_dump(rx_desc);
  64. hal_srng_dump_ring_desc(hal_soc, hal_ring_hdl, ring_desc);
  65. hal_srng_dump_ring(hal_soc, hal_ring_hdl);
  66. qdf_assert_always(0);
  67. }
  68. #endif
  69. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  70. #ifdef RX_DESC_SANITY_WAR
  71. QDF_STATUS dp_rx_desc_sanity(struct dp_soc *soc, hal_soc_handle_t hal_soc,
  72. hal_ring_handle_t hal_ring_hdl,
  73. hal_ring_desc_t ring_desc,
  74. struct dp_rx_desc *rx_desc)
  75. {
  76. uint8_t return_buffer_manager;
  77. if (qdf_unlikely(!rx_desc)) {
  78. /*
  79. * This is an unlikely case where the cookie obtained
  80. * from the ring_desc is invalid and hence we are not
  81. * able to find the corresponding rx_desc
  82. */
  83. goto fail;
  84. }
  85. return_buffer_manager = hal_rx_ret_buf_manager_get(hal_soc, ring_desc);
  86. if (qdf_unlikely(!(return_buffer_manager ==
  87. HAL_RX_BUF_RBM_SW1_BM(soc->wbm_sw0_bm_id) ||
  88. return_buffer_manager ==
  89. HAL_RX_BUF_RBM_SW3_BM(soc->wbm_sw0_bm_id)))) {
  90. goto fail;
  91. }
  92. return QDF_STATUS_SUCCESS;
  93. fail:
  94. DP_STATS_INC(soc, rx.err.invalid_cookie, 1);
  95. dp_err_rl("Sanity failed for ring Desc:");
  96. hal_srng_dump_ring_desc(hal_soc, hal_ring_hdl,
  97. ring_desc);
  98. return QDF_STATUS_E_NULL_VALUE;
  99. }
  100. #endif
  101. uint32_t dp_rx_srng_get_num_pending(hal_soc_handle_t hal_soc,
  102. hal_ring_handle_t hal_ring_hdl,
  103. uint32_t num_entries,
  104. bool *near_full)
  105. {
  106. uint32_t num_pending = 0;
  107. num_pending = hal_srng_dst_num_valid_locked(hal_soc,
  108. hal_ring_hdl,
  109. true);
  110. if (num_entries && (num_pending >= num_entries >> 1))
  111. *near_full = true;
  112. else
  113. *near_full = false;
  114. return num_pending;
  115. }
  116. #ifdef RX_DESC_DEBUG_CHECK
  117. QDF_STATUS dp_rx_desc_nbuf_sanity_check(struct dp_soc *soc,
  118. hal_ring_desc_t ring_desc,
  119. struct dp_rx_desc *rx_desc)
  120. {
  121. struct hal_buf_info hbi;
  122. hal_rx_reo_buf_paddr_get(soc->hal_soc, ring_desc, &hbi);
  123. /* Sanity check for possible buffer paddr corruption */
  124. if (dp_rx_desc_paddr_sanity_check(rx_desc, (&hbi)->paddr))
  125. return QDF_STATUS_SUCCESS;
  126. return QDF_STATUS_E_FAILURE;
  127. }
  128. /**
  129. * dp_rx_desc_nbuf_len_sanity_check - Add sanity check to catch Rx buffer
  130. * out of bound access from H.W
  131. *
  132. * @soc: DP soc
  133. * @pkt_len: Packet length received from H.W
  134. *
  135. * Return: NONE
  136. */
  137. static inline void
  138. dp_rx_desc_nbuf_len_sanity_check(struct dp_soc *soc,
  139. uint32_t pkt_len)
  140. {
  141. struct rx_desc_pool *rx_desc_pool;
  142. rx_desc_pool = &soc->rx_desc_buf[0];
  143. qdf_assert_always(pkt_len <= rx_desc_pool->buf_size);
  144. }
  145. #else
  146. static inline void
  147. dp_rx_desc_nbuf_len_sanity_check(struct dp_soc *soc, uint32_t pkt_len) { }
  148. #endif
  149. #ifdef WLAN_FEATURE_DP_RX_RING_HISTORY
  150. void
  151. dp_rx_ring_record_entry(struct dp_soc *soc, uint8_t ring_num,
  152. hal_ring_desc_t ring_desc)
  153. {
  154. struct dp_buf_info_record *record;
  155. struct hal_buf_info hbi;
  156. uint32_t idx;
  157. if (qdf_unlikely(!soc->rx_ring_history[ring_num]))
  158. return;
  159. hal_rx_reo_buf_paddr_get(soc->hal_soc, ring_desc, &hbi);
  160. /* buffer_addr_info is the first element of ring_desc */
  161. hal_rx_buf_cookie_rbm_get(soc->hal_soc, (uint32_t *)ring_desc,
  162. &hbi);
  163. idx = dp_history_get_next_index(&soc->rx_ring_history[ring_num]->index,
  164. DP_RX_HIST_MAX);
  165. /* No NULL check needed for record since its an array */
  166. record = &soc->rx_ring_history[ring_num]->entry[idx];
  167. record->timestamp = qdf_get_log_timestamp();
  168. record->hbi.paddr = hbi.paddr;
  169. record->hbi.sw_cookie = hbi.sw_cookie;
  170. record->hbi.rbm = hbi.rbm;
  171. }
  172. #endif
  173. #ifdef WLAN_FEATURE_MARK_FIRST_WAKEUP_PACKET
  174. void dp_rx_mark_first_packet_after_wow_wakeup(struct dp_pdev *pdev,
  175. uint8_t *rx_tlv,
  176. qdf_nbuf_t nbuf)
  177. {
  178. struct dp_soc *soc;
  179. if (!pdev->is_first_wakeup_packet)
  180. return;
  181. soc = pdev->soc;
  182. if (hal_get_first_wow_wakeup_packet(soc->hal_soc, rx_tlv)) {
  183. qdf_nbuf_mark_wakeup_frame(nbuf);
  184. dp_info("First packet after WOW Wakeup rcvd");
  185. }
  186. }
  187. #endif
  188. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  189. #endif /* WLAN_SOFTUMAC_SUPPORT */
  190. /**
  191. * dp_pdev_frag_alloc_and_map() - Allocate frag for desc buffer and map
  192. *
  193. * @dp_soc: struct dp_soc *
  194. * @nbuf_frag_info_t: nbuf frag info
  195. * @dp_pdev: struct dp_pdev *
  196. * @rx_desc_pool: Rx desc pool
  197. *
  198. * Return: QDF_STATUS
  199. */
  200. #ifdef DP_RX_MON_MEM_FRAG
  201. static inline QDF_STATUS
  202. dp_pdev_frag_alloc_and_map(struct dp_soc *dp_soc,
  203. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  204. struct dp_pdev *dp_pdev,
  205. struct rx_desc_pool *rx_desc_pool)
  206. {
  207. QDF_STATUS ret = QDF_STATUS_E_FAILURE;
  208. (nbuf_frag_info_t->virt_addr).vaddr =
  209. qdf_frag_alloc(&rx_desc_pool->pf_cache, rx_desc_pool->buf_size);
  210. if (!((nbuf_frag_info_t->virt_addr).vaddr)) {
  211. dp_err("Frag alloc failed");
  212. DP_STATS_INC(dp_pdev, replenish.frag_alloc_fail, 1);
  213. return QDF_STATUS_E_NOMEM;
  214. }
  215. ret = qdf_mem_map_page(dp_soc->osdev,
  216. (nbuf_frag_info_t->virt_addr).vaddr,
  217. QDF_DMA_FROM_DEVICE,
  218. rx_desc_pool->buf_size,
  219. &nbuf_frag_info_t->paddr);
  220. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  221. qdf_frag_free((nbuf_frag_info_t->virt_addr).vaddr);
  222. dp_err("Frag map failed");
  223. DP_STATS_INC(dp_pdev, replenish.map_err, 1);
  224. return QDF_STATUS_E_FAULT;
  225. }
  226. return QDF_STATUS_SUCCESS;
  227. }
  228. #else
  229. static inline QDF_STATUS
  230. dp_pdev_frag_alloc_and_map(struct dp_soc *dp_soc,
  231. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  232. struct dp_pdev *dp_pdev,
  233. struct rx_desc_pool *rx_desc_pool)
  234. {
  235. return QDF_STATUS_SUCCESS;
  236. }
  237. #endif /* DP_RX_MON_MEM_FRAG */
  238. #ifdef WLAN_FEATURE_DP_RX_RING_HISTORY
  239. /**
  240. * dp_rx_refill_ring_record_entry() - Record an entry into refill_ring history
  241. * @soc: Datapath soc structure
  242. * @ring_num: Refill ring number
  243. * @hal_ring_hdl:
  244. * @num_req: number of buffers requested for refill
  245. * @num_refill: number of buffers refilled
  246. *
  247. * Return: None
  248. */
  249. static inline void
  250. dp_rx_refill_ring_record_entry(struct dp_soc *soc, uint8_t ring_num,
  251. hal_ring_handle_t hal_ring_hdl,
  252. uint32_t num_req, uint32_t num_refill)
  253. {
  254. struct dp_refill_info_record *record;
  255. uint32_t idx;
  256. uint32_t tp;
  257. uint32_t hp;
  258. if (qdf_unlikely(ring_num >= MAX_PDEV_CNT ||
  259. !soc->rx_refill_ring_history[ring_num]))
  260. return;
  261. idx = dp_history_get_next_index(&soc->rx_refill_ring_history[ring_num]->index,
  262. DP_RX_REFILL_HIST_MAX);
  263. /* No NULL check needed for record since its an array */
  264. record = &soc->rx_refill_ring_history[ring_num]->entry[idx];
  265. hal_get_sw_hptp(soc->hal_soc, hal_ring_hdl, &tp, &hp);
  266. record->timestamp = qdf_get_log_timestamp();
  267. record->num_req = num_req;
  268. record->num_refill = num_refill;
  269. record->hp = hp;
  270. record->tp = tp;
  271. }
  272. #else
  273. static inline void
  274. dp_rx_refill_ring_record_entry(struct dp_soc *soc, uint8_t ring_num,
  275. hal_ring_handle_t hal_ring_hdl,
  276. uint32_t num_req, uint32_t num_refill)
  277. {
  278. }
  279. #endif
  280. /**
  281. * dp_pdev_nbuf_alloc_and_map_replenish() - Allocate nbuf for desc buffer and
  282. * map
  283. * @dp_soc: struct dp_soc *
  284. * @mac_id: Mac id
  285. * @num_entries_avail: num_entries_avail
  286. * @nbuf_frag_info_t: nbuf frag info
  287. * @dp_pdev: struct dp_pdev *
  288. * @rx_desc_pool: Rx desc pool
  289. *
  290. * Return: QDF_STATUS
  291. */
  292. static inline QDF_STATUS
  293. dp_pdev_nbuf_alloc_and_map_replenish(struct dp_soc *dp_soc,
  294. uint32_t mac_id,
  295. uint32_t num_entries_avail,
  296. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  297. struct dp_pdev *dp_pdev,
  298. struct rx_desc_pool *rx_desc_pool)
  299. {
  300. QDF_STATUS ret = QDF_STATUS_E_FAILURE;
  301. (nbuf_frag_info_t->virt_addr).nbuf =
  302. dp_rx_buffer_pool_nbuf_alloc(dp_soc,
  303. mac_id,
  304. rx_desc_pool,
  305. num_entries_avail);
  306. if (!((nbuf_frag_info_t->virt_addr).nbuf)) {
  307. dp_err("nbuf alloc failed");
  308. DP_STATS_INC(dp_pdev, replenish.nbuf_alloc_fail, 1);
  309. return QDF_STATUS_E_NOMEM;
  310. }
  311. ret = dp_rx_buffer_pool_nbuf_map(dp_soc, rx_desc_pool,
  312. nbuf_frag_info_t);
  313. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  314. dp_rx_buffer_pool_nbuf_free(dp_soc,
  315. (nbuf_frag_info_t->virt_addr).nbuf, mac_id);
  316. dp_err("nbuf map failed");
  317. DP_STATS_INC(dp_pdev, replenish.map_err, 1);
  318. return QDF_STATUS_E_FAULT;
  319. }
  320. nbuf_frag_info_t->paddr =
  321. qdf_nbuf_get_frag_paddr((nbuf_frag_info_t->virt_addr).nbuf, 0);
  322. dp_ipa_handle_rx_buf_smmu_mapping(dp_soc, (qdf_nbuf_t)(
  323. (nbuf_frag_info_t->virt_addr).nbuf),
  324. rx_desc_pool->buf_size,
  325. true, __func__, __LINE__);
  326. ret = dp_check_paddr(dp_soc, &((nbuf_frag_info_t->virt_addr).nbuf),
  327. &nbuf_frag_info_t->paddr,
  328. rx_desc_pool);
  329. if (ret == QDF_STATUS_E_FAILURE) {
  330. DP_STATS_INC(dp_pdev, replenish.x86_fail, 1);
  331. return QDF_STATUS_E_ADDRNOTAVAIL;
  332. }
  333. return QDF_STATUS_SUCCESS;
  334. }
  335. #if defined(QCA_DP_RX_NBUF_NO_MAP_UNMAP) && !defined(BUILD_X86)
  336. QDF_STATUS
  337. __dp_rx_buffers_no_map_lt_replenish(struct dp_soc *soc, uint32_t mac_id,
  338. struct dp_srng *dp_rxdma_srng,
  339. struct rx_desc_pool *rx_desc_pool,
  340. bool force_replenish)
  341. {
  342. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  343. uint32_t count;
  344. void *rxdma_ring_entry;
  345. union dp_rx_desc_list_elem_t *next = NULL;
  346. void *rxdma_srng;
  347. qdf_nbuf_t nbuf;
  348. qdf_dma_addr_t paddr;
  349. uint16_t num_entries_avail = 0;
  350. uint16_t num_alloc_desc = 0;
  351. union dp_rx_desc_list_elem_t *desc_list = NULL;
  352. union dp_rx_desc_list_elem_t *tail = NULL;
  353. int sync_hw_ptr = 0;
  354. rxdma_srng = dp_rxdma_srng->hal_srng;
  355. if (qdf_unlikely(!dp_pdev)) {
  356. dp_rx_err("%pK: pdev is null for mac_id = %d", soc, mac_id);
  357. return QDF_STATUS_E_FAILURE;
  358. }
  359. if (qdf_unlikely(!rxdma_srng)) {
  360. dp_rx_debug("%pK: rxdma srng not initialized", soc);
  361. return QDF_STATUS_E_FAILURE;
  362. }
  363. hal_srng_access_start(soc->hal_soc, rxdma_srng);
  364. num_entries_avail = hal_srng_src_num_avail(soc->hal_soc,
  365. rxdma_srng,
  366. sync_hw_ptr);
  367. dp_rx_debug("%pK: no of available entries in rxdma ring: %d",
  368. soc, num_entries_avail);
  369. if (qdf_unlikely(!force_replenish && (num_entries_avail <
  370. ((dp_rxdma_srng->num_entries * 3) / 4)))) {
  371. hal_srng_access_end(soc->hal_soc, rxdma_srng);
  372. return QDF_STATUS_E_FAILURE;
  373. }
  374. DP_STATS_INC(dp_pdev, replenish.low_thresh_intrs, 1);
  375. num_alloc_desc = dp_rx_get_free_desc_list(soc, mac_id,
  376. rx_desc_pool,
  377. num_entries_avail,
  378. &desc_list,
  379. &tail);
  380. if (!num_alloc_desc) {
  381. dp_rx_err("%pK: no free rx_descs in freelist", soc);
  382. DP_STATS_INC(dp_pdev, err.desc_lt_alloc_fail,
  383. num_entries_avail);
  384. hal_srng_access_end(soc->hal_soc, rxdma_srng);
  385. return QDF_STATUS_E_NOMEM;
  386. }
  387. for (count = 0; count < num_alloc_desc; count++) {
  388. next = desc_list->next;
  389. qdf_prefetch(next);
  390. nbuf = dp_rx_nbuf_alloc(soc, rx_desc_pool);
  391. if (qdf_unlikely(!nbuf)) {
  392. DP_STATS_INC(dp_pdev, replenish.nbuf_alloc_fail, 1);
  393. break;
  394. }
  395. paddr = dp_rx_nbuf_sync_no_dsb(soc, nbuf,
  396. rx_desc_pool->buf_size);
  397. rxdma_ring_entry = hal_srng_src_get_next(soc->hal_soc,
  398. rxdma_srng);
  399. qdf_assert_always(rxdma_ring_entry);
  400. desc_list->rx_desc.nbuf = nbuf;
  401. dp_rx_set_reuse_nbuf(&desc_list->rx_desc, nbuf);
  402. desc_list->rx_desc.rx_buf_start = nbuf->data;
  403. desc_list->rx_desc.paddr_buf_start = paddr;
  404. desc_list->rx_desc.unmapped = 0;
  405. /* rx_desc.in_use should be zero at this time*/
  406. qdf_assert_always(desc_list->rx_desc.in_use == 0);
  407. desc_list->rx_desc.in_use = 1;
  408. desc_list->rx_desc.in_err_state = 0;
  409. hal_rxdma_buff_addr_info_set(soc->hal_soc, rxdma_ring_entry,
  410. paddr,
  411. desc_list->rx_desc.cookie,
  412. rx_desc_pool->owner);
  413. desc_list = next;
  414. }
  415. qdf_dsb();
  416. hal_srng_access_end(soc->hal_soc, rxdma_srng);
  417. /* No need to count the number of bytes received during replenish.
  418. * Therefore set replenish.pkts.bytes as 0.
  419. */
  420. DP_STATS_INC_PKT(dp_pdev, replenish.pkts, count, 0);
  421. DP_STATS_INC(dp_pdev, buf_freelist, (num_alloc_desc - count));
  422. /*
  423. * add any available free desc back to the free list
  424. */
  425. if (desc_list)
  426. dp_rx_add_desc_list_to_free_list(soc, &desc_list, &tail,
  427. mac_id, rx_desc_pool);
  428. return QDF_STATUS_SUCCESS;
  429. }
  430. QDF_STATUS
  431. __dp_rx_buffers_no_map_replenish(struct dp_soc *soc, uint32_t mac_id,
  432. struct dp_srng *dp_rxdma_srng,
  433. struct rx_desc_pool *rx_desc_pool,
  434. uint32_t num_req_buffers,
  435. union dp_rx_desc_list_elem_t **desc_list,
  436. union dp_rx_desc_list_elem_t **tail)
  437. {
  438. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  439. uint32_t count;
  440. void *rxdma_ring_entry;
  441. union dp_rx_desc_list_elem_t *next;
  442. void *rxdma_srng;
  443. qdf_nbuf_t nbuf;
  444. qdf_nbuf_t nbuf_next;
  445. qdf_nbuf_t nbuf_head = NULL;
  446. qdf_nbuf_t nbuf_tail = NULL;
  447. qdf_dma_addr_t paddr;
  448. rxdma_srng = dp_rxdma_srng->hal_srng;
  449. if (qdf_unlikely(!dp_pdev)) {
  450. dp_rx_err("%pK: pdev is null for mac_id = %d",
  451. soc, mac_id);
  452. return QDF_STATUS_E_FAILURE;
  453. }
  454. if (qdf_unlikely(!rxdma_srng)) {
  455. dp_rx_debug("%pK: rxdma srng not initialized", soc);
  456. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  457. return QDF_STATUS_E_FAILURE;
  458. }
  459. /* Allocate required number of nbufs */
  460. for (count = 0; count < num_req_buffers; count++) {
  461. nbuf = dp_rx_nbuf_alloc(soc, rx_desc_pool);
  462. if (qdf_unlikely(!nbuf)) {
  463. DP_STATS_INC(dp_pdev, replenish.nbuf_alloc_fail, 1);
  464. /* Update num_req_buffers to nbufs allocated count */
  465. num_req_buffers = count;
  466. break;
  467. }
  468. paddr = dp_rx_nbuf_sync_no_dsb(soc, nbuf,
  469. rx_desc_pool->buf_size);
  470. QDF_NBUF_CB_PADDR(nbuf) = paddr;
  471. DP_RX_LIST_APPEND(nbuf_head,
  472. nbuf_tail,
  473. nbuf);
  474. }
  475. qdf_dsb();
  476. nbuf = nbuf_head;
  477. hal_srng_access_start(soc->hal_soc, rxdma_srng);
  478. for (count = 0; count < num_req_buffers; count++) {
  479. next = (*desc_list)->next;
  480. nbuf_next = nbuf->next;
  481. qdf_prefetch(next);
  482. rxdma_ring_entry = (struct dp_buffer_addr_info *)
  483. hal_srng_src_get_next(soc->hal_soc, rxdma_srng);
  484. if (!rxdma_ring_entry)
  485. break;
  486. (*desc_list)->rx_desc.nbuf = nbuf;
  487. dp_rx_set_reuse_nbuf(&(*desc_list)->rx_desc, nbuf);
  488. (*desc_list)->rx_desc.rx_buf_start = nbuf->data;
  489. (*desc_list)->rx_desc.paddr_buf_start = QDF_NBUF_CB_PADDR(nbuf);
  490. (*desc_list)->rx_desc.unmapped = 0;
  491. /* rx_desc.in_use should be zero at this time*/
  492. qdf_assert_always((*desc_list)->rx_desc.in_use == 0);
  493. (*desc_list)->rx_desc.in_use = 1;
  494. (*desc_list)->rx_desc.in_err_state = 0;
  495. hal_rxdma_buff_addr_info_set(soc->hal_soc, rxdma_ring_entry,
  496. QDF_NBUF_CB_PADDR(nbuf),
  497. (*desc_list)->rx_desc.cookie,
  498. rx_desc_pool->owner);
  499. *desc_list = next;
  500. nbuf = nbuf_next;
  501. }
  502. hal_srng_access_end(soc->hal_soc, rxdma_srng);
  503. /* No need to count the number of bytes received during replenish.
  504. * Therefore set replenish.pkts.bytes as 0.
  505. */
  506. DP_STATS_INC_PKT(dp_pdev, replenish.pkts, count, 0);
  507. DP_STATS_INC(dp_pdev, buf_freelist, (num_req_buffers - count));
  508. /*
  509. * add any available free desc back to the free list
  510. */
  511. if (*desc_list)
  512. dp_rx_add_desc_list_to_free_list(soc, desc_list, tail,
  513. mac_id, rx_desc_pool);
  514. while (nbuf) {
  515. nbuf_next = nbuf->next;
  516. dp_rx_nbuf_unmap_pool(soc, rx_desc_pool, nbuf);
  517. qdf_nbuf_free(nbuf);
  518. nbuf = nbuf_next;
  519. }
  520. return QDF_STATUS_SUCCESS;
  521. }
  522. #ifdef WLAN_SUPPORT_PPEDS
  523. QDF_STATUS
  524. __dp_rx_comp2refill_replenish(struct dp_soc *soc, uint32_t mac_id,
  525. struct dp_srng *dp_rxdma_srng,
  526. struct rx_desc_pool *rx_desc_pool,
  527. uint32_t num_req_buffers,
  528. union dp_rx_desc_list_elem_t **desc_list,
  529. union dp_rx_desc_list_elem_t **tail)
  530. {
  531. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  532. uint32_t count;
  533. void *rxdma_ring_entry;
  534. union dp_rx_desc_list_elem_t *next;
  535. union dp_rx_desc_list_elem_t *cur;
  536. void *rxdma_srng;
  537. qdf_nbuf_t nbuf;
  538. rxdma_srng = dp_rxdma_srng->hal_srng;
  539. if (qdf_unlikely(!dp_pdev)) {
  540. dp_rx_err("%pK: pdev is null for mac_id = %d",
  541. soc, mac_id);
  542. return QDF_STATUS_E_FAILURE;
  543. }
  544. if (qdf_unlikely(!rxdma_srng)) {
  545. dp_rx_debug("%pK: rxdma srng not initialized", soc);
  546. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  547. return QDF_STATUS_E_FAILURE;
  548. }
  549. hal_srng_access_start(soc->hal_soc, rxdma_srng);
  550. for (count = 0; count < num_req_buffers; count++) {
  551. next = (*desc_list)->next;
  552. qdf_prefetch(next);
  553. rxdma_ring_entry = (struct dp_buffer_addr_info *)
  554. hal_srng_src_get_next(soc->hal_soc, rxdma_srng);
  555. if (!rxdma_ring_entry)
  556. break;
  557. (*desc_list)->rx_desc.in_use = 1;
  558. (*desc_list)->rx_desc.in_err_state = 0;
  559. (*desc_list)->rx_desc.nbuf = (*desc_list)->rx_desc.reuse_nbuf;
  560. hal_rxdma_buff_addr_info_set(soc->hal_soc, rxdma_ring_entry,
  561. (*desc_list)->rx_desc.paddr_buf_start,
  562. (*desc_list)->rx_desc.cookie,
  563. rx_desc_pool->owner);
  564. *desc_list = next;
  565. }
  566. hal_srng_access_end(soc->hal_soc, rxdma_srng);
  567. /* No need to count the number of bytes received during replenish.
  568. * Therefore set replenish.pkts.bytes as 0.
  569. */
  570. DP_STATS_INC_PKT(dp_pdev, replenish.pkts, count, 0);
  571. DP_STATS_INC(dp_pdev, buf_freelist, (num_req_buffers - count));
  572. /*
  573. * add any available free desc back to the free list
  574. */
  575. cur = *desc_list;
  576. for ( ; count < num_req_buffers; count++) {
  577. next = cur->next;
  578. qdf_prefetch(next);
  579. nbuf = cur->rx_desc.reuse_nbuf;
  580. cur->rx_desc.nbuf = NULL;
  581. cur->rx_desc.in_use = 0;
  582. cur->rx_desc.has_reuse_nbuf = false;
  583. cur->rx_desc.reuse_nbuf = NULL;
  584. if (!nbuf->recycled_for_ds)
  585. dp_rx_nbuf_unmap_pool(soc, rx_desc_pool, nbuf);
  586. nbuf->recycled_for_ds = 0;
  587. nbuf->fast_recycled = 0;
  588. qdf_nbuf_free(nbuf);
  589. cur = next;
  590. }
  591. if (*desc_list)
  592. dp_rx_add_desc_list_to_free_list(soc, desc_list, tail,
  593. mac_id, rx_desc_pool);
  594. return QDF_STATUS_SUCCESS;
  595. }
  596. #endif
  597. QDF_STATUS __dp_pdev_rx_buffers_no_map_attach(struct dp_soc *soc,
  598. uint32_t mac_id,
  599. struct dp_srng *dp_rxdma_srng,
  600. struct rx_desc_pool *rx_desc_pool,
  601. uint32_t num_req_buffers)
  602. {
  603. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  604. uint32_t count;
  605. uint32_t nr_descs = 0;
  606. void *rxdma_ring_entry;
  607. union dp_rx_desc_list_elem_t *next;
  608. void *rxdma_srng;
  609. qdf_nbuf_t nbuf;
  610. qdf_dma_addr_t paddr;
  611. union dp_rx_desc_list_elem_t *desc_list = NULL;
  612. union dp_rx_desc_list_elem_t *tail = NULL;
  613. rxdma_srng = dp_rxdma_srng->hal_srng;
  614. if (qdf_unlikely(!dp_pdev)) {
  615. dp_rx_err("%pK: pdev is null for mac_id = %d",
  616. soc, mac_id);
  617. return QDF_STATUS_E_FAILURE;
  618. }
  619. if (qdf_unlikely(!rxdma_srng)) {
  620. dp_rx_debug("%pK: rxdma srng not initialized", soc);
  621. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  622. return QDF_STATUS_E_FAILURE;
  623. }
  624. dp_rx_debug("%pK: requested %d buffers for replenish",
  625. soc, num_req_buffers);
  626. nr_descs = dp_rx_get_free_desc_list(soc, mac_id, rx_desc_pool,
  627. num_req_buffers, &desc_list, &tail);
  628. if (!nr_descs) {
  629. dp_err("no free rx_descs in freelist");
  630. DP_STATS_INC(dp_pdev, err.desc_alloc_fail, num_req_buffers);
  631. return QDF_STATUS_E_NOMEM;
  632. }
  633. dp_debug("got %u RX descs for driver attach", nr_descs);
  634. hal_srng_access_start(soc->hal_soc, rxdma_srng);
  635. for (count = 0; count < nr_descs; count++) {
  636. next = desc_list->next;
  637. qdf_prefetch(next);
  638. nbuf = dp_rx_nbuf_alloc(soc, rx_desc_pool);
  639. if (qdf_unlikely(!nbuf)) {
  640. DP_STATS_INC(dp_pdev, replenish.nbuf_alloc_fail, 1);
  641. break;
  642. }
  643. paddr = dp_rx_nbuf_sync_no_dsb(soc, nbuf,
  644. rx_desc_pool->buf_size);
  645. rxdma_ring_entry = (struct dp_buffer_addr_info *)
  646. hal_srng_src_get_next(soc->hal_soc, rxdma_srng);
  647. if (!rxdma_ring_entry) {
  648. qdf_nbuf_free(nbuf);
  649. break;
  650. }
  651. desc_list->rx_desc.nbuf = nbuf;
  652. dp_rx_set_reuse_nbuf(&desc_list->rx_desc, nbuf);
  653. desc_list->rx_desc.rx_buf_start = nbuf->data;
  654. desc_list->rx_desc.paddr_buf_start = paddr;
  655. desc_list->rx_desc.unmapped = 0;
  656. /* rx_desc.in_use should be zero at this time*/
  657. qdf_assert_always(desc_list->rx_desc.in_use == 0);
  658. desc_list->rx_desc.in_use = 1;
  659. desc_list->rx_desc.in_err_state = 0;
  660. hal_rxdma_buff_addr_info_set(soc->hal_soc, rxdma_ring_entry,
  661. paddr,
  662. desc_list->rx_desc.cookie,
  663. rx_desc_pool->owner);
  664. desc_list = next;
  665. }
  666. qdf_dsb();
  667. hal_srng_access_end(soc->hal_soc, rxdma_srng);
  668. /* No need to count the number of bytes received during replenish.
  669. * Therefore set replenish.pkts.bytes as 0.
  670. */
  671. DP_STATS_INC_PKT(dp_pdev, replenish.pkts, count, 0);
  672. return QDF_STATUS_SUCCESS;
  673. }
  674. #endif
  675. #ifdef DP_UMAC_HW_RESET_SUPPORT
  676. #if defined(QCA_DP_RX_NBUF_NO_MAP_UNMAP) && !defined(BUILD_X86)
  677. static inline
  678. qdf_dma_addr_t dp_rx_rep_retrieve_paddr(struct dp_soc *dp_soc, qdf_nbuf_t nbuf,
  679. uint32_t buf_size)
  680. {
  681. return dp_rx_nbuf_sync_no_dsb(dp_soc, nbuf, buf_size);
  682. }
  683. #else
  684. static inline
  685. qdf_dma_addr_t dp_rx_rep_retrieve_paddr(struct dp_soc *dp_soc, qdf_nbuf_t nbuf,
  686. uint32_t buf_size)
  687. {
  688. return qdf_nbuf_get_frag_paddr(nbuf, 0);
  689. }
  690. #endif
  691. /**
  692. * dp_rx_desc_replenish() - Replenish the rx descriptors one at a time
  693. * @soc: core txrx main context
  694. * @dp_rxdma_srng: rxdma ring
  695. * @rx_desc_pool: rx descriptor pool
  696. * @rx_desc:rx descriptor
  697. *
  698. * Return: void
  699. */
  700. static inline
  701. void dp_rx_desc_replenish(struct dp_soc *soc, struct dp_srng *dp_rxdma_srng,
  702. struct rx_desc_pool *rx_desc_pool,
  703. struct dp_rx_desc *rx_desc)
  704. {
  705. void *rxdma_srng;
  706. void *rxdma_ring_entry;
  707. qdf_dma_addr_t paddr;
  708. rxdma_srng = dp_rxdma_srng->hal_srng;
  709. /* No one else should be accessing the srng at this point */
  710. hal_srng_access_start_unlocked(soc->hal_soc, rxdma_srng);
  711. rxdma_ring_entry = hal_srng_src_get_next(soc->hal_soc, rxdma_srng);
  712. qdf_assert_always(rxdma_ring_entry);
  713. rx_desc->in_err_state = 0;
  714. paddr = dp_rx_rep_retrieve_paddr(soc, rx_desc->nbuf,
  715. rx_desc_pool->buf_size);
  716. hal_rxdma_buff_addr_info_set(soc->hal_soc, rxdma_ring_entry, paddr,
  717. rx_desc->cookie, rx_desc_pool->owner);
  718. hal_srng_access_end_unlocked(soc->hal_soc, rxdma_srng);
  719. }
  720. void dp_rx_desc_reuse(struct dp_soc *soc, qdf_nbuf_t *nbuf_list)
  721. {
  722. int mac_id, i, j;
  723. union dp_rx_desc_list_elem_t *head = NULL;
  724. union dp_rx_desc_list_elem_t *tail = NULL;
  725. for (mac_id = 0; mac_id < MAX_PDEV_CNT; mac_id++) {
  726. struct dp_srng *dp_rxdma_srng =
  727. &soc->rx_refill_buf_ring[mac_id];
  728. struct rx_desc_pool *rx_desc_pool = &soc->rx_desc_buf[mac_id];
  729. uint32_t rx_sw_desc_num = rx_desc_pool->pool_size;
  730. /* Only fill up 1/3 of the ring size */
  731. uint32_t num_req_decs;
  732. if (!dp_rxdma_srng || !dp_rxdma_srng->hal_srng ||
  733. !rx_desc_pool->array)
  734. continue;
  735. num_req_decs = dp_rxdma_srng->num_entries / 3;
  736. for (i = 0, j = 0; i < rx_sw_desc_num; i++) {
  737. struct dp_rx_desc *rx_desc =
  738. (struct dp_rx_desc *)&rx_desc_pool->array[i];
  739. if (rx_desc->in_use) {
  740. if (j < (dp_rxdma_srng->num_entries - 1)) {
  741. dp_rx_desc_replenish(soc, dp_rxdma_srng,
  742. rx_desc_pool,
  743. rx_desc);
  744. } else {
  745. dp_rx_nbuf_unmap(soc, rx_desc, 0);
  746. rx_desc->unmapped = 0;
  747. rx_desc->nbuf->next = *nbuf_list;
  748. *nbuf_list = rx_desc->nbuf;
  749. dp_rx_add_to_free_desc_list(&head,
  750. &tail,
  751. rx_desc);
  752. }
  753. j++;
  754. }
  755. }
  756. if (head)
  757. dp_rx_add_desc_list_to_free_list(soc, &head, &tail,
  758. mac_id, rx_desc_pool);
  759. /* If num of descs in use were less, then we need to replenish
  760. * the ring with some buffers
  761. */
  762. head = NULL;
  763. tail = NULL;
  764. if (j < (num_req_decs - 1))
  765. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  766. rx_desc_pool,
  767. ((num_req_decs - 1) - j),
  768. &head, &tail, true);
  769. }
  770. }
  771. #endif
  772. QDF_STATUS __dp_rx_buffers_replenish(struct dp_soc *dp_soc, uint32_t mac_id,
  773. struct dp_srng *dp_rxdma_srng,
  774. struct rx_desc_pool *rx_desc_pool,
  775. uint32_t num_req_buffers,
  776. union dp_rx_desc_list_elem_t **desc_list,
  777. union dp_rx_desc_list_elem_t **tail,
  778. bool req_only, bool force_replenish,
  779. const char *func_name)
  780. {
  781. uint32_t num_alloc_desc;
  782. uint16_t num_desc_to_free = 0;
  783. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(dp_soc, mac_id);
  784. uint32_t num_entries_avail;
  785. uint32_t count;
  786. uint32_t extra_buffers;
  787. int sync_hw_ptr = 1;
  788. struct dp_rx_nbuf_frag_info nbuf_frag_info = {0};
  789. void *rxdma_ring_entry;
  790. union dp_rx_desc_list_elem_t *next;
  791. QDF_STATUS ret;
  792. void *rxdma_srng;
  793. union dp_rx_desc_list_elem_t *desc_list_append = NULL;
  794. union dp_rx_desc_list_elem_t *tail_append = NULL;
  795. union dp_rx_desc_list_elem_t *temp_list = NULL;
  796. rxdma_srng = dp_rxdma_srng->hal_srng;
  797. if (qdf_unlikely(!dp_pdev)) {
  798. dp_rx_err("%pK: pdev is null for mac_id = %d",
  799. dp_soc, mac_id);
  800. return QDF_STATUS_E_FAILURE;
  801. }
  802. if (qdf_unlikely(!rxdma_srng)) {
  803. dp_rx_debug("%pK: rxdma srng not initialized", dp_soc);
  804. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  805. return QDF_STATUS_E_FAILURE;
  806. }
  807. dp_verbose_debug("%pK: requested %d buffers for replenish",
  808. dp_soc, num_req_buffers);
  809. hal_srng_access_start(dp_soc->hal_soc, rxdma_srng);
  810. num_entries_avail = hal_srng_src_num_avail(dp_soc->hal_soc,
  811. rxdma_srng,
  812. sync_hw_ptr);
  813. dp_verbose_debug("%pK: no of available entries in rxdma ring: %d",
  814. dp_soc, num_entries_avail);
  815. if (!req_only && !(*desc_list) &&
  816. (force_replenish || (num_entries_avail >
  817. ((dp_rxdma_srng->num_entries * 3) / 4)))) {
  818. num_req_buffers = num_entries_avail;
  819. DP_STATS_INC(dp_pdev, replenish.low_thresh_intrs, 1);
  820. } else if (num_entries_avail < num_req_buffers) {
  821. num_desc_to_free = num_req_buffers - num_entries_avail;
  822. num_req_buffers = num_entries_avail;
  823. } else if ((*desc_list) &&
  824. dp_rxdma_srng->num_entries - num_entries_avail <
  825. CRITICAL_BUFFER_THRESHOLD) {
  826. /* set extra buffers to CRITICAL_BUFFER_THRESHOLD only if
  827. * total buff requested after adding extra buffers is less
  828. * than or equal to num entries available, else set it to max
  829. * possible additional buffers available at that moment
  830. */
  831. extra_buffers =
  832. ((num_req_buffers + CRITICAL_BUFFER_THRESHOLD) > num_entries_avail) ?
  833. (num_entries_avail - num_req_buffers) :
  834. CRITICAL_BUFFER_THRESHOLD;
  835. /* Append some free descriptors to tail */
  836. num_alloc_desc =
  837. dp_rx_get_free_desc_list(dp_soc, mac_id,
  838. rx_desc_pool,
  839. extra_buffers,
  840. &desc_list_append,
  841. &tail_append);
  842. if (num_alloc_desc) {
  843. temp_list = *desc_list;
  844. *desc_list = desc_list_append;
  845. tail_append->next = temp_list;
  846. num_req_buffers += num_alloc_desc;
  847. DP_STATS_DEC(dp_pdev,
  848. replenish.free_list,
  849. num_alloc_desc);
  850. } else
  851. dp_err_rl("%pK: no free rx_descs in freelist", dp_soc);
  852. }
  853. if (qdf_unlikely(!num_req_buffers)) {
  854. num_desc_to_free = num_req_buffers;
  855. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  856. goto free_descs;
  857. }
  858. /*
  859. * if desc_list is NULL, allocate the descs from freelist
  860. */
  861. if (!(*desc_list)) {
  862. num_alloc_desc = dp_rx_get_free_desc_list(dp_soc, mac_id,
  863. rx_desc_pool,
  864. num_req_buffers,
  865. desc_list,
  866. tail);
  867. if (!num_alloc_desc) {
  868. dp_rx_err("%pK: no free rx_descs in freelist", dp_soc);
  869. DP_STATS_INC(dp_pdev, err.desc_alloc_fail,
  870. num_req_buffers);
  871. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  872. return QDF_STATUS_E_NOMEM;
  873. }
  874. dp_verbose_debug("%pK: %d rx desc allocated", dp_soc,
  875. num_alloc_desc);
  876. num_req_buffers = num_alloc_desc;
  877. }
  878. count = 0;
  879. while (count < num_req_buffers) {
  880. /* Flag is set while pdev rx_desc_pool initialization */
  881. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  882. ret = dp_pdev_frag_alloc_and_map(dp_soc,
  883. &nbuf_frag_info,
  884. dp_pdev,
  885. rx_desc_pool);
  886. else
  887. ret = dp_pdev_nbuf_alloc_and_map_replenish(dp_soc,
  888. mac_id,
  889. num_entries_avail, &nbuf_frag_info,
  890. dp_pdev, rx_desc_pool);
  891. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  892. if (qdf_unlikely(ret == QDF_STATUS_E_FAULT))
  893. continue;
  894. break;
  895. }
  896. count++;
  897. rxdma_ring_entry = hal_srng_src_get_next(dp_soc->hal_soc,
  898. rxdma_srng);
  899. qdf_assert_always(rxdma_ring_entry);
  900. next = (*desc_list)->next;
  901. /* Flag is set while pdev rx_desc_pool initialization */
  902. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  903. dp_rx_desc_frag_prep(&((*desc_list)->rx_desc),
  904. &nbuf_frag_info);
  905. else
  906. dp_rx_desc_prep(&((*desc_list)->rx_desc),
  907. &nbuf_frag_info);
  908. /* rx_desc.in_use should be zero at this time*/
  909. qdf_assert_always((*desc_list)->rx_desc.in_use == 0);
  910. (*desc_list)->rx_desc.in_use = 1;
  911. (*desc_list)->rx_desc.in_err_state = 0;
  912. dp_rx_desc_update_dbg_info(&(*desc_list)->rx_desc,
  913. func_name, RX_DESC_REPLENISHED);
  914. dp_verbose_debug("rx_netbuf=%pK, paddr=0x%llx, cookie=%d",
  915. nbuf_frag_info.virt_addr.nbuf,
  916. (unsigned long long)(nbuf_frag_info.paddr),
  917. (*desc_list)->rx_desc.cookie);
  918. hal_rxdma_buff_addr_info_set(dp_soc->hal_soc, rxdma_ring_entry,
  919. nbuf_frag_info.paddr,
  920. (*desc_list)->rx_desc.cookie,
  921. rx_desc_pool->owner);
  922. *desc_list = next;
  923. }
  924. dp_rx_refill_ring_record_entry(dp_soc, dp_pdev->lmac_id, rxdma_srng,
  925. num_req_buffers, count);
  926. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  927. dp_rx_schedule_refill_thread(dp_soc);
  928. dp_verbose_debug("replenished buffers %d, rx desc added back to free list %u",
  929. count, num_desc_to_free);
  930. /* No need to count the number of bytes received during replenish.
  931. * Therefore set replenish.pkts.bytes as 0.
  932. */
  933. DP_STATS_INC_PKT(dp_pdev, replenish.pkts, count, 0);
  934. DP_STATS_INC(dp_pdev, replenish.free_list, num_req_buffers - count);
  935. free_descs:
  936. DP_STATS_INC(dp_pdev, buf_freelist, num_desc_to_free);
  937. /*
  938. * add any available free desc back to the free list
  939. */
  940. if (*desc_list)
  941. dp_rx_add_desc_list_to_free_list(dp_soc, desc_list, tail,
  942. mac_id, rx_desc_pool);
  943. return QDF_STATUS_SUCCESS;
  944. }
  945. qdf_export_symbol(__dp_rx_buffers_replenish);
  946. void
  947. dp_rx_deliver_raw(struct dp_vdev *vdev, qdf_nbuf_t nbuf_list,
  948. struct dp_txrx_peer *txrx_peer, uint8_t link_id)
  949. {
  950. qdf_nbuf_t deliver_list_head = NULL;
  951. qdf_nbuf_t deliver_list_tail = NULL;
  952. qdf_nbuf_t nbuf;
  953. nbuf = nbuf_list;
  954. while (nbuf) {
  955. qdf_nbuf_t next = qdf_nbuf_next(nbuf);
  956. DP_RX_LIST_APPEND(deliver_list_head, deliver_list_tail, nbuf);
  957. DP_STATS_INC(vdev->pdev, rx_raw_pkts, 1);
  958. DP_PEER_PER_PKT_STATS_INC_PKT(txrx_peer, rx.raw, 1,
  959. qdf_nbuf_len(nbuf), link_id);
  960. nbuf = next;
  961. }
  962. vdev->osif_rsim_rx_decap(vdev->osif_vdev, &deliver_list_head,
  963. &deliver_list_tail);
  964. vdev->osif_rx(vdev->osif_vdev, deliver_list_head);
  965. }
  966. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  967. #ifndef FEATURE_WDS
  968. void dp_rx_da_learn(struct dp_soc *soc, uint8_t *rx_tlv_hdr,
  969. struct dp_txrx_peer *ta_peer, qdf_nbuf_t nbuf)
  970. {
  971. }
  972. #endif
  973. #ifdef QCA_SUPPORT_TX_MIN_RATES_FOR_SPECIAL_FRAMES
  974. /**
  975. * dp_classify_critical_pkts() - API for marking critical packets
  976. * @soc: dp_soc context
  977. * @vdev: vdev on which packet is to be sent
  978. * @nbuf: nbuf that has to be classified
  979. *
  980. * The function parses the packet, identifies whether its a critical frame and
  981. * marks QDF_NBUF_CB_TX_EXTRA_IS_CRITICAL bit in qdf_nbuf_cb for the nbuf.
  982. * Code for marking which frames are CRITICAL is accessed via callback.
  983. * EAPOL, ARP, DHCP, DHCPv6, ICMPv6 NS/NA are the typical critical frames.
  984. *
  985. * Return: None
  986. */
  987. static
  988. void dp_classify_critical_pkts(struct dp_soc *soc, struct dp_vdev *vdev,
  989. qdf_nbuf_t nbuf)
  990. {
  991. if (vdev->tx_classify_critical_pkt_cb)
  992. vdev->tx_classify_critical_pkt_cb(vdev->osif_vdev, nbuf);
  993. }
  994. #else
  995. static inline
  996. void dp_classify_critical_pkts(struct dp_soc *soc, struct dp_vdev *vdev,
  997. qdf_nbuf_t nbuf)
  998. {
  999. }
  1000. #endif
  1001. #ifdef QCA_OL_TX_MULTIQ_SUPPORT
  1002. static inline
  1003. void dp_rx_nbuf_queue_mapping_set(qdf_nbuf_t nbuf, uint8_t ring_id)
  1004. {
  1005. qdf_nbuf_set_queue_mapping(nbuf, ring_id);
  1006. }
  1007. #else
  1008. static inline
  1009. void dp_rx_nbuf_queue_mapping_set(qdf_nbuf_t nbuf, uint8_t ring_id)
  1010. {
  1011. }
  1012. #endif
  1013. bool dp_rx_intrabss_mcbc_fwd(struct dp_soc *soc, struct dp_txrx_peer *ta_peer,
  1014. uint8_t *rx_tlv_hdr, qdf_nbuf_t nbuf,
  1015. struct cdp_tid_rx_stats *tid_stats,
  1016. uint8_t link_id)
  1017. {
  1018. uint16_t len;
  1019. qdf_nbuf_t nbuf_copy;
  1020. if (dp_rx_intrabss_eapol_drop_check(soc, ta_peer, rx_tlv_hdr,
  1021. nbuf))
  1022. return true;
  1023. if (!dp_rx_check_ndi_mdns_fwding(ta_peer, nbuf, link_id))
  1024. return false;
  1025. /* If the source peer in the isolation list
  1026. * then dont forward instead push to bridge stack
  1027. */
  1028. if (dp_get_peer_isolation(ta_peer))
  1029. return false;
  1030. nbuf_copy = qdf_nbuf_copy(nbuf);
  1031. if (!nbuf_copy)
  1032. return false;
  1033. len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  1034. qdf_mem_set(nbuf_copy->cb, 0x0, sizeof(nbuf_copy->cb));
  1035. dp_classify_critical_pkts(soc, ta_peer->vdev, nbuf_copy);
  1036. if (soc->arch_ops.dp_rx_intrabss_mcast_handler(soc, ta_peer,
  1037. nbuf_copy,
  1038. tid_stats,
  1039. link_id))
  1040. return false;
  1041. /* Don't send packets if tx is paused */
  1042. if (!soc->is_tx_pause &&
  1043. !dp_tx_send((struct cdp_soc_t *)soc,
  1044. ta_peer->vdev->vdev_id, nbuf_copy)) {
  1045. DP_PEER_PER_PKT_STATS_INC_PKT(ta_peer, rx.intra_bss.pkts, 1,
  1046. len, link_id);
  1047. tid_stats->intrabss_cnt++;
  1048. } else {
  1049. DP_PEER_PER_PKT_STATS_INC_PKT(ta_peer, rx.intra_bss.fail, 1,
  1050. len, link_id);
  1051. tid_stats->fail_cnt[INTRABSS_DROP]++;
  1052. dp_rx_nbuf_free(nbuf_copy);
  1053. }
  1054. return false;
  1055. }
  1056. bool dp_rx_intrabss_ucast_fwd(struct dp_soc *soc, struct dp_txrx_peer *ta_peer,
  1057. uint8_t tx_vdev_id,
  1058. uint8_t *rx_tlv_hdr, qdf_nbuf_t nbuf,
  1059. struct cdp_tid_rx_stats *tid_stats,
  1060. uint8_t link_id)
  1061. {
  1062. uint16_t len;
  1063. len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  1064. /* linearize the nbuf just before we send to
  1065. * dp_tx_send()
  1066. */
  1067. if (qdf_unlikely(qdf_nbuf_is_frag(nbuf))) {
  1068. if (qdf_nbuf_linearize(nbuf) == -ENOMEM)
  1069. return false;
  1070. nbuf = qdf_nbuf_unshare(nbuf);
  1071. if (!nbuf) {
  1072. DP_PEER_PER_PKT_STATS_INC_PKT(ta_peer,
  1073. rx.intra_bss.fail,
  1074. 1, len, link_id);
  1075. /* return true even though the pkt is
  1076. * not forwarded. Basically skb_unshare
  1077. * failed and we want to continue with
  1078. * next nbuf.
  1079. */
  1080. tid_stats->fail_cnt[INTRABSS_DROP]++;
  1081. return false;
  1082. }
  1083. }
  1084. qdf_mem_set(nbuf->cb, 0x0, sizeof(nbuf->cb));
  1085. dp_classify_critical_pkts(soc, ta_peer->vdev, nbuf);
  1086. /* Don't send packets if tx is paused */
  1087. if (!soc->is_tx_pause && !dp_tx_send((struct cdp_soc_t *)soc,
  1088. tx_vdev_id, nbuf)) {
  1089. DP_PEER_PER_PKT_STATS_INC_PKT(ta_peer, rx.intra_bss.pkts, 1,
  1090. len, link_id);
  1091. } else {
  1092. DP_PEER_PER_PKT_STATS_INC_PKT(ta_peer, rx.intra_bss.fail, 1,
  1093. len, link_id);
  1094. tid_stats->fail_cnt[INTRABSS_DROP]++;
  1095. return false;
  1096. }
  1097. return true;
  1098. }
  1099. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  1100. #ifdef MESH_MODE_SUPPORT
  1101. void dp_rx_fill_mesh_stats(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  1102. uint8_t *rx_tlv_hdr,
  1103. struct dp_txrx_peer *txrx_peer)
  1104. {
  1105. struct mesh_recv_hdr_s *rx_info = NULL;
  1106. uint32_t pkt_type;
  1107. uint32_t nss;
  1108. uint32_t rate_mcs;
  1109. uint32_t bw;
  1110. uint8_t primary_chan_num;
  1111. uint32_t center_chan_freq;
  1112. struct dp_soc *soc = vdev->pdev->soc;
  1113. struct dp_peer *peer;
  1114. struct dp_peer *primary_link_peer;
  1115. struct dp_soc *link_peer_soc;
  1116. cdp_peer_stats_param_t buf = {0};
  1117. /* fill recv mesh stats */
  1118. rx_info = qdf_mem_malloc(sizeof(struct mesh_recv_hdr_s));
  1119. /* upper layers are responsible to free this memory */
  1120. if (!rx_info) {
  1121. dp_rx_err("%pK: Memory allocation failed for mesh rx stats",
  1122. vdev->pdev->soc);
  1123. DP_STATS_INC(vdev->pdev, mesh_mem_alloc, 1);
  1124. return;
  1125. }
  1126. rx_info->rs_flags = MESH_RXHDR_VER1;
  1127. if (qdf_nbuf_is_rx_chfrag_start(nbuf))
  1128. rx_info->rs_flags |= MESH_RX_FIRST_MSDU;
  1129. if (qdf_nbuf_is_rx_chfrag_end(nbuf))
  1130. rx_info->rs_flags |= MESH_RX_LAST_MSDU;
  1131. peer = dp_peer_get_ref_by_id(soc, txrx_peer->peer_id, DP_MOD_ID_MESH);
  1132. if (peer) {
  1133. if (hal_rx_tlv_get_is_decrypted(soc->hal_soc, rx_tlv_hdr)) {
  1134. rx_info->rs_flags |= MESH_RX_DECRYPTED;
  1135. rx_info->rs_keyix = hal_rx_msdu_get_keyid(soc->hal_soc,
  1136. rx_tlv_hdr);
  1137. if (vdev->osif_get_key)
  1138. vdev->osif_get_key(vdev->osif_vdev,
  1139. &rx_info->rs_decryptkey[0],
  1140. &peer->mac_addr.raw[0],
  1141. rx_info->rs_keyix);
  1142. }
  1143. dp_peer_unref_delete(peer, DP_MOD_ID_MESH);
  1144. }
  1145. primary_link_peer = dp_get_primary_link_peer_by_id(soc,
  1146. txrx_peer->peer_id,
  1147. DP_MOD_ID_MESH);
  1148. if (qdf_likely(primary_link_peer)) {
  1149. link_peer_soc = primary_link_peer->vdev->pdev->soc;
  1150. dp_monitor_peer_get_stats_param(link_peer_soc,
  1151. primary_link_peer,
  1152. cdp_peer_rx_snr, &buf);
  1153. rx_info->rs_snr = buf.rx_snr;
  1154. dp_peer_unref_delete(primary_link_peer, DP_MOD_ID_MESH);
  1155. }
  1156. rx_info->rs_rssi = rx_info->rs_snr + DP_DEFAULT_NOISEFLOOR;
  1157. soc = vdev->pdev->soc;
  1158. primary_chan_num = hal_rx_tlv_get_freq(soc->hal_soc, rx_tlv_hdr);
  1159. center_chan_freq = hal_rx_tlv_get_freq(soc->hal_soc, rx_tlv_hdr) >> 16;
  1160. if (soc->cdp_soc.ol_ops && soc->cdp_soc.ol_ops->freq_to_band) {
  1161. rx_info->rs_band = soc->cdp_soc.ol_ops->freq_to_band(
  1162. soc->ctrl_psoc,
  1163. vdev->pdev->pdev_id,
  1164. center_chan_freq);
  1165. }
  1166. rx_info->rs_channel = primary_chan_num;
  1167. pkt_type = hal_rx_tlv_get_pkt_type(soc->hal_soc, rx_tlv_hdr);
  1168. rate_mcs = hal_rx_tlv_rate_mcs_get(soc->hal_soc, rx_tlv_hdr);
  1169. bw = hal_rx_tlv_bw_get(soc->hal_soc, rx_tlv_hdr);
  1170. nss = hal_rx_msdu_start_nss_get(soc->hal_soc, rx_tlv_hdr);
  1171. /*
  1172. * The MCS index does not start with 0 when NSS>1 in HT mode.
  1173. * MCS params for optional 20/40MHz, NSS=1~3, EQM(NSS>1):
  1174. * ------------------------------------------------------
  1175. * NSS | 1 | 2 | 3 | 4
  1176. * ------------------------------------------------------
  1177. * MCS index: HT20 | 0 ~ 7 | 8 ~ 15 | 16 ~ 23 | 24 ~ 31
  1178. * ------------------------------------------------------
  1179. * MCS index: HT40 | 0 ~ 7 | 8 ~ 15 | 16 ~ 23 | 24 ~ 31
  1180. * ------------------------------------------------------
  1181. * Currently, the MAX_NSS=2. If NSS>2, MCS index = 8 * (NSS-1)
  1182. */
  1183. if ((pkt_type == DOT11_N) && (nss == 2))
  1184. rate_mcs += 8;
  1185. rx_info->rs_ratephy1 = rate_mcs | (nss << 0x8) | (pkt_type << 16) |
  1186. (bw << 24);
  1187. qdf_nbuf_set_rx_fctx_type(nbuf, (void *)rx_info, CB_FTYPE_MESH_RX_INFO);
  1188. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_INFO_MED,
  1189. FL("Mesh rx stats: flags %x, rssi %x, chn %x, rate %x, kix %x, snr %x"),
  1190. rx_info->rs_flags,
  1191. rx_info->rs_rssi,
  1192. rx_info->rs_channel,
  1193. rx_info->rs_ratephy1,
  1194. rx_info->rs_keyix,
  1195. rx_info->rs_snr);
  1196. }
  1197. QDF_STATUS dp_rx_filter_mesh_packets(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  1198. uint8_t *rx_tlv_hdr)
  1199. {
  1200. union dp_align_mac_addr mac_addr;
  1201. struct dp_soc *soc = vdev->pdev->soc;
  1202. if (qdf_unlikely(vdev->mesh_rx_filter)) {
  1203. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_FROMDS)
  1204. if (hal_rx_mpdu_get_fr_ds(soc->hal_soc,
  1205. rx_tlv_hdr))
  1206. return QDF_STATUS_SUCCESS;
  1207. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_TODS)
  1208. if (hal_rx_mpdu_get_to_ds(soc->hal_soc,
  1209. rx_tlv_hdr))
  1210. return QDF_STATUS_SUCCESS;
  1211. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_NODS)
  1212. if (!hal_rx_mpdu_get_fr_ds(soc->hal_soc,
  1213. rx_tlv_hdr) &&
  1214. !hal_rx_mpdu_get_to_ds(soc->hal_soc,
  1215. rx_tlv_hdr))
  1216. return QDF_STATUS_SUCCESS;
  1217. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_RA) {
  1218. if (hal_rx_mpdu_get_addr1(soc->hal_soc,
  1219. rx_tlv_hdr,
  1220. &mac_addr.raw[0]))
  1221. return QDF_STATUS_E_FAILURE;
  1222. if (!qdf_mem_cmp(&mac_addr.raw[0],
  1223. &vdev->mac_addr.raw[0],
  1224. QDF_MAC_ADDR_SIZE))
  1225. return QDF_STATUS_SUCCESS;
  1226. }
  1227. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_TA) {
  1228. if (hal_rx_mpdu_get_addr2(soc->hal_soc,
  1229. rx_tlv_hdr,
  1230. &mac_addr.raw[0]))
  1231. return QDF_STATUS_E_FAILURE;
  1232. if (!qdf_mem_cmp(&mac_addr.raw[0],
  1233. &vdev->mac_addr.raw[0],
  1234. QDF_MAC_ADDR_SIZE))
  1235. return QDF_STATUS_SUCCESS;
  1236. }
  1237. }
  1238. return QDF_STATUS_E_FAILURE;
  1239. }
  1240. #else
  1241. void dp_rx_fill_mesh_stats(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  1242. uint8_t *rx_tlv_hdr, struct dp_txrx_peer *peer)
  1243. {
  1244. }
  1245. QDF_STATUS dp_rx_filter_mesh_packets(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  1246. uint8_t *rx_tlv_hdr)
  1247. {
  1248. return QDF_STATUS_E_FAILURE;
  1249. }
  1250. #endif
  1251. #ifdef RX_PEER_INVALID_ENH
  1252. uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu,
  1253. uint8_t mac_id)
  1254. {
  1255. struct dp_invalid_peer_msg msg;
  1256. struct dp_vdev *vdev = NULL;
  1257. struct dp_pdev *pdev = NULL;
  1258. struct ieee80211_frame *wh;
  1259. qdf_nbuf_t curr_nbuf, next_nbuf;
  1260. uint8_t *rx_tlv_hdr = qdf_nbuf_data(mpdu);
  1261. uint8_t *rx_pkt_hdr = NULL;
  1262. int i = 0;
  1263. uint32_t nbuf_len;
  1264. if (!HAL_IS_DECAP_FORMAT_RAW(soc->hal_soc, rx_tlv_hdr)) {
  1265. dp_rx_debug("%pK: Drop decapped frames", soc);
  1266. goto free;
  1267. }
  1268. /* In RAW packet, packet header will be part of data */
  1269. rx_pkt_hdr = rx_tlv_hdr + soc->rx_pkt_tlv_size;
  1270. wh = (struct ieee80211_frame *)rx_pkt_hdr;
  1271. if (!DP_FRAME_IS_DATA(wh)) {
  1272. dp_rx_debug("%pK: NAWDS valid only for data frames", soc);
  1273. goto free;
  1274. }
  1275. nbuf_len = qdf_nbuf_len(mpdu);
  1276. if (nbuf_len < sizeof(struct ieee80211_frame)) {
  1277. dp_rx_err("%pK: Invalid nbuf length: %u", soc, nbuf_len);
  1278. goto free;
  1279. }
  1280. /* In DMAC case the rx_desc_pools are common across PDEVs
  1281. * so PDEV cannot be derived from the pool_id.
  1282. *
  1283. * link_id need to derived from the TLV tag word which is
  1284. * disabled by default. For now adding a WAR to get vdev
  1285. * with brute force this need to fixed with word based subscription
  1286. * support is added by enabling TLV tag word
  1287. */
  1288. if (soc->features.dmac_cmn_src_rxbuf_ring_enabled) {
  1289. for (i = 0; i < MAX_PDEV_CNT; i++) {
  1290. pdev = soc->pdev_list[i];
  1291. if (!pdev || qdf_unlikely(pdev->is_pdev_down))
  1292. continue;
  1293. TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) {
  1294. if (qdf_mem_cmp(wh->i_addr1, vdev->mac_addr.raw,
  1295. QDF_MAC_ADDR_SIZE) == 0) {
  1296. goto out;
  1297. }
  1298. }
  1299. }
  1300. } else {
  1301. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1302. if (!pdev || qdf_unlikely(pdev->is_pdev_down)) {
  1303. dp_rx_err("%pK: PDEV %s",
  1304. soc, !pdev ? "not found" : "down");
  1305. goto free;
  1306. }
  1307. if (dp_monitor_filter_neighbour_peer(pdev, rx_pkt_hdr) ==
  1308. QDF_STATUS_SUCCESS)
  1309. return 0;
  1310. TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) {
  1311. if (qdf_mem_cmp(wh->i_addr1, vdev->mac_addr.raw,
  1312. QDF_MAC_ADDR_SIZE) == 0) {
  1313. goto out;
  1314. }
  1315. }
  1316. }
  1317. if (!vdev) {
  1318. dp_rx_err("%pK: VDEV not found", soc);
  1319. goto free;
  1320. }
  1321. out:
  1322. msg.wh = wh;
  1323. qdf_nbuf_pull_head(mpdu, soc->rx_pkt_tlv_size);
  1324. msg.nbuf = mpdu;
  1325. msg.vdev_id = vdev->vdev_id;
  1326. /*
  1327. * NOTE: Only valid for HKv1.
  1328. * If smart monitor mode is enabled on RE, we are getting invalid
  1329. * peer frames with RA as STA mac of RE and the TA not matching
  1330. * with any NAC list or the the BSSID.Such frames need to dropped
  1331. * in order to avoid HM_WDS false addition.
  1332. */
  1333. if (pdev->soc->cdp_soc.ol_ops->rx_invalid_peer) {
  1334. if (dp_monitor_drop_inv_peer_pkts(vdev) == QDF_STATUS_SUCCESS) {
  1335. dp_rx_warn("%pK: Drop inv peer pkts with STA RA:%pm",
  1336. soc, wh->i_addr1);
  1337. goto free;
  1338. }
  1339. pdev->soc->cdp_soc.ol_ops->rx_invalid_peer(
  1340. (struct cdp_ctrl_objmgr_psoc *)soc->ctrl_psoc,
  1341. pdev->pdev_id, &msg);
  1342. }
  1343. free:
  1344. /* Drop and free packet */
  1345. curr_nbuf = mpdu;
  1346. while (curr_nbuf) {
  1347. next_nbuf = qdf_nbuf_next(curr_nbuf);
  1348. dp_rx_nbuf_free(curr_nbuf);
  1349. curr_nbuf = next_nbuf;
  1350. }
  1351. return 0;
  1352. }
  1353. void dp_rx_process_invalid_peer_wrapper(struct dp_soc *soc,
  1354. qdf_nbuf_t mpdu, bool mpdu_done,
  1355. uint8_t mac_id)
  1356. {
  1357. /* Only trigger the process when mpdu is completed */
  1358. if (mpdu_done)
  1359. dp_rx_process_invalid_peer(soc, mpdu, mac_id);
  1360. }
  1361. #else
  1362. uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu,
  1363. uint8_t mac_id)
  1364. {
  1365. qdf_nbuf_t curr_nbuf, next_nbuf;
  1366. struct dp_pdev *pdev;
  1367. struct dp_vdev *vdev = NULL;
  1368. struct ieee80211_frame *wh;
  1369. struct dp_peer *peer = NULL;
  1370. uint8_t *rx_tlv_hdr = qdf_nbuf_data(mpdu);
  1371. uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(soc->hal_soc, rx_tlv_hdr);
  1372. uint32_t nbuf_len;
  1373. wh = (struct ieee80211_frame *)rx_pkt_hdr;
  1374. if (!DP_FRAME_IS_DATA(wh)) {
  1375. QDF_TRACE_ERROR_RL(QDF_MODULE_ID_DP,
  1376. "only for data frames");
  1377. goto free;
  1378. }
  1379. nbuf_len = qdf_nbuf_len(mpdu);
  1380. if (nbuf_len < sizeof(struct ieee80211_frame)) {
  1381. dp_rx_info_rl("%pK: Invalid nbuf length: %u", soc, nbuf_len);
  1382. goto free;
  1383. }
  1384. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1385. if (!pdev) {
  1386. dp_rx_info_rl("%pK: PDEV not found", soc);
  1387. goto free;
  1388. }
  1389. qdf_spin_lock_bh(&pdev->vdev_list_lock);
  1390. DP_PDEV_ITERATE_VDEV_LIST(pdev, vdev) {
  1391. if (qdf_mem_cmp(wh->i_addr1, vdev->mac_addr.raw,
  1392. QDF_MAC_ADDR_SIZE) == 0) {
  1393. qdf_spin_unlock_bh(&pdev->vdev_list_lock);
  1394. goto out;
  1395. }
  1396. }
  1397. qdf_spin_unlock_bh(&pdev->vdev_list_lock);
  1398. if (!vdev) {
  1399. dp_rx_info_rl("%pK: VDEV not found", soc);
  1400. goto free;
  1401. }
  1402. out:
  1403. if (vdev->opmode == wlan_op_mode_ap) {
  1404. peer = dp_peer_find_hash_find(soc, wh->i_addr2, 0,
  1405. vdev->vdev_id,
  1406. DP_MOD_ID_RX_ERR);
  1407. /* If SA is a valid peer in vdev,
  1408. * don't send disconnect
  1409. */
  1410. if (peer) {
  1411. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  1412. DP_STATS_INC(soc, rx.err.decrypt_err_drop, 1);
  1413. dp_err_rl("invalid peer frame with correct SA/RA is freed");
  1414. goto free;
  1415. }
  1416. }
  1417. if (soc->cdp_soc.ol_ops->rx_invalid_peer)
  1418. soc->cdp_soc.ol_ops->rx_invalid_peer(vdev->vdev_id, wh);
  1419. free:
  1420. /* Drop and free packet */
  1421. curr_nbuf = mpdu;
  1422. while (curr_nbuf) {
  1423. next_nbuf = qdf_nbuf_next(curr_nbuf);
  1424. dp_rx_nbuf_free(curr_nbuf);
  1425. curr_nbuf = next_nbuf;
  1426. }
  1427. /* Reset the head and tail pointers */
  1428. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1429. if (pdev) {
  1430. pdev->invalid_peer_head_msdu = NULL;
  1431. pdev->invalid_peer_tail_msdu = NULL;
  1432. }
  1433. return 0;
  1434. }
  1435. void dp_rx_process_invalid_peer_wrapper(struct dp_soc *soc,
  1436. qdf_nbuf_t mpdu, bool mpdu_done,
  1437. uint8_t mac_id)
  1438. {
  1439. /* Process the nbuf */
  1440. dp_rx_process_invalid_peer(soc, mpdu, mac_id);
  1441. }
  1442. #endif
  1443. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  1444. #ifdef RECEIVE_OFFLOAD
  1445. /**
  1446. * dp_rx_print_offload_info() - Print offload info from RX TLV
  1447. * @soc: dp soc handle
  1448. * @msdu: MSDU for which the offload info is to be printed
  1449. * @ofl_info: offload info saved in hal_offload_info structure
  1450. *
  1451. * Return: None
  1452. */
  1453. static void dp_rx_print_offload_info(struct dp_soc *soc,
  1454. qdf_nbuf_t msdu,
  1455. struct hal_offload_info *ofl_info)
  1456. {
  1457. dp_verbose_debug("----------------------RX DESC LRO/GRO----------------------");
  1458. dp_verbose_debug("lro_eligible 0x%x",
  1459. QDF_NBUF_CB_RX_LRO_ELIGIBLE(msdu));
  1460. dp_verbose_debug("pure_ack 0x%x", QDF_NBUF_CB_RX_TCP_PURE_ACK(msdu));
  1461. dp_verbose_debug("chksum 0x%x", QDF_NBUF_CB_RX_TCP_CHKSUM(msdu));
  1462. dp_verbose_debug("TCP seq num 0x%x", ofl_info->tcp_seq_num);
  1463. dp_verbose_debug("TCP ack num 0x%x", ofl_info->tcp_ack_num);
  1464. dp_verbose_debug("TCP window 0x%x", QDF_NBUF_CB_RX_TCP_WIN(msdu));
  1465. dp_verbose_debug("TCP protocol 0x%x", QDF_NBUF_CB_RX_TCP_PROTO(msdu));
  1466. dp_verbose_debug("TCP offset 0x%x", QDF_NBUF_CB_RX_TCP_OFFSET(msdu));
  1467. dp_verbose_debug("toeplitz 0x%x", QDF_NBUF_CB_RX_FLOW_ID(msdu));
  1468. dp_verbose_debug("---------------------------------------------------------");
  1469. }
  1470. void dp_rx_fill_gro_info(struct dp_soc *soc, uint8_t *rx_tlv,
  1471. qdf_nbuf_t msdu, uint32_t *rx_ol_pkt_cnt)
  1472. {
  1473. struct hal_offload_info offload_info;
  1474. if (!wlan_cfg_is_gro_enabled(soc->wlan_cfg_ctx))
  1475. return;
  1476. if (hal_rx_tlv_get_offload_info(soc->hal_soc, rx_tlv, &offload_info))
  1477. return;
  1478. *rx_ol_pkt_cnt = *rx_ol_pkt_cnt + 1;
  1479. QDF_NBUF_CB_RX_LRO_ELIGIBLE(msdu) = offload_info.lro_eligible;
  1480. QDF_NBUF_CB_RX_TCP_PURE_ACK(msdu) = offload_info.tcp_pure_ack;
  1481. QDF_NBUF_CB_RX_TCP_CHKSUM(msdu) =
  1482. hal_rx_tlv_get_tcp_chksum(soc->hal_soc,
  1483. rx_tlv);
  1484. QDF_NBUF_CB_RX_TCP_WIN(msdu) = offload_info.tcp_win;
  1485. QDF_NBUF_CB_RX_TCP_PROTO(msdu) = offload_info.tcp_proto;
  1486. QDF_NBUF_CB_RX_IPV6_PROTO(msdu) = offload_info.ipv6_proto;
  1487. QDF_NBUF_CB_RX_TCP_OFFSET(msdu) = offload_info.tcp_offset;
  1488. QDF_NBUF_CB_RX_FLOW_ID(msdu) = offload_info.flow_id;
  1489. dp_rx_print_offload_info(soc, msdu, &offload_info);
  1490. }
  1491. #endif /* RECEIVE_OFFLOAD */
  1492. /**
  1493. * dp_rx_adjust_nbuf_len() - set appropriate msdu length in nbuf.
  1494. *
  1495. * @soc: DP soc handle
  1496. * @nbuf: pointer to msdu.
  1497. * @mpdu_len: mpdu length
  1498. * @l3_pad_len: L3 padding length by HW
  1499. *
  1500. * Return: returns true if nbuf is last msdu of mpdu else returns false.
  1501. */
  1502. static inline bool dp_rx_adjust_nbuf_len(struct dp_soc *soc,
  1503. qdf_nbuf_t nbuf,
  1504. uint16_t *mpdu_len,
  1505. uint32_t l3_pad_len)
  1506. {
  1507. bool last_nbuf;
  1508. uint32_t pkt_hdr_size;
  1509. uint16_t buf_size;
  1510. buf_size = wlan_cfg_rx_buffer_size(soc->wlan_cfg_ctx);
  1511. pkt_hdr_size = soc->rx_pkt_tlv_size + l3_pad_len;
  1512. if ((*mpdu_len + pkt_hdr_size) > buf_size) {
  1513. qdf_nbuf_set_pktlen(nbuf, buf_size);
  1514. last_nbuf = false;
  1515. *mpdu_len -= (buf_size - pkt_hdr_size);
  1516. } else {
  1517. qdf_nbuf_set_pktlen(nbuf, (*mpdu_len + pkt_hdr_size));
  1518. last_nbuf = true;
  1519. *mpdu_len = 0;
  1520. }
  1521. return last_nbuf;
  1522. }
  1523. /**
  1524. * dp_get_l3_hdr_pad_len() - get L3 header padding length.
  1525. *
  1526. * @soc: DP soc handle
  1527. * @nbuf: pointer to msdu.
  1528. *
  1529. * Return: returns padding length in bytes.
  1530. */
  1531. static inline uint32_t dp_get_l3_hdr_pad_len(struct dp_soc *soc,
  1532. qdf_nbuf_t nbuf)
  1533. {
  1534. uint32_t l3_hdr_pad = 0;
  1535. uint8_t *rx_tlv_hdr;
  1536. struct hal_rx_msdu_metadata msdu_metadata;
  1537. while (nbuf) {
  1538. if (!qdf_nbuf_is_rx_chfrag_cont(nbuf)) {
  1539. /* scattered msdu end with continuation is 0 */
  1540. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  1541. hal_rx_msdu_metadata_get(soc->hal_soc,
  1542. rx_tlv_hdr,
  1543. &msdu_metadata);
  1544. l3_hdr_pad = msdu_metadata.l3_hdr_pad;
  1545. break;
  1546. }
  1547. nbuf = nbuf->next;
  1548. }
  1549. return l3_hdr_pad;
  1550. }
  1551. qdf_nbuf_t dp_rx_sg_create(struct dp_soc *soc, qdf_nbuf_t nbuf)
  1552. {
  1553. qdf_nbuf_t parent, frag_list, frag_tail, next = NULL;
  1554. uint16_t frag_list_len = 0;
  1555. uint16_t mpdu_len;
  1556. bool last_nbuf;
  1557. uint32_t l3_hdr_pad_offset = 0;
  1558. /*
  1559. * Use msdu len got from REO entry descriptor instead since
  1560. * there is case the RX PKT TLV is corrupted while msdu_len
  1561. * from REO descriptor is right for non-raw RX scatter msdu.
  1562. */
  1563. mpdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  1564. /*
  1565. * If MSDU length of the first fragment is zero, need to
  1566. * use the length of the last fragment to overwrite.
  1567. */
  1568. if (!mpdu_len) {
  1569. frag_tail = nbuf;
  1570. while (frag_tail && qdf_nbuf_is_rx_chfrag_cont(frag_tail))
  1571. frag_tail = frag_tail->next;
  1572. if (frag_tail)
  1573. QDF_NBUF_CB_RX_PKT_LEN(nbuf) =
  1574. QDF_NBUF_CB_RX_PKT_LEN(frag_tail);
  1575. }
  1576. /*
  1577. * this is a case where the complete msdu fits in one single nbuf.
  1578. * in this case HW sets both start and end bit and we only need to
  1579. * reset these bits for RAW mode simulator to decap the pkt
  1580. */
  1581. if (qdf_nbuf_is_rx_chfrag_start(nbuf) &&
  1582. qdf_nbuf_is_rx_chfrag_end(nbuf)) {
  1583. qdf_nbuf_set_pktlen(nbuf, mpdu_len + soc->rx_pkt_tlv_size);
  1584. qdf_nbuf_pull_head(nbuf, soc->rx_pkt_tlv_size);
  1585. return nbuf;
  1586. }
  1587. l3_hdr_pad_offset = dp_get_l3_hdr_pad_len(soc, nbuf);
  1588. /*
  1589. * This is a case where we have multiple msdus (A-MSDU) spread across
  1590. * multiple nbufs. here we create a fraglist out of these nbufs.
  1591. *
  1592. * the moment we encounter a nbuf with continuation bit set we
  1593. * know for sure we have an MSDU which is spread across multiple
  1594. * nbufs. We loop through and reap nbufs till we reach last nbuf.
  1595. */
  1596. parent = nbuf;
  1597. frag_list = nbuf->next;
  1598. nbuf = nbuf->next;
  1599. /*
  1600. * set the start bit in the first nbuf we encounter with continuation
  1601. * bit set. This has the proper mpdu length set as it is the first
  1602. * msdu of the mpdu. this becomes the parent nbuf and the subsequent
  1603. * nbufs will form the frag_list of the parent nbuf.
  1604. */
  1605. qdf_nbuf_set_rx_chfrag_start(parent, 1);
  1606. /*
  1607. * L3 header padding is only needed for the 1st buffer
  1608. * in a scattered msdu
  1609. */
  1610. last_nbuf = dp_rx_adjust_nbuf_len(soc, parent, &mpdu_len,
  1611. l3_hdr_pad_offset);
  1612. /*
  1613. * MSDU cont bit is set but reported MPDU length can fit
  1614. * in to single buffer
  1615. *
  1616. * Increment error stats and avoid SG list creation
  1617. */
  1618. if (last_nbuf) {
  1619. DP_STATS_INC(soc, rx.err.msdu_continuation_err, 1);
  1620. qdf_nbuf_pull_head(parent,
  1621. soc->rx_pkt_tlv_size + l3_hdr_pad_offset);
  1622. return parent;
  1623. }
  1624. /*
  1625. * this is where we set the length of the fragments which are
  1626. * associated to the parent nbuf. We iterate through the frag_list
  1627. * till we hit the last_nbuf of the list.
  1628. */
  1629. do {
  1630. last_nbuf = dp_rx_adjust_nbuf_len(soc, nbuf, &mpdu_len, 0);
  1631. qdf_nbuf_pull_head(nbuf,
  1632. soc->rx_pkt_tlv_size);
  1633. frag_list_len += qdf_nbuf_len(nbuf);
  1634. if (last_nbuf) {
  1635. next = nbuf->next;
  1636. nbuf->next = NULL;
  1637. break;
  1638. } else if (qdf_nbuf_is_rx_chfrag_end(nbuf)) {
  1639. dp_err("Invalid packet length");
  1640. qdf_assert_always(0);
  1641. }
  1642. nbuf = nbuf->next;
  1643. } while (!last_nbuf);
  1644. qdf_nbuf_set_rx_chfrag_start(nbuf, 0);
  1645. qdf_nbuf_append_ext_list(parent, frag_list, frag_list_len);
  1646. parent->next = next;
  1647. qdf_nbuf_pull_head(parent,
  1648. soc->rx_pkt_tlv_size + l3_hdr_pad_offset);
  1649. return parent;
  1650. }
  1651. #ifdef DP_RX_SG_FRAME_SUPPORT
  1652. bool dp_rx_is_sg_supported(void)
  1653. {
  1654. return true;
  1655. }
  1656. #else
  1657. bool dp_rx_is_sg_supported(void)
  1658. {
  1659. return false;
  1660. }
  1661. #endif
  1662. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  1663. #ifdef QCA_PEER_EXT_STATS
  1664. void dp_rx_compute_tid_delay(struct cdp_delay_tid_stats *stats,
  1665. qdf_nbuf_t nbuf)
  1666. {
  1667. struct cdp_delay_rx_stats *rx_delay = &stats->rx_delay;
  1668. uint32_t to_stack = qdf_nbuf_get_timedelta_ms(nbuf);
  1669. dp_hist_update_stats(&rx_delay->to_stack_delay, to_stack);
  1670. }
  1671. #endif /* QCA_PEER_EXT_STATS */
  1672. void dp_rx_compute_delay(struct dp_vdev *vdev, qdf_nbuf_t nbuf)
  1673. {
  1674. uint8_t ring_id = QDF_NBUF_CB_RX_CTX_ID(nbuf);
  1675. int64_t current_ts = qdf_ktime_to_ms(qdf_ktime_get());
  1676. uint32_t to_stack = qdf_nbuf_get_timedelta_ms(nbuf);
  1677. uint8_t tid = qdf_nbuf_get_tid_val(nbuf);
  1678. uint32_t interframe_delay =
  1679. (uint32_t)(current_ts - vdev->prev_rx_deliver_tstamp);
  1680. struct cdp_tid_rx_stats *rstats =
  1681. &vdev->pdev->stats.tid_stats.tid_rx_stats[ring_id][tid];
  1682. dp_update_delay_stats(NULL, rstats, to_stack, tid,
  1683. CDP_DELAY_STATS_REAP_STACK, ring_id, false);
  1684. /*
  1685. * Update interframe delay stats calculated at deliver_data_ol point.
  1686. * Value of vdev->prev_rx_deliver_tstamp will be 0 for 1st frame, so
  1687. * interframe delay will not be calculate correctly for 1st frame.
  1688. * On the other side, this will help in avoiding extra per packet check
  1689. * of vdev->prev_rx_deliver_tstamp.
  1690. */
  1691. dp_update_delay_stats(NULL, rstats, interframe_delay, tid,
  1692. CDP_DELAY_STATS_RX_INTERFRAME, ring_id, false);
  1693. vdev->prev_rx_deliver_tstamp = current_ts;
  1694. }
  1695. /**
  1696. * dp_rx_drop_nbuf_list() - drop an nbuf list
  1697. * @pdev: dp pdev reference
  1698. * @buf_list: buffer list to be dropepd
  1699. *
  1700. * Return: int (number of bufs dropped)
  1701. */
  1702. static inline int dp_rx_drop_nbuf_list(struct dp_pdev *pdev,
  1703. qdf_nbuf_t buf_list)
  1704. {
  1705. struct cdp_tid_rx_stats *stats = NULL;
  1706. uint8_t tid = 0, ring_id = 0;
  1707. int num_dropped = 0;
  1708. qdf_nbuf_t buf, next_buf;
  1709. buf = buf_list;
  1710. while (buf) {
  1711. ring_id = QDF_NBUF_CB_RX_CTX_ID(buf);
  1712. next_buf = qdf_nbuf_queue_next(buf);
  1713. tid = qdf_nbuf_get_tid_val(buf);
  1714. if (qdf_likely(pdev)) {
  1715. stats = &pdev->stats.tid_stats.tid_rx_stats[ring_id][tid];
  1716. stats->fail_cnt[INVALID_PEER_VDEV]++;
  1717. stats->delivered_to_stack--;
  1718. }
  1719. dp_rx_nbuf_free(buf);
  1720. buf = next_buf;
  1721. num_dropped++;
  1722. }
  1723. return num_dropped;
  1724. }
  1725. #ifdef QCA_SUPPORT_WDS_EXTENDED
  1726. /**
  1727. * dp_rx_deliver_to_stack_ext() - Deliver to netdev per sta
  1728. * @soc: core txrx main context
  1729. * @vdev: vdev
  1730. * @txrx_peer: txrx peer
  1731. * @nbuf_head: skb list head
  1732. *
  1733. * Return: true if packet is delivered to netdev per STA.
  1734. */
  1735. bool
  1736. dp_rx_deliver_to_stack_ext(struct dp_soc *soc, struct dp_vdev *vdev,
  1737. struct dp_txrx_peer *txrx_peer, qdf_nbuf_t nbuf_head)
  1738. {
  1739. /*
  1740. * When extended WDS is disabled, frames are sent to AP netdevice.
  1741. */
  1742. if (qdf_likely(!vdev->wds_ext_enabled))
  1743. return false;
  1744. /*
  1745. * There can be 2 cases:
  1746. * 1. Send frame to parent netdev if its not for netdev per STA
  1747. * 2. If frame is meant for netdev per STA:
  1748. * a. Send frame to appropriate netdev using registered fp.
  1749. * b. If fp is NULL, drop the frames.
  1750. */
  1751. if (!txrx_peer->wds_ext.init)
  1752. return false;
  1753. if (txrx_peer->osif_rx)
  1754. txrx_peer->osif_rx(txrx_peer->wds_ext.osif_peer, nbuf_head);
  1755. else
  1756. dp_rx_drop_nbuf_list(vdev->pdev, nbuf_head);
  1757. return true;
  1758. }
  1759. #else
  1760. static inline bool
  1761. dp_rx_deliver_to_stack_ext(struct dp_soc *soc, struct dp_vdev *vdev,
  1762. struct dp_txrx_peer *txrx_peer, qdf_nbuf_t nbuf_head)
  1763. {
  1764. return false;
  1765. }
  1766. #endif
  1767. #ifdef PEER_CACHE_RX_PKTS
  1768. #if defined(WLAN_FEATURE_11BE_MLO) && defined(DP_MLO_LINK_STATS_SUPPORT)
  1769. /**
  1770. * dp_set_nbuf_band() - Set band in nbuf cb
  1771. * @peer: dp_peer
  1772. * @nbuf: nbuf
  1773. *
  1774. * Return: None
  1775. */
  1776. static inline void
  1777. dp_set_nbuf_band(struct dp_peer *peer, qdf_nbuf_t nbuf)
  1778. {
  1779. uint8_t link_id = 0;
  1780. link_id = dp_rx_get_stats_arr_idx_from_link_id(nbuf, peer->txrx_peer);
  1781. dp_rx_set_nbuf_band(nbuf, peer->txrx_peer, link_id);
  1782. }
  1783. #else
  1784. static inline void
  1785. dp_set_nbuf_band(struct dp_peer *peer, qdf_nbuf_t nbuf)
  1786. {
  1787. }
  1788. #endif
  1789. void dp_rx_flush_rx_cached(struct dp_peer *peer, bool drop)
  1790. {
  1791. struct dp_peer_cached_bufq *bufqi;
  1792. struct dp_rx_cached_buf *cache_buf = NULL;
  1793. ol_txrx_rx_fp data_rx = NULL;
  1794. int num_buff_elem;
  1795. QDF_STATUS status;
  1796. /*
  1797. * Flush dp cached frames only for mld peers and legacy peers, as
  1798. * link peers don't store cached frames
  1799. */
  1800. if (IS_MLO_DP_LINK_PEER(peer))
  1801. return;
  1802. if (!peer->txrx_peer) {
  1803. dp_err("txrx_peer NULL!! peer mac_addr("QDF_MAC_ADDR_FMT")",
  1804. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  1805. return;
  1806. }
  1807. if (qdf_atomic_inc_return(&peer->txrx_peer->flush_in_progress) > 1) {
  1808. qdf_atomic_dec(&peer->txrx_peer->flush_in_progress);
  1809. return;
  1810. }
  1811. qdf_spin_lock_bh(&peer->peer_info_lock);
  1812. if (peer->state >= OL_TXRX_PEER_STATE_CONN && peer->vdev->osif_rx)
  1813. data_rx = peer->vdev->osif_rx;
  1814. else
  1815. drop = true;
  1816. qdf_spin_unlock_bh(&peer->peer_info_lock);
  1817. bufqi = &peer->txrx_peer->bufq_info;
  1818. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1819. qdf_list_remove_front(&bufqi->cached_bufq,
  1820. (qdf_list_node_t **)&cache_buf);
  1821. while (cache_buf) {
  1822. num_buff_elem = QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(
  1823. cache_buf->buf);
  1824. bufqi->entries -= num_buff_elem;
  1825. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1826. if (drop) {
  1827. bufqi->dropped = dp_rx_drop_nbuf_list(peer->vdev->pdev,
  1828. cache_buf->buf);
  1829. } else {
  1830. dp_set_nbuf_band(peer, cache_buf->buf);
  1831. /* Flush the cached frames to OSIF DEV */
  1832. status = data_rx(peer->vdev->osif_vdev, cache_buf->buf);
  1833. if (status != QDF_STATUS_SUCCESS)
  1834. bufqi->dropped = dp_rx_drop_nbuf_list(
  1835. peer->vdev->pdev,
  1836. cache_buf->buf);
  1837. }
  1838. qdf_mem_free(cache_buf);
  1839. cache_buf = NULL;
  1840. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1841. qdf_list_remove_front(&bufqi->cached_bufq,
  1842. (qdf_list_node_t **)&cache_buf);
  1843. }
  1844. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1845. qdf_atomic_dec(&peer->txrx_peer->flush_in_progress);
  1846. }
  1847. /**
  1848. * dp_rx_enqueue_rx() - cache rx frames
  1849. * @peer: peer
  1850. * @txrx_peer: DP txrx_peer
  1851. * @rx_buf_list: cache buffer list
  1852. *
  1853. * Return: None
  1854. */
  1855. static QDF_STATUS
  1856. dp_rx_enqueue_rx(struct dp_peer *peer,
  1857. struct dp_txrx_peer *txrx_peer,
  1858. qdf_nbuf_t rx_buf_list)
  1859. {
  1860. struct dp_rx_cached_buf *cache_buf;
  1861. struct dp_peer_cached_bufq *bufqi = &txrx_peer->bufq_info;
  1862. int num_buff_elem;
  1863. QDF_STATUS ret = QDF_STATUS_SUCCESS;
  1864. struct dp_soc *soc = txrx_peer->vdev->pdev->soc;
  1865. struct dp_peer *ta_peer = NULL;
  1866. /*
  1867. * If peer id is invalid which likely peer map has not completed,
  1868. * then need caller provide dp_peer pointer, else it's ok to use
  1869. * txrx_peer->peer_id to get dp_peer.
  1870. */
  1871. if (peer) {
  1872. if (QDF_STATUS_SUCCESS ==
  1873. dp_peer_get_ref(soc, peer, DP_MOD_ID_RX))
  1874. ta_peer = peer;
  1875. } else {
  1876. ta_peer = dp_peer_get_ref_by_id(soc, txrx_peer->peer_id,
  1877. DP_MOD_ID_RX);
  1878. }
  1879. if (!ta_peer) {
  1880. bufqi->dropped = dp_rx_drop_nbuf_list(txrx_peer->vdev->pdev,
  1881. rx_buf_list);
  1882. return QDF_STATUS_E_INVAL;
  1883. }
  1884. dp_debug_rl("bufq->curr %d bufq->drops %d", bufqi->entries,
  1885. bufqi->dropped);
  1886. if (!ta_peer->valid) {
  1887. bufqi->dropped = dp_rx_drop_nbuf_list(txrx_peer->vdev->pdev,
  1888. rx_buf_list);
  1889. ret = QDF_STATUS_E_INVAL;
  1890. goto fail;
  1891. }
  1892. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1893. if (bufqi->entries >= bufqi->thresh) {
  1894. bufqi->dropped = dp_rx_drop_nbuf_list(txrx_peer->vdev->pdev,
  1895. rx_buf_list);
  1896. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1897. ret = QDF_STATUS_E_RESOURCES;
  1898. goto fail;
  1899. }
  1900. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1901. num_buff_elem = QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(rx_buf_list);
  1902. cache_buf = qdf_mem_malloc_atomic(sizeof(*cache_buf));
  1903. if (!cache_buf) {
  1904. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1905. "Failed to allocate buf to cache rx frames");
  1906. bufqi->dropped = dp_rx_drop_nbuf_list(txrx_peer->vdev->pdev,
  1907. rx_buf_list);
  1908. ret = QDF_STATUS_E_NOMEM;
  1909. goto fail;
  1910. }
  1911. cache_buf->buf = rx_buf_list;
  1912. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1913. qdf_list_insert_back(&bufqi->cached_bufq,
  1914. &cache_buf->node);
  1915. bufqi->entries += num_buff_elem;
  1916. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1917. fail:
  1918. dp_peer_unref_delete(ta_peer, DP_MOD_ID_RX);
  1919. return ret;
  1920. }
  1921. static inline
  1922. bool dp_rx_is_peer_cache_bufq_supported(void)
  1923. {
  1924. return true;
  1925. }
  1926. #else
  1927. static inline
  1928. bool dp_rx_is_peer_cache_bufq_supported(void)
  1929. {
  1930. return false;
  1931. }
  1932. static inline QDF_STATUS
  1933. dp_rx_enqueue_rx(struct dp_peer *peer,
  1934. struct dp_txrx_peer *txrx_peer,
  1935. qdf_nbuf_t rx_buf_list)
  1936. {
  1937. return QDF_STATUS_SUCCESS;
  1938. }
  1939. #endif
  1940. #ifndef DELIVERY_TO_STACK_STATUS_CHECK
  1941. /**
  1942. * dp_rx_check_delivery_to_stack() - Deliver pkts to network
  1943. * using the appropriate call back functions.
  1944. * @soc: soc
  1945. * @vdev: vdev
  1946. * @txrx_peer: peer
  1947. * @nbuf_head: skb list head
  1948. *
  1949. * Return: None
  1950. */
  1951. static void dp_rx_check_delivery_to_stack(struct dp_soc *soc,
  1952. struct dp_vdev *vdev,
  1953. struct dp_txrx_peer *txrx_peer,
  1954. qdf_nbuf_t nbuf_head)
  1955. {
  1956. if (qdf_unlikely(dp_rx_deliver_to_stack_ext(soc, vdev,
  1957. txrx_peer, nbuf_head)))
  1958. return;
  1959. /* Function pointer initialized only when FISA is enabled */
  1960. if (vdev->osif_fisa_rx)
  1961. /* on failure send it via regular path */
  1962. vdev->osif_fisa_rx(soc, vdev, nbuf_head);
  1963. else
  1964. vdev->osif_rx(vdev->osif_vdev, nbuf_head);
  1965. }
  1966. #else
  1967. /**
  1968. * dp_rx_check_delivery_to_stack() - Deliver pkts to network
  1969. * using the appropriate call back functions.
  1970. * @soc: soc
  1971. * @vdev: vdev
  1972. * @txrx_peer: txrx peer
  1973. * @nbuf_head: skb list head
  1974. *
  1975. * Check the return status of the call back function and drop
  1976. * the packets if the return status indicates a failure.
  1977. *
  1978. * Return: None
  1979. */
  1980. static void dp_rx_check_delivery_to_stack(struct dp_soc *soc,
  1981. struct dp_vdev *vdev,
  1982. struct dp_txrx_peer *txrx_peer,
  1983. qdf_nbuf_t nbuf_head)
  1984. {
  1985. int num_nbuf = 0;
  1986. QDF_STATUS ret_val = QDF_STATUS_E_FAILURE;
  1987. /* Function pointer initialized only when FISA is enabled */
  1988. if (vdev->osif_fisa_rx)
  1989. /* on failure send it via regular path */
  1990. ret_val = vdev->osif_fisa_rx(soc, vdev, nbuf_head);
  1991. else if (vdev->osif_rx)
  1992. ret_val = vdev->osif_rx(vdev->osif_vdev, nbuf_head);
  1993. if (!QDF_IS_STATUS_SUCCESS(ret_val)) {
  1994. num_nbuf = dp_rx_drop_nbuf_list(vdev->pdev, nbuf_head);
  1995. DP_STATS_INC(soc, rx.err.rejected, num_nbuf);
  1996. if (txrx_peer)
  1997. DP_PEER_STATS_FLAT_DEC(txrx_peer, to_stack.num,
  1998. num_nbuf);
  1999. }
  2000. }
  2001. #endif /* ifdef DELIVERY_TO_STACK_STATUS_CHECK */
  2002. /**
  2003. * dp_rx_validate_rx_callbacks() - validate rx callbacks
  2004. * @soc: DP soc
  2005. * @vdev: DP vdev handle
  2006. * @txrx_peer: pointer to the txrx peer object
  2007. * @nbuf_head: skb list head
  2008. *
  2009. * Return: QDF_STATUS - QDF_STATUS_SUCCESS
  2010. * QDF_STATUS_E_FAILURE
  2011. */
  2012. static inline QDF_STATUS
  2013. dp_rx_validate_rx_callbacks(struct dp_soc *soc,
  2014. struct dp_vdev *vdev,
  2015. struct dp_txrx_peer *txrx_peer,
  2016. qdf_nbuf_t nbuf_head)
  2017. {
  2018. int num_nbuf;
  2019. if (qdf_unlikely(!vdev || vdev->delete.pending)) {
  2020. num_nbuf = dp_rx_drop_nbuf_list(NULL, nbuf_head);
  2021. /*
  2022. * This is a special case where vdev is invalid,
  2023. * so we cannot know the pdev to which this packet
  2024. * belonged. Hence we update the soc rx error stats.
  2025. */
  2026. DP_STATS_INC(soc, rx.err.invalid_vdev, num_nbuf);
  2027. return QDF_STATUS_E_FAILURE;
  2028. }
  2029. /*
  2030. * highly unlikely to have a vdev without a registered rx
  2031. * callback function. if so let us free the nbuf_list.
  2032. */
  2033. if (qdf_unlikely(!vdev->osif_rx)) {
  2034. if (txrx_peer && dp_rx_is_peer_cache_bufq_supported()) {
  2035. dp_rx_enqueue_rx(NULL, txrx_peer, nbuf_head);
  2036. } else {
  2037. num_nbuf = dp_rx_drop_nbuf_list(vdev->pdev,
  2038. nbuf_head);
  2039. DP_PEER_TO_STACK_DECC(txrx_peer, num_nbuf,
  2040. vdev->pdev->enhanced_stats_en);
  2041. }
  2042. return QDF_STATUS_E_FAILURE;
  2043. }
  2044. return QDF_STATUS_SUCCESS;
  2045. }
  2046. #if defined(WLAN_FEATURE_11BE_MLO) && defined(RAW_PKT_MLD_ADDR_CONVERSION)
  2047. static void dp_rx_raw_pkt_mld_addr_conv(struct dp_soc *soc,
  2048. struct dp_vdev *vdev,
  2049. struct dp_txrx_peer *txrx_peer,
  2050. qdf_nbuf_t nbuf_head)
  2051. {
  2052. qdf_nbuf_t nbuf, next;
  2053. struct dp_peer *peer = NULL;
  2054. struct ieee80211_frame *wh = NULL;
  2055. if (vdev->rx_decap_type == htt_cmn_pkt_type_native_wifi)
  2056. return;
  2057. peer = dp_peer_get_ref_by_id(soc, txrx_peer->peer_id,
  2058. DP_MOD_ID_RX);
  2059. if (!peer)
  2060. return;
  2061. if (!IS_MLO_DP_MLD_PEER(peer)) {
  2062. dp_peer_unref_delete(peer, DP_MOD_ID_RX);
  2063. return;
  2064. }
  2065. nbuf = nbuf_head;
  2066. while (nbuf) {
  2067. next = nbuf->next;
  2068. wh = (struct ieee80211_frame *)qdf_nbuf_data(nbuf);
  2069. qdf_mem_copy(wh->i_addr1, vdev->mld_mac_addr.raw,
  2070. QDF_MAC_ADDR_SIZE);
  2071. qdf_mem_copy(wh->i_addr2, peer->mac_addr.raw,
  2072. QDF_MAC_ADDR_SIZE);
  2073. nbuf = next;
  2074. }
  2075. dp_peer_unref_delete(peer, DP_MOD_ID_RX);
  2076. }
  2077. #else
  2078. static inline
  2079. void dp_rx_raw_pkt_mld_addr_conv(struct dp_soc *soc,
  2080. struct dp_vdev *vdev,
  2081. struct dp_txrx_peer *txrx_peer,
  2082. qdf_nbuf_t nbuf_head)
  2083. { }
  2084. #endif
  2085. QDF_STATUS dp_rx_deliver_to_stack(struct dp_soc *soc,
  2086. struct dp_vdev *vdev,
  2087. struct dp_txrx_peer *txrx_peer,
  2088. qdf_nbuf_t nbuf_head,
  2089. qdf_nbuf_t nbuf_tail)
  2090. {
  2091. if (dp_rx_validate_rx_callbacks(soc, vdev, txrx_peer, nbuf_head) !=
  2092. QDF_STATUS_SUCCESS)
  2093. return QDF_STATUS_E_FAILURE;
  2094. if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw) ||
  2095. (vdev->rx_decap_type == htt_cmn_pkt_type_native_wifi)) {
  2096. dp_rx_raw_pkt_mld_addr_conv(soc, vdev, txrx_peer, nbuf_head);
  2097. vdev->osif_rsim_rx_decap(vdev->osif_vdev, &nbuf_head,
  2098. &nbuf_tail);
  2099. }
  2100. dp_rx_check_delivery_to_stack(soc, vdev, txrx_peer, nbuf_head);
  2101. return QDF_STATUS_SUCCESS;
  2102. }
  2103. #ifdef QCA_SUPPORT_EAPOL_OVER_CONTROL_PORT
  2104. QDF_STATUS dp_rx_eapol_deliver_to_stack(struct dp_soc *soc,
  2105. struct dp_vdev *vdev,
  2106. struct dp_txrx_peer *txrx_peer,
  2107. qdf_nbuf_t nbuf_head,
  2108. qdf_nbuf_t nbuf_tail)
  2109. {
  2110. if (dp_rx_validate_rx_callbacks(soc, vdev, txrx_peer, nbuf_head) !=
  2111. QDF_STATUS_SUCCESS)
  2112. return QDF_STATUS_E_FAILURE;
  2113. vdev->osif_rx_eapol(vdev->osif_vdev, nbuf_head);
  2114. return QDF_STATUS_SUCCESS;
  2115. }
  2116. #endif
  2117. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  2118. #ifdef VDEV_PEER_PROTOCOL_COUNT
  2119. #define dp_rx_msdu_stats_update_prot_cnts(vdev_hdl, nbuf, txrx_peer) \
  2120. { \
  2121. qdf_nbuf_t nbuf_local; \
  2122. struct dp_txrx_peer *txrx_peer_local; \
  2123. struct dp_vdev *vdev_local = vdev_hdl; \
  2124. do { \
  2125. if (qdf_likely(!((vdev_local)->peer_protocol_count_track))) \
  2126. break; \
  2127. nbuf_local = nbuf; \
  2128. txrx_peer_local = txrx_peer; \
  2129. if (qdf_unlikely(qdf_nbuf_is_frag((nbuf_local)))) \
  2130. break; \
  2131. else if (qdf_unlikely(qdf_nbuf_is_raw_frame((nbuf_local)))) \
  2132. break; \
  2133. dp_vdev_peer_stats_update_protocol_cnt((vdev_local), \
  2134. (nbuf_local), \
  2135. (txrx_peer_local), 0, 1); \
  2136. } while (0); \
  2137. }
  2138. #else
  2139. #define dp_rx_msdu_stats_update_prot_cnts(vdev_hdl, nbuf, txrx_peer)
  2140. #endif
  2141. #ifdef FEATURE_RX_LINKSPEED_ROAM_TRIGGER
  2142. /**
  2143. * dp_rx_rates_stats_update() - update rate stats
  2144. * from rx msdu.
  2145. * @soc: datapath soc handle
  2146. * @nbuf: received msdu buffer
  2147. * @rx_tlv_hdr: rx tlv header
  2148. * @txrx_peer: datapath txrx_peer handle
  2149. * @sgi: Short Guard Interval
  2150. * @mcs: Modulation and Coding Set
  2151. * @nss: Number of Spatial Streams
  2152. * @bw: BandWidth
  2153. * @pkt_type: Corresponds to preamble
  2154. * @link_id: Link Id on which packet is received
  2155. *
  2156. * To be precisely record rates, following factors are considered:
  2157. * Exclude specific frames, ARP, DHCP, ssdp, etc.
  2158. * Make sure to affect rx throughput as least as possible.
  2159. *
  2160. * Return: void
  2161. */
  2162. static void
  2163. dp_rx_rates_stats_update(struct dp_soc *soc, qdf_nbuf_t nbuf,
  2164. uint8_t *rx_tlv_hdr, struct dp_txrx_peer *txrx_peer,
  2165. uint32_t sgi, uint32_t mcs,
  2166. uint32_t nss, uint32_t bw, uint32_t pkt_type,
  2167. uint8_t link_id)
  2168. {
  2169. uint32_t rix;
  2170. uint16_t ratecode;
  2171. uint32_t avg_rx_rate;
  2172. uint32_t ratekbps;
  2173. enum cdp_punctured_modes punc_mode = NO_PUNCTURE;
  2174. if (soc->high_throughput ||
  2175. dp_rx_data_is_specific(soc->hal_soc, rx_tlv_hdr, nbuf)) {
  2176. return;
  2177. }
  2178. DP_PEER_EXTD_STATS_UPD(txrx_peer, rx.rx_rate, mcs, link_id);
  2179. /* In 11b mode, the nss we get from tlv is 0, invalid and should be 1 */
  2180. if (qdf_unlikely(pkt_type == DOT11_B))
  2181. nss = 1;
  2182. /* here pkt_type corresponds to preamble */
  2183. ratekbps = dp_getrateindex(sgi,
  2184. mcs,
  2185. nss - 1,
  2186. pkt_type,
  2187. bw,
  2188. punc_mode,
  2189. &rix,
  2190. &ratecode);
  2191. DP_PEER_EXTD_STATS_UPD(txrx_peer, rx.last_rx_rate, ratekbps, link_id);
  2192. avg_rx_rate =
  2193. dp_ath_rate_lpf(
  2194. txrx_peer->stats[link_id].extd_stats.rx.avg_rx_rate,
  2195. ratekbps);
  2196. DP_PEER_EXTD_STATS_UPD(txrx_peer, rx.avg_rx_rate, avg_rx_rate, link_id);
  2197. DP_PEER_EXTD_STATS_UPD(txrx_peer, rx.nss_info, nss, link_id);
  2198. DP_PEER_EXTD_STATS_UPD(txrx_peer, rx.mcs_info, mcs, link_id);
  2199. DP_PEER_EXTD_STATS_UPD(txrx_peer, rx.bw_info, bw, link_id);
  2200. DP_PEER_EXTD_STATS_UPD(txrx_peer, rx.gi_info, sgi, link_id);
  2201. DP_PEER_EXTD_STATS_UPD(txrx_peer, rx.preamble_info, pkt_type, link_id);
  2202. }
  2203. #else
  2204. static inline void
  2205. dp_rx_rates_stats_update(struct dp_soc *soc, qdf_nbuf_t nbuf,
  2206. uint8_t *rx_tlv_hdr, struct dp_txrx_peer *txrx_peer,
  2207. uint32_t sgi, uint32_t mcs,
  2208. uint32_t nss, uint32_t bw, uint32_t pkt_type,
  2209. uint8_t link_id)
  2210. {
  2211. }
  2212. #endif /* FEATURE_RX_LINKSPEED_ROAM_TRIGGER */
  2213. #ifndef QCA_ENHANCED_STATS_SUPPORT
  2214. /**
  2215. * dp_rx_msdu_extd_stats_update(): Update Rx extended path stats for peer
  2216. *
  2217. * @soc: datapath soc handle
  2218. * @nbuf: received msdu buffer
  2219. * @rx_tlv_hdr: rx tlv header
  2220. * @txrx_peer: datapath txrx_peer handle
  2221. * @link_id: link id on which the packet is received
  2222. *
  2223. * Return: void
  2224. */
  2225. static inline
  2226. void dp_rx_msdu_extd_stats_update(struct dp_soc *soc, qdf_nbuf_t nbuf,
  2227. uint8_t *rx_tlv_hdr,
  2228. struct dp_txrx_peer *txrx_peer,
  2229. uint8_t link_id)
  2230. {
  2231. bool is_ampdu;
  2232. uint32_t sgi, mcs, tid, nss, bw, reception_type, pkt_type;
  2233. uint8_t dst_mcs_idx;
  2234. /*
  2235. * TODO - For KIWI this field is present in ring_desc
  2236. * Try to use ring desc instead of tlv.
  2237. */
  2238. is_ampdu = hal_rx_mpdu_info_ampdu_flag_get(soc->hal_soc, rx_tlv_hdr);
  2239. DP_PEER_EXTD_STATS_INCC(txrx_peer, rx.ampdu_cnt, 1, is_ampdu, link_id);
  2240. DP_PEER_EXTD_STATS_INCC(txrx_peer, rx.non_ampdu_cnt, 1, !(is_ampdu),
  2241. link_id);
  2242. sgi = hal_rx_tlv_sgi_get(soc->hal_soc, rx_tlv_hdr);
  2243. mcs = hal_rx_tlv_rate_mcs_get(soc->hal_soc, rx_tlv_hdr);
  2244. tid = qdf_nbuf_get_tid_val(nbuf);
  2245. bw = hal_rx_tlv_bw_get(soc->hal_soc, rx_tlv_hdr);
  2246. reception_type = hal_rx_msdu_start_reception_type_get(soc->hal_soc,
  2247. rx_tlv_hdr);
  2248. nss = hal_rx_msdu_start_nss_get(soc->hal_soc, rx_tlv_hdr);
  2249. pkt_type = hal_rx_tlv_get_pkt_type(soc->hal_soc, rx_tlv_hdr);
  2250. /* do HW to SW pkt type conversion */
  2251. pkt_type = (pkt_type >= HAL_DOT11_MAX ? DOT11_MAX :
  2252. hal_2_dp_pkt_type_map[pkt_type]);
  2253. /*
  2254. * The MCS index does not start with 0 when NSS>1 in HT mode.
  2255. * MCS params for optional 20/40MHz, NSS=1~3, EQM(NSS>1):
  2256. * ------------------------------------------------------
  2257. * NSS | 1 | 2 | 3 | 4
  2258. * ------------------------------------------------------
  2259. * MCS index: HT20 | 0 ~ 7 | 8 ~ 15 | 16 ~ 23 | 24 ~ 31
  2260. * ------------------------------------------------------
  2261. * MCS index: HT40 | 0 ~ 7 | 8 ~ 15 | 16 ~ 23 | 24 ~ 31
  2262. * ------------------------------------------------------
  2263. * Currently, the MAX_NSS=2. If NSS>2, MCS index = 8 * (NSS-1)
  2264. */
  2265. if ((pkt_type == DOT11_N) && (nss == 2))
  2266. mcs += 8;
  2267. DP_PEER_EXTD_STATS_INCC(txrx_peer, rx.rx_mpdu_cnt[mcs], 1,
  2268. ((mcs < MAX_MCS) && QDF_NBUF_CB_RX_CHFRAG_START(nbuf)),
  2269. link_id);
  2270. DP_PEER_EXTD_STATS_INCC(txrx_peer, rx.rx_mpdu_cnt[MAX_MCS - 1], 1,
  2271. ((mcs >= MAX_MCS) && QDF_NBUF_CB_RX_CHFRAG_START(nbuf)),
  2272. link_id);
  2273. DP_PEER_EXTD_STATS_INC(txrx_peer, rx.bw[bw], 1, link_id);
  2274. /*
  2275. * only if nss > 0 and pkt_type is 11N/AC/AX,
  2276. * then increase index [nss - 1] in array counter.
  2277. */
  2278. if (nss > 0 && CDP_IS_PKT_TYPE_SUPPORT_NSS(pkt_type))
  2279. DP_PEER_EXTD_STATS_INC(txrx_peer, rx.nss[nss - 1], 1, link_id);
  2280. DP_PEER_EXTD_STATS_INC(txrx_peer, rx.sgi_count[sgi], 1, link_id);
  2281. DP_PEER_PER_PKT_STATS_INCC(txrx_peer, rx.err.mic_err, 1,
  2282. hal_rx_tlv_mic_err_get(soc->hal_soc,
  2283. rx_tlv_hdr), link_id);
  2284. DP_PEER_PER_PKT_STATS_INCC(txrx_peer, rx.err.decrypt_err, 1,
  2285. hal_rx_tlv_decrypt_err_get(soc->hal_soc,
  2286. rx_tlv_hdr), link_id);
  2287. DP_PEER_EXTD_STATS_INC(txrx_peer, rx.wme_ac_type[TID_TO_WME_AC(tid)], 1,
  2288. link_id);
  2289. DP_PEER_EXTD_STATS_INC(txrx_peer, rx.reception_type[reception_type], 1,
  2290. link_id);
  2291. dst_mcs_idx = dp_get_mcs_array_index_by_pkt_type_mcs(pkt_type, mcs);
  2292. if (MCS_INVALID_ARRAY_INDEX != dst_mcs_idx)
  2293. DP_PEER_EXTD_STATS_INC(txrx_peer,
  2294. rx.pkt_type[pkt_type].mcs_count[dst_mcs_idx],
  2295. 1, link_id);
  2296. dp_rx_rates_stats_update(soc, nbuf, rx_tlv_hdr, txrx_peer,
  2297. sgi, mcs, nss, bw, pkt_type, link_id);
  2298. }
  2299. #else
  2300. static inline
  2301. void dp_rx_msdu_extd_stats_update(struct dp_soc *soc, qdf_nbuf_t nbuf,
  2302. uint8_t *rx_tlv_hdr,
  2303. struct dp_txrx_peer *txrx_peer,
  2304. uint8_t link_id)
  2305. {
  2306. }
  2307. #endif
  2308. #if defined(DP_PKT_STATS_PER_LMAC) && defined(WLAN_FEATURE_11BE_MLO)
  2309. static inline void
  2310. dp_peer_update_rx_pkt_per_lmac(struct dp_txrx_peer *txrx_peer,
  2311. qdf_nbuf_t nbuf, uint8_t link_id)
  2312. {
  2313. uint8_t lmac_id = qdf_nbuf_get_lmac_id(nbuf);
  2314. if (qdf_unlikely(lmac_id >= CDP_MAX_LMACS)) {
  2315. dp_err_rl("Invalid lmac_id: %u vdev_id: %u",
  2316. lmac_id, QDF_NBUF_CB_RX_VDEV_ID(nbuf));
  2317. if (qdf_likely(txrx_peer))
  2318. dp_err_rl("peer_id: %u", txrx_peer->peer_id);
  2319. return;
  2320. }
  2321. /* only count stats per lmac for MLO connection*/
  2322. DP_PEER_PER_PKT_STATS_INCC_PKT(txrx_peer, rx.rx_lmac[lmac_id], 1,
  2323. QDF_NBUF_CB_RX_PKT_LEN(nbuf),
  2324. txrx_peer->is_mld_peer, link_id);
  2325. }
  2326. #else
  2327. static inline void
  2328. dp_peer_update_rx_pkt_per_lmac(struct dp_txrx_peer *txrx_peer,
  2329. qdf_nbuf_t nbuf, uint8_t link_id)
  2330. {
  2331. }
  2332. #endif
  2333. void dp_rx_msdu_stats_update(struct dp_soc *soc, qdf_nbuf_t nbuf,
  2334. uint8_t *rx_tlv_hdr,
  2335. struct dp_txrx_peer *txrx_peer,
  2336. uint8_t ring_id,
  2337. struct cdp_tid_rx_stats *tid_stats,
  2338. uint8_t link_id)
  2339. {
  2340. bool is_not_amsdu;
  2341. struct dp_vdev *vdev = txrx_peer->vdev;
  2342. uint8_t enh_flag;
  2343. qdf_ether_header_t *eh;
  2344. uint16_t msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  2345. dp_rx_msdu_stats_update_prot_cnts(vdev, nbuf, txrx_peer);
  2346. is_not_amsdu = qdf_nbuf_is_rx_chfrag_start(nbuf) &
  2347. qdf_nbuf_is_rx_chfrag_end(nbuf);
  2348. DP_PEER_PER_PKT_STATS_INC_PKT(txrx_peer, rx.rcvd_reo[ring_id], 1,
  2349. msdu_len, link_id);
  2350. DP_PEER_PER_PKT_STATS_INCC(txrx_peer, rx.non_amsdu_cnt, 1,
  2351. is_not_amsdu, link_id);
  2352. DP_PEER_PER_PKT_STATS_INCC(txrx_peer, rx.amsdu_cnt, 1,
  2353. !is_not_amsdu, link_id);
  2354. DP_PEER_PER_PKT_STATS_INCC(txrx_peer, rx.rx_retries, 1,
  2355. qdf_nbuf_is_rx_retry_flag(nbuf), link_id);
  2356. dp_peer_update_rx_pkt_per_lmac(txrx_peer, nbuf, link_id);
  2357. tid_stats->msdu_cnt++;
  2358. enh_flag = vdev->pdev->enhanced_stats_en;
  2359. if (qdf_unlikely(qdf_nbuf_is_da_mcbc(nbuf) &&
  2360. (vdev->rx_decap_type == htt_cmn_pkt_type_ethernet))) {
  2361. eh = (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
  2362. DP_PEER_MC_INCC_PKT(txrx_peer, 1, msdu_len, enh_flag, link_id);
  2363. tid_stats->mcast_msdu_cnt++;
  2364. if (QDF_IS_ADDR_BROADCAST(eh->ether_dhost)) {
  2365. DP_PEER_BC_INCC_PKT(txrx_peer, 1, msdu_len,
  2366. enh_flag, link_id);
  2367. tid_stats->bcast_msdu_cnt++;
  2368. }
  2369. } else {
  2370. DP_PEER_UC_INCC_PKT(txrx_peer, 1, msdu_len,
  2371. enh_flag, link_id);
  2372. }
  2373. txrx_peer->stats[link_id].per_pkt_stats.rx.last_rx_ts =
  2374. qdf_system_ticks();
  2375. dp_rx_msdu_extd_stats_update(soc, nbuf, rx_tlv_hdr,
  2376. txrx_peer, link_id);
  2377. }
  2378. #ifndef WDS_VENDOR_EXTENSION
  2379. int dp_wds_rx_policy_check(uint8_t *rx_tlv_hdr,
  2380. struct dp_vdev *vdev,
  2381. struct dp_txrx_peer *txrx_peer)
  2382. {
  2383. return 1;
  2384. }
  2385. #endif
  2386. #ifdef DP_RX_PKT_NO_PEER_DELIVER
  2387. #ifdef DP_RX_UDP_OVER_PEER_ROAM
  2388. /**
  2389. * dp_rx_is_udp_allowed_over_roam_peer() - check if udp data received
  2390. * during roaming
  2391. * @vdev: dp_vdev pointer
  2392. * @rx_tlv_hdr: rx tlv header
  2393. * @nbuf: pkt skb pointer
  2394. *
  2395. * This function will check if rx udp data is received from authorised
  2396. * roamed peer before peer map indication is received from FW after
  2397. * roaming. This is needed for VoIP scenarios in which packet loss
  2398. * expected during roaming is minimal.
  2399. *
  2400. * Return: bool
  2401. */
  2402. static bool dp_rx_is_udp_allowed_over_roam_peer(struct dp_vdev *vdev,
  2403. uint8_t *rx_tlv_hdr,
  2404. qdf_nbuf_t nbuf)
  2405. {
  2406. char *hdr_desc;
  2407. struct ieee80211_frame *wh = NULL;
  2408. hdr_desc = hal_rx_desc_get_80211_hdr(vdev->pdev->soc->hal_soc,
  2409. rx_tlv_hdr);
  2410. wh = (struct ieee80211_frame *)hdr_desc;
  2411. if (vdev->roaming_peer_status ==
  2412. WLAN_ROAM_PEER_AUTH_STATUS_AUTHENTICATED &&
  2413. !qdf_mem_cmp(vdev->roaming_peer_mac.raw, wh->i_addr2,
  2414. QDF_MAC_ADDR_SIZE) && (qdf_nbuf_is_ipv4_udp_pkt(nbuf) ||
  2415. qdf_nbuf_is_ipv6_udp_pkt(nbuf)))
  2416. return true;
  2417. return false;
  2418. }
  2419. #else
  2420. static bool dp_rx_is_udp_allowed_over_roam_peer(struct dp_vdev *vdev,
  2421. uint8_t *rx_tlv_hdr,
  2422. qdf_nbuf_t nbuf)
  2423. {
  2424. return false;
  2425. }
  2426. #endif
  2427. #if defined(WLAN_FEATURE_11BE_MLO) && defined(DP_MLO_LINK_STATS_SUPPORT)
  2428. /**
  2429. * dp_rx_nbuf_band_set() - set nbuf band.
  2430. * @soc: dp soc handle
  2431. * @nbuf: nbuf handle
  2432. *
  2433. * Return: None
  2434. */
  2435. static inline void
  2436. dp_rx_nbuf_band_set(struct dp_soc *soc, qdf_nbuf_t nbuf)
  2437. {
  2438. struct qdf_mac_addr *mac_addr;
  2439. struct dp_peer *peer;
  2440. struct dp_txrx_peer *txrx_peer;
  2441. uint8_t link_id;
  2442. mac_addr = (struct qdf_mac_addr *)(qdf_nbuf_data(nbuf) +
  2443. QDF_NBUF_SRC_MAC_OFFSET);
  2444. peer = dp_mld_peer_find_hash_find(soc, mac_addr->bytes, 0,
  2445. DP_VDEV_ALL, DP_MOD_ID_RX);
  2446. if (qdf_likely(peer)) {
  2447. txrx_peer = dp_get_txrx_peer(peer);
  2448. if (qdf_likely(txrx_peer)) {
  2449. link_id = QDF_NBUF_CB_RX_LOGICAL_LINK_ID(nbuf);
  2450. qdf_nbuf_rx_set_band(nbuf, txrx_peer->ll_band[link_id]);
  2451. }
  2452. dp_peer_unref_delete(peer, DP_MOD_ID_RX);
  2453. }
  2454. }
  2455. #else
  2456. static inline void
  2457. dp_rx_nbuf_band_set(struct dp_soc *soc, qdf_nbuf_t nbuf)
  2458. {
  2459. }
  2460. #endif
  2461. void dp_rx_deliver_to_stack_no_peer(struct dp_soc *soc, qdf_nbuf_t nbuf)
  2462. {
  2463. uint16_t peer_id;
  2464. uint8_t vdev_id;
  2465. struct dp_vdev *vdev = NULL;
  2466. uint32_t l2_hdr_offset = 0;
  2467. uint16_t msdu_len = 0;
  2468. uint32_t pkt_len = 0;
  2469. uint8_t *rx_tlv_hdr;
  2470. uint32_t frame_mask = FRAME_MASK_IPV4_ARP | FRAME_MASK_IPV4_DHCP |
  2471. FRAME_MASK_IPV4_EAPOL | FRAME_MASK_IPV6_DHCP |
  2472. FRAME_MASK_DNS_QUERY | FRAME_MASK_DNS_RESP;
  2473. bool is_special_frame = false;
  2474. struct dp_peer *peer = NULL;
  2475. peer_id = QDF_NBUF_CB_RX_PEER_ID(nbuf);
  2476. if (peer_id > soc->max_peer_id)
  2477. goto deliver_fail;
  2478. vdev_id = QDF_NBUF_CB_RX_VDEV_ID(nbuf);
  2479. vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_RX);
  2480. if (!vdev || vdev->delete.pending)
  2481. goto deliver_fail;
  2482. if (qdf_unlikely(qdf_nbuf_is_frag(nbuf)))
  2483. goto deliver_fail;
  2484. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  2485. l2_hdr_offset =
  2486. hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc, rx_tlv_hdr);
  2487. msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  2488. pkt_len = msdu_len + l2_hdr_offset + soc->rx_pkt_tlv_size;
  2489. QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(nbuf) = 1;
  2490. qdf_nbuf_set_pktlen(nbuf, pkt_len);
  2491. qdf_nbuf_pull_head(nbuf, soc->rx_pkt_tlv_size + l2_hdr_offset);
  2492. is_special_frame = dp_rx_is_special_frame(nbuf, frame_mask);
  2493. if (qdf_likely(vdev->osif_rx)) {
  2494. if (is_special_frame ||
  2495. dp_rx_is_udp_allowed_over_roam_peer(vdev, rx_tlv_hdr,
  2496. nbuf)) {
  2497. dp_rx_nbuf_band_set(soc, nbuf);
  2498. qdf_nbuf_set_exc_frame(nbuf, 1);
  2499. if (QDF_STATUS_SUCCESS !=
  2500. vdev->osif_rx(vdev->osif_vdev, nbuf))
  2501. goto deliver_fail;
  2502. DP_STATS_INC(soc, rx.err.pkt_delivered_no_peer, 1);
  2503. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_RX);
  2504. return;
  2505. }
  2506. } else if (is_special_frame) {
  2507. /*
  2508. * If MLO connection, txrx_peer for link peer does not exist,
  2509. * try to store these RX packets to txrx_peer's bufq of MLD
  2510. * peer until vdev->osif_rx is registered from CP and flush
  2511. * them to stack.
  2512. */
  2513. peer = dp_peer_get_tgt_peer_by_id(soc, peer_id,
  2514. DP_MOD_ID_RX);
  2515. if (!peer)
  2516. goto deliver_fail;
  2517. /* only check for MLO connection */
  2518. if (IS_MLO_DP_MLD_PEER(peer) && peer->txrx_peer &&
  2519. dp_rx_is_peer_cache_bufq_supported()) {
  2520. qdf_nbuf_set_exc_frame(nbuf, 1);
  2521. if (QDF_STATUS_SUCCESS ==
  2522. dp_rx_enqueue_rx(peer, peer->txrx_peer, nbuf)) {
  2523. DP_STATS_INC(soc,
  2524. rx.err.pkt_delivered_no_peer,
  2525. 1);
  2526. } else {
  2527. DP_STATS_INC(soc,
  2528. rx.err.rx_invalid_peer.num,
  2529. 1);
  2530. }
  2531. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_RX);
  2532. dp_peer_unref_delete(peer, DP_MOD_ID_RX);
  2533. return;
  2534. }
  2535. dp_peer_unref_delete(peer, DP_MOD_ID_RX);
  2536. }
  2537. deliver_fail:
  2538. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  2539. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  2540. dp_rx_nbuf_free(nbuf);
  2541. if (vdev)
  2542. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_RX);
  2543. }
  2544. #else
  2545. void dp_rx_deliver_to_stack_no_peer(struct dp_soc *soc, qdf_nbuf_t nbuf)
  2546. {
  2547. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  2548. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  2549. dp_rx_nbuf_free(nbuf);
  2550. }
  2551. #endif
  2552. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  2553. #ifdef WLAN_SUPPORT_RX_FISA
  2554. QDF_STATUS dp_fisa_config(ol_txrx_soc_handle cdp_soc, uint8_t pdev_id,
  2555. enum cdp_fisa_config_id config_id,
  2556. union cdp_fisa_config *cfg)
  2557. {
  2558. struct dp_soc *soc = (struct dp_soc *)cdp_soc;
  2559. struct dp_pdev *pdev;
  2560. QDF_STATUS status;
  2561. pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id);
  2562. if (!pdev) {
  2563. dp_err("pdev is NULL for pdev_id %u", pdev_id);
  2564. return QDF_STATUS_E_INVAL;
  2565. }
  2566. switch (config_id) {
  2567. case CDP_FISA_HTT_RX_FISA_CFG:
  2568. status = dp_htt_rx_fisa_config(pdev, cfg->fisa_config);
  2569. break;
  2570. case CDP_FISA_HTT_RX_FSE_OP_CFG:
  2571. status = dp_htt_rx_flow_fse_operation(pdev, cfg->fse_op_cmd);
  2572. break;
  2573. case CDP_FISA_HTT_RX_FSE_SETUP_CFG:
  2574. status = dp_htt_rx_flow_fst_setup(pdev, cfg->fse_setup_info);
  2575. break;
  2576. default:
  2577. status = QDF_STATUS_E_INVAL;
  2578. }
  2579. return status;
  2580. }
  2581. void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding)
  2582. {
  2583. QDF_NBUF_CB_RX_PACKET_L3_HDR_PAD(nbuf) = l3_padding;
  2584. qdf_nbuf_pull_head(nbuf, l3_padding + soc->rx_pkt_tlv_size);
  2585. }
  2586. #else
  2587. void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding)
  2588. {
  2589. qdf_nbuf_pull_head(nbuf, l3_padding + soc->rx_pkt_tlv_size);
  2590. }
  2591. #endif
  2592. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  2593. #ifdef DP_RX_DROP_RAW_FRM
  2594. bool dp_rx_is_raw_frame_dropped(qdf_nbuf_t nbuf)
  2595. {
  2596. if (qdf_nbuf_is_raw_frame(nbuf)) {
  2597. dp_rx_nbuf_free(nbuf);
  2598. return true;
  2599. }
  2600. return false;
  2601. }
  2602. #endif
  2603. #ifdef WLAN_DP_FEATURE_SW_LATENCY_MGR
  2604. void dp_rx_update_stats(struct dp_soc *soc, qdf_nbuf_t nbuf)
  2605. {
  2606. DP_STATS_INC_PKT(soc, rx.ingress, 1,
  2607. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  2608. }
  2609. #endif
  2610. #ifdef WLAN_FEATURE_PKT_CAPTURE_V2
  2611. void dp_rx_deliver_to_pkt_capture(struct dp_soc *soc, struct dp_pdev *pdev,
  2612. uint16_t peer_id, uint32_t is_offload,
  2613. qdf_nbuf_t netbuf)
  2614. {
  2615. if (wlan_cfg_get_pkt_capture_mode(soc->wlan_cfg_ctx))
  2616. dp_wdi_event_handler(WDI_EVENT_PKT_CAPTURE_RX_DATA, soc, netbuf,
  2617. peer_id, is_offload, pdev->pdev_id);
  2618. }
  2619. void dp_rx_deliver_to_pkt_capture_no_peer(struct dp_soc *soc, qdf_nbuf_t nbuf,
  2620. uint32_t is_offload)
  2621. {
  2622. if (wlan_cfg_get_pkt_capture_mode(soc->wlan_cfg_ctx))
  2623. dp_wdi_event_handler(WDI_EVENT_PKT_CAPTURE_RX_DATA_NO_PEER,
  2624. soc, nbuf, HTT_INVALID_VDEV,
  2625. is_offload, 0);
  2626. }
  2627. #endif
  2628. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  2629. QDF_STATUS dp_rx_vdev_detach(struct dp_vdev *vdev)
  2630. {
  2631. QDF_STATUS ret;
  2632. if (vdev->osif_rx_flush) {
  2633. ret = vdev->osif_rx_flush(vdev->osif_vdev, vdev->vdev_id);
  2634. if (!QDF_IS_STATUS_SUCCESS(ret)) {
  2635. dp_err("Failed to flush rx pkts for vdev %d",
  2636. vdev->vdev_id);
  2637. return ret;
  2638. }
  2639. }
  2640. return QDF_STATUS_SUCCESS;
  2641. }
  2642. static QDF_STATUS
  2643. dp_pdev_nbuf_alloc_and_map(struct dp_soc *dp_soc,
  2644. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  2645. struct dp_pdev *dp_pdev,
  2646. struct rx_desc_pool *rx_desc_pool,
  2647. bool dp_buf_page_frag_alloc_enable)
  2648. {
  2649. QDF_STATUS ret = QDF_STATUS_E_FAILURE;
  2650. if (dp_buf_page_frag_alloc_enable) {
  2651. (nbuf_frag_info_t->virt_addr).nbuf =
  2652. qdf_nbuf_frag_alloc(dp_soc->osdev,
  2653. rx_desc_pool->buf_size,
  2654. RX_BUFFER_RESERVATION,
  2655. rx_desc_pool->buf_alignment, FALSE);
  2656. } else {
  2657. (nbuf_frag_info_t->virt_addr).nbuf =
  2658. qdf_nbuf_alloc(dp_soc->osdev, rx_desc_pool->buf_size,
  2659. RX_BUFFER_RESERVATION,
  2660. rx_desc_pool->buf_alignment, FALSE);
  2661. }
  2662. if (!((nbuf_frag_info_t->virt_addr).nbuf)) {
  2663. dp_err("nbuf alloc failed");
  2664. DP_STATS_INC(dp_pdev, replenish.nbuf_alloc_fail, 1);
  2665. return ret;
  2666. }
  2667. ret = qdf_nbuf_map_nbytes_single(dp_soc->osdev,
  2668. (nbuf_frag_info_t->virt_addr).nbuf,
  2669. QDF_DMA_FROM_DEVICE,
  2670. rx_desc_pool->buf_size);
  2671. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  2672. qdf_nbuf_free((nbuf_frag_info_t->virt_addr).nbuf);
  2673. dp_err("nbuf map failed");
  2674. DP_STATS_INC(dp_pdev, replenish.map_err, 1);
  2675. return ret;
  2676. }
  2677. nbuf_frag_info_t->paddr =
  2678. qdf_nbuf_get_frag_paddr((nbuf_frag_info_t->virt_addr).nbuf, 0);
  2679. ret = dp_check_paddr(dp_soc, &((nbuf_frag_info_t->virt_addr).nbuf),
  2680. &nbuf_frag_info_t->paddr,
  2681. rx_desc_pool);
  2682. if (ret == QDF_STATUS_E_FAILURE) {
  2683. dp_err("nbuf check x86 failed");
  2684. DP_STATS_INC(dp_pdev, replenish.x86_fail, 1);
  2685. return ret;
  2686. }
  2687. return QDF_STATUS_SUCCESS;
  2688. }
  2689. QDF_STATUS
  2690. dp_pdev_rx_buffers_attach(struct dp_soc *dp_soc, uint32_t mac_id,
  2691. struct dp_srng *dp_rxdma_srng,
  2692. struct rx_desc_pool *rx_desc_pool,
  2693. uint32_t num_req_buffers)
  2694. {
  2695. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(dp_soc, mac_id);
  2696. hal_ring_handle_t rxdma_srng = dp_rxdma_srng->hal_srng;
  2697. union dp_rx_desc_list_elem_t *next;
  2698. void *rxdma_ring_entry;
  2699. qdf_dma_addr_t paddr;
  2700. struct dp_rx_nbuf_frag_info *nf_info;
  2701. uint32_t nr_descs, nr_nbuf = 0, nr_nbuf_total = 0;
  2702. uint32_t buffer_index, nbuf_ptrs_per_page;
  2703. qdf_nbuf_t nbuf;
  2704. QDF_STATUS ret;
  2705. int page_idx, total_pages;
  2706. union dp_rx_desc_list_elem_t *desc_list = NULL;
  2707. union dp_rx_desc_list_elem_t *tail = NULL;
  2708. int sync_hw_ptr = 1;
  2709. uint32_t num_entries_avail;
  2710. bool dp_buf_page_frag_alloc_enable;
  2711. if (qdf_unlikely(!dp_pdev)) {
  2712. dp_rx_err("%pK: pdev is null for mac_id = %d",
  2713. dp_soc, mac_id);
  2714. return QDF_STATUS_E_FAILURE;
  2715. }
  2716. dp_buf_page_frag_alloc_enable =
  2717. wlan_cfg_is_dp_buf_page_frag_alloc_enable(dp_soc->wlan_cfg_ctx);
  2718. if (qdf_unlikely(!rxdma_srng)) {
  2719. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  2720. return QDF_STATUS_E_FAILURE;
  2721. }
  2722. dp_debug("requested %u RX buffers for driver attach", num_req_buffers);
  2723. hal_srng_access_start(dp_soc->hal_soc, rxdma_srng);
  2724. num_entries_avail = hal_srng_src_num_avail(dp_soc->hal_soc,
  2725. rxdma_srng,
  2726. sync_hw_ptr);
  2727. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  2728. if (!num_entries_avail) {
  2729. dp_err("Num of available entries is zero, nothing to do");
  2730. return QDF_STATUS_E_NOMEM;
  2731. }
  2732. if (num_entries_avail < num_req_buffers)
  2733. num_req_buffers = num_entries_avail;
  2734. nr_descs = dp_rx_get_free_desc_list(dp_soc, mac_id, rx_desc_pool,
  2735. num_req_buffers, &desc_list, &tail);
  2736. if (!nr_descs) {
  2737. dp_err("no free rx_descs in freelist");
  2738. DP_STATS_INC(dp_pdev, err.desc_alloc_fail, num_req_buffers);
  2739. return QDF_STATUS_E_NOMEM;
  2740. }
  2741. dp_debug("got %u RX descs for driver attach", nr_descs);
  2742. /*
  2743. * Try to allocate pointers to the nbuf one page at a time.
  2744. * Take pointers that can fit in one page of memory and
  2745. * iterate through the total descriptors that need to be
  2746. * allocated in order of pages. Reuse the pointers that
  2747. * have been allocated to fit in one page across each
  2748. * iteration to index into the nbuf.
  2749. */
  2750. total_pages = (nr_descs * sizeof(*nf_info)) / DP_BLOCKMEM_SIZE;
  2751. /*
  2752. * Add an extra page to store the remainder if any
  2753. */
  2754. if ((nr_descs * sizeof(*nf_info)) % DP_BLOCKMEM_SIZE)
  2755. total_pages++;
  2756. nf_info = qdf_mem_malloc(DP_BLOCKMEM_SIZE);
  2757. if (!nf_info) {
  2758. dp_err("failed to allocate nbuf array");
  2759. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  2760. QDF_BUG(0);
  2761. return QDF_STATUS_E_NOMEM;
  2762. }
  2763. nbuf_ptrs_per_page = DP_BLOCKMEM_SIZE / sizeof(*nf_info);
  2764. for (page_idx = 0; page_idx < total_pages; page_idx++) {
  2765. qdf_mem_zero(nf_info, DP_BLOCKMEM_SIZE);
  2766. for (nr_nbuf = 0; nr_nbuf < nbuf_ptrs_per_page; nr_nbuf++) {
  2767. /*
  2768. * The last page of buffer pointers may not be required
  2769. * completely based on the number of descriptors. Below
  2770. * check will ensure we are allocating only the
  2771. * required number of descriptors.
  2772. */
  2773. if (nr_nbuf_total >= nr_descs)
  2774. break;
  2775. /* Flag is set while pdev rx_desc_pool initialization */
  2776. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  2777. ret = dp_pdev_frag_alloc_and_map(dp_soc,
  2778. &nf_info[nr_nbuf], dp_pdev,
  2779. rx_desc_pool);
  2780. else
  2781. ret = dp_pdev_nbuf_alloc_and_map(dp_soc,
  2782. &nf_info[nr_nbuf], dp_pdev,
  2783. rx_desc_pool,
  2784. dp_buf_page_frag_alloc_enable);
  2785. if (QDF_IS_STATUS_ERROR(ret))
  2786. break;
  2787. nr_nbuf_total++;
  2788. }
  2789. hal_srng_access_start(dp_soc->hal_soc, rxdma_srng);
  2790. for (buffer_index = 0; buffer_index < nr_nbuf; buffer_index++) {
  2791. rxdma_ring_entry =
  2792. hal_srng_src_get_next(dp_soc->hal_soc,
  2793. rxdma_srng);
  2794. qdf_assert_always(rxdma_ring_entry);
  2795. next = desc_list->next;
  2796. paddr = nf_info[buffer_index].paddr;
  2797. nbuf = nf_info[buffer_index].virt_addr.nbuf;
  2798. /* Flag is set while pdev rx_desc_pool initialization */
  2799. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  2800. dp_rx_desc_frag_prep(&desc_list->rx_desc,
  2801. &nf_info[buffer_index]);
  2802. else
  2803. dp_rx_desc_prep(&desc_list->rx_desc,
  2804. &nf_info[buffer_index]);
  2805. desc_list->rx_desc.in_use = 1;
  2806. dp_rx_desc_alloc_dbg_info(&desc_list->rx_desc);
  2807. dp_rx_desc_update_dbg_info(&desc_list->rx_desc,
  2808. __func__,
  2809. RX_DESC_REPLENISHED);
  2810. hal_rxdma_buff_addr_info_set(dp_soc->hal_soc ,rxdma_ring_entry, paddr,
  2811. desc_list->rx_desc.cookie,
  2812. rx_desc_pool->owner);
  2813. dp_ipa_handle_rx_buf_smmu_mapping(
  2814. dp_soc, nbuf,
  2815. rx_desc_pool->buf_size, true,
  2816. __func__, __LINE__);
  2817. dp_audio_smmu_map(dp_soc->osdev,
  2818. qdf_mem_paddr_from_dmaaddr(dp_soc->osdev,
  2819. QDF_NBUF_CB_PADDR(nbuf)),
  2820. QDF_NBUF_CB_PADDR(nbuf),
  2821. rx_desc_pool->buf_size);
  2822. desc_list = next;
  2823. }
  2824. dp_rx_refill_ring_record_entry(dp_soc, dp_pdev->lmac_id,
  2825. rxdma_srng, nr_nbuf, nr_nbuf);
  2826. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  2827. }
  2828. dp_info("filled %u RX buffers for driver attach", nr_nbuf_total);
  2829. qdf_mem_free(nf_info);
  2830. if (!nr_nbuf_total) {
  2831. dp_err("No nbuf's allocated");
  2832. QDF_BUG(0);
  2833. return QDF_STATUS_E_RESOURCES;
  2834. }
  2835. /* No need to count the number of bytes received during replenish.
  2836. * Therefore set replenish.pkts.bytes as 0.
  2837. */
  2838. DP_STATS_INC_PKT(dp_pdev, replenish.pkts, nr_nbuf, 0);
  2839. return QDF_STATUS_SUCCESS;
  2840. }
  2841. qdf_export_symbol(dp_pdev_rx_buffers_attach);
  2842. #ifdef DP_RX_MON_MEM_FRAG
  2843. void dp_rx_enable_mon_dest_frag(struct rx_desc_pool *rx_desc_pool,
  2844. bool is_mon_dest_desc)
  2845. {
  2846. rx_desc_pool->rx_mon_dest_frag_enable = is_mon_dest_desc;
  2847. if (is_mon_dest_desc)
  2848. dp_alert("Feature DP_RX_MON_MEM_FRAG for mon_dest is enabled");
  2849. else
  2850. qdf_frag_cache_drain(&rx_desc_pool->pf_cache);
  2851. }
  2852. #else
  2853. void dp_rx_enable_mon_dest_frag(struct rx_desc_pool *rx_desc_pool,
  2854. bool is_mon_dest_desc)
  2855. {
  2856. rx_desc_pool->rx_mon_dest_frag_enable = false;
  2857. if (is_mon_dest_desc)
  2858. dp_alert("Feature DP_RX_MON_MEM_FRAG for mon_dest is disabled");
  2859. }
  2860. #endif
  2861. qdf_export_symbol(dp_rx_enable_mon_dest_frag);
  2862. QDF_STATUS
  2863. dp_rx_pdev_desc_pool_alloc(struct dp_pdev *pdev)
  2864. {
  2865. struct dp_soc *soc = pdev->soc;
  2866. uint32_t rxdma_entries;
  2867. uint32_t rx_sw_desc_num;
  2868. struct dp_srng *dp_rxdma_srng;
  2869. struct rx_desc_pool *rx_desc_pool;
  2870. uint32_t status = QDF_STATUS_SUCCESS;
  2871. int mac_for_pdev;
  2872. mac_for_pdev = pdev->lmac_id;
  2873. if (wlan_cfg_get_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx)) {
  2874. dp_rx_info("%pK: nss-wifi<4> skip Rx refil %d",
  2875. soc, mac_for_pdev);
  2876. return status;
  2877. }
  2878. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_for_pdev];
  2879. rxdma_entries = dp_rxdma_srng->num_entries;
  2880. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2881. rx_sw_desc_num = wlan_cfg_get_dp_soc_rx_sw_desc_num(soc->wlan_cfg_ctx);
  2882. rx_desc_pool->desc_type = QDF_DP_RX_DESC_BUF_TYPE;
  2883. status = dp_rx_desc_pool_alloc(soc,
  2884. rx_sw_desc_num,
  2885. rx_desc_pool);
  2886. if (status != QDF_STATUS_SUCCESS)
  2887. return status;
  2888. return status;
  2889. }
  2890. void dp_rx_pdev_desc_pool_free(struct dp_pdev *pdev)
  2891. {
  2892. int mac_for_pdev = pdev->lmac_id;
  2893. struct dp_soc *soc = pdev->soc;
  2894. struct rx_desc_pool *rx_desc_pool;
  2895. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2896. dp_rx_desc_pool_free(soc, rx_desc_pool);
  2897. }
  2898. QDF_STATUS dp_rx_pdev_desc_pool_init(struct dp_pdev *pdev)
  2899. {
  2900. int mac_for_pdev = pdev->lmac_id;
  2901. struct dp_soc *soc = pdev->soc;
  2902. uint32_t rxdma_entries;
  2903. uint32_t rx_sw_desc_num;
  2904. struct dp_srng *dp_rxdma_srng;
  2905. struct rx_desc_pool *rx_desc_pool;
  2906. uint32_t target_type = hal_get_target_type(soc->hal_soc);
  2907. uint16_t buf_size;
  2908. buf_size = wlan_cfg_rx_buffer_size(soc->wlan_cfg_ctx);
  2909. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2910. if (wlan_cfg_get_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx)) {
  2911. /*
  2912. * If NSS is enabled, rx_desc_pool is already filled.
  2913. * Hence, just disable desc_pool frag flag.
  2914. */
  2915. dp_rx_enable_mon_dest_frag(rx_desc_pool, false);
  2916. dp_rx_info("%pK: nss-wifi<4> skip Rx refil %d",
  2917. soc, mac_for_pdev);
  2918. return QDF_STATUS_SUCCESS;
  2919. }
  2920. if (dp_rx_desc_pool_is_allocated(rx_desc_pool) == QDF_STATUS_E_NOMEM)
  2921. return QDF_STATUS_E_NOMEM;
  2922. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_for_pdev];
  2923. rxdma_entries = dp_rxdma_srng->num_entries;
  2924. soc->process_rx_status = CONFIG_PROCESS_RX_STATUS;
  2925. rx_sw_desc_num =
  2926. wlan_cfg_get_dp_soc_rx_sw_desc_num(soc->wlan_cfg_ctx);
  2927. rx_desc_pool->owner = dp_rx_get_rx_bm_id(soc);
  2928. rx_desc_pool->buf_size = buf_size;
  2929. rx_desc_pool->buf_alignment = RX_DATA_BUFFER_ALIGNMENT;
  2930. /* Disable monitor dest processing via frag */
  2931. if (target_type == TARGET_TYPE_QCN9160) {
  2932. rx_desc_pool->buf_size = RX_MONITOR_BUFFER_SIZE;
  2933. rx_desc_pool->buf_alignment = RX_MONITOR_BUFFER_ALIGNMENT;
  2934. dp_rx_enable_mon_dest_frag(rx_desc_pool, true);
  2935. } else {
  2936. dp_rx_enable_mon_dest_frag(rx_desc_pool, false);
  2937. }
  2938. dp_rx_desc_pool_init(soc, mac_for_pdev,
  2939. rx_sw_desc_num, rx_desc_pool);
  2940. return QDF_STATUS_SUCCESS;
  2941. }
  2942. void dp_rx_pdev_desc_pool_deinit(struct dp_pdev *pdev)
  2943. {
  2944. int mac_for_pdev = pdev->lmac_id;
  2945. struct dp_soc *soc = pdev->soc;
  2946. struct rx_desc_pool *rx_desc_pool;
  2947. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2948. dp_rx_desc_pool_deinit(soc, rx_desc_pool, mac_for_pdev);
  2949. }
  2950. QDF_STATUS
  2951. dp_rx_pdev_buffers_alloc(struct dp_pdev *pdev)
  2952. {
  2953. int mac_for_pdev = pdev->lmac_id;
  2954. struct dp_soc *soc = pdev->soc;
  2955. struct dp_srng *dp_rxdma_srng;
  2956. struct rx_desc_pool *rx_desc_pool;
  2957. uint32_t rxdma_entries;
  2958. uint32_t target_type = hal_get_target_type(soc->hal_soc);
  2959. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_for_pdev];
  2960. rxdma_entries = dp_rxdma_srng->num_entries;
  2961. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2962. /* Initialize RX buffer pool which will be
  2963. * used during low memory conditions
  2964. */
  2965. dp_rx_buffer_pool_init(soc, mac_for_pdev);
  2966. if (target_type == TARGET_TYPE_QCN9160)
  2967. return dp_pdev_rx_buffers_attach(soc, mac_for_pdev,
  2968. dp_rxdma_srng,
  2969. rx_desc_pool,
  2970. rxdma_entries - 1);
  2971. else
  2972. return dp_pdev_rx_buffers_attach_simple(soc, mac_for_pdev,
  2973. dp_rxdma_srng,
  2974. rx_desc_pool,
  2975. rxdma_entries - 1);
  2976. }
  2977. void
  2978. dp_rx_pdev_buffers_free(struct dp_pdev *pdev)
  2979. {
  2980. int mac_for_pdev = pdev->lmac_id;
  2981. struct dp_soc *soc = pdev->soc;
  2982. struct rx_desc_pool *rx_desc_pool;
  2983. uint32_t target_type = hal_get_target_type(soc->hal_soc);
  2984. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2985. if (target_type == TARGET_TYPE_QCN9160)
  2986. dp_rx_desc_frag_free(soc, rx_desc_pool);
  2987. else
  2988. dp_rx_desc_nbuf_free(soc, rx_desc_pool, false);
  2989. dp_rx_buffer_pool_deinit(soc, mac_for_pdev);
  2990. }
  2991. #ifdef DP_RX_SPECIAL_FRAME_NEED
  2992. bool dp_rx_deliver_special_frame(struct dp_soc *soc,
  2993. struct dp_txrx_peer *txrx_peer,
  2994. qdf_nbuf_t nbuf, uint32_t frame_mask,
  2995. uint8_t *rx_tlv_hdr)
  2996. {
  2997. uint32_t l2_hdr_offset = 0;
  2998. uint16_t msdu_len = 0;
  2999. uint32_t skip_len;
  3000. l2_hdr_offset =
  3001. hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc, rx_tlv_hdr);
  3002. if (qdf_unlikely(qdf_nbuf_is_frag(nbuf))) {
  3003. skip_len = l2_hdr_offset;
  3004. } else {
  3005. msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  3006. skip_len = l2_hdr_offset + soc->rx_pkt_tlv_size;
  3007. qdf_nbuf_set_pktlen(nbuf, msdu_len + skip_len);
  3008. }
  3009. QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(nbuf) = 1;
  3010. dp_rx_set_hdr_pad(nbuf, l2_hdr_offset);
  3011. qdf_nbuf_pull_head(nbuf, skip_len);
  3012. if (txrx_peer->vdev) {
  3013. dp_rx_send_pktlog(soc, txrx_peer->vdev->pdev, nbuf,
  3014. QDF_TX_RX_STATUS_OK);
  3015. }
  3016. if (dp_rx_is_special_frame(nbuf, frame_mask)) {
  3017. dp_info("special frame, mpdu sn 0x%x",
  3018. hal_rx_get_rx_sequence(soc->hal_soc, rx_tlv_hdr));
  3019. qdf_nbuf_set_exc_frame(nbuf, 1);
  3020. dp_rx_deliver_to_stack(soc, txrx_peer->vdev, txrx_peer,
  3021. nbuf, NULL);
  3022. return true;
  3023. }
  3024. return false;
  3025. }
  3026. #endif
  3027. #ifdef QCA_MULTIPASS_SUPPORT
  3028. bool dp_rx_multipass_process(struct dp_txrx_peer *txrx_peer, qdf_nbuf_t nbuf,
  3029. uint8_t tid)
  3030. {
  3031. struct vlan_ethhdr *vethhdrp;
  3032. if (qdf_unlikely(!txrx_peer->vlan_id))
  3033. return true;
  3034. vethhdrp = (struct vlan_ethhdr *)qdf_nbuf_data(nbuf);
  3035. /*
  3036. * h_vlan_proto & h_vlan_TCI should be 0x8100 & zero respectively
  3037. * as it is expected to be padded by 0
  3038. * return false if frame doesn't have above tag so that caller will
  3039. * drop the frame.
  3040. */
  3041. if (qdf_unlikely(vethhdrp->h_vlan_proto != htons(QDF_ETH_TYPE_8021Q)) ||
  3042. qdf_unlikely(vethhdrp->h_vlan_TCI != 0))
  3043. return false;
  3044. vethhdrp->h_vlan_TCI = htons(((tid & 0x7) << VLAN_PRIO_SHIFT) |
  3045. (txrx_peer->vlan_id & VLAN_VID_MASK));
  3046. if (vethhdrp->h_vlan_encapsulated_proto == htons(ETHERTYPE_PAE))
  3047. dp_tx_remove_vlan_tag(txrx_peer->vdev, nbuf);
  3048. return true;
  3049. }
  3050. #endif /* QCA_MULTIPASS_SUPPORT */