dp_rx.c 92 KB

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