dp_rx.c 72 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625
  1. /*
  2. * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for
  5. * any purpose with or without fee is hereby granted, provided that the
  6. * above copyright notice and this permission notice appear in all
  7. * copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16. * PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #include "hal_hw_headers.h"
  19. #include "dp_types.h"
  20. #include "dp_rx.h"
  21. #include "dp_tx.h"
  22. #include "dp_peer.h"
  23. #include "hal_rx.h"
  24. #include "hal_api.h"
  25. #include "qdf_nbuf.h"
  26. #ifdef MESH_MODE_SUPPORT
  27. #include "if_meta_hdr.h"
  28. #endif
  29. #include "dp_internal.h"
  30. #include "dp_ipa.h"
  31. #include "dp_hist.h"
  32. #include "dp_rx_buffer_pool.h"
  33. #ifdef WIFI_MONITOR_SUPPORT
  34. #include "dp_htt.h"
  35. #include <dp_mon.h>
  36. #endif
  37. #ifdef FEATURE_WDS
  38. #include "dp_txrx_wds.h"
  39. #endif
  40. #ifdef DUP_RX_DESC_WAR
  41. void dp_rx_dump_info_and_assert(struct dp_soc *soc,
  42. hal_ring_handle_t hal_ring,
  43. hal_ring_desc_t ring_desc,
  44. struct dp_rx_desc *rx_desc)
  45. {
  46. void *hal_soc = soc->hal_soc;
  47. hal_srng_dump_ring_desc(hal_soc, hal_ring, ring_desc);
  48. dp_rx_desc_dump(rx_desc);
  49. }
  50. #else
  51. void dp_rx_dump_info_and_assert(struct dp_soc *soc,
  52. hal_ring_handle_t hal_ring_hdl,
  53. hal_ring_desc_t ring_desc,
  54. struct dp_rx_desc *rx_desc)
  55. {
  56. hal_soc_handle_t hal_soc = soc->hal_soc;
  57. dp_rx_desc_dump(rx_desc);
  58. hal_srng_dump_ring_desc(hal_soc, hal_ring_hdl, ring_desc);
  59. hal_srng_dump_ring(hal_soc, hal_ring_hdl);
  60. qdf_assert_always(0);
  61. }
  62. #endif
  63. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  64. #ifdef RX_DESC_SANITY_WAR
  65. QDF_STATUS dp_rx_desc_sanity(struct dp_soc *soc, hal_soc_handle_t hal_soc,
  66. hal_ring_handle_t hal_ring_hdl,
  67. hal_ring_desc_t ring_desc,
  68. struct dp_rx_desc *rx_desc)
  69. {
  70. uint8_t return_buffer_manager;
  71. if (qdf_unlikely(!rx_desc)) {
  72. /*
  73. * This is an unlikely case where the cookie obtained
  74. * from the ring_desc is invalid and hence we are not
  75. * able to find the corresponding rx_desc
  76. */
  77. goto fail;
  78. }
  79. return_buffer_manager = hal_rx_ret_buf_manager_get(hal_soc, ring_desc);
  80. if (qdf_unlikely(!(return_buffer_manager ==
  81. HAL_RX_BUF_RBM_SW1_BM(soc->wbm_sw0_bm_id) ||
  82. return_buffer_manager ==
  83. HAL_RX_BUF_RBM_SW3_BM(soc->wbm_sw0_bm_id)))) {
  84. goto fail;
  85. }
  86. return QDF_STATUS_SUCCESS;
  87. fail:
  88. DP_STATS_INC(soc, rx.err.invalid_cookie, 1);
  89. dp_err("Ring Desc:");
  90. hal_srng_dump_ring_desc(hal_soc, hal_ring_hdl,
  91. ring_desc);
  92. return QDF_STATUS_E_NULL_VALUE;
  93. }
  94. #endif
  95. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  96. /**
  97. * dp_pdev_frag_alloc_and_map() - Allocate frag for desc buffer and map
  98. *
  99. * @dp_soc: struct dp_soc *
  100. * @nbuf_frag_info_t: nbuf frag info
  101. * @dp_pdev: struct dp_pdev *
  102. * @rx_desc_pool: Rx desc pool
  103. *
  104. * Return: QDF_STATUS
  105. */
  106. #ifdef DP_RX_MON_MEM_FRAG
  107. static inline QDF_STATUS
  108. dp_pdev_frag_alloc_and_map(struct dp_soc *dp_soc,
  109. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  110. struct dp_pdev *dp_pdev,
  111. struct rx_desc_pool *rx_desc_pool)
  112. {
  113. QDF_STATUS ret = QDF_STATUS_E_FAILURE;
  114. (nbuf_frag_info_t->virt_addr).vaddr =
  115. qdf_frag_alloc(rx_desc_pool->buf_size);
  116. if (!((nbuf_frag_info_t->virt_addr).vaddr)) {
  117. dp_err("Frag alloc failed");
  118. DP_STATS_INC(dp_pdev, replenish.frag_alloc_fail, 1);
  119. return QDF_STATUS_E_NOMEM;
  120. }
  121. ret = qdf_mem_map_page(dp_soc->osdev,
  122. (nbuf_frag_info_t->virt_addr).vaddr,
  123. QDF_DMA_FROM_DEVICE,
  124. rx_desc_pool->buf_size,
  125. &nbuf_frag_info_t->paddr);
  126. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  127. qdf_frag_free((nbuf_frag_info_t->virt_addr).vaddr);
  128. dp_err("Frag map failed");
  129. DP_STATS_INC(dp_pdev, replenish.map_err, 1);
  130. return QDF_STATUS_E_FAULT;
  131. }
  132. return QDF_STATUS_SUCCESS;
  133. }
  134. #else
  135. static inline QDF_STATUS
  136. dp_pdev_frag_alloc_and_map(struct dp_soc *dp_soc,
  137. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  138. struct dp_pdev *dp_pdev,
  139. struct rx_desc_pool *rx_desc_pool)
  140. {
  141. return QDF_STATUS_SUCCESS;
  142. }
  143. #endif /* DP_RX_MON_MEM_FRAG */
  144. #ifdef WLAN_FEATURE_DP_RX_RING_HISTORY
  145. /**
  146. * dp_rx_refill_ring_record_entry() - Record an entry into refill_ring history
  147. * @soc: Datapath soc structure
  148. * @ring_num: Refill ring number
  149. * @num_req: number of buffers requested for refill
  150. * @num_refill: number of buffers refilled
  151. *
  152. * Returns: None
  153. */
  154. static inline void
  155. dp_rx_refill_ring_record_entry(struct dp_soc *soc, uint8_t ring_num,
  156. hal_ring_handle_t hal_ring_hdl,
  157. uint32_t num_req, uint32_t num_refill)
  158. {
  159. struct dp_refill_info_record *record;
  160. uint32_t idx;
  161. uint32_t tp;
  162. uint32_t hp;
  163. if (qdf_unlikely(ring_num >= MAX_PDEV_CNT ||
  164. !soc->rx_refill_ring_history[ring_num]))
  165. return;
  166. idx = dp_history_get_next_index(&soc->rx_refill_ring_history[ring_num]->index,
  167. DP_RX_REFILL_HIST_MAX);
  168. /* No NULL check needed for record since its an array */
  169. record = &soc->rx_refill_ring_history[ring_num]->entry[idx];
  170. hal_get_sw_hptp(soc->hal_soc, hal_ring_hdl, &tp, &hp);
  171. record->timestamp = qdf_get_log_timestamp();
  172. record->num_req = num_req;
  173. record->num_refill = num_refill;
  174. record->hp = hp;
  175. record->tp = tp;
  176. }
  177. #else
  178. static inline void
  179. dp_rx_refill_ring_record_entry(struct dp_soc *soc, uint8_t ring_num,
  180. hal_ring_handle_t hal_ring_hdl,
  181. uint32_t num_req, uint32_t num_refill)
  182. {
  183. }
  184. #endif
  185. /**
  186. * dp_pdev_nbuf_alloc_and_map() - Allocate nbuf for desc buffer and map
  187. *
  188. * @dp_soc: struct dp_soc *
  189. * @mac_id: Mac id
  190. * @num_entries_avail: num_entries_avail
  191. * @nbuf_frag_info_t: nbuf frag info
  192. * @dp_pdev: struct dp_pdev *
  193. * @rx_desc_pool: Rx desc pool
  194. *
  195. * Return: QDF_STATUS
  196. */
  197. static inline QDF_STATUS
  198. dp_pdev_nbuf_alloc_and_map_replenish(struct dp_soc *dp_soc,
  199. uint32_t mac_id,
  200. uint32_t num_entries_avail,
  201. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  202. struct dp_pdev *dp_pdev,
  203. struct rx_desc_pool *rx_desc_pool)
  204. {
  205. QDF_STATUS ret = QDF_STATUS_E_FAILURE;
  206. (nbuf_frag_info_t->virt_addr).nbuf =
  207. dp_rx_buffer_pool_nbuf_alloc(dp_soc,
  208. mac_id,
  209. rx_desc_pool,
  210. num_entries_avail);
  211. if (!((nbuf_frag_info_t->virt_addr).nbuf)) {
  212. dp_err("nbuf alloc failed");
  213. DP_STATS_INC(dp_pdev, replenish.nbuf_alloc_fail, 1);
  214. return QDF_STATUS_E_NOMEM;
  215. }
  216. ret = dp_rx_buffer_pool_nbuf_map(dp_soc, rx_desc_pool,
  217. nbuf_frag_info_t);
  218. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  219. dp_rx_buffer_pool_nbuf_free(dp_soc,
  220. (nbuf_frag_info_t->virt_addr).nbuf, mac_id);
  221. dp_err("nbuf map failed");
  222. DP_STATS_INC(dp_pdev, replenish.map_err, 1);
  223. return QDF_STATUS_E_FAULT;
  224. }
  225. nbuf_frag_info_t->paddr =
  226. qdf_nbuf_get_frag_paddr((nbuf_frag_info_t->virt_addr).nbuf, 0);
  227. dp_ipa_handle_rx_buf_smmu_mapping(dp_soc,
  228. (qdf_nbuf_t)((nbuf_frag_info_t->virt_addr).nbuf),
  229. rx_desc_pool->buf_size,
  230. true);
  231. ret = dp_check_paddr(dp_soc, &((nbuf_frag_info_t->virt_addr).nbuf),
  232. &nbuf_frag_info_t->paddr,
  233. rx_desc_pool);
  234. if (ret == QDF_STATUS_E_FAILURE) {
  235. DP_STATS_INC(dp_pdev, replenish.x86_fail, 1);
  236. return QDF_STATUS_E_ADDRNOTAVAIL;
  237. }
  238. return QDF_STATUS_SUCCESS;
  239. }
  240. /*
  241. * dp_rx_buffers_replenish() - replenish rxdma ring with rx nbufs
  242. * called during dp rx initialization
  243. * and at the end of dp_rx_process.
  244. *
  245. * @soc: core txrx main context
  246. * @mac_id: mac_id which is one of 3 mac_ids
  247. * @dp_rxdma_srng: dp rxdma circular ring
  248. * @rx_desc_pool: Pointer to free Rx descriptor pool
  249. * @num_req_buffers: number of buffer to be replenished
  250. * @desc_list: list of descs if called from dp_rx_process
  251. * or NULL during dp rx initialization or out of buffer
  252. * interrupt.
  253. * @tail: tail of descs list
  254. * @func_name: name of the caller function
  255. * Return: return success or failure
  256. */
  257. QDF_STATUS __dp_rx_buffers_replenish(struct dp_soc *dp_soc, uint32_t mac_id,
  258. struct dp_srng *dp_rxdma_srng,
  259. struct rx_desc_pool *rx_desc_pool,
  260. uint32_t num_req_buffers,
  261. union dp_rx_desc_list_elem_t **desc_list,
  262. union dp_rx_desc_list_elem_t **tail,
  263. const char *func_name)
  264. {
  265. uint32_t num_alloc_desc;
  266. uint16_t num_desc_to_free = 0;
  267. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(dp_soc, mac_id);
  268. uint32_t num_entries_avail;
  269. uint32_t count;
  270. int sync_hw_ptr = 1;
  271. struct dp_rx_nbuf_frag_info nbuf_frag_info = {0};
  272. void *rxdma_ring_entry;
  273. union dp_rx_desc_list_elem_t *next;
  274. QDF_STATUS ret;
  275. void *rxdma_srng;
  276. rxdma_srng = dp_rxdma_srng->hal_srng;
  277. if (qdf_unlikely(!dp_pdev)) {
  278. dp_rx_err("%pK: pdev is null for mac_id = %d",
  279. dp_soc, mac_id);
  280. return QDF_STATUS_E_FAILURE;
  281. }
  282. if (qdf_unlikely(!rxdma_srng)) {
  283. dp_rx_debug("%pK: rxdma srng not initialized", dp_soc);
  284. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  285. return QDF_STATUS_E_FAILURE;
  286. }
  287. dp_rx_debug("%pK: requested %d buffers for replenish",
  288. dp_soc, num_req_buffers);
  289. hal_srng_access_start(dp_soc->hal_soc, rxdma_srng);
  290. num_entries_avail = hal_srng_src_num_avail(dp_soc->hal_soc,
  291. rxdma_srng,
  292. sync_hw_ptr);
  293. dp_rx_debug("%pK: no of available entries in rxdma ring: %d",
  294. dp_soc, num_entries_avail);
  295. if (!(*desc_list) && (num_entries_avail >
  296. ((dp_rxdma_srng->num_entries * 3) / 4))) {
  297. num_req_buffers = num_entries_avail;
  298. } else if (num_entries_avail < num_req_buffers) {
  299. num_desc_to_free = num_req_buffers - num_entries_avail;
  300. num_req_buffers = num_entries_avail;
  301. }
  302. if (qdf_unlikely(!num_req_buffers)) {
  303. num_desc_to_free = num_req_buffers;
  304. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  305. goto free_descs;
  306. }
  307. /*
  308. * if desc_list is NULL, allocate the descs from freelist
  309. */
  310. if (!(*desc_list)) {
  311. num_alloc_desc = dp_rx_get_free_desc_list(dp_soc, mac_id,
  312. rx_desc_pool,
  313. num_req_buffers,
  314. desc_list,
  315. tail);
  316. if (!num_alloc_desc) {
  317. dp_rx_err("%pK: no free rx_descs in freelist", dp_soc);
  318. DP_STATS_INC(dp_pdev, err.desc_alloc_fail,
  319. num_req_buffers);
  320. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  321. return QDF_STATUS_E_NOMEM;
  322. }
  323. dp_rx_debug("%pK: %d rx desc allocated", dp_soc, num_alloc_desc);
  324. num_req_buffers = num_alloc_desc;
  325. }
  326. count = 0;
  327. while (count < num_req_buffers) {
  328. /* Flag is set while pdev rx_desc_pool initialization */
  329. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  330. ret = dp_pdev_frag_alloc_and_map(dp_soc,
  331. &nbuf_frag_info,
  332. dp_pdev,
  333. rx_desc_pool);
  334. else
  335. ret = dp_pdev_nbuf_alloc_and_map_replenish(dp_soc,
  336. mac_id,
  337. num_entries_avail, &nbuf_frag_info,
  338. dp_pdev, rx_desc_pool);
  339. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  340. if (qdf_unlikely(ret == QDF_STATUS_E_FAULT))
  341. continue;
  342. break;
  343. }
  344. count++;
  345. rxdma_ring_entry = hal_srng_src_get_next(dp_soc->hal_soc,
  346. rxdma_srng);
  347. qdf_assert_always(rxdma_ring_entry);
  348. next = (*desc_list)->next;
  349. /* Flag is set while pdev rx_desc_pool initialization */
  350. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  351. dp_rx_desc_frag_prep(&((*desc_list)->rx_desc),
  352. &nbuf_frag_info);
  353. else
  354. dp_rx_desc_prep(&((*desc_list)->rx_desc),
  355. &nbuf_frag_info);
  356. /* rx_desc.in_use should be zero at this time*/
  357. qdf_assert_always((*desc_list)->rx_desc.in_use == 0);
  358. (*desc_list)->rx_desc.in_use = 1;
  359. (*desc_list)->rx_desc.in_err_state = 0;
  360. dp_rx_desc_update_dbg_info(&(*desc_list)->rx_desc,
  361. func_name, RX_DESC_REPLENISHED);
  362. dp_verbose_debug("rx_netbuf=%pK, paddr=0x%llx, cookie=%d",
  363. nbuf_frag_info.virt_addr.nbuf,
  364. (unsigned long long)(nbuf_frag_info.paddr),
  365. (*desc_list)->rx_desc.cookie);
  366. hal_rxdma_buff_addr_info_set(dp_soc->hal_soc, rxdma_ring_entry,
  367. nbuf_frag_info.paddr,
  368. (*desc_list)->rx_desc.cookie,
  369. rx_desc_pool->owner);
  370. *desc_list = next;
  371. }
  372. dp_rx_refill_ring_record_entry(dp_soc, dp_pdev->lmac_id, rxdma_srng,
  373. num_req_buffers, count);
  374. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  375. dp_rx_schedule_refill_thread(dp_soc);
  376. dp_verbose_debug("replenished buffers %d, rx desc added back to free list %u",
  377. count, num_desc_to_free);
  378. /* No need to count the number of bytes received during replenish.
  379. * Therefore set replenish.pkts.bytes as 0.
  380. */
  381. DP_STATS_INC_PKT(dp_pdev, replenish.pkts, count, 0);
  382. free_descs:
  383. DP_STATS_INC(dp_pdev, buf_freelist, num_desc_to_free);
  384. /*
  385. * add any available free desc back to the free list
  386. */
  387. if (*desc_list)
  388. dp_rx_add_desc_list_to_free_list(dp_soc, desc_list, tail,
  389. mac_id, rx_desc_pool);
  390. return QDF_STATUS_SUCCESS;
  391. }
  392. qdf_export_symbol(__dp_rx_buffers_replenish);
  393. /*
  394. * dp_rx_deliver_raw() - process RAW mode pkts and hand over the
  395. * pkts to RAW mode simulation to
  396. * decapsulate the pkt.
  397. *
  398. * @vdev: vdev on which RAW mode is enabled
  399. * @nbuf_list: list of RAW pkts to process
  400. * @peer: peer object from which the pkt is rx
  401. *
  402. * Return: void
  403. */
  404. void
  405. dp_rx_deliver_raw(struct dp_vdev *vdev, qdf_nbuf_t nbuf_list,
  406. struct dp_peer *peer)
  407. {
  408. qdf_nbuf_t deliver_list_head = NULL;
  409. qdf_nbuf_t deliver_list_tail = NULL;
  410. qdf_nbuf_t nbuf;
  411. nbuf = nbuf_list;
  412. while (nbuf) {
  413. qdf_nbuf_t next = qdf_nbuf_next(nbuf);
  414. DP_RX_LIST_APPEND(deliver_list_head, deliver_list_tail, nbuf);
  415. DP_STATS_INC(vdev->pdev, rx_raw_pkts, 1);
  416. DP_STATS_INC_PKT(peer, rx.raw, 1, qdf_nbuf_len(nbuf));
  417. /*
  418. * reset the chfrag_start and chfrag_end bits in nbuf cb
  419. * as this is a non-amsdu pkt and RAW mode simulation expects
  420. * these bit s to be 0 for non-amsdu pkt.
  421. */
  422. if (qdf_nbuf_is_rx_chfrag_start(nbuf) &&
  423. qdf_nbuf_is_rx_chfrag_end(nbuf)) {
  424. qdf_nbuf_set_rx_chfrag_start(nbuf, 0);
  425. qdf_nbuf_set_rx_chfrag_end(nbuf, 0);
  426. }
  427. nbuf = next;
  428. }
  429. vdev->osif_rsim_rx_decap(vdev->osif_vdev, &deliver_list_head,
  430. &deliver_list_tail, peer->mac_addr.raw);
  431. vdev->osif_rx(vdev->osif_vdev, deliver_list_head);
  432. }
  433. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  434. #ifndef FEATURE_WDS
  435. void dp_rx_da_learn(struct dp_soc *soc, uint8_t *rx_tlv_hdr,
  436. struct dp_peer *ta_peer, qdf_nbuf_t nbuf)
  437. {
  438. }
  439. #endif
  440. /*
  441. * dp_rx_intrabss_fwd() - Implements the Intra-BSS forwarding logic
  442. *
  443. * @soc: core txrx main context
  444. * @ta_peer : source peer entry
  445. * @rx_tlv_hdr : start address of rx tlvs
  446. * @nbuf : nbuf that has to be intrabss forwarded
  447. *
  448. * Return: bool: true if it is forwarded else false
  449. */
  450. bool
  451. dp_rx_intrabss_fwd(struct dp_soc *soc,
  452. struct dp_peer *ta_peer,
  453. uint8_t *rx_tlv_hdr,
  454. qdf_nbuf_t nbuf,
  455. struct hal_rx_msdu_metadata msdu_metadata)
  456. {
  457. uint16_t len;
  458. uint8_t is_frag;
  459. uint16_t da_peer_id = HTT_INVALID_PEER;
  460. struct dp_peer *da_peer = NULL;
  461. bool is_da_bss_peer = false;
  462. struct dp_ast_entry *ast_entry;
  463. qdf_nbuf_t nbuf_copy;
  464. uint8_t tid = qdf_nbuf_get_tid_val(nbuf);
  465. uint8_t ring_id = QDF_NBUF_CB_RX_CTX_ID(nbuf);
  466. struct cdp_tid_rx_stats *tid_stats = &ta_peer->vdev->pdev->stats.
  467. tid_stats.tid_rx_stats[ring_id][tid];
  468. /* check if the destination peer is available in peer table
  469. * and also check if the source peer and destination peer
  470. * belong to the same vap and destination peer is not bss peer.
  471. */
  472. if ((qdf_nbuf_is_da_valid(nbuf) && !qdf_nbuf_is_da_mcbc(nbuf))) {
  473. if (dp_rx_intrabss_eapol_drop_check(soc, ta_peer, rx_tlv_hdr,
  474. nbuf))
  475. return true;
  476. ast_entry = soc->ast_table[msdu_metadata.da_idx];
  477. if (!ast_entry)
  478. return false;
  479. if (ast_entry->type == CDP_TXRX_AST_TYPE_DA) {
  480. ast_entry->is_active = TRUE;
  481. return false;
  482. }
  483. da_peer_id = ast_entry->peer_id;
  484. if (da_peer_id == HTT_INVALID_PEER)
  485. return false;
  486. /* TA peer cannot be same as peer(DA) on which AST is present
  487. * this indicates a change in topology and that AST entries
  488. * are yet to be updated.
  489. */
  490. if (da_peer_id == ta_peer->peer_id)
  491. return false;
  492. if (ast_entry->vdev_id != ta_peer->vdev->vdev_id)
  493. return false;
  494. da_peer = dp_peer_get_ref_by_id(soc, da_peer_id,
  495. DP_MOD_ID_RX);
  496. if (!da_peer)
  497. return false;
  498. /* If the source or destination peer in the isolation
  499. * list then dont forward instead push to bridge stack.
  500. */
  501. if (dp_get_peer_isolation(ta_peer) ||
  502. dp_get_peer_isolation(da_peer)) {
  503. dp_peer_unref_delete(da_peer, DP_MOD_ID_RX);
  504. return false;
  505. }
  506. is_da_bss_peer = da_peer->bss_peer;
  507. dp_peer_unref_delete(da_peer, DP_MOD_ID_RX);
  508. if (!is_da_bss_peer) {
  509. len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  510. is_frag = qdf_nbuf_is_frag(nbuf);
  511. memset(nbuf->cb, 0x0, sizeof(nbuf->cb));
  512. /* linearize the nbuf just before we send to
  513. * dp_tx_send()
  514. */
  515. if (qdf_unlikely(is_frag)) {
  516. if (qdf_nbuf_linearize(nbuf) == -ENOMEM)
  517. return false;
  518. nbuf = qdf_nbuf_unshare(nbuf);
  519. if (!nbuf) {
  520. DP_STATS_INC_PKT(ta_peer,
  521. rx.intra_bss.fail,
  522. 1,
  523. len);
  524. /* return true even though the pkt is
  525. * not forwarded. Basically skb_unshare
  526. * failed and we want to continue with
  527. * next nbuf.
  528. */
  529. tid_stats->fail_cnt[INTRABSS_DROP]++;
  530. return true;
  531. }
  532. }
  533. if (!dp_tx_send((struct cdp_soc_t *)soc,
  534. ta_peer->vdev->vdev_id, nbuf)) {
  535. DP_STATS_INC_PKT(ta_peer, rx.intra_bss.pkts, 1,
  536. len);
  537. return true;
  538. } else {
  539. DP_STATS_INC_PKT(ta_peer, rx.intra_bss.fail, 1,
  540. len);
  541. tid_stats->fail_cnt[INTRABSS_DROP]++;
  542. return false;
  543. }
  544. }
  545. }
  546. /* if it is a broadcast pkt (eg: ARP) and it is not its own
  547. * source, then clone the pkt and send the cloned pkt for
  548. * intra BSS forwarding and original pkt up the network stack
  549. * Note: how do we handle multicast pkts. do we forward
  550. * all multicast pkts as is or let a higher layer module
  551. * like igmpsnoop decide whether to forward or not with
  552. * Mcast enhancement.
  553. */
  554. else if (qdf_unlikely((qdf_nbuf_is_da_mcbc(nbuf) &&
  555. !ta_peer->bss_peer))) {
  556. if (dp_rx_intrabss_eapol_drop_check(soc, ta_peer, rx_tlv_hdr,
  557. nbuf))
  558. return true;
  559. if (!dp_rx_check_ndi_mdns_fwding(ta_peer, nbuf))
  560. goto end;
  561. /* If the source peer in the isolation list
  562. * then dont forward instead push to bridge stack
  563. */
  564. if (dp_get_peer_isolation(ta_peer))
  565. goto end;
  566. nbuf_copy = qdf_nbuf_copy(nbuf);
  567. if (!nbuf_copy)
  568. goto end;
  569. len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  570. if (dp_tx_send((struct cdp_soc_t *)soc,
  571. ta_peer->vdev->vdev_id, nbuf_copy)) {
  572. DP_STATS_INC_PKT(ta_peer, rx.intra_bss.fail, 1, len);
  573. tid_stats->fail_cnt[INTRABSS_DROP]++;
  574. qdf_nbuf_free(nbuf_copy);
  575. } else {
  576. DP_STATS_INC_PKT(ta_peer, rx.intra_bss.pkts, 1, len);
  577. tid_stats->intrabss_cnt++;
  578. }
  579. }
  580. end:
  581. /* return false as we have to still send the original pkt
  582. * up the stack
  583. */
  584. return false;
  585. }
  586. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  587. #ifdef MESH_MODE_SUPPORT
  588. /**
  589. * dp_rx_fill_mesh_stats() - Fills the mesh per packet receive stats
  590. *
  591. * @vdev: DP Virtual device handle
  592. * @nbuf: Buffer pointer
  593. * @rx_tlv_hdr: start of rx tlv header
  594. * @peer: pointer to peer
  595. *
  596. * This function allocated memory for mesh receive stats and fill the
  597. * required stats. Stores the memory address in skb cb.
  598. *
  599. * Return: void
  600. */
  601. void dp_rx_fill_mesh_stats(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  602. uint8_t *rx_tlv_hdr, struct dp_peer *peer)
  603. {
  604. struct mesh_recv_hdr_s *rx_info = NULL;
  605. uint32_t pkt_type;
  606. uint32_t nss;
  607. uint32_t rate_mcs;
  608. uint32_t bw;
  609. uint8_t primary_chan_num;
  610. uint32_t center_chan_freq;
  611. struct dp_soc *soc = vdev->pdev->soc;
  612. /* fill recv mesh stats */
  613. rx_info = qdf_mem_malloc(sizeof(struct mesh_recv_hdr_s));
  614. /* upper layers are resposible to free this memory */
  615. if (!rx_info) {
  616. dp_rx_err("%pK: Memory allocation failed for mesh rx stats",
  617. vdev->pdev->soc);
  618. DP_STATS_INC(vdev->pdev, mesh_mem_alloc, 1);
  619. return;
  620. }
  621. rx_info->rs_flags = MESH_RXHDR_VER1;
  622. if (qdf_nbuf_is_rx_chfrag_start(nbuf))
  623. rx_info->rs_flags |= MESH_RX_FIRST_MSDU;
  624. if (qdf_nbuf_is_rx_chfrag_end(nbuf))
  625. rx_info->rs_flags |= MESH_RX_LAST_MSDU;
  626. if (hal_rx_tlv_get_is_decrypted(soc->hal_soc, rx_tlv_hdr)) {
  627. rx_info->rs_flags |= MESH_RX_DECRYPTED;
  628. rx_info->rs_keyix = hal_rx_msdu_get_keyid(soc->hal_soc,
  629. rx_tlv_hdr);
  630. if (vdev->osif_get_key)
  631. vdev->osif_get_key(vdev->osif_vdev,
  632. &rx_info->rs_decryptkey[0],
  633. &peer->mac_addr.raw[0],
  634. rx_info->rs_keyix);
  635. }
  636. rx_info->rs_snr = peer->stats.rx.snr;
  637. rx_info->rs_rssi = rx_info->rs_snr + DP_DEFAULT_NOISEFLOOR;
  638. soc = vdev->pdev->soc;
  639. primary_chan_num = hal_rx_tlv_get_freq(soc->hal_soc, rx_tlv_hdr);
  640. center_chan_freq = hal_rx_tlv_get_freq(soc->hal_soc, rx_tlv_hdr) >> 16;
  641. if (soc->cdp_soc.ol_ops && soc->cdp_soc.ol_ops->freq_to_band) {
  642. rx_info->rs_band = soc->cdp_soc.ol_ops->freq_to_band(
  643. soc->ctrl_psoc,
  644. vdev->pdev->pdev_id,
  645. center_chan_freq);
  646. }
  647. rx_info->rs_channel = primary_chan_num;
  648. pkt_type = hal_rx_tlv_get_pkt_type(soc->hal_soc, rx_tlv_hdr);
  649. rate_mcs = hal_rx_tlv_rate_mcs_get(soc->hal_soc, rx_tlv_hdr);
  650. bw = hal_rx_tlv_bw_get(soc->hal_soc, rx_tlv_hdr);
  651. nss = hal_rx_msdu_start_nss_get(soc->hal_soc, rx_tlv_hdr);
  652. rx_info->rs_ratephy1 = rate_mcs | (nss << 0x8) | (pkt_type << 16) |
  653. (bw << 24);
  654. qdf_nbuf_set_rx_fctx_type(nbuf, (void *)rx_info, CB_FTYPE_MESH_RX_INFO);
  655. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_INFO_MED,
  656. FL("Mesh rx stats: flags %x, rssi %x, chn %x, rate %x, kix %x, snr %x"),
  657. rx_info->rs_flags,
  658. rx_info->rs_rssi,
  659. rx_info->rs_channel,
  660. rx_info->rs_ratephy1,
  661. rx_info->rs_keyix,
  662. rx_info->rs_snr);
  663. }
  664. /**
  665. * dp_rx_filter_mesh_packets() - Filters mesh unwanted packets
  666. *
  667. * @vdev: DP Virtual device handle
  668. * @nbuf: Buffer pointer
  669. * @rx_tlv_hdr: start of rx tlv header
  670. *
  671. * This checks if the received packet is matching any filter out
  672. * catogery and and drop the packet if it matches.
  673. *
  674. * Return: status(0 indicates drop, 1 indicate to no drop)
  675. */
  676. QDF_STATUS dp_rx_filter_mesh_packets(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  677. uint8_t *rx_tlv_hdr)
  678. {
  679. union dp_align_mac_addr mac_addr;
  680. struct dp_soc *soc = vdev->pdev->soc;
  681. if (qdf_unlikely(vdev->mesh_rx_filter)) {
  682. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_FROMDS)
  683. if (hal_rx_mpdu_get_fr_ds(soc->hal_soc,
  684. rx_tlv_hdr))
  685. return QDF_STATUS_SUCCESS;
  686. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_TODS)
  687. if (hal_rx_mpdu_get_to_ds(soc->hal_soc,
  688. rx_tlv_hdr))
  689. return QDF_STATUS_SUCCESS;
  690. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_NODS)
  691. if (!hal_rx_mpdu_get_fr_ds(soc->hal_soc,
  692. rx_tlv_hdr) &&
  693. !hal_rx_mpdu_get_to_ds(soc->hal_soc,
  694. rx_tlv_hdr))
  695. return QDF_STATUS_SUCCESS;
  696. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_RA) {
  697. if (hal_rx_mpdu_get_addr1(soc->hal_soc,
  698. rx_tlv_hdr,
  699. &mac_addr.raw[0]))
  700. return QDF_STATUS_E_FAILURE;
  701. if (!qdf_mem_cmp(&mac_addr.raw[0],
  702. &vdev->mac_addr.raw[0],
  703. QDF_MAC_ADDR_SIZE))
  704. return QDF_STATUS_SUCCESS;
  705. }
  706. if (vdev->mesh_rx_filter & MESH_FILTER_OUT_TA) {
  707. if (hal_rx_mpdu_get_addr2(soc->hal_soc,
  708. rx_tlv_hdr,
  709. &mac_addr.raw[0]))
  710. return QDF_STATUS_E_FAILURE;
  711. if (!qdf_mem_cmp(&mac_addr.raw[0],
  712. &vdev->mac_addr.raw[0],
  713. QDF_MAC_ADDR_SIZE))
  714. return QDF_STATUS_SUCCESS;
  715. }
  716. }
  717. return QDF_STATUS_E_FAILURE;
  718. }
  719. #else
  720. void dp_rx_fill_mesh_stats(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  721. uint8_t *rx_tlv_hdr, struct dp_peer *peer)
  722. {
  723. }
  724. QDF_STATUS dp_rx_filter_mesh_packets(struct dp_vdev *vdev, qdf_nbuf_t nbuf,
  725. uint8_t *rx_tlv_hdr)
  726. {
  727. return QDF_STATUS_E_FAILURE;
  728. }
  729. #endif
  730. #ifdef FEATURE_NAC_RSSI
  731. /**
  732. * dp_rx_process_invalid_peer(): Function to pass invalid peer list to umac
  733. * @soc: DP SOC handle
  734. * @mpdu: mpdu for which peer is invalid
  735. * @mac_id: mac_id which is one of 3 mac_ids(Assuming mac_id and
  736. * pool_id has same mapping)
  737. *
  738. * return: integer type
  739. */
  740. uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu,
  741. uint8_t mac_id)
  742. {
  743. struct dp_invalid_peer_msg msg;
  744. struct dp_vdev *vdev = NULL;
  745. struct dp_pdev *pdev = NULL;
  746. struct ieee80211_frame *wh;
  747. qdf_nbuf_t curr_nbuf, next_nbuf;
  748. uint8_t *rx_tlv_hdr = qdf_nbuf_data(mpdu);
  749. uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(soc->hal_soc, rx_tlv_hdr);
  750. if (!HAL_IS_DECAP_FORMAT_RAW(soc->hal_soc, rx_tlv_hdr)) {
  751. dp_rx_debug("%pK: Drop decapped frames", soc);
  752. goto free;
  753. }
  754. wh = (struct ieee80211_frame *)rx_pkt_hdr;
  755. if (!DP_FRAME_IS_DATA(wh)) {
  756. dp_rx_debug("%pK: NAWDS valid only for data frames", soc);
  757. goto free;
  758. }
  759. if (qdf_nbuf_len(mpdu) < sizeof(struct ieee80211_frame)) {
  760. dp_rx_err("%pK: Invalid nbuf length", soc);
  761. goto free;
  762. }
  763. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  764. if (!pdev || qdf_unlikely(pdev->is_pdev_down)) {
  765. dp_rx_err("%pK: PDEV %s", soc, !pdev ? "not found" : "down");
  766. goto free;
  767. }
  768. if (dp_monitor_filter_neighbour_peer(pdev, rx_pkt_hdr) ==
  769. QDF_STATUS_SUCCESS)
  770. return 0;
  771. TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) {
  772. if (qdf_mem_cmp(wh->i_addr1, vdev->mac_addr.raw,
  773. QDF_MAC_ADDR_SIZE) == 0) {
  774. goto out;
  775. }
  776. }
  777. if (!vdev) {
  778. dp_rx_err("%pK: VDEV not found", soc);
  779. goto free;
  780. }
  781. out:
  782. msg.wh = wh;
  783. qdf_nbuf_pull_head(mpdu, soc->rx_pkt_tlv_size);
  784. msg.nbuf = mpdu;
  785. msg.vdev_id = vdev->vdev_id;
  786. /*
  787. * NOTE: Only valid for HKv1.
  788. * If smart monitor mode is enabled on RE, we are getting invalid
  789. * peer frames with RA as STA mac of RE and the TA not matching
  790. * with any NAC list or the the BSSID.Such frames need to dropped
  791. * in order to avoid HM_WDS false addition.
  792. */
  793. if (pdev->soc->cdp_soc.ol_ops->rx_invalid_peer) {
  794. if (dp_monitor_drop_inv_peer_pkts(vdev) == QDF_STATUS_SUCCESS) {
  795. dp_rx_warn("%pK: Drop inv peer pkts with STA RA:%pm",
  796. soc, wh->i_addr1);
  797. goto free;
  798. }
  799. pdev->soc->cdp_soc.ol_ops->rx_invalid_peer(
  800. (struct cdp_ctrl_objmgr_psoc *)soc->ctrl_psoc,
  801. pdev->pdev_id, &msg);
  802. }
  803. free:
  804. /* Drop and free packet */
  805. curr_nbuf = mpdu;
  806. while (curr_nbuf) {
  807. next_nbuf = qdf_nbuf_next(curr_nbuf);
  808. qdf_nbuf_free(curr_nbuf);
  809. curr_nbuf = next_nbuf;
  810. }
  811. return 0;
  812. }
  813. /**
  814. * dp_rx_process_invalid_peer_wrapper(): Function to wrap invalid peer handler
  815. * @soc: DP SOC handle
  816. * @mpdu: mpdu for which peer is invalid
  817. * @mpdu_done: if an mpdu is completed
  818. * @mac_id: mac_id which is one of 3 mac_ids(Assuming mac_id and
  819. * pool_id has same mapping)
  820. *
  821. * return: integer type
  822. */
  823. void dp_rx_process_invalid_peer_wrapper(struct dp_soc *soc,
  824. qdf_nbuf_t mpdu, bool mpdu_done,
  825. uint8_t mac_id)
  826. {
  827. /* Only trigger the process when mpdu is completed */
  828. if (mpdu_done)
  829. dp_rx_process_invalid_peer(soc, mpdu, mac_id);
  830. }
  831. #else
  832. uint8_t dp_rx_process_invalid_peer(struct dp_soc *soc, qdf_nbuf_t mpdu,
  833. uint8_t mac_id)
  834. {
  835. qdf_nbuf_t curr_nbuf, next_nbuf;
  836. struct dp_pdev *pdev;
  837. struct dp_vdev *vdev = NULL;
  838. struct ieee80211_frame *wh;
  839. uint8_t *rx_tlv_hdr = qdf_nbuf_data(mpdu);
  840. uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(soc->hal_soc, rx_tlv_hdr);
  841. wh = (struct ieee80211_frame *)rx_pkt_hdr;
  842. if (!DP_FRAME_IS_DATA(wh)) {
  843. QDF_TRACE_ERROR_RL(QDF_MODULE_ID_DP,
  844. "only for data frames");
  845. goto free;
  846. }
  847. if (qdf_nbuf_len(mpdu) < sizeof(struct ieee80211_frame)) {
  848. dp_rx_info_rl("%pK: Invalid nbuf length", soc);
  849. goto free;
  850. }
  851. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  852. if (!pdev) {
  853. dp_rx_info_rl("%pK: PDEV not found", soc);
  854. goto free;
  855. }
  856. qdf_spin_lock_bh(&pdev->vdev_list_lock);
  857. DP_PDEV_ITERATE_VDEV_LIST(pdev, vdev) {
  858. if (qdf_mem_cmp(wh->i_addr1, vdev->mac_addr.raw,
  859. QDF_MAC_ADDR_SIZE) == 0) {
  860. qdf_spin_unlock_bh(&pdev->vdev_list_lock);
  861. goto out;
  862. }
  863. }
  864. qdf_spin_unlock_bh(&pdev->vdev_list_lock);
  865. if (!vdev) {
  866. dp_rx_info_rl("%pK: VDEV not found", soc);
  867. goto free;
  868. }
  869. out:
  870. if (soc->cdp_soc.ol_ops->rx_invalid_peer)
  871. soc->cdp_soc.ol_ops->rx_invalid_peer(vdev->vdev_id, wh);
  872. free:
  873. /* reset the head and tail pointers */
  874. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  875. if (pdev) {
  876. pdev->invalid_peer_head_msdu = NULL;
  877. pdev->invalid_peer_tail_msdu = NULL;
  878. }
  879. /* Drop and free packet */
  880. curr_nbuf = mpdu;
  881. while (curr_nbuf) {
  882. next_nbuf = qdf_nbuf_next(curr_nbuf);
  883. qdf_nbuf_free(curr_nbuf);
  884. curr_nbuf = next_nbuf;
  885. }
  886. /* Reset the head and tail pointers */
  887. pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  888. if (pdev) {
  889. pdev->invalid_peer_head_msdu = NULL;
  890. pdev->invalid_peer_tail_msdu = NULL;
  891. }
  892. return 0;
  893. }
  894. void dp_rx_process_invalid_peer_wrapper(struct dp_soc *soc,
  895. qdf_nbuf_t mpdu, bool mpdu_done,
  896. uint8_t mac_id)
  897. {
  898. /* Process the nbuf */
  899. dp_rx_process_invalid_peer(soc, mpdu, mac_id);
  900. }
  901. #endif
  902. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  903. #ifdef RECEIVE_OFFLOAD
  904. /**
  905. * dp_rx_print_offload_info() - Print offload info from RX TLV
  906. * @soc: dp soc handle
  907. * @msdu: MSDU for which the offload info is to be printed
  908. *
  909. * Return: None
  910. */
  911. static void dp_rx_print_offload_info(struct dp_soc *soc,
  912. qdf_nbuf_t msdu)
  913. {
  914. dp_verbose_debug("----------------------RX DESC LRO/GRO----------------------");
  915. dp_verbose_debug("lro_eligible 0x%x",
  916. QDF_NBUF_CB_RX_LRO_ELIGIBLE(msdu));
  917. dp_verbose_debug("pure_ack 0x%x", QDF_NBUF_CB_RX_TCP_PURE_ACK(msdu));
  918. dp_verbose_debug("chksum 0x%x", QDF_NBUF_CB_RX_TCP_CHKSUM(msdu));
  919. dp_verbose_debug("TCP seq num 0x%x", QDF_NBUF_CB_RX_TCP_SEQ_NUM(msdu));
  920. dp_verbose_debug("TCP ack num 0x%x", QDF_NBUF_CB_RX_TCP_ACK_NUM(msdu));
  921. dp_verbose_debug("TCP window 0x%x", QDF_NBUF_CB_RX_TCP_WIN(msdu));
  922. dp_verbose_debug("TCP protocol 0x%x", QDF_NBUF_CB_RX_TCP_PROTO(msdu));
  923. dp_verbose_debug("TCP offset 0x%x", QDF_NBUF_CB_RX_TCP_OFFSET(msdu));
  924. dp_verbose_debug("toeplitz 0x%x", QDF_NBUF_CB_RX_FLOW_ID(msdu));
  925. dp_verbose_debug("---------------------------------------------------------");
  926. }
  927. /**
  928. * dp_rx_fill_gro_info() - Fill GRO info from RX TLV into skb->cb
  929. * @soc: DP SOC handle
  930. * @rx_tlv: RX TLV received for the msdu
  931. * @msdu: msdu for which GRO info needs to be filled
  932. * @rx_ol_pkt_cnt: counter to be incremented for GRO eligible packets
  933. *
  934. * Return: None
  935. */
  936. void dp_rx_fill_gro_info(struct dp_soc *soc, uint8_t *rx_tlv,
  937. qdf_nbuf_t msdu, uint32_t *rx_ol_pkt_cnt)
  938. {
  939. struct hal_offload_info offload_info;
  940. if (!wlan_cfg_is_gro_enabled(soc->wlan_cfg_ctx))
  941. return;
  942. if (hal_rx_tlv_get_offload_info(soc->hal_soc, rx_tlv, &offload_info))
  943. return;
  944. *rx_ol_pkt_cnt = *rx_ol_pkt_cnt + 1;
  945. QDF_NBUF_CB_RX_LRO_ELIGIBLE(msdu) = offload_info.lro_eligible;
  946. QDF_NBUF_CB_RX_TCP_PURE_ACK(msdu) = offload_info.tcp_pure_ack;
  947. QDF_NBUF_CB_RX_TCP_CHKSUM(msdu) =
  948. hal_rx_tlv_get_tcp_chksum(soc->hal_soc,
  949. rx_tlv);
  950. QDF_NBUF_CB_RX_TCP_SEQ_NUM(msdu) = offload_info.tcp_seq_num;
  951. QDF_NBUF_CB_RX_TCP_ACK_NUM(msdu) = offload_info.tcp_ack_num;
  952. QDF_NBUF_CB_RX_TCP_WIN(msdu) = offload_info.tcp_win;
  953. QDF_NBUF_CB_RX_TCP_PROTO(msdu) = offload_info.tcp_proto;
  954. QDF_NBUF_CB_RX_IPV6_PROTO(msdu) = offload_info.ipv6_proto;
  955. QDF_NBUF_CB_RX_TCP_OFFSET(msdu) = offload_info.tcp_offset;
  956. QDF_NBUF_CB_RX_FLOW_ID(msdu) = offload_info.flow_id;
  957. dp_rx_print_offload_info(soc, msdu);
  958. }
  959. #endif /* RECEIVE_OFFLOAD */
  960. /**
  961. * dp_rx_adjust_nbuf_len() - set appropriate msdu length in nbuf.
  962. *
  963. * @soc: DP soc handle
  964. * @nbuf: pointer to msdu.
  965. * @mpdu_len: mpdu length
  966. * @l3_pad_len: L3 padding length by HW
  967. *
  968. * Return: returns true if nbuf is last msdu of mpdu else retuns false.
  969. */
  970. static inline bool dp_rx_adjust_nbuf_len(struct dp_soc *soc,
  971. qdf_nbuf_t nbuf,
  972. uint16_t *mpdu_len,
  973. uint32_t l3_pad_len)
  974. {
  975. bool last_nbuf;
  976. uint32_t pkt_hdr_size;
  977. pkt_hdr_size = soc->rx_pkt_tlv_size + l3_pad_len;
  978. if ((*mpdu_len + pkt_hdr_size) > RX_DATA_BUFFER_SIZE) {
  979. qdf_nbuf_set_pktlen(nbuf, RX_DATA_BUFFER_SIZE);
  980. last_nbuf = false;
  981. *mpdu_len -= (RX_DATA_BUFFER_SIZE - pkt_hdr_size);
  982. } else {
  983. qdf_nbuf_set_pktlen(nbuf, (*mpdu_len + pkt_hdr_size));
  984. last_nbuf = true;
  985. *mpdu_len = 0;
  986. }
  987. return last_nbuf;
  988. }
  989. /**
  990. * dp_get_l3_hdr_pad_len() - get L3 header padding length.
  991. *
  992. * @soc: DP soc handle
  993. * @nbuf: pointer to msdu.
  994. *
  995. * Return: returns padding length in bytes.
  996. */
  997. static inline uint32_t dp_get_l3_hdr_pad_len(struct dp_soc *soc,
  998. qdf_nbuf_t nbuf)
  999. {
  1000. uint32_t l3_hdr_pad = 0;
  1001. uint8_t *rx_tlv_hdr;
  1002. struct hal_rx_msdu_metadata msdu_metadata;
  1003. while (nbuf) {
  1004. if (!qdf_nbuf_is_rx_chfrag_cont(nbuf)) {
  1005. /* scattered msdu end with continuation is 0 */
  1006. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  1007. hal_rx_msdu_metadata_get(soc->hal_soc,
  1008. rx_tlv_hdr,
  1009. &msdu_metadata);
  1010. l3_hdr_pad = msdu_metadata.l3_hdr_pad;
  1011. break;
  1012. }
  1013. nbuf = nbuf->next;
  1014. }
  1015. return l3_hdr_pad;
  1016. }
  1017. /**
  1018. * dp_rx_sg_create() - create a frag_list for MSDUs which are spread across
  1019. * multiple nbufs.
  1020. * @soc: DP SOC handle
  1021. * @nbuf: pointer to the first msdu of an amsdu.
  1022. *
  1023. * This function implements the creation of RX frag_list for cases
  1024. * where an MSDU is spread across multiple nbufs.
  1025. *
  1026. * Return: returns the head nbuf which contains complete frag_list.
  1027. */
  1028. qdf_nbuf_t dp_rx_sg_create(struct dp_soc *soc, qdf_nbuf_t nbuf)
  1029. {
  1030. qdf_nbuf_t parent, frag_list, next = NULL;
  1031. uint16_t frag_list_len = 0;
  1032. uint16_t mpdu_len;
  1033. bool last_nbuf;
  1034. uint32_t l3_hdr_pad_offset = 0;
  1035. /*
  1036. * Use msdu len got from REO entry descriptor instead since
  1037. * there is case the RX PKT TLV is corrupted while msdu_len
  1038. * from REO descriptor is right for non-raw RX scatter msdu.
  1039. */
  1040. mpdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  1041. /*
  1042. * this is a case where the complete msdu fits in one single nbuf.
  1043. * in this case HW sets both start and end bit and we only need to
  1044. * reset these bits for RAW mode simulator to decap the pkt
  1045. */
  1046. if (qdf_nbuf_is_rx_chfrag_start(nbuf) &&
  1047. qdf_nbuf_is_rx_chfrag_end(nbuf)) {
  1048. qdf_nbuf_set_pktlen(nbuf, mpdu_len + soc->rx_pkt_tlv_size);
  1049. qdf_nbuf_pull_head(nbuf, soc->rx_pkt_tlv_size);
  1050. return nbuf;
  1051. }
  1052. l3_hdr_pad_offset = dp_get_l3_hdr_pad_len(soc, nbuf);
  1053. /*
  1054. * This is a case where we have multiple msdus (A-MSDU) spread across
  1055. * multiple nbufs. here we create a fraglist out of these nbufs.
  1056. *
  1057. * the moment we encounter a nbuf with continuation bit set we
  1058. * know for sure we have an MSDU which is spread across multiple
  1059. * nbufs. We loop through and reap nbufs till we reach last nbuf.
  1060. */
  1061. parent = nbuf;
  1062. frag_list = nbuf->next;
  1063. nbuf = nbuf->next;
  1064. /*
  1065. * set the start bit in the first nbuf we encounter with continuation
  1066. * bit set. This has the proper mpdu length set as it is the first
  1067. * msdu of the mpdu. this becomes the parent nbuf and the subsequent
  1068. * nbufs will form the frag_list of the parent nbuf.
  1069. */
  1070. qdf_nbuf_set_rx_chfrag_start(parent, 1);
  1071. /*
  1072. * L3 header padding is only needed for the 1st buffer
  1073. * in a scattered msdu
  1074. */
  1075. last_nbuf = dp_rx_adjust_nbuf_len(soc, parent, &mpdu_len,
  1076. l3_hdr_pad_offset);
  1077. /*
  1078. * MSDU cont bit is set but reported MPDU length can fit
  1079. * in to single buffer
  1080. *
  1081. * Increment error stats and avoid SG list creation
  1082. */
  1083. if (last_nbuf) {
  1084. DP_STATS_INC(soc, rx.err.msdu_continuation_err, 1);
  1085. qdf_nbuf_pull_head(parent,
  1086. soc->rx_pkt_tlv_size + l3_hdr_pad_offset);
  1087. return parent;
  1088. }
  1089. /*
  1090. * this is where we set the length of the fragments which are
  1091. * associated to the parent nbuf. We iterate through the frag_list
  1092. * till we hit the last_nbuf of the list.
  1093. */
  1094. do {
  1095. last_nbuf = dp_rx_adjust_nbuf_len(soc, nbuf, &mpdu_len, 0);
  1096. qdf_nbuf_pull_head(nbuf,
  1097. soc->rx_pkt_tlv_size);
  1098. frag_list_len += qdf_nbuf_len(nbuf);
  1099. if (last_nbuf) {
  1100. next = nbuf->next;
  1101. nbuf->next = NULL;
  1102. break;
  1103. }
  1104. nbuf = nbuf->next;
  1105. } while (!last_nbuf);
  1106. qdf_nbuf_set_rx_chfrag_start(nbuf, 0);
  1107. qdf_nbuf_append_ext_list(parent, frag_list, frag_list_len);
  1108. parent->next = next;
  1109. qdf_nbuf_pull_head(parent,
  1110. soc->rx_pkt_tlv_size + l3_hdr_pad_offset);
  1111. return parent;
  1112. }
  1113. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  1114. #ifdef QCA_PEER_EXT_STATS
  1115. /*
  1116. * dp_rx_compute_tid_delay - Computer per TID delay stats
  1117. * @peer: DP soc context
  1118. * @nbuf: NBuffer
  1119. *
  1120. * Return: Void
  1121. */
  1122. void dp_rx_compute_tid_delay(struct cdp_delay_tid_stats *stats,
  1123. qdf_nbuf_t nbuf)
  1124. {
  1125. struct cdp_delay_rx_stats *rx_delay = &stats->rx_delay;
  1126. uint32_t to_stack = qdf_nbuf_get_timedelta_ms(nbuf);
  1127. dp_hist_update_stats(&rx_delay->to_stack_delay, to_stack);
  1128. }
  1129. #endif /* QCA_PEER_EXT_STATS */
  1130. /**
  1131. * dp_rx_compute_delay() - Compute and fill in all timestamps
  1132. * to pass in correct fields
  1133. *
  1134. * @vdev: pdev handle
  1135. * @tx_desc: tx descriptor
  1136. * @tid: tid value
  1137. * Return: none
  1138. */
  1139. void dp_rx_compute_delay(struct dp_vdev *vdev, qdf_nbuf_t nbuf)
  1140. {
  1141. uint8_t ring_id = QDF_NBUF_CB_RX_CTX_ID(nbuf);
  1142. int64_t current_ts = qdf_ktime_to_ms(qdf_ktime_get());
  1143. uint32_t to_stack = qdf_nbuf_get_timedelta_ms(nbuf);
  1144. uint8_t tid = qdf_nbuf_get_tid_val(nbuf);
  1145. uint32_t interframe_delay =
  1146. (uint32_t)(current_ts - vdev->prev_rx_deliver_tstamp);
  1147. dp_update_delay_stats(vdev->pdev, to_stack, tid,
  1148. CDP_DELAY_STATS_REAP_STACK, ring_id);
  1149. /*
  1150. * Update interframe delay stats calculated at deliver_data_ol point.
  1151. * Value of vdev->prev_rx_deliver_tstamp will be 0 for 1st frame, so
  1152. * interframe delay will not be calculate correctly for 1st frame.
  1153. * On the other side, this will help in avoiding extra per packet check
  1154. * of vdev->prev_rx_deliver_tstamp.
  1155. */
  1156. dp_update_delay_stats(vdev->pdev, interframe_delay, tid,
  1157. CDP_DELAY_STATS_RX_INTERFRAME, ring_id);
  1158. vdev->prev_rx_deliver_tstamp = current_ts;
  1159. }
  1160. /**
  1161. * dp_rx_drop_nbuf_list() - drop an nbuf list
  1162. * @pdev: dp pdev reference
  1163. * @buf_list: buffer list to be dropepd
  1164. *
  1165. * Return: int (number of bufs dropped)
  1166. */
  1167. static inline int dp_rx_drop_nbuf_list(struct dp_pdev *pdev,
  1168. qdf_nbuf_t buf_list)
  1169. {
  1170. struct cdp_tid_rx_stats *stats = NULL;
  1171. uint8_t tid = 0, ring_id = 0;
  1172. int num_dropped = 0;
  1173. qdf_nbuf_t buf, next_buf;
  1174. buf = buf_list;
  1175. while (buf) {
  1176. ring_id = QDF_NBUF_CB_RX_CTX_ID(buf);
  1177. next_buf = qdf_nbuf_queue_next(buf);
  1178. tid = qdf_nbuf_get_tid_val(buf);
  1179. if (qdf_likely(pdev)) {
  1180. stats = &pdev->stats.tid_stats.tid_rx_stats[ring_id][tid];
  1181. stats->fail_cnt[INVALID_PEER_VDEV]++;
  1182. stats->delivered_to_stack--;
  1183. }
  1184. qdf_nbuf_free(buf);
  1185. buf = next_buf;
  1186. num_dropped++;
  1187. }
  1188. return num_dropped;
  1189. }
  1190. #ifdef QCA_SUPPORT_WDS_EXTENDED
  1191. /**
  1192. * dp_rx_deliver_to_stack_ext() - Deliver to netdev per sta
  1193. * @soc: core txrx main context
  1194. * @vdev: vdev
  1195. * @peer: peer
  1196. * @nbuf_head: skb list head
  1197. *
  1198. * Return: true if packet is delivered to netdev per STA.
  1199. */
  1200. static inline bool
  1201. dp_rx_deliver_to_stack_ext(struct dp_soc *soc, struct dp_vdev *vdev,
  1202. struct dp_peer *peer, qdf_nbuf_t nbuf_head)
  1203. {
  1204. /*
  1205. * When extended WDS is disabled, frames are sent to AP netdevice.
  1206. */
  1207. if (qdf_likely(!vdev->wds_ext_enabled))
  1208. return false;
  1209. /*
  1210. * There can be 2 cases:
  1211. * 1. Send frame to parent netdev if its not for netdev per STA
  1212. * 2. If frame is meant for netdev per STA:
  1213. * a. Send frame to appropriate netdev using registered fp.
  1214. * b. If fp is NULL, drop the frames.
  1215. */
  1216. if (!peer->wds_ext.init)
  1217. return false;
  1218. if (peer->osif_rx)
  1219. peer->osif_rx(peer->wds_ext.osif_peer, nbuf_head);
  1220. else
  1221. dp_rx_drop_nbuf_list(vdev->pdev, nbuf_head);
  1222. return true;
  1223. }
  1224. #else
  1225. static inline bool
  1226. dp_rx_deliver_to_stack_ext(struct dp_soc *soc, struct dp_vdev *vdev,
  1227. struct dp_peer *peer, qdf_nbuf_t nbuf_head)
  1228. {
  1229. return false;
  1230. }
  1231. #endif
  1232. #ifdef PEER_CACHE_RX_PKTS
  1233. /**
  1234. * dp_rx_flush_rx_cached() - flush cached rx frames
  1235. * @peer: peer
  1236. * @drop: flag to drop frames or forward to net stack
  1237. *
  1238. * Return: None
  1239. */
  1240. void dp_rx_flush_rx_cached(struct dp_peer *peer, bool drop)
  1241. {
  1242. struct dp_peer_cached_bufq *bufqi;
  1243. struct dp_rx_cached_buf *cache_buf = NULL;
  1244. ol_txrx_rx_fp data_rx = NULL;
  1245. int num_buff_elem;
  1246. QDF_STATUS status;
  1247. if (qdf_atomic_inc_return(&peer->flush_in_progress) > 1) {
  1248. qdf_atomic_dec(&peer->flush_in_progress);
  1249. return;
  1250. }
  1251. qdf_spin_lock_bh(&peer->peer_info_lock);
  1252. if (peer->state >= OL_TXRX_PEER_STATE_CONN && peer->vdev->osif_rx)
  1253. data_rx = peer->vdev->osif_rx;
  1254. else
  1255. drop = true;
  1256. qdf_spin_unlock_bh(&peer->peer_info_lock);
  1257. bufqi = &peer->bufq_info;
  1258. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1259. qdf_list_remove_front(&bufqi->cached_bufq,
  1260. (qdf_list_node_t **)&cache_buf);
  1261. while (cache_buf) {
  1262. num_buff_elem = QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(
  1263. cache_buf->buf);
  1264. bufqi->entries -= num_buff_elem;
  1265. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1266. if (drop) {
  1267. bufqi->dropped = dp_rx_drop_nbuf_list(peer->vdev->pdev,
  1268. cache_buf->buf);
  1269. } else {
  1270. /* Flush the cached frames to OSIF DEV */
  1271. status = data_rx(peer->vdev->osif_vdev, cache_buf->buf);
  1272. if (status != QDF_STATUS_SUCCESS)
  1273. bufqi->dropped = dp_rx_drop_nbuf_list(
  1274. peer->vdev->pdev,
  1275. cache_buf->buf);
  1276. }
  1277. qdf_mem_free(cache_buf);
  1278. cache_buf = NULL;
  1279. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1280. qdf_list_remove_front(&bufqi->cached_bufq,
  1281. (qdf_list_node_t **)&cache_buf);
  1282. }
  1283. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1284. qdf_atomic_dec(&peer->flush_in_progress);
  1285. }
  1286. /**
  1287. * dp_rx_enqueue_rx() - cache rx frames
  1288. * @peer: peer
  1289. * @rx_buf_list: cache buffer list
  1290. *
  1291. * Return: None
  1292. */
  1293. static QDF_STATUS
  1294. dp_rx_enqueue_rx(struct dp_peer *peer, qdf_nbuf_t rx_buf_list)
  1295. {
  1296. struct dp_rx_cached_buf *cache_buf;
  1297. struct dp_peer_cached_bufq *bufqi = &peer->bufq_info;
  1298. int num_buff_elem;
  1299. dp_debug_rl("bufq->curr %d bufq->drops %d", bufqi->entries,
  1300. bufqi->dropped);
  1301. if (!peer->valid) {
  1302. bufqi->dropped = dp_rx_drop_nbuf_list(peer->vdev->pdev,
  1303. rx_buf_list);
  1304. return QDF_STATUS_E_INVAL;
  1305. }
  1306. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1307. if (bufqi->entries >= bufqi->thresh) {
  1308. bufqi->dropped = dp_rx_drop_nbuf_list(peer->vdev->pdev,
  1309. rx_buf_list);
  1310. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1311. return QDF_STATUS_E_RESOURCES;
  1312. }
  1313. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1314. num_buff_elem = QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(rx_buf_list);
  1315. cache_buf = qdf_mem_malloc_atomic(sizeof(*cache_buf));
  1316. if (!cache_buf) {
  1317. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1318. "Failed to allocate buf to cache rx frames");
  1319. bufqi->dropped = dp_rx_drop_nbuf_list(peer->vdev->pdev,
  1320. rx_buf_list);
  1321. return QDF_STATUS_E_NOMEM;
  1322. }
  1323. cache_buf->buf = rx_buf_list;
  1324. qdf_spin_lock_bh(&bufqi->bufq_lock);
  1325. qdf_list_insert_back(&bufqi->cached_bufq,
  1326. &cache_buf->node);
  1327. bufqi->entries += num_buff_elem;
  1328. qdf_spin_unlock_bh(&bufqi->bufq_lock);
  1329. return QDF_STATUS_SUCCESS;
  1330. }
  1331. static inline
  1332. bool dp_rx_is_peer_cache_bufq_supported(void)
  1333. {
  1334. return true;
  1335. }
  1336. #else
  1337. static inline
  1338. bool dp_rx_is_peer_cache_bufq_supported(void)
  1339. {
  1340. return false;
  1341. }
  1342. static inline QDF_STATUS
  1343. dp_rx_enqueue_rx(struct dp_peer *peer, qdf_nbuf_t rx_buf_list)
  1344. {
  1345. return QDF_STATUS_SUCCESS;
  1346. }
  1347. #endif
  1348. #ifndef DELIVERY_TO_STACK_STATUS_CHECK
  1349. /**
  1350. * dp_rx_check_delivery_to_stack() - Deliver pkts to network
  1351. * using the appropriate call back functions.
  1352. * @soc: soc
  1353. * @vdev: vdev
  1354. * @peer: peer
  1355. * @nbuf_head: skb list head
  1356. * @nbuf_tail: skb list tail
  1357. *
  1358. * Return: None
  1359. */
  1360. static void dp_rx_check_delivery_to_stack(struct dp_soc *soc,
  1361. struct dp_vdev *vdev,
  1362. struct dp_peer *peer,
  1363. qdf_nbuf_t nbuf_head)
  1364. {
  1365. if (qdf_unlikely(dp_rx_deliver_to_stack_ext(soc, vdev,
  1366. peer, nbuf_head)))
  1367. return;
  1368. /* Function pointer initialized only when FISA is enabled */
  1369. if (vdev->osif_fisa_rx)
  1370. /* on failure send it via regular path */
  1371. vdev->osif_fisa_rx(soc, vdev, nbuf_head);
  1372. else
  1373. vdev->osif_rx(vdev->osif_vdev, nbuf_head);
  1374. }
  1375. #else
  1376. /**
  1377. * dp_rx_check_delivery_to_stack() - Deliver pkts to network
  1378. * using the appropriate call back functions.
  1379. * @soc: soc
  1380. * @vdev: vdev
  1381. * @peer: peer
  1382. * @nbuf_head: skb list head
  1383. * @nbuf_tail: skb list tail
  1384. *
  1385. * Check the return status of the call back function and drop
  1386. * the packets if the return status indicates a failure.
  1387. *
  1388. * Return: None
  1389. */
  1390. static void dp_rx_check_delivery_to_stack(struct dp_soc *soc,
  1391. struct dp_vdev *vdev,
  1392. struct dp_peer *peer,
  1393. qdf_nbuf_t nbuf_head)
  1394. {
  1395. int num_nbuf = 0;
  1396. QDF_STATUS ret_val = QDF_STATUS_E_FAILURE;
  1397. /* Function pointer initialized only when FISA is enabled */
  1398. if (vdev->osif_fisa_rx)
  1399. /* on failure send it via regular path */
  1400. ret_val = vdev->osif_fisa_rx(soc, vdev, nbuf_head);
  1401. else if (vdev->osif_rx)
  1402. ret_val = vdev->osif_rx(vdev->osif_vdev, nbuf_head);
  1403. if (!QDF_IS_STATUS_SUCCESS(ret_val)) {
  1404. num_nbuf = dp_rx_drop_nbuf_list(vdev->pdev, nbuf_head);
  1405. DP_STATS_INC(soc, rx.err.rejected, num_nbuf);
  1406. if (peer)
  1407. DP_STATS_DEC(peer, rx.to_stack.num, num_nbuf);
  1408. }
  1409. }
  1410. #endif /* ifdef DELIVERY_TO_STACK_STATUS_CHECK */
  1411. /*
  1412. * dp_rx_validate_rx_callbacks() - validate rx callbacks
  1413. * @soc DP soc
  1414. * @vdev: DP vdev handle
  1415. * @peer: pointer to the peer object
  1416. * nbuf_head: skb list head
  1417. *
  1418. * Return: QDF_STATUS - QDF_STATUS_SUCCESS
  1419. * QDF_STATUS_E_FAILURE
  1420. */
  1421. static inline QDF_STATUS
  1422. dp_rx_validate_rx_callbacks(struct dp_soc *soc,
  1423. struct dp_vdev *vdev,
  1424. struct dp_peer *peer,
  1425. qdf_nbuf_t nbuf_head)
  1426. {
  1427. int num_nbuf;
  1428. if (qdf_unlikely(!vdev || vdev->delete.pending)) {
  1429. num_nbuf = dp_rx_drop_nbuf_list(NULL, nbuf_head);
  1430. /*
  1431. * This is a special case where vdev is invalid,
  1432. * so we cannot know the pdev to which this packet
  1433. * belonged. Hence we update the soc rx error stats.
  1434. */
  1435. DP_STATS_INC(soc, rx.err.invalid_vdev, num_nbuf);
  1436. return QDF_STATUS_E_FAILURE;
  1437. }
  1438. /*
  1439. * highly unlikely to have a vdev without a registered rx
  1440. * callback function. if so let us free the nbuf_list.
  1441. */
  1442. if (qdf_unlikely(!vdev->osif_rx)) {
  1443. if (peer && dp_rx_is_peer_cache_bufq_supported()) {
  1444. dp_rx_enqueue_rx(peer, nbuf_head);
  1445. } else {
  1446. num_nbuf = dp_rx_drop_nbuf_list(vdev->pdev,
  1447. nbuf_head);
  1448. DP_STATS_DEC(peer, rx.to_stack.num, num_nbuf);
  1449. }
  1450. return QDF_STATUS_E_FAILURE;
  1451. }
  1452. return QDF_STATUS_SUCCESS;
  1453. }
  1454. QDF_STATUS dp_rx_deliver_to_stack(struct dp_soc *soc,
  1455. struct dp_vdev *vdev,
  1456. struct dp_peer *peer,
  1457. qdf_nbuf_t nbuf_head,
  1458. qdf_nbuf_t nbuf_tail)
  1459. {
  1460. if (dp_rx_validate_rx_callbacks(soc, vdev, peer, nbuf_head) !=
  1461. QDF_STATUS_SUCCESS)
  1462. return QDF_STATUS_E_FAILURE;
  1463. if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw) ||
  1464. (vdev->rx_decap_type == htt_cmn_pkt_type_native_wifi)) {
  1465. vdev->osif_rsim_rx_decap(vdev->osif_vdev, &nbuf_head,
  1466. &nbuf_tail, peer->mac_addr.raw);
  1467. }
  1468. dp_rx_check_delivery_to_stack(soc, vdev, peer, nbuf_head);
  1469. return QDF_STATUS_SUCCESS;
  1470. }
  1471. #ifdef QCA_SUPPORT_EAPOL_OVER_CONTROL_PORT
  1472. QDF_STATUS dp_rx_eapol_deliver_to_stack(struct dp_soc *soc,
  1473. struct dp_vdev *vdev,
  1474. struct dp_peer *peer,
  1475. qdf_nbuf_t nbuf_head,
  1476. qdf_nbuf_t nbuf_tail)
  1477. {
  1478. if (dp_rx_validate_rx_callbacks(soc, vdev, peer, nbuf_head) !=
  1479. QDF_STATUS_SUCCESS)
  1480. return QDF_STATUS_E_FAILURE;
  1481. vdev->osif_rx_eapol(vdev->osif_vdev, nbuf_head);
  1482. return QDF_STATUS_SUCCESS;
  1483. }
  1484. #endif
  1485. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  1486. #ifdef VDEV_PEER_PROTOCOL_COUNT
  1487. #define dp_rx_msdu_stats_update_prot_cnts(vdev_hdl, nbuf, peer) \
  1488. { \
  1489. qdf_nbuf_t nbuf_local; \
  1490. struct dp_peer *peer_local; \
  1491. struct dp_vdev *vdev_local = vdev_hdl; \
  1492. do { \
  1493. if (qdf_likely(!((vdev_local)->peer_protocol_count_track))) \
  1494. break; \
  1495. nbuf_local = nbuf; \
  1496. peer_local = peer; \
  1497. if (qdf_unlikely(qdf_nbuf_is_frag((nbuf_local)))) \
  1498. break; \
  1499. else if (qdf_unlikely(qdf_nbuf_is_raw_frame((nbuf_local)))) \
  1500. break; \
  1501. dp_vdev_peer_stats_update_protocol_cnt((vdev_local), \
  1502. (nbuf_local), \
  1503. (peer_local), 0, 1); \
  1504. } while (0); \
  1505. }
  1506. #else
  1507. #define dp_rx_msdu_stats_update_prot_cnts(vdev_hdl, nbuf, peer)
  1508. #endif
  1509. /**
  1510. * dp_rx_msdu_stats_update() - update per msdu stats.
  1511. * @soc: core txrx main context
  1512. * @nbuf: pointer to the first msdu of an amsdu.
  1513. * @rx_tlv_hdr: pointer to the start of RX TLV headers.
  1514. * @peer: pointer to the peer object.
  1515. * @ring_id: reo dest ring number on which pkt is reaped.
  1516. * @tid_stats: per tid rx stats.
  1517. *
  1518. * update all the per msdu stats for that nbuf.
  1519. * Return: void
  1520. */
  1521. void dp_rx_msdu_stats_update(struct dp_soc *soc, qdf_nbuf_t nbuf,
  1522. uint8_t *rx_tlv_hdr, struct dp_peer *peer,
  1523. uint8_t ring_id,
  1524. struct cdp_tid_rx_stats *tid_stats)
  1525. {
  1526. bool is_ampdu, is_not_amsdu;
  1527. uint32_t sgi, mcs, tid, nss, bw, reception_type, pkt_type;
  1528. struct dp_vdev *vdev = peer->vdev;
  1529. qdf_ether_header_t *eh;
  1530. uint16_t msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  1531. dp_rx_msdu_stats_update_prot_cnts(vdev, nbuf, peer);
  1532. is_not_amsdu = qdf_nbuf_is_rx_chfrag_start(nbuf) &
  1533. qdf_nbuf_is_rx_chfrag_end(nbuf);
  1534. DP_STATS_INC_PKT(peer, rx.rcvd_reo[ring_id], 1, msdu_len);
  1535. DP_STATS_INCC(peer, rx.non_amsdu_cnt, 1, is_not_amsdu);
  1536. DP_STATS_INCC(peer, rx.amsdu_cnt, 1, !is_not_amsdu);
  1537. DP_STATS_INCC(peer, rx.rx_retries, 1, qdf_nbuf_is_rx_retry_flag(nbuf));
  1538. tid_stats->msdu_cnt++;
  1539. if (qdf_unlikely(qdf_nbuf_is_da_mcbc(nbuf) &&
  1540. (vdev->rx_decap_type == htt_cmn_pkt_type_ethernet))) {
  1541. eh = (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
  1542. DP_STATS_INC_PKT(peer, rx.multicast, 1, msdu_len);
  1543. tid_stats->mcast_msdu_cnt++;
  1544. if (QDF_IS_ADDR_BROADCAST(eh->ether_dhost)) {
  1545. DP_STATS_INC_PKT(peer, rx.bcast, 1, msdu_len);
  1546. tid_stats->bcast_msdu_cnt++;
  1547. }
  1548. }
  1549. /*
  1550. * currently we can return from here as we have similar stats
  1551. * updated at per ppdu level instead of msdu level
  1552. */
  1553. if (!soc->process_rx_status)
  1554. return;
  1555. /*
  1556. * TODO - For WCN7850 this field is present in ring_desc
  1557. * Try to use ring desc instead of tlv.
  1558. */
  1559. is_ampdu = hal_rx_mpdu_info_ampdu_flag_get(soc->hal_soc, rx_tlv_hdr);
  1560. DP_STATS_INCC(peer, rx.ampdu_cnt, 1, is_ampdu);
  1561. DP_STATS_INCC(peer, rx.non_ampdu_cnt, 1, !(is_ampdu));
  1562. sgi = hal_rx_tlv_sgi_get(soc->hal_soc, rx_tlv_hdr);
  1563. mcs = hal_rx_tlv_rate_mcs_get(soc->hal_soc, rx_tlv_hdr);
  1564. tid = qdf_nbuf_get_tid_val(nbuf);
  1565. bw = hal_rx_tlv_bw_get(soc->hal_soc, rx_tlv_hdr);
  1566. reception_type = hal_rx_msdu_start_reception_type_get(soc->hal_soc,
  1567. rx_tlv_hdr);
  1568. nss = hal_rx_msdu_start_nss_get(soc->hal_soc, rx_tlv_hdr);
  1569. pkt_type = hal_rx_tlv_get_pkt_type(soc->hal_soc, rx_tlv_hdr);
  1570. DP_STATS_INCC(peer, rx.rx_mpdu_cnt[mcs], 1,
  1571. ((mcs < MAX_MCS) && QDF_NBUF_CB_RX_CHFRAG_START(nbuf)));
  1572. DP_STATS_INCC(peer, rx.rx_mpdu_cnt[MAX_MCS - 1], 1,
  1573. ((mcs >= MAX_MCS) && QDF_NBUF_CB_RX_CHFRAG_START(nbuf)));
  1574. DP_STATS_INC(peer, rx.bw[bw], 1);
  1575. /*
  1576. * only if nss > 0 and pkt_type is 11N/AC/AX,
  1577. * then increase index [nss - 1] in array counter.
  1578. */
  1579. if (nss > 0 && (pkt_type == DOT11_N ||
  1580. pkt_type == DOT11_AC ||
  1581. pkt_type == DOT11_AX))
  1582. DP_STATS_INC(peer, rx.nss[nss - 1], 1);
  1583. DP_STATS_INC(peer, rx.sgi_count[sgi], 1);
  1584. DP_STATS_INCC(peer, rx.err.mic_err, 1,
  1585. hal_rx_tlv_mic_err_get(soc->hal_soc, rx_tlv_hdr));
  1586. DP_STATS_INCC(peer, rx.err.decrypt_err, 1,
  1587. hal_rx_tlv_decrypt_err_get(soc->hal_soc, rx_tlv_hdr));
  1588. DP_STATS_INC(peer, rx.wme_ac_type[TID_TO_WME_AC(tid)], 1);
  1589. DP_STATS_INC(peer, rx.reception_type[reception_type], 1);
  1590. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS - 1], 1,
  1591. ((mcs >= MAX_MCS_11A) && (pkt_type == DOT11_A)));
  1592. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1,
  1593. ((mcs <= MAX_MCS_11A) && (pkt_type == DOT11_A)));
  1594. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS - 1], 1,
  1595. ((mcs >= MAX_MCS_11B) && (pkt_type == DOT11_B)));
  1596. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1,
  1597. ((mcs <= MAX_MCS_11B) && (pkt_type == DOT11_B)));
  1598. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS - 1], 1,
  1599. ((mcs >= MAX_MCS_11A) && (pkt_type == DOT11_N)));
  1600. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1,
  1601. ((mcs <= MAX_MCS_11A) && (pkt_type == DOT11_N)));
  1602. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS - 1], 1,
  1603. ((mcs >= MAX_MCS_11AC) && (pkt_type == DOT11_AC)));
  1604. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1,
  1605. ((mcs <= MAX_MCS_11AC) && (pkt_type == DOT11_AC)));
  1606. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[MAX_MCS - 1], 1,
  1607. ((mcs >= MAX_MCS) && (pkt_type == DOT11_AX)));
  1608. DP_STATS_INCC(peer, rx.pkt_type[pkt_type].mcs_count[mcs], 1,
  1609. ((mcs < MAX_MCS) && (pkt_type == DOT11_AX)));
  1610. }
  1611. #ifndef WDS_VENDOR_EXTENSION
  1612. int dp_wds_rx_policy_check(uint8_t *rx_tlv_hdr,
  1613. struct dp_vdev *vdev,
  1614. struct dp_peer *peer)
  1615. {
  1616. return 1;
  1617. }
  1618. #endif
  1619. #ifdef RX_DESC_DEBUG_CHECK
  1620. /**
  1621. * dp_rx_desc_nbuf_sanity_check - Add sanity check to catch REO rx_desc paddr
  1622. * corruption
  1623. *
  1624. * @ring_desc: REO ring descriptor
  1625. * @rx_desc: Rx descriptor
  1626. *
  1627. * Return: NONE
  1628. */
  1629. QDF_STATUS dp_rx_desc_nbuf_sanity_check(struct dp_soc *soc,
  1630. hal_ring_desc_t ring_desc,
  1631. struct dp_rx_desc *rx_desc)
  1632. {
  1633. struct hal_buf_info hbi;
  1634. hal_rx_reo_buf_paddr_get(soc->hal_soc, ring_desc, &hbi);
  1635. /* Sanity check for possible buffer paddr corruption */
  1636. if (dp_rx_desc_paddr_sanity_check(rx_desc, (&hbi)->paddr))
  1637. return QDF_STATUS_SUCCESS;
  1638. return QDF_STATUS_E_FAILURE;
  1639. }
  1640. /**
  1641. * dp_rx_desc_nbuf_len_sanity_check - Add sanity check to catch Rx buffer
  1642. * out of bound access from H.W
  1643. *
  1644. * @soc: DP soc
  1645. * @pkt_len: Packet length received from H.W
  1646. *
  1647. * Return: NONE
  1648. */
  1649. static inline void
  1650. dp_rx_desc_nbuf_len_sanity_check(struct dp_soc *soc,
  1651. uint32_t pkt_len)
  1652. {
  1653. struct rx_desc_pool *rx_desc_pool;
  1654. rx_desc_pool = &soc->rx_desc_buf[0];
  1655. qdf_assert_always(pkt_len <= rx_desc_pool->buf_size);
  1656. }
  1657. #else
  1658. static inline void
  1659. dp_rx_desc_nbuf_len_sanity_check(struct dp_soc *soc, uint32_t pkt_len) { }
  1660. #endif
  1661. #ifdef DP_RX_PKT_NO_PEER_DELIVER
  1662. /**
  1663. * dp_rx_deliver_to_stack_no_peer() - try deliver rx data even if
  1664. * no corresbonding peer found
  1665. * @soc: core txrx main context
  1666. * @nbuf: pkt skb pointer
  1667. *
  1668. * This function will try to deliver some RX special frames to stack
  1669. * even there is no peer matched found. for instance, LFR case, some
  1670. * eapol data will be sent to host before peer_map done.
  1671. *
  1672. * Return: None
  1673. */
  1674. void dp_rx_deliver_to_stack_no_peer(struct dp_soc *soc, qdf_nbuf_t nbuf)
  1675. {
  1676. uint16_t peer_id;
  1677. uint8_t vdev_id;
  1678. struct dp_vdev *vdev = NULL;
  1679. uint32_t l2_hdr_offset = 0;
  1680. uint16_t msdu_len = 0;
  1681. uint32_t pkt_len = 0;
  1682. uint8_t *rx_tlv_hdr;
  1683. uint32_t frame_mask = FRAME_MASK_IPV4_ARP | FRAME_MASK_IPV4_DHCP |
  1684. FRAME_MASK_IPV4_EAPOL | FRAME_MASK_IPV6_DHCP;
  1685. peer_id = QDF_NBUF_CB_RX_PEER_ID(nbuf);
  1686. if (peer_id > soc->max_peers)
  1687. goto deliver_fail;
  1688. vdev_id = QDF_NBUF_CB_RX_VDEV_ID(nbuf);
  1689. vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_RX);
  1690. if (!vdev || vdev->delete.pending || !vdev->osif_rx)
  1691. goto deliver_fail;
  1692. if (qdf_unlikely(qdf_nbuf_is_frag(nbuf)))
  1693. goto deliver_fail;
  1694. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  1695. l2_hdr_offset =
  1696. hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc, rx_tlv_hdr);
  1697. msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  1698. pkt_len = msdu_len + l2_hdr_offset + soc->rx_pkt_tlv_size;
  1699. QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(nbuf) = 1;
  1700. qdf_nbuf_set_pktlen(nbuf, pkt_len);
  1701. qdf_nbuf_pull_head(nbuf, soc->rx_pkt_tlv_size + l2_hdr_offset);
  1702. if (dp_rx_is_special_frame(nbuf, frame_mask)) {
  1703. qdf_nbuf_set_exc_frame(nbuf, 1);
  1704. if (QDF_STATUS_SUCCESS !=
  1705. vdev->osif_rx(vdev->osif_vdev, nbuf))
  1706. goto deliver_fail;
  1707. DP_STATS_INC(soc, rx.err.pkt_delivered_no_peer, 1);
  1708. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_RX);
  1709. return;
  1710. }
  1711. deliver_fail:
  1712. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  1713. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  1714. qdf_nbuf_free(nbuf);
  1715. if (vdev)
  1716. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_RX);
  1717. }
  1718. #else
  1719. void dp_rx_deliver_to_stack_no_peer(struct dp_soc *soc, qdf_nbuf_t nbuf)
  1720. {
  1721. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  1722. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  1723. qdf_nbuf_free(nbuf);
  1724. }
  1725. #endif
  1726. /**
  1727. * dp_rx_srng_get_num_pending() - get number of pending entries
  1728. * @hal_soc: hal soc opaque pointer
  1729. * @hal_ring: opaque pointer to the HAL Rx Ring
  1730. * @num_entries: number of entries in the hal_ring.
  1731. * @near_full: pointer to a boolean. This is set if ring is near full.
  1732. *
  1733. * The function returns the number of entries in a destination ring which are
  1734. * yet to be reaped. The function also checks if the ring is near full.
  1735. * If more than half of the ring needs to be reaped, the ring is considered
  1736. * approaching full.
  1737. * The function useses hal_srng_dst_num_valid_locked to get the number of valid
  1738. * entries. It should not be called within a SRNG lock. HW pointer value is
  1739. * synced into cached_hp.
  1740. *
  1741. * Return: Number of pending entries if any
  1742. */
  1743. uint32_t dp_rx_srng_get_num_pending(hal_soc_handle_t hal_soc,
  1744. hal_ring_handle_t hal_ring_hdl,
  1745. uint32_t num_entries,
  1746. bool *near_full)
  1747. {
  1748. uint32_t num_pending = 0;
  1749. num_pending = hal_srng_dst_num_valid_locked(hal_soc,
  1750. hal_ring_hdl,
  1751. true);
  1752. if (num_entries && (num_pending >= num_entries >> 1))
  1753. *near_full = true;
  1754. else
  1755. *near_full = false;
  1756. return num_pending;
  1757. }
  1758. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  1759. #ifdef WLAN_SUPPORT_RX_FISA
  1760. void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding)
  1761. {
  1762. QDF_NBUF_CB_RX_PACKET_L3_HDR_PAD(nbuf) = l3_padding;
  1763. qdf_nbuf_pull_head(nbuf, l3_padding + soc->rx_pkt_tlv_size);
  1764. }
  1765. /**
  1766. * dp_rx_set_hdr_pad() - set l3 padding in nbuf cb
  1767. * @nbuf: pkt skb pointer
  1768. * @l3_padding: l3 padding
  1769. *
  1770. * Return: None
  1771. */
  1772. static inline
  1773. void dp_rx_set_hdr_pad(qdf_nbuf_t nbuf, uint32_t l3_padding)
  1774. {
  1775. QDF_NBUF_CB_RX_PACKET_L3_HDR_PAD(nbuf) = l3_padding;
  1776. }
  1777. #else
  1778. void dp_rx_skip_tlvs(struct dp_soc *soc, qdf_nbuf_t nbuf, uint32_t l3_padding)
  1779. {
  1780. qdf_nbuf_pull_head(nbuf, l3_padding + soc->rx_pkt_tlv_size);
  1781. }
  1782. static inline
  1783. void dp_rx_set_hdr_pad(qdf_nbuf_t nbuf, uint32_t l3_padding)
  1784. {
  1785. }
  1786. #endif
  1787. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  1788. #ifdef DP_RX_DROP_RAW_FRM
  1789. /**
  1790. * dp_rx_is_raw_frame_dropped() - if raw frame nbuf, free and drop
  1791. * @nbuf: pkt skb pointer
  1792. *
  1793. * Return: true - raw frame, dropped
  1794. * false - not raw frame, do nothing
  1795. */
  1796. bool dp_rx_is_raw_frame_dropped(qdf_nbuf_t nbuf)
  1797. {
  1798. if (qdf_nbuf_is_raw_frame(nbuf)) {
  1799. qdf_nbuf_free(nbuf);
  1800. return true;
  1801. }
  1802. return false;
  1803. }
  1804. #endif
  1805. #ifdef WLAN_FEATURE_DP_RX_RING_HISTORY
  1806. /**
  1807. * dp_rx_ring_record_entry() - Record an entry into the rx ring history.
  1808. * @soc: Datapath soc structure
  1809. * @ring_num: REO ring number
  1810. * @ring_desc: REO ring descriptor
  1811. *
  1812. * Returns: None
  1813. */
  1814. void
  1815. dp_rx_ring_record_entry(struct dp_soc *soc, uint8_t ring_num,
  1816. hal_ring_desc_t ring_desc)
  1817. {
  1818. struct dp_buf_info_record *record;
  1819. struct hal_buf_info hbi;
  1820. uint32_t idx;
  1821. if (qdf_unlikely(!soc->rx_ring_history[ring_num]))
  1822. return;
  1823. hal_rx_reo_buf_paddr_get(soc->hal_soc, ring_desc, &hbi);
  1824. /* buffer_addr_info is the first element of ring_desc */
  1825. hal_rx_buf_cookie_rbm_get(soc->hal_soc, (uint32_t *)ring_desc,
  1826. &hbi);
  1827. idx = dp_history_get_next_index(&soc->rx_ring_history[ring_num]->index,
  1828. DP_RX_HIST_MAX);
  1829. /* No NULL check needed for record since its an array */
  1830. record = &soc->rx_ring_history[ring_num]->entry[idx];
  1831. record->timestamp = qdf_get_log_timestamp();
  1832. record->hbi.paddr = hbi.paddr;
  1833. record->hbi.sw_cookie = hbi.sw_cookie;
  1834. record->hbi.rbm = hbi.rbm;
  1835. }
  1836. #endif
  1837. #ifdef WLAN_DP_FEATURE_SW_LATENCY_MGR
  1838. /**
  1839. * dp_rx_update_stats() - Update soc level rx packet count
  1840. * @soc: DP soc handle
  1841. * @nbuf: nbuf received
  1842. *
  1843. * Returns: none
  1844. */
  1845. void dp_rx_update_stats(struct dp_soc *soc, qdf_nbuf_t nbuf)
  1846. {
  1847. DP_STATS_INC_PKT(soc, rx.ingress, 1,
  1848. QDF_NBUF_CB_RX_PKT_LEN(nbuf));
  1849. }
  1850. #endif
  1851. #ifdef WLAN_FEATURE_PKT_CAPTURE_V2
  1852. /**
  1853. * dp_rx_deliver_to_pkt_capture() - deliver rx packet to packet capture
  1854. * @soc : dp_soc handle
  1855. * @pdev: dp_pdev handle
  1856. * @peer_id: peer_id of the peer for which completion came
  1857. * @ppdu_id: ppdu_id
  1858. * @netbuf: Buffer pointer
  1859. *
  1860. * This function is used to deliver rx packet to packet capture
  1861. */
  1862. void dp_rx_deliver_to_pkt_capture(struct dp_soc *soc, struct dp_pdev *pdev,
  1863. uint16_t peer_id, uint32_t is_offload,
  1864. qdf_nbuf_t netbuf)
  1865. {
  1866. if (wlan_cfg_get_pkt_capture_mode(soc->wlan_cfg_ctx))
  1867. dp_wdi_event_handler(WDI_EVENT_PKT_CAPTURE_RX_DATA, soc, netbuf,
  1868. peer_id, is_offload, pdev->pdev_id);
  1869. }
  1870. void dp_rx_deliver_to_pkt_capture_no_peer(struct dp_soc *soc, qdf_nbuf_t nbuf,
  1871. uint32_t is_offload)
  1872. {
  1873. if (wlan_cfg_get_pkt_capture_mode(soc->wlan_cfg_ctx))
  1874. dp_wdi_event_handler(WDI_EVENT_PKT_CAPTURE_RX_DATA_NO_PEER,
  1875. soc, nbuf, HTT_INVALID_VDEV,
  1876. is_offload, 0);
  1877. }
  1878. #endif
  1879. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  1880. QDF_STATUS dp_rx_vdev_detach(struct dp_vdev *vdev)
  1881. {
  1882. QDF_STATUS ret;
  1883. if (vdev->osif_rx_flush) {
  1884. ret = vdev->osif_rx_flush(vdev->osif_vdev, vdev->vdev_id);
  1885. if (!QDF_IS_STATUS_SUCCESS(ret)) {
  1886. dp_err("Failed to flush rx pkts for vdev %d\n",
  1887. vdev->vdev_id);
  1888. return ret;
  1889. }
  1890. }
  1891. return QDF_STATUS_SUCCESS;
  1892. }
  1893. static QDF_STATUS
  1894. dp_pdev_nbuf_alloc_and_map(struct dp_soc *dp_soc,
  1895. struct dp_rx_nbuf_frag_info *nbuf_frag_info_t,
  1896. struct dp_pdev *dp_pdev,
  1897. struct rx_desc_pool *rx_desc_pool)
  1898. {
  1899. QDF_STATUS ret = QDF_STATUS_E_FAILURE;
  1900. (nbuf_frag_info_t->virt_addr).nbuf =
  1901. qdf_nbuf_alloc(dp_soc->osdev, rx_desc_pool->buf_size,
  1902. RX_BUFFER_RESERVATION,
  1903. rx_desc_pool->buf_alignment, FALSE);
  1904. if (!((nbuf_frag_info_t->virt_addr).nbuf)) {
  1905. dp_err("nbuf alloc failed");
  1906. DP_STATS_INC(dp_pdev, replenish.nbuf_alloc_fail, 1);
  1907. return ret;
  1908. }
  1909. ret = qdf_nbuf_map_nbytes_single(dp_soc->osdev,
  1910. (nbuf_frag_info_t->virt_addr).nbuf,
  1911. QDF_DMA_FROM_DEVICE,
  1912. rx_desc_pool->buf_size);
  1913. if (qdf_unlikely(QDF_IS_STATUS_ERROR(ret))) {
  1914. qdf_nbuf_free((nbuf_frag_info_t->virt_addr).nbuf);
  1915. dp_err("nbuf map failed");
  1916. DP_STATS_INC(dp_pdev, replenish.map_err, 1);
  1917. return ret;
  1918. }
  1919. nbuf_frag_info_t->paddr =
  1920. qdf_nbuf_get_frag_paddr((nbuf_frag_info_t->virt_addr).nbuf, 0);
  1921. ret = dp_check_paddr(dp_soc, &((nbuf_frag_info_t->virt_addr).nbuf),
  1922. &nbuf_frag_info_t->paddr,
  1923. rx_desc_pool);
  1924. if (ret == QDF_STATUS_E_FAILURE) {
  1925. dp_err("nbuf check x86 failed");
  1926. DP_STATS_INC(dp_pdev, replenish.x86_fail, 1);
  1927. return ret;
  1928. }
  1929. return QDF_STATUS_SUCCESS;
  1930. }
  1931. QDF_STATUS
  1932. dp_pdev_rx_buffers_attach(struct dp_soc *dp_soc, uint32_t mac_id,
  1933. struct dp_srng *dp_rxdma_srng,
  1934. struct rx_desc_pool *rx_desc_pool,
  1935. uint32_t num_req_buffers)
  1936. {
  1937. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(dp_soc, mac_id);
  1938. hal_ring_handle_t rxdma_srng = dp_rxdma_srng->hal_srng;
  1939. union dp_rx_desc_list_elem_t *next;
  1940. void *rxdma_ring_entry;
  1941. qdf_dma_addr_t paddr;
  1942. struct dp_rx_nbuf_frag_info *nf_info;
  1943. uint32_t nr_descs, nr_nbuf = 0, nr_nbuf_total = 0;
  1944. uint32_t buffer_index, nbuf_ptrs_per_page;
  1945. qdf_nbuf_t nbuf;
  1946. QDF_STATUS ret;
  1947. int page_idx, total_pages;
  1948. union dp_rx_desc_list_elem_t *desc_list = NULL;
  1949. union dp_rx_desc_list_elem_t *tail = NULL;
  1950. int sync_hw_ptr = 1;
  1951. uint32_t num_entries_avail;
  1952. if (qdf_unlikely(!dp_pdev)) {
  1953. dp_rx_err("%pK: pdev is null for mac_id = %d",
  1954. dp_soc, mac_id);
  1955. return QDF_STATUS_E_FAILURE;
  1956. }
  1957. if (qdf_unlikely(!rxdma_srng)) {
  1958. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  1959. return QDF_STATUS_E_FAILURE;
  1960. }
  1961. dp_debug("requested %u RX buffers for driver attach", num_req_buffers);
  1962. hal_srng_access_start(dp_soc->hal_soc, rxdma_srng);
  1963. num_entries_avail = hal_srng_src_num_avail(dp_soc->hal_soc,
  1964. rxdma_srng,
  1965. sync_hw_ptr);
  1966. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  1967. if (!num_entries_avail) {
  1968. dp_err("Num of available entries is zero, nothing to do");
  1969. return QDF_STATUS_E_NOMEM;
  1970. }
  1971. if (num_entries_avail < num_req_buffers)
  1972. num_req_buffers = num_entries_avail;
  1973. nr_descs = dp_rx_get_free_desc_list(dp_soc, mac_id, rx_desc_pool,
  1974. num_req_buffers, &desc_list, &tail);
  1975. if (!nr_descs) {
  1976. dp_err("no free rx_descs in freelist");
  1977. DP_STATS_INC(dp_pdev, err.desc_alloc_fail, num_req_buffers);
  1978. return QDF_STATUS_E_NOMEM;
  1979. }
  1980. dp_debug("got %u RX descs for driver attach", nr_descs);
  1981. /*
  1982. * Try to allocate pointers to the nbuf one page at a time.
  1983. * Take pointers that can fit in one page of memory and
  1984. * iterate through the total descriptors that need to be
  1985. * allocated in order of pages. Reuse the pointers that
  1986. * have been allocated to fit in one page across each
  1987. * iteration to index into the nbuf.
  1988. */
  1989. total_pages = (nr_descs * sizeof(*nf_info)) / PAGE_SIZE;
  1990. /*
  1991. * Add an extra page to store the remainder if any
  1992. */
  1993. if ((nr_descs * sizeof(*nf_info)) % PAGE_SIZE)
  1994. total_pages++;
  1995. nf_info = qdf_mem_malloc(PAGE_SIZE);
  1996. if (!nf_info) {
  1997. dp_err("failed to allocate nbuf array");
  1998. DP_STATS_INC(dp_pdev, replenish.rxdma_err, num_req_buffers);
  1999. QDF_BUG(0);
  2000. return QDF_STATUS_E_NOMEM;
  2001. }
  2002. nbuf_ptrs_per_page = PAGE_SIZE / sizeof(*nf_info);
  2003. for (page_idx = 0; page_idx < total_pages; page_idx++) {
  2004. qdf_mem_zero(nf_info, PAGE_SIZE);
  2005. for (nr_nbuf = 0; nr_nbuf < nbuf_ptrs_per_page; nr_nbuf++) {
  2006. /*
  2007. * The last page of buffer pointers may not be required
  2008. * completely based on the number of descriptors. Below
  2009. * check will ensure we are allocating only the
  2010. * required number of descriptors.
  2011. */
  2012. if (nr_nbuf_total >= nr_descs)
  2013. break;
  2014. /* Flag is set while pdev rx_desc_pool initialization */
  2015. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  2016. ret = dp_pdev_frag_alloc_and_map(dp_soc,
  2017. &nf_info[nr_nbuf], dp_pdev,
  2018. rx_desc_pool);
  2019. else
  2020. ret = dp_pdev_nbuf_alloc_and_map(dp_soc,
  2021. &nf_info[nr_nbuf], dp_pdev,
  2022. rx_desc_pool);
  2023. if (QDF_IS_STATUS_ERROR(ret))
  2024. break;
  2025. nr_nbuf_total++;
  2026. }
  2027. hal_srng_access_start(dp_soc->hal_soc, rxdma_srng);
  2028. for (buffer_index = 0; buffer_index < nr_nbuf; buffer_index++) {
  2029. rxdma_ring_entry =
  2030. hal_srng_src_get_next(dp_soc->hal_soc,
  2031. rxdma_srng);
  2032. qdf_assert_always(rxdma_ring_entry);
  2033. next = desc_list->next;
  2034. paddr = nf_info[buffer_index].paddr;
  2035. nbuf = nf_info[buffer_index].virt_addr.nbuf;
  2036. /* Flag is set while pdev rx_desc_pool initialization */
  2037. if (qdf_unlikely(rx_desc_pool->rx_mon_dest_frag_enable))
  2038. dp_rx_desc_frag_prep(&desc_list->rx_desc,
  2039. &nf_info[buffer_index]);
  2040. else
  2041. dp_rx_desc_prep(&desc_list->rx_desc,
  2042. &nf_info[buffer_index]);
  2043. desc_list->rx_desc.in_use = 1;
  2044. dp_rx_desc_alloc_dbg_info(&desc_list->rx_desc);
  2045. dp_rx_desc_update_dbg_info(&desc_list->rx_desc,
  2046. __func__,
  2047. RX_DESC_REPLENISHED);
  2048. hal_rxdma_buff_addr_info_set(dp_soc->hal_soc ,rxdma_ring_entry, paddr,
  2049. desc_list->rx_desc.cookie,
  2050. rx_desc_pool->owner);
  2051. dp_ipa_handle_rx_buf_smmu_mapping(
  2052. dp_soc, nbuf,
  2053. rx_desc_pool->buf_size,
  2054. true);
  2055. desc_list = next;
  2056. }
  2057. dp_rx_refill_ring_record_entry(dp_soc, dp_pdev->lmac_id,
  2058. rxdma_srng, nr_nbuf, nr_nbuf);
  2059. hal_srng_access_end(dp_soc->hal_soc, rxdma_srng);
  2060. }
  2061. dp_info("filled %u RX buffers for driver attach", nr_nbuf_total);
  2062. qdf_mem_free(nf_info);
  2063. if (!nr_nbuf_total) {
  2064. dp_err("No nbuf's allocated");
  2065. QDF_BUG(0);
  2066. return QDF_STATUS_E_RESOURCES;
  2067. }
  2068. /* No need to count the number of bytes received during replenish.
  2069. * Therefore set replenish.pkts.bytes as 0.
  2070. */
  2071. DP_STATS_INC_PKT(dp_pdev, replenish.pkts, nr_nbuf, 0);
  2072. return QDF_STATUS_SUCCESS;
  2073. }
  2074. qdf_export_symbol(dp_pdev_rx_buffers_attach);
  2075. /**
  2076. * dp_rx_enable_mon_dest_frag() - Enable frag processing for
  2077. * monitor destination ring via frag.
  2078. *
  2079. * Enable this flag only for monitor destination buffer processing
  2080. * if DP_RX_MON_MEM_FRAG feature is enabled.
  2081. * If flag is set then frag based function will be called for alloc,
  2082. * map, prep desc and free ops for desc buffer else normal nbuf based
  2083. * function will be called.
  2084. *
  2085. * @rx_desc_pool: Rx desc pool
  2086. * @is_mon_dest_desc: Is it for monitor dest buffer
  2087. *
  2088. * Return: None
  2089. */
  2090. #ifdef DP_RX_MON_MEM_FRAG
  2091. void dp_rx_enable_mon_dest_frag(struct rx_desc_pool *rx_desc_pool,
  2092. bool is_mon_dest_desc)
  2093. {
  2094. rx_desc_pool->rx_mon_dest_frag_enable = is_mon_dest_desc;
  2095. if (is_mon_dest_desc)
  2096. dp_alert("Feature DP_RX_MON_MEM_FRAG for mon_dest is enabled");
  2097. }
  2098. #else
  2099. void dp_rx_enable_mon_dest_frag(struct rx_desc_pool *rx_desc_pool,
  2100. bool is_mon_dest_desc)
  2101. {
  2102. rx_desc_pool->rx_mon_dest_frag_enable = false;
  2103. if (is_mon_dest_desc)
  2104. dp_alert("Feature DP_RX_MON_MEM_FRAG for mon_dest is disabled");
  2105. }
  2106. #endif
  2107. qdf_export_symbol(dp_rx_enable_mon_dest_frag);
  2108. /*
  2109. * dp_rx_pdev_desc_pool_alloc() - allocate memory for software rx descriptor
  2110. * pool
  2111. *
  2112. * @pdev: core txrx pdev context
  2113. *
  2114. * Return: QDF_STATUS - QDF_STATUS_SUCCESS
  2115. * QDF_STATUS_E_NOMEM
  2116. */
  2117. QDF_STATUS
  2118. dp_rx_pdev_desc_pool_alloc(struct dp_pdev *pdev)
  2119. {
  2120. struct dp_soc *soc = pdev->soc;
  2121. uint32_t rxdma_entries;
  2122. uint32_t rx_sw_desc_num;
  2123. struct dp_srng *dp_rxdma_srng;
  2124. struct rx_desc_pool *rx_desc_pool;
  2125. uint32_t status = QDF_STATUS_SUCCESS;
  2126. int mac_for_pdev;
  2127. mac_for_pdev = pdev->lmac_id;
  2128. if (wlan_cfg_get_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx)) {
  2129. dp_rx_info("%pK: nss-wifi<4> skip Rx refil %d",
  2130. soc, mac_for_pdev);
  2131. return status;
  2132. }
  2133. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_for_pdev];
  2134. rxdma_entries = dp_rxdma_srng->num_entries;
  2135. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2136. rx_sw_desc_num = wlan_cfg_get_dp_soc_rx_sw_desc_num(soc->wlan_cfg_ctx);
  2137. rx_desc_pool->desc_type = DP_RX_DESC_BUF_TYPE;
  2138. status = dp_rx_desc_pool_alloc(soc,
  2139. rx_sw_desc_num,
  2140. rx_desc_pool);
  2141. if (status != QDF_STATUS_SUCCESS)
  2142. return status;
  2143. return status;
  2144. }
  2145. /*
  2146. * dp_rx_pdev_desc_pool_free() - free software rx descriptor pool
  2147. *
  2148. * @pdev: core txrx pdev context
  2149. */
  2150. void dp_rx_pdev_desc_pool_free(struct dp_pdev *pdev)
  2151. {
  2152. int mac_for_pdev = pdev->lmac_id;
  2153. struct dp_soc *soc = pdev->soc;
  2154. struct rx_desc_pool *rx_desc_pool;
  2155. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2156. dp_rx_desc_pool_free(soc, rx_desc_pool);
  2157. }
  2158. /*
  2159. * dp_rx_pdev_desc_pool_init() - initialize software rx descriptors
  2160. *
  2161. * @pdev: core txrx pdev context
  2162. *
  2163. * Return: QDF_STATUS - QDF_STATUS_SUCCESS
  2164. * QDF_STATUS_E_NOMEM
  2165. */
  2166. QDF_STATUS dp_rx_pdev_desc_pool_init(struct dp_pdev *pdev)
  2167. {
  2168. int mac_for_pdev = pdev->lmac_id;
  2169. struct dp_soc *soc = pdev->soc;
  2170. uint32_t rxdma_entries;
  2171. uint32_t rx_sw_desc_num;
  2172. struct dp_srng *dp_rxdma_srng;
  2173. struct rx_desc_pool *rx_desc_pool;
  2174. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2175. if (wlan_cfg_get_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx)) {
  2176. /**
  2177. * If NSS is enabled, rx_desc_pool is already filled.
  2178. * Hence, just disable desc_pool frag flag.
  2179. */
  2180. dp_rx_enable_mon_dest_frag(rx_desc_pool, false);
  2181. dp_rx_info("%pK: nss-wifi<4> skip Rx refil %d",
  2182. soc, mac_for_pdev);
  2183. return QDF_STATUS_SUCCESS;
  2184. }
  2185. if (dp_rx_desc_pool_is_allocated(rx_desc_pool) == QDF_STATUS_E_NOMEM)
  2186. return QDF_STATUS_E_NOMEM;
  2187. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_for_pdev];
  2188. rxdma_entries = dp_rxdma_srng->num_entries;
  2189. soc->process_rx_status = CONFIG_PROCESS_RX_STATUS;
  2190. rx_sw_desc_num =
  2191. wlan_cfg_get_dp_soc_rx_sw_desc_num(soc->wlan_cfg_ctx);
  2192. rx_desc_pool->owner = DP_WBM2SW_RBM(soc->wbm_sw0_bm_id);
  2193. rx_desc_pool->buf_size = RX_DATA_BUFFER_SIZE;
  2194. rx_desc_pool->buf_alignment = RX_DATA_BUFFER_ALIGNMENT;
  2195. /* Disable monitor dest processing via frag */
  2196. dp_rx_enable_mon_dest_frag(rx_desc_pool, false);
  2197. dp_rx_desc_pool_init(soc, mac_for_pdev,
  2198. rx_sw_desc_num, rx_desc_pool);
  2199. return QDF_STATUS_SUCCESS;
  2200. }
  2201. /*
  2202. * dp_rx_pdev_desc_pool_deinit() - de-initialize software rx descriptor pools
  2203. * @pdev: core txrx pdev context
  2204. *
  2205. * This function resets the freelist of rx descriptors and destroys locks
  2206. * associated with this list of descriptors.
  2207. */
  2208. void dp_rx_pdev_desc_pool_deinit(struct dp_pdev *pdev)
  2209. {
  2210. int mac_for_pdev = pdev->lmac_id;
  2211. struct dp_soc *soc = pdev->soc;
  2212. struct rx_desc_pool *rx_desc_pool;
  2213. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2214. dp_rx_desc_pool_deinit(soc, rx_desc_pool, mac_for_pdev);
  2215. }
  2216. /*
  2217. * dp_rx_pdev_buffers_alloc() - Allocate nbufs (skbs) and replenish RxDMA ring
  2218. *
  2219. * @pdev: core txrx pdev context
  2220. *
  2221. * Return: QDF_STATUS - QDF_STATUS_SUCCESS
  2222. * QDF_STATUS_E_NOMEM
  2223. */
  2224. QDF_STATUS
  2225. dp_rx_pdev_buffers_alloc(struct dp_pdev *pdev)
  2226. {
  2227. int mac_for_pdev = pdev->lmac_id;
  2228. struct dp_soc *soc = pdev->soc;
  2229. struct dp_srng *dp_rxdma_srng;
  2230. struct rx_desc_pool *rx_desc_pool;
  2231. uint32_t rxdma_entries;
  2232. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_for_pdev];
  2233. rxdma_entries = dp_rxdma_srng->num_entries;
  2234. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2235. /* Initialize RX buffer pool which will be
  2236. * used during low memory conditions
  2237. */
  2238. dp_rx_buffer_pool_init(soc, mac_for_pdev);
  2239. return dp_pdev_rx_buffers_attach(soc, mac_for_pdev, dp_rxdma_srng,
  2240. rx_desc_pool, rxdma_entries - 1);
  2241. }
  2242. /*
  2243. * dp_rx_pdev_buffers_free - Free nbufs (skbs)
  2244. *
  2245. * @pdev: core txrx pdev context
  2246. */
  2247. void
  2248. dp_rx_pdev_buffers_free(struct dp_pdev *pdev)
  2249. {
  2250. int mac_for_pdev = pdev->lmac_id;
  2251. struct dp_soc *soc = pdev->soc;
  2252. struct rx_desc_pool *rx_desc_pool;
  2253. rx_desc_pool = &soc->rx_desc_buf[mac_for_pdev];
  2254. dp_rx_desc_nbuf_free(soc, rx_desc_pool);
  2255. dp_rx_buffer_pool_deinit(soc, mac_for_pdev);
  2256. }
  2257. #ifdef DP_RX_SPECIAL_FRAME_NEED
  2258. bool dp_rx_deliver_special_frame(struct dp_soc *soc, struct dp_peer *peer,
  2259. qdf_nbuf_t nbuf, uint32_t frame_mask,
  2260. uint8_t *rx_tlv_hdr)
  2261. {
  2262. uint32_t l2_hdr_offset = 0;
  2263. uint16_t msdu_len = 0;
  2264. uint32_t skip_len;
  2265. l2_hdr_offset =
  2266. hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc, rx_tlv_hdr);
  2267. if (qdf_unlikely(qdf_nbuf_is_frag(nbuf))) {
  2268. skip_len = l2_hdr_offset;
  2269. } else {
  2270. msdu_len = QDF_NBUF_CB_RX_PKT_LEN(nbuf);
  2271. skip_len = l2_hdr_offset + soc->rx_pkt_tlv_size;
  2272. qdf_nbuf_set_pktlen(nbuf, msdu_len + skip_len);
  2273. }
  2274. QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST(nbuf) = 1;
  2275. dp_rx_set_hdr_pad(nbuf, l2_hdr_offset);
  2276. qdf_nbuf_pull_head(nbuf, skip_len);
  2277. if (dp_rx_is_special_frame(nbuf, frame_mask)) {
  2278. dp_info("special frame, mpdu sn 0x%x",
  2279. hal_rx_get_rx_sequence(soc->hal_soc, rx_tlv_hdr));
  2280. qdf_nbuf_set_exc_frame(nbuf, 1);
  2281. dp_rx_deliver_to_stack(soc, peer->vdev, peer,
  2282. nbuf, NULL);
  2283. return true;
  2284. }
  2285. return false;
  2286. }
  2287. #endif