dp_rx.c 76 KB

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