dp_rx_err.c 77 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859
  1. /*
  2. * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for
  5. * any purpose with or without fee is hereby granted, provided that the
  6. * above copyright notice and this permission notice appear in all
  7. * copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16. * PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #include "hal_hw_headers.h"
  19. #include "dp_types.h"
  20. #include "dp_rx.h"
  21. #include "dp_peer.h"
  22. #include "dp_internal.h"
  23. #include "hal_api.h"
  24. #include "qdf_trace.h"
  25. #include "qdf_nbuf.h"
  26. #include "dp_rx_defrag.h"
  27. #include "dp_ipa.h"
  28. #ifdef FEATURE_WDS
  29. #include "dp_txrx_wds.h"
  30. #endif
  31. #include <enet.h> /* LLC_SNAP_HDR_LEN */
  32. #include "qdf_net_types.h"
  33. #include "dp_rx_buffer_pool.h"
  34. #define dp_rx_err_alert(params...) QDF_TRACE_FATAL(QDF_MODULE_ID_DP_RX_ERROR, params)
  35. #define dp_rx_err_err(params...) QDF_TRACE_ERROR(QDF_MODULE_ID_DP_RX_ERROR, params)
  36. #define dp_rx_err_warn(params...) QDF_TRACE_WARN(QDF_MODULE_ID_DP_RX_ERROR, params)
  37. #define dp_rx_err_info(params...) \
  38. __QDF_TRACE_FL(QDF_TRACE_LEVEL_INFO_HIGH, QDF_MODULE_ID_DP_RX_ERROR, ## params)
  39. #define dp_rx_err_debug(params...) QDF_TRACE_DEBUG(QDF_MODULE_ID_DP_RX_ERROR, params)
  40. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  41. /* Max buffer in invalid peer SG list*/
  42. #define DP_MAX_INVALID_BUFFERS 10
  43. #ifdef FEATURE_MEC
  44. /**
  45. * dp_rx_mcast_echo_check() - check if the mcast pkt is a loop
  46. * back on same vap or a different vap.
  47. *
  48. * @soc: core DP main context
  49. * @peer: dp peer handler
  50. * @rx_tlv_hdr: start of the rx TLV header
  51. * @nbuf: pkt buffer
  52. *
  53. * Return: bool (true if it is a looped back pkt else false)
  54. *
  55. */
  56. static inline bool dp_rx_mcast_echo_check(struct dp_soc *soc,
  57. struct dp_peer *peer,
  58. uint8_t *rx_tlv_hdr,
  59. qdf_nbuf_t nbuf)
  60. {
  61. struct dp_vdev *vdev = peer->vdev;
  62. struct dp_pdev *pdev = vdev->pdev;
  63. struct dp_mec_entry *mecentry = NULL;
  64. uint8_t *data;
  65. /*
  66. * Multicast Echo Check is required only if vdev is STA and
  67. * received pkt is a multicast/broadcast pkt. otherwise
  68. * skip the MEC check.
  69. */
  70. if (vdev->opmode != wlan_op_mode_sta)
  71. return false;
  72. if (!hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc, rx_tlv_hdr))
  73. return false;
  74. data = qdf_nbuf_data(nbuf);
  75. /*
  76. * if the received pkts src mac addr matches with vdev
  77. * mac address then drop the pkt as it is looped back
  78. */
  79. if (!(qdf_mem_cmp(&data[QDF_MAC_ADDR_SIZE],
  80. vdev->mac_addr.raw,
  81. QDF_MAC_ADDR_SIZE)))
  82. return true;
  83. /*
  84. * In case of qwrap isolation mode, donot drop loopback packets.
  85. * In isolation mode, all packets from the wired stations need to go
  86. * to rootap and loop back to reach the wireless stations and
  87. * vice-versa.
  88. */
  89. if (qdf_unlikely(vdev->isolation_vdev))
  90. return false;
  91. /* if the received pkts src mac addr matches with the
  92. * wired PCs MAC addr which is behind the STA or with
  93. * wireless STAs MAC addr which are behind the Repeater,
  94. * then drop the pkt as it is looped back
  95. */
  96. qdf_spin_lock_bh(&soc->mec_lock);
  97. mecentry = dp_peer_mec_hash_find_by_pdevid(soc, pdev->pdev_id,
  98. &data[QDF_MAC_ADDR_SIZE]);
  99. if (!mecentry) {
  100. qdf_spin_unlock_bh(&soc->mec_lock);
  101. return false;
  102. }
  103. qdf_spin_unlock_bh(&soc->mec_lock);
  104. dp_rx_err_info("%pK: received pkt with same src mac " QDF_MAC_ADDR_FMT,
  105. soc, QDF_MAC_ADDR_REF(&data[QDF_MAC_ADDR_SIZE]));
  106. return true;
  107. }
  108. #else
  109. static inline bool dp_rx_mcast_echo_check(struct dp_soc *soc,
  110. struct dp_peer *peer,
  111. uint8_t *rx_tlv_hdr,
  112. qdf_nbuf_t nbuf)
  113. {
  114. return false;
  115. }
  116. #endif
  117. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  118. void dp_rx_link_desc_refill_duplicate_check(
  119. struct dp_soc *soc,
  120. struct hal_buf_info *buf_info,
  121. hal_buff_addrinfo_t ring_buf_info)
  122. {
  123. struct hal_buf_info current_link_desc_buf_info = { 0 };
  124. /* do duplicate link desc address check */
  125. hal_rx_buffer_addr_info_get_paddr(ring_buf_info,
  126. &current_link_desc_buf_info);
  127. if (qdf_unlikely(current_link_desc_buf_info.paddr ==
  128. buf_info->paddr)) {
  129. dp_info_rl("duplicate link desc addr: %llu, cookie: 0x%x",
  130. current_link_desc_buf_info.paddr,
  131. current_link_desc_buf_info.sw_cookie);
  132. DP_STATS_INC(soc, rx.err.dup_refill_link_desc, 1);
  133. }
  134. *buf_info = current_link_desc_buf_info;
  135. }
  136. /**
  137. * dp_rx_link_desc_return_by_addr - Return a MPDU link descriptor to
  138. * (WBM) by address
  139. *
  140. * @soc: core DP main context
  141. * @link_desc_addr: link descriptor addr
  142. *
  143. * Return: QDF_STATUS
  144. */
  145. QDF_STATUS
  146. dp_rx_link_desc_return_by_addr(struct dp_soc *soc,
  147. hal_buff_addrinfo_t link_desc_addr,
  148. uint8_t bm_action)
  149. {
  150. struct dp_srng *wbm_desc_rel_ring = &soc->wbm_desc_rel_ring;
  151. hal_ring_handle_t wbm_rel_srng = wbm_desc_rel_ring->hal_srng;
  152. hal_soc_handle_t hal_soc = soc->hal_soc;
  153. QDF_STATUS status = QDF_STATUS_E_FAILURE;
  154. void *src_srng_desc;
  155. if (!wbm_rel_srng) {
  156. dp_rx_err_err("%pK: WBM RELEASE RING not initialized", soc);
  157. return status;
  158. }
  159. /* do duplicate link desc address check */
  160. dp_rx_link_desc_refill_duplicate_check(
  161. soc,
  162. &soc->last_op_info.wbm_rel_link_desc,
  163. link_desc_addr);
  164. if (qdf_unlikely(hal_srng_access_start(hal_soc, wbm_rel_srng))) {
  165. /* TODO */
  166. /*
  167. * Need API to convert from hal_ring pointer to
  168. * Ring Type / Ring Id combo
  169. */
  170. dp_rx_err_err("%pK: HAL RING Access For WBM Release SRNG Failed - %pK",
  171. soc, wbm_rel_srng);
  172. DP_STATS_INC(soc, rx.err.hal_ring_access_fail, 1);
  173. goto done;
  174. }
  175. src_srng_desc = hal_srng_src_get_next(hal_soc, wbm_rel_srng);
  176. if (qdf_likely(src_srng_desc)) {
  177. /* Return link descriptor through WBM ring (SW2WBM)*/
  178. hal_rx_msdu_link_desc_set(hal_soc,
  179. src_srng_desc, link_desc_addr, bm_action);
  180. status = QDF_STATUS_SUCCESS;
  181. } else {
  182. struct hal_srng *srng = (struct hal_srng *)wbm_rel_srng;
  183. DP_STATS_INC(soc, rx.err.hal_ring_access_full_fail, 1);
  184. dp_info_rl("WBM Release Ring (Id %d) Full(Fail CNT %u)",
  185. srng->ring_id,
  186. soc->stats.rx.err.hal_ring_access_full_fail);
  187. dp_info_rl("HP 0x%x Reap HP 0x%x TP 0x%x Cached TP 0x%x",
  188. *srng->u.src_ring.hp_addr,
  189. srng->u.src_ring.reap_hp,
  190. *srng->u.src_ring.tp_addr,
  191. srng->u.src_ring.cached_tp);
  192. QDF_BUG(0);
  193. }
  194. done:
  195. hal_srng_access_end(hal_soc, wbm_rel_srng);
  196. return status;
  197. }
  198. /**
  199. * dp_rx_link_desc_return() - Return a MPDU link descriptor to HW
  200. * (WBM), following error handling
  201. *
  202. * @soc: core DP main context
  203. * @ring_desc: opaque pointer to the REO error ring descriptor
  204. *
  205. * Return: QDF_STATUS
  206. */
  207. QDF_STATUS
  208. dp_rx_link_desc_return(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  209. uint8_t bm_action)
  210. {
  211. void *buf_addr_info = HAL_RX_REO_BUF_ADDR_INFO_GET(ring_desc);
  212. return dp_rx_link_desc_return_by_addr(soc, buf_addr_info, bm_action);
  213. }
  214. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  215. /**
  216. * dp_rx_msdus_drop() - Drops all MSDU's per MPDU
  217. *
  218. * @soc: core txrx main context
  219. * @ring_desc: opaque pointer to the REO error ring descriptor
  220. * @mpdu_desc_info: MPDU descriptor information from ring descriptor
  221. * @head: head of the local descriptor free-list
  222. * @tail: tail of the local descriptor free-list
  223. * @quota: No. of units (packets) that can be serviced in one shot.
  224. *
  225. * This function is used to drop all MSDU in an MPDU
  226. *
  227. * Return: uint32_t: No. of elements processed
  228. */
  229. static uint32_t
  230. dp_rx_msdus_drop(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  231. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  232. uint8_t *mac_id,
  233. uint32_t quota)
  234. {
  235. uint32_t rx_bufs_used = 0;
  236. void *link_desc_va;
  237. struct hal_buf_info buf_info;
  238. struct dp_pdev *pdev;
  239. struct hal_rx_msdu_list msdu_list; /* MSDU's per MPDU */
  240. int i;
  241. uint8_t *rx_tlv_hdr;
  242. uint32_t tid;
  243. struct rx_desc_pool *rx_desc_pool;
  244. struct dp_rx_desc *rx_desc;
  245. /* First field in REO Dst ring Desc is buffer_addr_info */
  246. void *buf_addr_info = ring_desc;
  247. struct buffer_addr_info cur_link_desc_addr_info = { 0 };
  248. struct buffer_addr_info next_link_desc_addr_info = { 0 };
  249. hal_rx_reo_buf_paddr_get(ring_desc, &buf_info);
  250. link_desc_va = dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  251. more_msdu_link_desc:
  252. /* No UNMAP required -- this is "malloc_consistent" memory */
  253. hal_rx_msdu_list_get(soc->hal_soc, link_desc_va, &msdu_list,
  254. &mpdu_desc_info->msdu_count);
  255. for (i = 0; (i < mpdu_desc_info->msdu_count); i++) {
  256. rx_desc = dp_rx_cookie_2_va_rxdma_buf(soc,
  257. msdu_list.sw_cookie[i]);
  258. qdf_assert_always(rx_desc);
  259. /* all buffers from a MSDU link link belong to same pdev */
  260. *mac_id = rx_desc->pool_id;
  261. pdev = dp_get_pdev_for_lmac_id(soc, rx_desc->pool_id);
  262. if (!pdev) {
  263. dp_rx_err_debug("%pK: pdev is null for pool_id = %d",
  264. soc, rx_desc->pool_id);
  265. return rx_bufs_used;
  266. }
  267. if (!dp_rx_desc_check_magic(rx_desc)) {
  268. dp_rx_err_err("%pK: Invalid rx_desc cookie=%d",
  269. soc, msdu_list.sw_cookie[i]);
  270. return rx_bufs_used;
  271. }
  272. rx_desc_pool = &soc->rx_desc_buf[rx_desc->pool_id];
  273. dp_ipa_handle_rx_buf_smmu_mapping(soc, rx_desc->nbuf,
  274. rx_desc_pool->buf_size,
  275. false);
  276. qdf_nbuf_unmap_nbytes_single(soc->osdev, rx_desc->nbuf,
  277. QDF_DMA_FROM_DEVICE,
  278. rx_desc_pool->buf_size);
  279. rx_desc->unmapped = 1;
  280. rx_desc->rx_buf_start = qdf_nbuf_data(rx_desc->nbuf);
  281. rx_bufs_used++;
  282. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc,
  283. rx_desc->rx_buf_start);
  284. dp_rx_err_err("%pK: Packet received with PN error for tid :%d",
  285. soc, tid);
  286. rx_tlv_hdr = qdf_nbuf_data(rx_desc->nbuf);
  287. if (hal_rx_encryption_info_valid(soc->hal_soc, rx_tlv_hdr))
  288. hal_rx_print_pn(soc->hal_soc, rx_tlv_hdr);
  289. /* Just free the buffers */
  290. dp_rx_buffer_pool_nbuf_free(soc, rx_desc->nbuf, *mac_id);
  291. dp_rx_add_to_free_desc_list(&pdev->free_list_head,
  292. &pdev->free_list_tail, rx_desc);
  293. }
  294. /*
  295. * If the msdu's are spread across multiple link-descriptors,
  296. * we cannot depend solely on the msdu_count(e.g., if msdu is
  297. * spread across multiple buffers).Hence, it is
  298. * necessary to check the next link_descriptor and release
  299. * all the msdu's that are part of it.
  300. */
  301. hal_rx_get_next_msdu_link_desc_buf_addr_info(
  302. link_desc_va,
  303. &next_link_desc_addr_info);
  304. if (hal_rx_is_buf_addr_info_valid(
  305. &next_link_desc_addr_info)) {
  306. /* Clear the next link desc info for the current link_desc */
  307. hal_rx_clear_next_msdu_link_desc_buf_addr_info(link_desc_va);
  308. dp_rx_link_desc_return_by_addr(soc, buf_addr_info,
  309. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  310. hal_rx_buffer_addr_info_get_paddr(
  311. &next_link_desc_addr_info,
  312. &buf_info);
  313. cur_link_desc_addr_info = next_link_desc_addr_info;
  314. buf_addr_info = &cur_link_desc_addr_info;
  315. link_desc_va =
  316. dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  317. goto more_msdu_link_desc;
  318. }
  319. quota--;
  320. dp_rx_link_desc_return_by_addr(soc, buf_addr_info,
  321. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  322. return rx_bufs_used;
  323. }
  324. /**
  325. * dp_rx_pn_error_handle() - Handles PN check errors
  326. *
  327. * @soc: core txrx main context
  328. * @ring_desc: opaque pointer to the REO error ring descriptor
  329. * @mpdu_desc_info: MPDU descriptor information from ring descriptor
  330. * @head: head of the local descriptor free-list
  331. * @tail: tail of the local descriptor free-list
  332. * @quota: No. of units (packets) that can be serviced in one shot.
  333. *
  334. * This function implements PN error handling
  335. * If the peer is configured to ignore the PN check errors
  336. * or if DP feels, that this frame is still OK, the frame can be
  337. * re-injected back to REO to use some of the other features
  338. * of REO e.g. duplicate detection/routing to other cores
  339. *
  340. * Return: uint32_t: No. of elements processed
  341. */
  342. static uint32_t
  343. dp_rx_pn_error_handle(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  344. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  345. uint8_t *mac_id,
  346. uint32_t quota)
  347. {
  348. uint16_t peer_id;
  349. uint32_t rx_bufs_used = 0;
  350. struct dp_peer *peer;
  351. bool peer_pn_policy = false;
  352. peer_id = DP_PEER_METADATA_PEER_ID_GET(
  353. mpdu_desc_info->peer_meta_data);
  354. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
  355. if (qdf_likely(peer)) {
  356. /*
  357. * TODO: Check for peer specific policies & set peer_pn_policy
  358. */
  359. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  360. "discard rx due to PN error for peer %pK "QDF_MAC_ADDR_FMT,
  361. peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  362. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  363. }
  364. dp_rx_err_err("%pK: Packet received with PN error", soc);
  365. /* No peer PN policy -- definitely drop */
  366. if (!peer_pn_policy)
  367. rx_bufs_used = dp_rx_msdus_drop(soc, ring_desc,
  368. mpdu_desc_info,
  369. mac_id, quota);
  370. return rx_bufs_used;
  371. }
  372. /**
  373. * dp_rx_oor_handle() - Handles the msdu which is OOR error
  374. *
  375. * @soc: core txrx main context
  376. * @nbuf: pointer to msdu skb
  377. * @rx_tlv_hdr: start of rx tlv header
  378. * @mpdu_desc_info: pointer to mpdu level description info
  379. * @peer_id: dp peer ID
  380. * @tid: dp tid
  381. *
  382. * This function process the msdu delivered from REO2TCL
  383. * ring with error type OOR
  384. *
  385. * Return: None
  386. */
  387. static void
  388. dp_rx_oor_handle(struct dp_soc *soc,
  389. qdf_nbuf_t nbuf,
  390. uint8_t *rx_tlv_hdr,
  391. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  392. uint16_t peer_id,
  393. uint8_t tid)
  394. {
  395. uint32_t frame_mask = FRAME_MASK_IPV4_ARP | FRAME_MASK_IPV4_DHCP |
  396. FRAME_MASK_IPV4_EAPOL | FRAME_MASK_IPV6_DHCP;
  397. struct dp_peer *peer = NULL;
  398. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
  399. if (!peer || tid >= DP_MAX_TIDS) {
  400. dp_info_rl("peer or tid %d not valid", tid);
  401. goto free_nbuf;
  402. }
  403. /*
  404. * For REO error 7 OOR, if it is retry frame under BA session,
  405. * then it is likely SN duplicated frame, do not deliver EAPOL
  406. * to stack in this case since the connection might fail due to
  407. * duplicated EAP response.
  408. */
  409. if (mpdu_desc_info &&
  410. mpdu_desc_info->mpdu_flags & HAL_MPDU_F_RETRY_BIT &&
  411. peer->rx_tid[tid].ba_status == DP_RX_BA_ACTIVE) {
  412. frame_mask &= ~FRAME_MASK_IPV4_EAPOL;
  413. DP_STATS_INC(soc, rx.err.reo_err_oor_eapol_drop, 1);
  414. }
  415. if (dp_rx_deliver_special_frame(soc, peer, nbuf, frame_mask,
  416. rx_tlv_hdr)) {
  417. DP_STATS_INC(soc, rx.err.reo_err_oor_to_stack, 1);
  418. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  419. return;
  420. }
  421. free_nbuf:
  422. if (peer)
  423. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  424. DP_STATS_INC(soc, rx.err.reo_err_oor_drop, 1);
  425. qdf_nbuf_free(nbuf);
  426. }
  427. /**
  428. * dp_rx_reo_err_entry_process() - Handles for REO error entry processing
  429. *
  430. * @soc: core txrx main context
  431. * @ring_desc: opaque pointer to the REO error ring descriptor
  432. * @mpdu_desc_info: pointer to mpdu level description info
  433. * @link_desc_va: pointer to msdu_link_desc virtual address
  434. * @err_code: reo erro code fetched from ring entry
  435. *
  436. * Function to handle msdus fetched from msdu link desc, currently
  437. * only support 2K jump, OOR error.
  438. *
  439. * Return: msdu count processed.
  440. */
  441. static uint32_t
  442. dp_rx_reo_err_entry_process(struct dp_soc *soc,
  443. void *ring_desc,
  444. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  445. void *link_desc_va,
  446. enum hal_reo_error_code err_code)
  447. {
  448. uint32_t rx_bufs_used = 0;
  449. struct dp_pdev *pdev;
  450. int i;
  451. uint8_t *rx_tlv_hdr_first;
  452. uint8_t *rx_tlv_hdr_last;
  453. uint32_t tid = DP_MAX_TIDS;
  454. uint16_t peer_id;
  455. struct dp_rx_desc *rx_desc;
  456. struct rx_desc_pool *rx_desc_pool;
  457. qdf_nbuf_t nbuf;
  458. struct hal_buf_info buf_info;
  459. struct hal_rx_msdu_list msdu_list;
  460. uint16_t num_msdus;
  461. struct buffer_addr_info cur_link_desc_addr_info = { 0 };
  462. struct buffer_addr_info next_link_desc_addr_info = { 0 };
  463. /* First field in REO Dst ring Desc is buffer_addr_info */
  464. void *buf_addr_info = ring_desc;
  465. qdf_nbuf_t head_nbuf = NULL;
  466. qdf_nbuf_t tail_nbuf = NULL;
  467. uint16_t msdu_processed = 0;
  468. peer_id = DP_PEER_METADATA_PEER_ID_GET(
  469. mpdu_desc_info->peer_meta_data);
  470. more_msdu_link_desc:
  471. hal_rx_msdu_list_get(soc->hal_soc, link_desc_va, &msdu_list,
  472. &num_msdus);
  473. for (i = 0; i < num_msdus; i++) {
  474. rx_desc = dp_rx_cookie_2_va_rxdma_buf(
  475. soc,
  476. msdu_list.sw_cookie[i]);
  477. qdf_assert_always(rx_desc);
  478. /* all buffers from a MSDU link belong to same pdev */
  479. pdev = dp_get_pdev_for_lmac_id(soc, rx_desc->pool_id);
  480. nbuf = rx_desc->nbuf;
  481. rx_desc_pool = &soc->rx_desc_buf[rx_desc->pool_id];
  482. dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf,
  483. rx_desc_pool->buf_size,
  484. false);
  485. qdf_nbuf_unmap_nbytes_single(soc->osdev, nbuf,
  486. QDF_DMA_FROM_DEVICE,
  487. rx_desc_pool->buf_size);
  488. rx_desc->unmapped = 1;
  489. QDF_NBUF_CB_RX_PKT_LEN(nbuf) = msdu_list.msdu_info[i].msdu_len;
  490. rx_bufs_used++;
  491. dp_rx_add_to_free_desc_list(&pdev->free_list_head,
  492. &pdev->free_list_tail, rx_desc);
  493. DP_RX_LIST_APPEND(head_nbuf, tail_nbuf, nbuf);
  494. if (qdf_unlikely(msdu_list.msdu_info[i].msdu_flags &
  495. HAL_MSDU_F_MSDU_CONTINUATION))
  496. continue;
  497. if (dp_rx_buffer_pool_refill(soc, head_nbuf,
  498. rx_desc->pool_id)) {
  499. /* MSDU queued back to the pool */
  500. goto process_next_msdu;
  501. }
  502. rx_tlv_hdr_first = qdf_nbuf_data(head_nbuf);
  503. rx_tlv_hdr_last = qdf_nbuf_data(tail_nbuf);
  504. if (qdf_unlikely(head_nbuf != tail_nbuf)) {
  505. nbuf = dp_rx_sg_create(soc, head_nbuf);
  506. qdf_nbuf_set_is_frag(nbuf, 1);
  507. DP_STATS_INC(soc, rx.err.reo_err_oor_sg_count, 1);
  508. }
  509. /*
  510. * only first msdu, mpdu start description tlv valid?
  511. * and use it for following msdu.
  512. */
  513. if (hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  514. rx_tlv_hdr_last))
  515. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc,
  516. rx_tlv_hdr_first);
  517. switch (err_code) {
  518. case HAL_REO_ERR_REGULAR_FRAME_2K_JUMP:
  519. dp_2k_jump_handle(soc, nbuf, rx_tlv_hdr_last,
  520. peer_id, tid);
  521. break;
  522. case HAL_REO_ERR_REGULAR_FRAME_OOR:
  523. dp_rx_oor_handle(soc, nbuf, rx_tlv_hdr_last,
  524. mpdu_desc_info, peer_id, tid);
  525. break;
  526. default:
  527. dp_err_rl("Non-support error code %d", err_code);
  528. qdf_nbuf_free(nbuf);
  529. }
  530. process_next_msdu:
  531. msdu_processed++;
  532. head_nbuf = NULL;
  533. tail_nbuf = NULL;
  534. }
  535. /*
  536. * If the msdu's are spread across multiple link-descriptors,
  537. * we cannot depend solely on the msdu_count(e.g., if msdu is
  538. * spread across multiple buffers).Hence, it is
  539. * necessary to check the next link_descriptor and release
  540. * all the msdu's that are part of it.
  541. */
  542. hal_rx_get_next_msdu_link_desc_buf_addr_info(
  543. link_desc_va,
  544. &next_link_desc_addr_info);
  545. if (hal_rx_is_buf_addr_info_valid(
  546. &next_link_desc_addr_info)) {
  547. /* Clear the next link desc info for the current link_desc */
  548. hal_rx_clear_next_msdu_link_desc_buf_addr_info(link_desc_va);
  549. dp_rx_link_desc_return_by_addr(
  550. soc,
  551. buf_addr_info,
  552. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  553. hal_rx_buffer_addr_info_get_paddr(
  554. &next_link_desc_addr_info,
  555. &buf_info);
  556. link_desc_va =
  557. dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  558. cur_link_desc_addr_info = next_link_desc_addr_info;
  559. buf_addr_info = &cur_link_desc_addr_info;
  560. goto more_msdu_link_desc;
  561. }
  562. dp_rx_link_desc_return_by_addr(soc, buf_addr_info,
  563. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  564. if (qdf_unlikely(msdu_processed != mpdu_desc_info->msdu_count))
  565. DP_STATS_INC(soc, rx.err.msdu_count_mismatch, 1);
  566. return rx_bufs_used;
  567. }
  568. #ifdef DP_INVALID_PEER_ASSERT
  569. #define DP_PDEV_INVALID_PEER_MSDU_CHECK(head, tail) \
  570. do { \
  571. qdf_assert_always(!(head)); \
  572. qdf_assert_always(!(tail)); \
  573. } while (0)
  574. #else
  575. #define DP_PDEV_INVALID_PEER_MSDU_CHECK(head, tail) /* no op */
  576. #endif
  577. /**
  578. * dp_rx_chain_msdus() - Function to chain all msdus of a mpdu
  579. * to pdev invalid peer list
  580. *
  581. * @soc: core DP main context
  582. * @nbuf: Buffer pointer
  583. * @rx_tlv_hdr: start of rx tlv header
  584. * @mac_id: mac id
  585. *
  586. * Return: bool: true for last msdu of mpdu
  587. */
  588. static bool
  589. dp_rx_chain_msdus(struct dp_soc *soc, qdf_nbuf_t nbuf,
  590. uint8_t *rx_tlv_hdr, uint8_t mac_id)
  591. {
  592. bool mpdu_done = false;
  593. qdf_nbuf_t curr_nbuf = NULL;
  594. qdf_nbuf_t tmp_nbuf = NULL;
  595. /* TODO: Currently only single radio is supported, hence
  596. * pdev hard coded to '0' index
  597. */
  598. struct dp_pdev *dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  599. if (!dp_pdev) {
  600. dp_rx_err_debug("%pK: pdev is null for mac_id = %d", soc, mac_id);
  601. return mpdu_done;
  602. }
  603. /* if invalid peer SG list has max values free the buffers in list
  604. * and treat current buffer as start of list
  605. *
  606. * current logic to detect the last buffer from attn_tlv is not reliable
  607. * in OFDMA UL scenario hence add max buffers check to avoid list pile
  608. * up
  609. */
  610. if (!dp_pdev->first_nbuf ||
  611. (dp_pdev->invalid_peer_head_msdu &&
  612. QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST
  613. (dp_pdev->invalid_peer_head_msdu) >= DP_MAX_INVALID_BUFFERS)) {
  614. qdf_nbuf_set_rx_chfrag_start(nbuf, 1);
  615. dp_pdev->ppdu_id = hal_rx_get_ppdu_id(soc->hal_soc,
  616. rx_tlv_hdr);
  617. dp_pdev->first_nbuf = true;
  618. /* If the new nbuf received is the first msdu of the
  619. * amsdu and there are msdus in the invalid peer msdu
  620. * list, then let us free all the msdus of the invalid
  621. * peer msdu list.
  622. * This scenario can happen when we start receiving
  623. * new a-msdu even before the previous a-msdu is completely
  624. * received.
  625. */
  626. curr_nbuf = dp_pdev->invalid_peer_head_msdu;
  627. while (curr_nbuf) {
  628. tmp_nbuf = curr_nbuf->next;
  629. qdf_nbuf_free(curr_nbuf);
  630. curr_nbuf = tmp_nbuf;
  631. }
  632. dp_pdev->invalid_peer_head_msdu = NULL;
  633. dp_pdev->invalid_peer_tail_msdu = NULL;
  634. hal_rx_mon_hw_desc_get_mpdu_status(soc->hal_soc, rx_tlv_hdr,
  635. &(dp_pdev->ppdu_info.rx_status));
  636. }
  637. if (dp_pdev->ppdu_id == hal_rx_attn_phy_ppdu_id_get(rx_tlv_hdr) &&
  638. hal_rx_attn_msdu_done_get(rx_tlv_hdr)) {
  639. qdf_nbuf_set_rx_chfrag_end(nbuf, 1);
  640. qdf_assert_always(dp_pdev->first_nbuf == true);
  641. dp_pdev->first_nbuf = false;
  642. mpdu_done = true;
  643. }
  644. /*
  645. * For MCL, invalid_peer_head_msdu and invalid_peer_tail_msdu
  646. * should be NULL here, add the checking for debugging purpose
  647. * in case some corner case.
  648. */
  649. DP_PDEV_INVALID_PEER_MSDU_CHECK(dp_pdev->invalid_peer_head_msdu,
  650. dp_pdev->invalid_peer_tail_msdu);
  651. DP_RX_LIST_APPEND(dp_pdev->invalid_peer_head_msdu,
  652. dp_pdev->invalid_peer_tail_msdu,
  653. nbuf);
  654. return mpdu_done;
  655. }
  656. static
  657. void dp_rx_err_handle_bar(struct dp_soc *soc,
  658. struct dp_peer *peer,
  659. qdf_nbuf_t nbuf)
  660. {
  661. uint8_t *rx_tlv_hdr;
  662. unsigned char type, subtype;
  663. uint16_t start_seq_num;
  664. uint32_t tid;
  665. struct ieee80211_frame_bar *bar;
  666. /*
  667. * 1. Is this a BAR frame. If not Discard it.
  668. * 2. If it is, get the peer id, tid, ssn
  669. * 2a Do a tid update
  670. */
  671. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  672. bar = (struct ieee80211_frame_bar *)(rx_tlv_hdr + SIZE_OF_DATA_RX_TLV);
  673. type = bar->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
  674. subtype = bar->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
  675. if (!(type == IEEE80211_FC0_TYPE_CTL &&
  676. subtype == QDF_IEEE80211_FC0_SUBTYPE_BAR)) {
  677. dp_err_rl("Not a BAR frame!");
  678. return;
  679. }
  680. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc, rx_tlv_hdr);
  681. qdf_assert_always(tid < DP_MAX_TIDS);
  682. start_seq_num = le16toh(bar->i_seq) >> IEEE80211_SEQ_SEQ_SHIFT;
  683. dp_info_rl("tid %u window_size %u start_seq_num %u",
  684. tid, peer->rx_tid[tid].ba_win_size, start_seq_num);
  685. dp_rx_tid_update_wifi3(peer, tid,
  686. peer->rx_tid[tid].ba_win_size,
  687. start_seq_num);
  688. }
  689. static void
  690. dp_rx_bar_frame_handle(struct dp_soc *soc,
  691. hal_ring_desc_t ring_desc,
  692. struct dp_rx_desc *rx_desc,
  693. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  694. uint8_t error)
  695. {
  696. qdf_nbuf_t nbuf;
  697. struct dp_pdev *pdev;
  698. struct dp_peer *peer;
  699. struct rx_desc_pool *rx_desc_pool;
  700. uint16_t peer_id;
  701. uint8_t *rx_tlv_hdr;
  702. uint32_t tid;
  703. nbuf = rx_desc->nbuf;
  704. rx_desc_pool = &soc->rx_desc_buf[rx_desc->pool_id];
  705. dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf,
  706. rx_desc_pool->buf_size,
  707. false);
  708. qdf_nbuf_unmap_nbytes_single(soc->osdev, nbuf,
  709. QDF_DMA_FROM_DEVICE,
  710. rx_desc_pool->buf_size);
  711. rx_desc->unmapped = 1;
  712. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  713. peer_id =
  714. hal_rx_mpdu_start_sw_peer_id_get(soc->hal_soc,
  715. rx_tlv_hdr);
  716. peer = dp_peer_get_ref_by_id(soc, peer_id,
  717. DP_MOD_ID_RX_ERR);
  718. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc,
  719. rx_tlv_hdr);
  720. pdev = dp_get_pdev_for_lmac_id(soc, rx_desc->pool_id);
  721. if (!peer)
  722. goto next;
  723. dp_info("BAR frame: peer = "QDF_MAC_ADDR_FMT
  724. " peer_id = %d"
  725. " tid = %u"
  726. " SSN = %d"
  727. " error status = %d",
  728. QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  729. peer->peer_id,
  730. tid,
  731. mpdu_desc_info->mpdu_seq,
  732. error);
  733. switch (error) {
  734. case HAL_REO_ERR_BAR_FRAME_2K_JUMP:
  735. /* fallthrough */
  736. case HAL_REO_ERR_BAR_FRAME_OOR:
  737. dp_rx_err_handle_bar(soc, peer, nbuf);
  738. DP_STATS_INC(soc,
  739. rx.err.reo_error[error], 1);
  740. break;
  741. default:
  742. DP_STATS_INC(soc, rx.bar_frame, 1);
  743. }
  744. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  745. next:
  746. dp_rx_link_desc_return(soc, ring_desc,
  747. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  748. dp_rx_add_to_free_desc_list(&pdev->free_list_head,
  749. &pdev->free_list_tail,
  750. rx_desc);
  751. qdf_nbuf_free(nbuf);
  752. }
  753. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  754. /**
  755. * dp_2k_jump_handle() - Function to handle 2k jump exception
  756. * on WBM ring
  757. *
  758. * @soc: core DP main context
  759. * @nbuf: buffer pointer
  760. * @rx_tlv_hdr: start of rx tlv header
  761. * @peer_id: peer id of first msdu
  762. * @tid: Tid for which exception occurred
  763. *
  764. * This function handles 2k jump violations arising out
  765. * of receiving aggregates in non BA case. This typically
  766. * may happen if aggregates are received on a QOS enabled TID
  767. * while Rx window size is still initialized to value of 2. Or
  768. * it may also happen if negotiated window size is 1 but peer
  769. * sends aggregates.
  770. *
  771. */
  772. void
  773. dp_2k_jump_handle(struct dp_soc *soc,
  774. qdf_nbuf_t nbuf,
  775. uint8_t *rx_tlv_hdr,
  776. uint16_t peer_id,
  777. uint8_t tid)
  778. {
  779. struct dp_peer *peer = NULL;
  780. struct dp_rx_tid *rx_tid = NULL;
  781. uint32_t frame_mask = FRAME_MASK_IPV4_ARP;
  782. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
  783. if (!peer) {
  784. dp_rx_err_err("%pK: peer not found", soc);
  785. goto free_nbuf;
  786. }
  787. if (tid >= DP_MAX_TIDS) {
  788. dp_info_rl("invalid tid");
  789. goto nbuf_deliver;
  790. }
  791. rx_tid = &peer->rx_tid[tid];
  792. qdf_spin_lock_bh(&rx_tid->tid_lock);
  793. /* only if BA session is active, allow send Delba */
  794. if (rx_tid->ba_status != DP_RX_BA_ACTIVE) {
  795. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  796. goto nbuf_deliver;
  797. }
  798. if (!rx_tid->delba_tx_status) {
  799. rx_tid->delba_tx_retry++;
  800. rx_tid->delba_tx_status = 1;
  801. rx_tid->delba_rcode =
  802. IEEE80211_REASON_QOS_SETUP_REQUIRED;
  803. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  804. if (soc->cdp_soc.ol_ops->send_delba) {
  805. DP_STATS_INC(soc, rx.err.rx_2k_jump_delba_sent, 1);
  806. soc->cdp_soc.ol_ops->send_delba(
  807. peer->vdev->pdev->soc->ctrl_psoc,
  808. peer->vdev->vdev_id,
  809. peer->mac_addr.raw,
  810. tid,
  811. rx_tid->delba_rcode);
  812. }
  813. } else {
  814. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  815. }
  816. nbuf_deliver:
  817. if (dp_rx_deliver_special_frame(soc, peer, nbuf, frame_mask,
  818. rx_tlv_hdr)) {
  819. DP_STATS_INC(soc, rx.err.rx_2k_jump_to_stack, 1);
  820. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  821. return;
  822. }
  823. free_nbuf:
  824. if (peer)
  825. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  826. DP_STATS_INC(soc, rx.err.rx_2k_jump_drop, 1);
  827. qdf_nbuf_free(nbuf);
  828. }
  829. #if defined(QCA_WIFI_QCA6390) || defined(QCA_WIFI_QCA6490) || \
  830. defined(QCA_WIFI_QCA6750)
  831. /**
  832. * dp_rx_null_q_handle_invalid_peer_id_exception() - to find exception
  833. * @soc: pointer to dp_soc struct
  834. * @pool_id: Pool id to find dp_pdev
  835. * @rx_tlv_hdr: TLV header of received packet
  836. * @nbuf: SKB
  837. *
  838. * In certain types of packets if peer_id is not correct then
  839. * driver may not be able find. Try finding peer by addr_2 of
  840. * received MPDU. If you find the peer then most likely sw_peer_id &
  841. * ast_idx is corrupted.
  842. *
  843. * Return: True if you find the peer by addr_2 of received MPDU else false
  844. */
  845. static bool
  846. dp_rx_null_q_handle_invalid_peer_id_exception(struct dp_soc *soc,
  847. uint8_t pool_id,
  848. uint8_t *rx_tlv_hdr,
  849. qdf_nbuf_t nbuf)
  850. {
  851. struct dp_peer *peer = NULL;
  852. uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(rx_tlv_hdr);
  853. struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, pool_id);
  854. struct ieee80211_frame *wh = (struct ieee80211_frame *)rx_pkt_hdr;
  855. if (!pdev) {
  856. dp_rx_err_debug("%pK: pdev is null for pool_id = %d",
  857. soc, pool_id);
  858. return false;
  859. }
  860. /*
  861. * WAR- In certain types of packets if peer_id is not correct then
  862. * driver may not be able find. Try finding peer by addr_2 of
  863. * received MPDU
  864. */
  865. if (wh)
  866. peer = dp_peer_find_hash_find(soc, wh->i_addr2, 0,
  867. DP_VDEV_ALL, DP_MOD_ID_RX_ERR);
  868. if (peer) {
  869. dp_verbose_debug("MPDU sw_peer_id & ast_idx is corrupted");
  870. hal_rx_dump_pkt_tlvs(soc->hal_soc, rx_tlv_hdr,
  871. QDF_TRACE_LEVEL_DEBUG);
  872. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer_id,
  873. 1, qdf_nbuf_len(nbuf));
  874. qdf_nbuf_free(nbuf);
  875. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  876. return true;
  877. }
  878. return false;
  879. }
  880. /**
  881. * dp_rx_check_pkt_len() - Check for pktlen validity
  882. * @soc: DP SOC context
  883. * @pkt_len: computed length of the pkt from caller in bytes
  884. *
  885. * Return: true if pktlen > RX_BUFFER_SIZE, else return false
  886. *
  887. */
  888. static inline
  889. bool dp_rx_check_pkt_len(struct dp_soc *soc, uint32_t pkt_len)
  890. {
  891. if (qdf_unlikely(pkt_len > RX_DATA_BUFFER_SIZE)) {
  892. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_pkt_len,
  893. 1, pkt_len);
  894. return true;
  895. } else {
  896. return false;
  897. }
  898. }
  899. #else
  900. static inline bool
  901. dp_rx_null_q_handle_invalid_peer_id_exception(struct dp_soc *soc,
  902. uint8_t pool_id,
  903. uint8_t *rx_tlv_hdr,
  904. qdf_nbuf_t nbuf)
  905. {
  906. return false;
  907. }
  908. static inline
  909. bool dp_rx_check_pkt_len(struct dp_soc *soc, uint32_t pkt_len)
  910. {
  911. return false;
  912. }
  913. #endif
  914. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  915. /**
  916. * dp_rx_null_q_desc_handle() - Function to handle NULL Queue
  917. * descriptor violation on either a
  918. * REO or WBM ring
  919. *
  920. * @soc: core DP main context
  921. * @nbuf: buffer pointer
  922. * @rx_tlv_hdr: start of rx tlv header
  923. * @pool_id: mac id
  924. * @peer: peer handle
  925. *
  926. * This function handles NULL queue descriptor violations arising out
  927. * a missing REO queue for a given peer or a given TID. This typically
  928. * may happen if a packet is received on a QOS enabled TID before the
  929. * ADDBA negotiation for that TID, when the TID queue is setup. Or
  930. * it may also happen for MC/BC frames if they are not routed to the
  931. * non-QOS TID queue, in the absence of any other default TID queue.
  932. * This error can show up both in a REO destination or WBM release ring.
  933. *
  934. * Return: QDF_STATUS_SUCCESS, if nbuf handled successfully. QDF status code
  935. * if nbuf could not be handled or dropped.
  936. */
  937. static QDF_STATUS
  938. dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
  939. uint8_t *rx_tlv_hdr, uint8_t pool_id,
  940. struct dp_peer *peer)
  941. {
  942. uint32_t pkt_len;
  943. uint16_t msdu_len;
  944. struct dp_vdev *vdev;
  945. uint8_t tid;
  946. qdf_ether_header_t *eh;
  947. struct hal_rx_msdu_metadata msdu_metadata;
  948. uint16_t sa_idx = 0;
  949. qdf_nbuf_set_rx_chfrag_start(nbuf,
  950. hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  951. rx_tlv_hdr));
  952. qdf_nbuf_set_rx_chfrag_end(nbuf,
  953. hal_rx_msdu_end_last_msdu_get(soc->hal_soc,
  954. rx_tlv_hdr));
  955. qdf_nbuf_set_da_mcbc(nbuf, hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
  956. rx_tlv_hdr));
  957. qdf_nbuf_set_da_valid(nbuf,
  958. hal_rx_msdu_end_da_is_valid_get(soc->hal_soc,
  959. rx_tlv_hdr));
  960. qdf_nbuf_set_sa_valid(nbuf,
  961. hal_rx_msdu_end_sa_is_valid_get(soc->hal_soc,
  962. rx_tlv_hdr));
  963. hal_rx_msdu_metadata_get(soc->hal_soc, rx_tlv_hdr, &msdu_metadata);
  964. msdu_len = hal_rx_msdu_start_msdu_len_get(rx_tlv_hdr);
  965. pkt_len = msdu_len + msdu_metadata.l3_hdr_pad + RX_PKT_TLVS_LEN;
  966. if (qdf_likely(!qdf_nbuf_is_frag(nbuf))) {
  967. if (dp_rx_check_pkt_len(soc, pkt_len))
  968. goto drop_nbuf;
  969. /* Set length in nbuf */
  970. qdf_nbuf_set_pktlen(
  971. nbuf, qdf_min(pkt_len, (uint32_t)RX_DATA_BUFFER_SIZE));
  972. qdf_assert_always(nbuf->data == rx_tlv_hdr);
  973. }
  974. /*
  975. * Check if DMA completed -- msdu_done is the last bit
  976. * to be written
  977. */
  978. if (!hal_rx_attn_msdu_done_get(rx_tlv_hdr)) {
  979. dp_err_rl("MSDU DONE failure");
  980. hal_rx_dump_pkt_tlvs(soc->hal_soc, rx_tlv_hdr,
  981. QDF_TRACE_LEVEL_INFO);
  982. qdf_assert(0);
  983. }
  984. if (!peer &&
  985. dp_rx_null_q_handle_invalid_peer_id_exception(soc, pool_id,
  986. rx_tlv_hdr, nbuf))
  987. return QDF_STATUS_E_FAILURE;
  988. if (!peer) {
  989. bool mpdu_done = false;
  990. struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, pool_id);
  991. if (!pdev) {
  992. dp_err_rl("pdev is null for pool_id = %d", pool_id);
  993. return QDF_STATUS_E_FAILURE;
  994. }
  995. dp_err_rl("peer is NULL");
  996. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  997. qdf_nbuf_len(nbuf));
  998. /* QCN9000 has the support enabled */
  999. if (qdf_unlikely(soc->wbm_release_desc_rx_sg_support)) {
  1000. mpdu_done = true;
  1001. nbuf->next = NULL;
  1002. /* Trigger invalid peer handler wrapper */
  1003. dp_rx_process_invalid_peer_wrapper(soc,
  1004. nbuf, mpdu_done, pool_id);
  1005. } else {
  1006. mpdu_done = dp_rx_chain_msdus(soc, nbuf, rx_tlv_hdr, pool_id);
  1007. /* Trigger invalid peer handler wrapper */
  1008. dp_rx_process_invalid_peer_wrapper(soc,
  1009. pdev->invalid_peer_head_msdu,
  1010. mpdu_done, pool_id);
  1011. }
  1012. if (mpdu_done) {
  1013. pdev->invalid_peer_head_msdu = NULL;
  1014. pdev->invalid_peer_tail_msdu = NULL;
  1015. }
  1016. return QDF_STATUS_E_FAILURE;
  1017. }
  1018. vdev = peer->vdev;
  1019. if (!vdev) {
  1020. dp_err_rl("Null vdev!");
  1021. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  1022. goto drop_nbuf;
  1023. }
  1024. /*
  1025. * Advance the packet start pointer by total size of
  1026. * pre-header TLV's
  1027. */
  1028. if (qdf_nbuf_is_frag(nbuf))
  1029. qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN);
  1030. else
  1031. qdf_nbuf_pull_head(nbuf, (msdu_metadata.l3_hdr_pad +
  1032. RX_PKT_TLVS_LEN));
  1033. dp_vdev_peer_stats_update_protocol_cnt(vdev, nbuf, NULL, 0, 1);
  1034. if (hal_rx_msdu_end_sa_is_valid_get(soc->hal_soc, rx_tlv_hdr)) {
  1035. sa_idx = hal_rx_msdu_end_sa_idx_get(soc->hal_soc, rx_tlv_hdr);
  1036. if ((sa_idx < 0) ||
  1037. (sa_idx >= wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx))) {
  1038. DP_STATS_INC(soc, rx.err.invalid_sa_da_idx, 1);
  1039. goto drop_nbuf;
  1040. }
  1041. }
  1042. if (dp_rx_mcast_echo_check(soc, peer, rx_tlv_hdr, nbuf)) {
  1043. /* this is a looped back MCBC pkt, drop it */
  1044. DP_STATS_INC_PKT(peer, rx.mec_drop, 1, qdf_nbuf_len(nbuf));
  1045. goto drop_nbuf;
  1046. }
  1047. /*
  1048. * In qwrap mode if the received packet matches with any of the vdev
  1049. * mac addresses, drop it. Donot receive multicast packets originated
  1050. * from any proxysta.
  1051. */
  1052. if (check_qwrap_multicast_loopback(vdev, nbuf)) {
  1053. DP_STATS_INC_PKT(peer, rx.mec_drop, 1, qdf_nbuf_len(nbuf));
  1054. goto drop_nbuf;
  1055. }
  1056. if (qdf_unlikely((peer->nawds_enabled == true) &&
  1057. hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
  1058. rx_tlv_hdr))) {
  1059. dp_err_rl("free buffer for multicast packet");
  1060. DP_STATS_INC(peer, rx.nawds_mcast_drop, 1);
  1061. goto drop_nbuf;
  1062. }
  1063. if (!dp_wds_rx_policy_check(rx_tlv_hdr, vdev, peer)) {
  1064. dp_err_rl("mcast Policy Check Drop pkt");
  1065. goto drop_nbuf;
  1066. }
  1067. /* WDS Source Port Learning */
  1068. if (qdf_likely(vdev->rx_decap_type == htt_cmn_pkt_type_ethernet &&
  1069. vdev->wds_enabled))
  1070. dp_rx_wds_srcport_learn(soc, rx_tlv_hdr, peer, nbuf,
  1071. msdu_metadata);
  1072. if (hal_rx_is_unicast(soc->hal_soc, rx_tlv_hdr)) {
  1073. tid = hal_rx_tid_get(soc->hal_soc, rx_tlv_hdr);
  1074. if (!peer->rx_tid[tid].hw_qdesc_vaddr_unaligned)
  1075. dp_rx_tid_setup_wifi3(peer, tid, 1, IEEE80211_SEQ_MAX);
  1076. /* IEEE80211_SEQ_MAX indicates invalid start_seq */
  1077. }
  1078. if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw)) {
  1079. qdf_nbuf_set_next(nbuf, NULL);
  1080. dp_rx_deliver_raw(vdev, nbuf, peer);
  1081. } else {
  1082. qdf_nbuf_set_next(nbuf, NULL);
  1083. DP_STATS_INC_PKT(peer, rx.to_stack, 1,
  1084. qdf_nbuf_len(nbuf));
  1085. /*
  1086. * Update the protocol tag in SKB based on
  1087. * CCE metadata
  1088. */
  1089. dp_rx_update_protocol_tag(soc, vdev, nbuf, rx_tlv_hdr,
  1090. EXCEPTION_DEST_RING_ID,
  1091. true, true);
  1092. /* Update the flow tag in SKB based on FSE metadata */
  1093. dp_rx_update_flow_tag(soc, vdev, nbuf,
  1094. rx_tlv_hdr, true);
  1095. if (qdf_unlikely(hal_rx_msdu_end_da_is_mcbc_get(
  1096. soc->hal_soc, rx_tlv_hdr) &&
  1097. (vdev->rx_decap_type ==
  1098. htt_cmn_pkt_type_ethernet))) {
  1099. eh = (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
  1100. DP_STATS_INC_PKT(peer, rx.multicast, 1,
  1101. qdf_nbuf_len(nbuf));
  1102. if (QDF_IS_ADDR_BROADCAST(eh->ether_dhost))
  1103. DP_STATS_INC_PKT(peer, rx.bcast, 1,
  1104. qdf_nbuf_len(nbuf));
  1105. }
  1106. qdf_nbuf_set_exc_frame(nbuf, 1);
  1107. dp_rx_deliver_to_stack(soc, vdev, peer, nbuf, NULL);
  1108. }
  1109. return QDF_STATUS_SUCCESS;
  1110. drop_nbuf:
  1111. qdf_nbuf_free(nbuf);
  1112. return QDF_STATUS_E_FAILURE;
  1113. }
  1114. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  1115. /**
  1116. * dp_rx_process_rxdma_err() - Function to deliver rxdma unencrypted_err
  1117. * frames to OS or wifi parse errors.
  1118. * @soc: core DP main context
  1119. * @nbuf: buffer pointer
  1120. * @rx_tlv_hdr: start of rx tlv header
  1121. * @peer: peer reference
  1122. * @err_code: rxdma err code
  1123. * @mac_id: mac_id which is one of 3 mac_ids(Assuming mac_id and
  1124. * pool_id has same mapping)
  1125. *
  1126. * Return: None
  1127. */
  1128. void
  1129. dp_rx_process_rxdma_err(struct dp_soc *soc, qdf_nbuf_t nbuf,
  1130. uint8_t *rx_tlv_hdr, struct dp_peer *peer,
  1131. uint8_t err_code, uint8_t mac_id)
  1132. {
  1133. uint32_t pkt_len, l2_hdr_offset;
  1134. uint16_t msdu_len;
  1135. struct dp_vdev *vdev;
  1136. qdf_ether_header_t *eh;
  1137. bool is_broadcast;
  1138. /*
  1139. * Check if DMA completed -- msdu_done is the last bit
  1140. * to be written
  1141. */
  1142. if (!hal_rx_attn_msdu_done_get(rx_tlv_hdr)) {
  1143. dp_err_rl("MSDU DONE failure");
  1144. hal_rx_dump_pkt_tlvs(soc->hal_soc, rx_tlv_hdr,
  1145. QDF_TRACE_LEVEL_INFO);
  1146. qdf_assert(0);
  1147. }
  1148. l2_hdr_offset = hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc,
  1149. rx_tlv_hdr);
  1150. msdu_len = hal_rx_msdu_start_msdu_len_get(rx_tlv_hdr);
  1151. pkt_len = msdu_len + l2_hdr_offset + RX_PKT_TLVS_LEN;
  1152. if (dp_rx_check_pkt_len(soc, pkt_len)) {
  1153. /* Drop & free packet */
  1154. qdf_nbuf_free(nbuf);
  1155. return;
  1156. }
  1157. /* Set length in nbuf */
  1158. qdf_nbuf_set_pktlen(nbuf, pkt_len);
  1159. qdf_nbuf_set_next(nbuf, NULL);
  1160. qdf_nbuf_set_rx_chfrag_start(nbuf, 1);
  1161. qdf_nbuf_set_rx_chfrag_end(nbuf, 1);
  1162. if (!peer) {
  1163. QDF_TRACE_ERROR_RL(QDF_MODULE_ID_DP, "peer is NULL");
  1164. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  1165. qdf_nbuf_len(nbuf));
  1166. /* Trigger invalid peer handler wrapper */
  1167. dp_rx_process_invalid_peer_wrapper(soc, nbuf, true, mac_id);
  1168. return;
  1169. }
  1170. vdev = peer->vdev;
  1171. if (!vdev) {
  1172. dp_rx_err_err("%pK: INVALID vdev %pK OR osif_rx", soc,
  1173. vdev);
  1174. /* Drop & free packet */
  1175. qdf_nbuf_free(nbuf);
  1176. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  1177. return;
  1178. }
  1179. /*
  1180. * Advance the packet start pointer by total size of
  1181. * pre-header TLV's
  1182. */
  1183. dp_rx_skip_tlvs(nbuf, l2_hdr_offset);
  1184. if (err_code == HAL_RXDMA_ERR_WIFI_PARSE) {
  1185. uint8_t *pkt_type;
  1186. pkt_type = qdf_nbuf_data(nbuf) + (2 * QDF_MAC_ADDR_SIZE);
  1187. if (*(uint16_t *)pkt_type == htons(QDF_ETH_TYPE_8021Q)) {
  1188. if (*(uint16_t *)(pkt_type + DP_SKIP_VLAN) ==
  1189. htons(QDF_LLC_STP)) {
  1190. DP_STATS_INC(vdev->pdev, vlan_tag_stp_cnt, 1);
  1191. goto process_mesh;
  1192. } else {
  1193. goto process_rx;
  1194. }
  1195. }
  1196. }
  1197. if (vdev->rx_decap_type == htt_cmn_pkt_type_raw)
  1198. goto process_mesh;
  1199. /*
  1200. * WAPI cert AP sends rekey frames as unencrypted.
  1201. * Thus RXDMA will report unencrypted frame error.
  1202. * To pass WAPI cert case, SW needs to pass unencrypted
  1203. * rekey frame to stack.
  1204. */
  1205. if (qdf_nbuf_is_ipv4_wapi_pkt(nbuf)) {
  1206. goto process_rx;
  1207. }
  1208. /*
  1209. * In dynamic WEP case rekey frames are not encrypted
  1210. * similar to WAPI. Allow EAPOL when 8021+wep is enabled and
  1211. * key install is already done
  1212. */
  1213. if ((vdev->sec_type == cdp_sec_type_wep104) &&
  1214. (qdf_nbuf_is_ipv4_eapol_pkt(nbuf)))
  1215. goto process_rx;
  1216. process_mesh:
  1217. if (!vdev->mesh_vdev && err_code == HAL_RXDMA_ERR_UNENCRYPTED) {
  1218. qdf_nbuf_free(nbuf);
  1219. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  1220. return;
  1221. }
  1222. if (vdev->mesh_vdev) {
  1223. if (dp_rx_filter_mesh_packets(vdev, nbuf, rx_tlv_hdr)
  1224. == QDF_STATUS_SUCCESS) {
  1225. dp_rx_err_info("%pK: mesh pkt filtered", soc);
  1226. DP_STATS_INC(vdev->pdev, dropped.mesh_filter, 1);
  1227. qdf_nbuf_free(nbuf);
  1228. return;
  1229. }
  1230. dp_rx_fill_mesh_stats(vdev, nbuf, rx_tlv_hdr, peer);
  1231. }
  1232. process_rx:
  1233. if (qdf_unlikely(hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
  1234. rx_tlv_hdr) &&
  1235. (vdev->rx_decap_type ==
  1236. htt_cmn_pkt_type_ethernet))) {
  1237. eh = (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
  1238. is_broadcast = (QDF_IS_ADDR_BROADCAST
  1239. (eh->ether_dhost)) ? 1 : 0 ;
  1240. DP_STATS_INC_PKT(peer, rx.multicast, 1, qdf_nbuf_len(nbuf));
  1241. if (is_broadcast) {
  1242. DP_STATS_INC_PKT(peer, rx.bcast, 1,
  1243. qdf_nbuf_len(nbuf));
  1244. }
  1245. }
  1246. if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw)) {
  1247. dp_rx_deliver_raw(vdev, nbuf, peer);
  1248. } else {
  1249. /* Update the protocol tag in SKB based on CCE metadata */
  1250. dp_rx_update_protocol_tag(soc, vdev, nbuf, rx_tlv_hdr,
  1251. EXCEPTION_DEST_RING_ID, true, true);
  1252. /* Update the flow tag in SKB based on FSE metadata */
  1253. dp_rx_update_flow_tag(soc, vdev, nbuf, rx_tlv_hdr, true);
  1254. DP_STATS_INC(peer, rx.to_stack.num, 1);
  1255. qdf_nbuf_set_exc_frame(nbuf, 1);
  1256. dp_rx_deliver_to_stack(soc, vdev, peer, nbuf, NULL);
  1257. }
  1258. return;
  1259. }
  1260. /**
  1261. * dp_rx_process_mic_error(): Function to pass mic error indication to umac
  1262. * @soc: core DP main context
  1263. * @nbuf: buffer pointer
  1264. * @rx_tlv_hdr: start of rx tlv header
  1265. * @peer: peer handle
  1266. *
  1267. * return: void
  1268. */
  1269. void dp_rx_process_mic_error(struct dp_soc *soc, qdf_nbuf_t nbuf,
  1270. uint8_t *rx_tlv_hdr, struct dp_peer *peer)
  1271. {
  1272. struct dp_vdev *vdev = NULL;
  1273. struct dp_pdev *pdev = NULL;
  1274. struct ol_if_ops *tops = NULL;
  1275. uint16_t rx_seq, fragno;
  1276. uint8_t is_raw;
  1277. unsigned int tid;
  1278. QDF_STATUS status;
  1279. struct cdp_rx_mic_err_info mic_failure_info;
  1280. if (!hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  1281. rx_tlv_hdr))
  1282. return;
  1283. if (!peer) {
  1284. dp_info_rl("peer not found");
  1285. goto fail;
  1286. }
  1287. vdev = peer->vdev;
  1288. if (!vdev) {
  1289. dp_info_rl("VDEV not found");
  1290. goto fail;
  1291. }
  1292. pdev = vdev->pdev;
  1293. if (!pdev) {
  1294. dp_info_rl("PDEV not found");
  1295. goto fail;
  1296. }
  1297. is_raw = HAL_IS_DECAP_FORMAT_RAW(soc->hal_soc, qdf_nbuf_data(nbuf));
  1298. if (is_raw) {
  1299. fragno = dp_rx_frag_get_mpdu_frag_number(qdf_nbuf_data(nbuf));
  1300. /* Can get only last fragment */
  1301. if (fragno) {
  1302. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc,
  1303. qdf_nbuf_data(nbuf));
  1304. rx_seq = hal_rx_get_rx_sequence(soc->hal_soc,
  1305. qdf_nbuf_data(nbuf));
  1306. status = dp_rx_defrag_add_last_frag(soc, peer,
  1307. tid, rx_seq, nbuf);
  1308. dp_info_rl("Frag pkt seq# %d frag# %d consumed "
  1309. "status %d !", rx_seq, fragno, status);
  1310. return;
  1311. }
  1312. }
  1313. if (hal_rx_mpdu_get_addr1(soc->hal_soc, qdf_nbuf_data(nbuf),
  1314. &mic_failure_info.da_mac_addr.bytes[0])) {
  1315. dp_err_rl("Failed to get da_mac_addr");
  1316. goto fail;
  1317. }
  1318. if (hal_rx_mpdu_get_addr2(soc->hal_soc, qdf_nbuf_data(nbuf),
  1319. &mic_failure_info.ta_mac_addr.bytes[0])) {
  1320. dp_err_rl("Failed to get ta_mac_addr");
  1321. goto fail;
  1322. }
  1323. mic_failure_info.key_id = 0;
  1324. mic_failure_info.multicast =
  1325. IEEE80211_IS_MULTICAST(mic_failure_info.da_mac_addr.bytes);
  1326. qdf_mem_zero(mic_failure_info.tsc, MIC_SEQ_CTR_SIZE);
  1327. mic_failure_info.frame_type = cdp_rx_frame_type_802_11;
  1328. mic_failure_info.data = NULL;
  1329. mic_failure_info.vdev_id = vdev->vdev_id;
  1330. tops = pdev->soc->cdp_soc.ol_ops;
  1331. if (tops->rx_mic_error)
  1332. tops->rx_mic_error(soc->ctrl_psoc, pdev->pdev_id,
  1333. &mic_failure_info);
  1334. fail:
  1335. qdf_nbuf_free(nbuf);
  1336. return;
  1337. }
  1338. #ifdef WLAN_SUPPORT_RX_PROTOCOL_TYPE_TAG
  1339. /**
  1340. * dp_rx_err_route_hdl() - Function to send EAPOL frames to stack
  1341. * Free any other packet which comes in
  1342. * this path.
  1343. *
  1344. * @soc: core DP main context
  1345. * @nbuf: buffer pointer
  1346. * @peer: peer handle
  1347. * @rx_tlv_hdr: start of rx tlv header
  1348. * @err_src: rxdma/reo
  1349. *
  1350. * This function indicates EAPOL frame received in wbm error ring to stack.
  1351. * Any other frame should be dropped.
  1352. *
  1353. * Return: SUCCESS if delivered to stack
  1354. */
  1355. static void
  1356. dp_rx_err_route_hdl(struct dp_soc *soc, qdf_nbuf_t nbuf,
  1357. struct dp_peer *peer, uint8_t *rx_tlv_hdr,
  1358. enum hal_rx_wbm_error_source err_src)
  1359. {
  1360. uint32_t pkt_len;
  1361. uint16_t msdu_len;
  1362. struct dp_vdev *vdev;
  1363. struct hal_rx_msdu_metadata msdu_metadata;
  1364. hal_rx_msdu_metadata_get(soc->hal_soc, rx_tlv_hdr, &msdu_metadata);
  1365. msdu_len = hal_rx_msdu_start_msdu_len_get(rx_tlv_hdr);
  1366. pkt_len = msdu_len + msdu_metadata.l3_hdr_pad + RX_PKT_TLVS_LEN;
  1367. if (qdf_likely(!qdf_nbuf_is_frag(nbuf))) {
  1368. if (dp_rx_check_pkt_len(soc, pkt_len))
  1369. goto drop_nbuf;
  1370. /* Set length in nbuf */
  1371. qdf_nbuf_set_pktlen(
  1372. nbuf, qdf_min(pkt_len, (uint32_t)RX_DATA_BUFFER_SIZE));
  1373. qdf_assert_always(nbuf->data == rx_tlv_hdr);
  1374. }
  1375. /*
  1376. * Check if DMA completed -- msdu_done is the last bit
  1377. * to be written
  1378. */
  1379. if (!hal_rx_attn_msdu_done_get(rx_tlv_hdr)) {
  1380. dp_err_rl("MSDU DONE failure");
  1381. hal_rx_dump_pkt_tlvs(soc->hal_soc, rx_tlv_hdr,
  1382. QDF_TRACE_LEVEL_INFO);
  1383. qdf_assert(0);
  1384. }
  1385. if (!peer)
  1386. goto drop_nbuf;
  1387. vdev = peer->vdev;
  1388. if (!vdev) {
  1389. dp_err_rl("Null vdev!");
  1390. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  1391. goto drop_nbuf;
  1392. }
  1393. /*
  1394. * Advance the packet start pointer by total size of
  1395. * pre-header TLV's
  1396. */
  1397. if (qdf_nbuf_is_frag(nbuf))
  1398. qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN);
  1399. else
  1400. qdf_nbuf_pull_head(nbuf, (msdu_metadata.l3_hdr_pad +
  1401. RX_PKT_TLVS_LEN));
  1402. dp_vdev_peer_stats_update_protocol_cnt(vdev, nbuf, NULL, 0, 1);
  1403. /*
  1404. * Indicate EAPOL frame to stack only when vap mac address
  1405. * matches the destination address.
  1406. */
  1407. if (qdf_nbuf_is_ipv4_eapol_pkt(nbuf) ||
  1408. qdf_nbuf_is_ipv4_wapi_pkt(nbuf)) {
  1409. qdf_ether_header_t *eh =
  1410. (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
  1411. if (qdf_mem_cmp(eh->ether_dhost, &vdev->mac_addr.raw[0],
  1412. QDF_MAC_ADDR_SIZE) == 0) {
  1413. /*
  1414. * Update the protocol tag in SKB based on
  1415. * CCE metadata.
  1416. */
  1417. dp_rx_update_protocol_tag(soc, vdev, nbuf, rx_tlv_hdr,
  1418. EXCEPTION_DEST_RING_ID,
  1419. true, true);
  1420. /* Update the flow tag in SKB based on FSE metadata */
  1421. dp_rx_update_flow_tag(soc, vdev, nbuf, rx_tlv_hdr,
  1422. true);
  1423. DP_STATS_INC(peer, rx.to_stack.num, 1);
  1424. qdf_nbuf_set_exc_frame(nbuf, 1);
  1425. dp_rx_deliver_to_stack(soc, vdev, peer, nbuf, NULL);
  1426. return;
  1427. }
  1428. }
  1429. drop_nbuf:
  1430. DP_STATS_INCC(soc, rx.reo2rel_route_drop, 1,
  1431. err_src == HAL_RX_WBM_ERR_SRC_REO);
  1432. DP_STATS_INCC(soc, rx.rxdma2rel_route_drop, 1,
  1433. err_src == HAL_RX_WBM_ERR_SRC_RXDMA);
  1434. qdf_nbuf_free(nbuf);
  1435. }
  1436. #else
  1437. static void
  1438. dp_rx_err_route_hdl(struct dp_soc *soc, qdf_nbuf_t nbuf,
  1439. struct dp_peer *peer, uint8_t *rx_tlv_hdr,
  1440. enum hal_rx_wbm_error_source err_src)
  1441. {
  1442. DP_STATS_INCC(soc, rx.reo2rel_route_drop, 1,
  1443. err_src == HAL_RX_WBM_ERR_SRC_REO);
  1444. DP_STATS_INCC(soc, rx.rxdma2rel_route_drop, 1,
  1445. err_src == HAL_RX_WBM_ERR_SRC_RXDMA);
  1446. qdf_nbuf_free(nbuf);
  1447. }
  1448. #endif
  1449. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  1450. #ifdef DP_RX_DESC_COOKIE_INVALIDATE
  1451. /**
  1452. * dp_rx_link_cookie_check() - Validate link desc cookie
  1453. * @ring_desc: ring descriptor
  1454. *
  1455. * Return: qdf status
  1456. */
  1457. static inline QDF_STATUS
  1458. dp_rx_link_cookie_check(hal_ring_desc_t ring_desc)
  1459. {
  1460. if (qdf_unlikely(HAL_RX_REO_BUF_LINK_COOKIE_INVALID_GET(ring_desc)))
  1461. return QDF_STATUS_E_FAILURE;
  1462. return QDF_STATUS_SUCCESS;
  1463. }
  1464. /**
  1465. * dp_rx_link_cookie_invalidate() - Invalidate link desc cookie
  1466. * @ring_desc: ring descriptor
  1467. *
  1468. * Return: None
  1469. */
  1470. static inline void
  1471. dp_rx_link_cookie_invalidate(hal_ring_desc_t ring_desc)
  1472. {
  1473. HAL_RX_REO_BUF_LINK_COOKIE_INVALID_SET(ring_desc);
  1474. }
  1475. #else
  1476. static inline QDF_STATUS
  1477. dp_rx_link_cookie_check(hal_ring_desc_t ring_desc)
  1478. {
  1479. return QDF_STATUS_SUCCESS;
  1480. }
  1481. static inline void
  1482. dp_rx_link_cookie_invalidate(hal_ring_desc_t ring_desc)
  1483. {
  1484. }
  1485. #endif
  1486. #ifdef WLAN_FEATURE_DP_RX_RING_HISTORY
  1487. /**
  1488. * dp_rx_err_ring_record_entry() - Record rx err ring history
  1489. * @soc: Datapath soc structure
  1490. * @paddr: paddr of the buffer in RX err ring
  1491. * @sw_cookie: SW cookie of the buffer in RX err ring
  1492. * @rbm: Return buffer manager of the buffer in RX err ring
  1493. *
  1494. * Returns: None
  1495. */
  1496. static inline void
  1497. dp_rx_err_ring_record_entry(struct dp_soc *soc, uint64_t paddr,
  1498. uint32_t sw_cookie, uint8_t rbm)
  1499. {
  1500. struct dp_buf_info_record *record;
  1501. uint32_t idx;
  1502. if (qdf_unlikely(!soc->rx_err_ring_history))
  1503. return;
  1504. idx = dp_history_get_next_index(&soc->rx_err_ring_history->index,
  1505. DP_RX_ERR_HIST_MAX);
  1506. /* No NULL check needed for record since its an array */
  1507. record = &soc->rx_err_ring_history->entry[idx];
  1508. record->timestamp = qdf_get_log_timestamp();
  1509. record->hbi.paddr = paddr;
  1510. record->hbi.sw_cookie = sw_cookie;
  1511. record->hbi.rbm = rbm;
  1512. }
  1513. #else
  1514. static inline void
  1515. dp_rx_err_ring_record_entry(struct dp_soc *soc, uint64_t paddr,
  1516. uint32_t sw_cookie, uint8_t rbm)
  1517. {
  1518. }
  1519. #endif
  1520. uint32_t
  1521. dp_rx_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
  1522. hal_ring_handle_t hal_ring_hdl, uint32_t quota)
  1523. {
  1524. hal_ring_desc_t ring_desc;
  1525. hal_soc_handle_t hal_soc;
  1526. uint32_t count = 0;
  1527. uint32_t rx_bufs_used = 0;
  1528. uint32_t rx_bufs_reaped[MAX_PDEV_CNT] = { 0 };
  1529. uint8_t mac_id = 0;
  1530. uint8_t buf_type;
  1531. uint8_t error, rbm;
  1532. struct hal_rx_mpdu_desc_info mpdu_desc_info;
  1533. struct hal_buf_info hbi;
  1534. struct dp_pdev *dp_pdev;
  1535. struct dp_srng *dp_rxdma_srng;
  1536. struct rx_desc_pool *rx_desc_pool;
  1537. uint32_t cookie = 0;
  1538. void *link_desc_va;
  1539. struct hal_rx_msdu_list msdu_list; /* MSDU's per MPDU */
  1540. uint16_t num_msdus;
  1541. struct dp_rx_desc *rx_desc = NULL;
  1542. QDF_STATUS status;
  1543. bool ret;
  1544. /* Debug -- Remove later */
  1545. qdf_assert(soc && hal_ring_hdl);
  1546. hal_soc = soc->hal_soc;
  1547. /* Debug -- Remove later */
  1548. qdf_assert(hal_soc);
  1549. if (qdf_unlikely(dp_srng_access_start(int_ctx, soc, hal_ring_hdl))) {
  1550. /* TODO */
  1551. /*
  1552. * Need API to convert from hal_ring pointer to
  1553. * Ring Type / Ring Id combo
  1554. */
  1555. DP_STATS_INC(soc, rx.err.hal_ring_access_fail, 1);
  1556. dp_rx_err_err("%pK: HAL RING Access Failed -- %pK", soc,
  1557. hal_ring_hdl);
  1558. goto done;
  1559. }
  1560. while (qdf_likely(quota-- && (ring_desc =
  1561. hal_srng_dst_peek(hal_soc,
  1562. hal_ring_hdl)))) {
  1563. DP_STATS_INC(soc, rx.err_ring_pkts, 1);
  1564. error = HAL_RX_ERROR_STATUS_GET(ring_desc);
  1565. buf_type = HAL_RX_REO_BUF_TYPE_GET(ring_desc);
  1566. /* Get the MPDU DESC info */
  1567. hal_rx_mpdu_desc_info_get(ring_desc, &mpdu_desc_info);
  1568. if (mpdu_desc_info.msdu_count == 0)
  1569. goto next_entry;
  1570. /*
  1571. * For REO error ring, expect only MSDU LINK DESC
  1572. */
  1573. qdf_assert_always(buf_type == HAL_RX_REO_MSDU_LINK_DESC_TYPE);
  1574. cookie = HAL_RX_REO_BUF_COOKIE_GET(ring_desc);
  1575. /*
  1576. * check for the magic number in the sw cookie
  1577. */
  1578. qdf_assert_always((cookie >> LINK_DESC_ID_SHIFT) &
  1579. LINK_DESC_ID_START);
  1580. status = dp_rx_link_cookie_check(ring_desc);
  1581. if (qdf_unlikely(QDF_IS_STATUS_ERROR(status))) {
  1582. DP_STATS_INC(soc, rx.err.invalid_link_cookie, 1);
  1583. break;
  1584. }
  1585. /*
  1586. * Check if the buffer is to be processed on this processor
  1587. */
  1588. rbm = hal_rx_ret_buf_manager_get(ring_desc);
  1589. hal_rx_reo_buf_paddr_get(ring_desc, &hbi);
  1590. link_desc_va = dp_rx_cookie_2_link_desc_va(soc, &hbi);
  1591. hal_rx_msdu_list_get(soc->hal_soc, link_desc_va, &msdu_list,
  1592. &num_msdus);
  1593. dp_rx_err_ring_record_entry(soc, msdu_list.paddr[0],
  1594. msdu_list.sw_cookie[0],
  1595. msdu_list.rbm[0]);
  1596. if (qdf_unlikely((msdu_list.rbm[0] != DP_WBM2SW_RBM) &&
  1597. (msdu_list.rbm[0] !=
  1598. HAL_RX_BUF_RBM_WBM_IDLE_DESC_LIST) &&
  1599. (msdu_list.rbm[0] != DP_DEFRAG_RBM))) {
  1600. /* TODO */
  1601. /* Call appropriate handler */
  1602. if (!wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) {
  1603. DP_STATS_INC(soc, rx.err.invalid_rbm, 1);
  1604. dp_rx_err_err("%pK: Invalid RBM %d",
  1605. soc, msdu_list.rbm[0]);
  1606. }
  1607. /* Return link descriptor through WBM ring (SW2WBM)*/
  1608. dp_rx_link_desc_return(soc, ring_desc,
  1609. HAL_BM_ACTION_RELEASE_MSDU_LIST);
  1610. goto next_entry;
  1611. }
  1612. rx_desc = dp_rx_cookie_2_va_rxdma_buf(soc,
  1613. msdu_list.sw_cookie[0]);
  1614. qdf_assert_always(rx_desc);
  1615. mac_id = rx_desc->pool_id;
  1616. if (mpdu_desc_info.bar_frame) {
  1617. qdf_assert_always(mpdu_desc_info.msdu_count == 1);
  1618. dp_rx_bar_frame_handle(soc,
  1619. ring_desc,
  1620. rx_desc,
  1621. &mpdu_desc_info,
  1622. error);
  1623. rx_bufs_reaped[mac_id] += 1;
  1624. goto next_entry;
  1625. }
  1626. dp_info_rl("Got pkt with REO ERROR: %d", error);
  1627. if (mpdu_desc_info.mpdu_flags & HAL_MPDU_F_FRAGMENT) {
  1628. /*
  1629. * We only handle one msdu per link desc for fragmented
  1630. * case. We drop the msdus and release the link desc
  1631. * back if there are more than one msdu in link desc.
  1632. */
  1633. if (qdf_unlikely(num_msdus > 1)) {
  1634. count = dp_rx_msdus_drop(soc, ring_desc,
  1635. &mpdu_desc_info,
  1636. &mac_id, quota);
  1637. rx_bufs_reaped[mac_id] += count;
  1638. goto next_entry;
  1639. }
  1640. /*
  1641. * this is a unlikely scenario where the host is reaping
  1642. * a descriptor which it already reaped just a while ago
  1643. * but is yet to replenish it back to HW.
  1644. * In this case host will dump the last 128 descriptors
  1645. * including the software descriptor rx_desc and assert.
  1646. */
  1647. if (qdf_unlikely(!rx_desc->in_use)) {
  1648. DP_STATS_INC(soc, rx.err.hal_reo_dest_dup, 1);
  1649. dp_info_rl("Reaping rx_desc not in use!");
  1650. dp_rx_dump_info_and_assert(soc, hal_ring_hdl,
  1651. ring_desc, rx_desc);
  1652. /* ignore duplicate RX desc and continue */
  1653. /* Pop out the descriptor */
  1654. goto next_entry;
  1655. }
  1656. ret = dp_rx_desc_paddr_sanity_check(rx_desc,
  1657. msdu_list.paddr[0]);
  1658. if (!ret) {
  1659. DP_STATS_INC(soc, rx.err.nbuf_sanity_fail, 1);
  1660. rx_desc->in_err_state = 1;
  1661. goto next_entry;
  1662. }
  1663. count = dp_rx_frag_handle(soc,
  1664. ring_desc, &mpdu_desc_info,
  1665. rx_desc, &mac_id, quota);
  1666. rx_bufs_reaped[mac_id] += count;
  1667. DP_STATS_INC(soc, rx.rx_frags, 1);
  1668. goto next_entry;
  1669. }
  1670. /*
  1671. * Expect REO errors to be handled after this point
  1672. */
  1673. qdf_assert_always(error == HAL_REO_ERROR_DETECTED);
  1674. if (hal_rx_reo_is_pn_error(ring_desc)) {
  1675. /* TOD0 */
  1676. DP_STATS_INC(soc,
  1677. rx.err.
  1678. reo_error[HAL_REO_ERR_PN_CHECK_FAILED],
  1679. 1);
  1680. /* increment @pdev level */
  1681. dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1682. if (dp_pdev)
  1683. DP_STATS_INC(dp_pdev, err.reo_error, 1);
  1684. count = dp_rx_pn_error_handle(soc,
  1685. ring_desc,
  1686. &mpdu_desc_info, &mac_id,
  1687. quota);
  1688. rx_bufs_reaped[mac_id] += count;
  1689. goto next_entry;
  1690. }
  1691. if (hal_rx_reo_is_2k_jump(ring_desc)) {
  1692. /* TOD0 */
  1693. DP_STATS_INC(soc,
  1694. rx.err.
  1695. reo_error[HAL_REO_ERR_REGULAR_FRAME_2K_JUMP],
  1696. 1);
  1697. /* increment @pdev level */
  1698. dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1699. if (dp_pdev)
  1700. DP_STATS_INC(dp_pdev, err.reo_error, 1);
  1701. count = dp_rx_reo_err_entry_process(
  1702. soc,
  1703. ring_desc,
  1704. &mpdu_desc_info,
  1705. link_desc_va,
  1706. HAL_REO_ERR_REGULAR_FRAME_2K_JUMP);
  1707. rx_bufs_reaped[mac_id] += count;
  1708. goto next_entry;
  1709. }
  1710. if (hal_rx_reo_is_oor_error(ring_desc)) {
  1711. DP_STATS_INC(
  1712. soc,
  1713. rx.err.
  1714. reo_error[HAL_REO_ERR_REGULAR_FRAME_OOR],
  1715. 1);
  1716. /* increment @pdev level */
  1717. dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1718. if (dp_pdev)
  1719. DP_STATS_INC(dp_pdev, err.reo_error, 1);
  1720. count = dp_rx_reo_err_entry_process(
  1721. soc,
  1722. ring_desc,
  1723. &mpdu_desc_info,
  1724. link_desc_va,
  1725. HAL_REO_ERR_REGULAR_FRAME_OOR);
  1726. rx_bufs_reaped[mac_id] += count;
  1727. goto next_entry;
  1728. }
  1729. /* Assert if unexpected error type */
  1730. qdf_assert_always(0);
  1731. next_entry:
  1732. dp_rx_link_cookie_invalidate(ring_desc);
  1733. hal_srng_dst_get_next(hal_soc, hal_ring_hdl);
  1734. }
  1735. done:
  1736. dp_srng_access_end(int_ctx, soc, hal_ring_hdl);
  1737. if (soc->rx.flags.defrag_timeout_check) {
  1738. uint32_t now_ms =
  1739. qdf_system_ticks_to_msecs(qdf_system_ticks());
  1740. if (now_ms >= soc->rx.defrag.next_flush_ms)
  1741. dp_rx_defrag_waitlist_flush(soc);
  1742. }
  1743. for (mac_id = 0; mac_id < MAX_PDEV_CNT; mac_id++) {
  1744. if (rx_bufs_reaped[mac_id]) {
  1745. dp_pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1746. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_id];
  1747. rx_desc_pool = &soc->rx_desc_buf[mac_id];
  1748. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  1749. rx_desc_pool,
  1750. rx_bufs_reaped[mac_id],
  1751. &dp_pdev->free_list_head,
  1752. &dp_pdev->free_list_tail);
  1753. rx_bufs_used += rx_bufs_reaped[mac_id];
  1754. }
  1755. }
  1756. return rx_bufs_used; /* Assume no scale factor for now */
  1757. }
  1758. #ifdef DROP_RXDMA_DECRYPT_ERR
  1759. /**
  1760. * dp_handle_rxdma_decrypt_err() - Check if decrypt err frames can be handled
  1761. *
  1762. * Return: true if rxdma decrypt err frames are handled and false otheriwse
  1763. */
  1764. static inline bool dp_handle_rxdma_decrypt_err(void)
  1765. {
  1766. return false;
  1767. }
  1768. #else
  1769. static inline bool dp_handle_rxdma_decrypt_err(void)
  1770. {
  1771. return true;
  1772. }
  1773. #endif
  1774. static inline bool
  1775. dp_rx_is_sg_formation_required(struct hal_wbm_err_desc_info *info)
  1776. {
  1777. /*
  1778. * Currently Null Queue and Unencrypted error handlers has support for
  1779. * SG. Other error handler do not deal with SG buffer.
  1780. */
  1781. if (((info->wbm_err_src == HAL_RX_WBM_ERR_SRC_REO) &&
  1782. (info->reo_err_code == HAL_REO_ERR_QUEUE_DESC_ADDR_0)) ||
  1783. ((info->wbm_err_src == HAL_RX_WBM_ERR_SRC_RXDMA) &&
  1784. (info->rxdma_err_code == HAL_RXDMA_ERR_UNENCRYPTED)))
  1785. return true;
  1786. return false;
  1787. }
  1788. uint32_t
  1789. dp_rx_wbm_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
  1790. hal_ring_handle_t hal_ring_hdl, uint32_t quota)
  1791. {
  1792. hal_ring_desc_t ring_desc;
  1793. hal_soc_handle_t hal_soc;
  1794. struct dp_rx_desc *rx_desc;
  1795. union dp_rx_desc_list_elem_t *head[MAX_PDEV_CNT] = { NULL };
  1796. union dp_rx_desc_list_elem_t *tail[MAX_PDEV_CNT] = { NULL };
  1797. uint32_t rx_bufs_used = 0;
  1798. uint32_t rx_bufs_reaped[MAX_PDEV_CNT] = { 0 };
  1799. uint8_t buf_type, rbm;
  1800. uint32_t rx_buf_cookie;
  1801. uint8_t mac_id;
  1802. struct dp_pdev *dp_pdev;
  1803. struct dp_srng *dp_rxdma_srng;
  1804. struct rx_desc_pool *rx_desc_pool;
  1805. uint8_t *rx_tlv_hdr;
  1806. qdf_nbuf_t nbuf_head = NULL;
  1807. qdf_nbuf_t nbuf_tail = NULL;
  1808. qdf_nbuf_t nbuf, next;
  1809. struct hal_wbm_err_desc_info wbm_err_info = { 0 };
  1810. uint8_t pool_id;
  1811. uint8_t tid = 0;
  1812. uint8_t msdu_continuation = 0;
  1813. bool process_sg_buf = false;
  1814. /* Debug -- Remove later */
  1815. qdf_assert(soc && hal_ring_hdl);
  1816. hal_soc = soc->hal_soc;
  1817. /* Debug -- Remove later */
  1818. qdf_assert(hal_soc);
  1819. if (qdf_unlikely(dp_srng_access_start(int_ctx, soc, hal_ring_hdl))) {
  1820. /* TODO */
  1821. /*
  1822. * Need API to convert from hal_ring pointer to
  1823. * Ring Type / Ring Id combo
  1824. */
  1825. dp_rx_err_err("%pK: HAL RING Access Failed -- %pK",
  1826. soc, hal_ring_hdl);
  1827. goto done;
  1828. }
  1829. while (qdf_likely(quota)) {
  1830. ring_desc = hal_srng_dst_get_next(hal_soc, hal_ring_hdl);
  1831. if (qdf_unlikely(!ring_desc))
  1832. break;
  1833. /* XXX */
  1834. buf_type = HAL_RX_WBM_BUF_TYPE_GET(ring_desc);
  1835. /*
  1836. * For WBM ring, expect only MSDU buffers
  1837. */
  1838. qdf_assert_always(buf_type == HAL_RX_WBM_BUF_TYPE_REL_BUF);
  1839. qdf_assert((HAL_RX_WBM_ERR_SRC_GET(ring_desc)
  1840. == HAL_RX_WBM_ERR_SRC_RXDMA) ||
  1841. (HAL_RX_WBM_ERR_SRC_GET(ring_desc)
  1842. == HAL_RX_WBM_ERR_SRC_REO));
  1843. /*
  1844. * Check if the buffer is to be processed on this processor
  1845. */
  1846. rbm = hal_rx_ret_buf_manager_get(ring_desc);
  1847. if (qdf_unlikely(rbm != HAL_RX_BUF_RBM_SW3_BM)) {
  1848. /* TODO */
  1849. /* Call appropriate handler */
  1850. DP_STATS_INC(soc, rx.err.invalid_rbm, 1);
  1851. dp_rx_err_err("%pK: Invalid RBM %d", soc, rbm);
  1852. continue;
  1853. }
  1854. rx_buf_cookie = HAL_RX_WBM_BUF_COOKIE_GET(ring_desc);
  1855. rx_desc = dp_rx_cookie_2_va_rxdma_buf(soc, rx_buf_cookie);
  1856. qdf_assert_always(rx_desc);
  1857. if (!dp_rx_desc_check_magic(rx_desc)) {
  1858. dp_rx_err_err("%pk: Invalid rx_desc cookie=%d",
  1859. soc, rx_buf_cookie);
  1860. continue;
  1861. }
  1862. /*
  1863. * this is a unlikely scenario where the host is reaping
  1864. * a descriptor which it already reaped just a while ago
  1865. * but is yet to replenish it back to HW.
  1866. * In this case host will dump the last 128 descriptors
  1867. * including the software descriptor rx_desc and assert.
  1868. */
  1869. if (qdf_unlikely(!rx_desc->in_use)) {
  1870. DP_STATS_INC(soc, rx.err.hal_wbm_rel_dup, 1);
  1871. dp_rx_dump_info_and_assert(soc, hal_ring_hdl,
  1872. ring_desc, rx_desc);
  1873. }
  1874. hal_rx_wbm_err_info_get(ring_desc, &wbm_err_info, hal_soc);
  1875. nbuf = rx_desc->nbuf;
  1876. rx_desc_pool = &soc->rx_desc_buf[rx_desc->pool_id];
  1877. dp_ipa_handle_rx_buf_smmu_mapping(soc, nbuf,
  1878. rx_desc_pool->buf_size,
  1879. false);
  1880. qdf_nbuf_unmap_nbytes_single(soc->osdev, nbuf,
  1881. QDF_DMA_FROM_DEVICE,
  1882. rx_desc_pool->buf_size);
  1883. rx_desc->unmapped = 1;
  1884. if (qdf_unlikely(soc->wbm_release_desc_rx_sg_support &&
  1885. dp_rx_is_sg_formation_required(&wbm_err_info))) {
  1886. /* SG is detected from continuation bit */
  1887. msdu_continuation = hal_rx_wbm_err_msdu_continuation_get(hal_soc,
  1888. ring_desc);
  1889. if (msdu_continuation &&
  1890. !(soc->wbm_sg_param.wbm_is_first_msdu_in_sg)) {
  1891. /* Update length from first buffer in SG */
  1892. soc->wbm_sg_param.wbm_sg_desc_msdu_len =
  1893. hal_rx_msdu_start_msdu_len_get(
  1894. qdf_nbuf_data(nbuf));
  1895. soc->wbm_sg_param.wbm_is_first_msdu_in_sg = true;
  1896. }
  1897. if (msdu_continuation) {
  1898. /* MSDU continued packets */
  1899. qdf_nbuf_set_rx_chfrag_cont(nbuf, 1);
  1900. QDF_NBUF_CB_RX_PKT_LEN(nbuf) =
  1901. soc->wbm_sg_param.wbm_sg_desc_msdu_len;
  1902. } else {
  1903. /* This is the terminal packet in SG */
  1904. qdf_nbuf_set_rx_chfrag_start(nbuf, 1);
  1905. qdf_nbuf_set_rx_chfrag_end(nbuf, 1);
  1906. QDF_NBUF_CB_RX_PKT_LEN(nbuf) =
  1907. soc->wbm_sg_param.wbm_sg_desc_msdu_len;
  1908. process_sg_buf = true;
  1909. }
  1910. }
  1911. /*
  1912. * save the wbm desc info in nbuf TLV. We will need this
  1913. * info when we do the actual nbuf processing
  1914. */
  1915. wbm_err_info.pool_id = rx_desc->pool_id;
  1916. hal_rx_wbm_err_info_set_in_tlv(qdf_nbuf_data(nbuf),
  1917. &wbm_err_info);
  1918. rx_bufs_reaped[rx_desc->pool_id]++;
  1919. if (qdf_nbuf_is_rx_chfrag_cont(nbuf) || process_sg_buf) {
  1920. DP_RX_LIST_APPEND(soc->wbm_sg_param.wbm_sg_nbuf_head,
  1921. soc->wbm_sg_param.wbm_sg_nbuf_tail,
  1922. nbuf);
  1923. if (process_sg_buf) {
  1924. if (!dp_rx_buffer_pool_refill(
  1925. soc,
  1926. soc->wbm_sg_param.wbm_sg_nbuf_head,
  1927. rx_desc->pool_id))
  1928. DP_RX_MERGE_TWO_LIST(
  1929. nbuf_head, nbuf_tail,
  1930. soc->wbm_sg_param.wbm_sg_nbuf_head,
  1931. soc->wbm_sg_param.wbm_sg_nbuf_tail);
  1932. dp_rx_wbm_sg_list_reset(soc);
  1933. process_sg_buf = false;
  1934. }
  1935. } else if (!dp_rx_buffer_pool_refill(soc, nbuf,
  1936. rx_desc->pool_id)) {
  1937. DP_RX_LIST_APPEND(nbuf_head, nbuf_tail, nbuf);
  1938. }
  1939. dp_rx_add_to_free_desc_list(&head[rx_desc->pool_id],
  1940. &tail[rx_desc->pool_id],
  1941. rx_desc);
  1942. /*
  1943. * if continuation bit is set then we have MSDU spread
  1944. * across multiple buffers, let us not decrement quota
  1945. * till we reap all buffers of that MSDU.
  1946. */
  1947. if (qdf_likely(!msdu_continuation))
  1948. quota -= 1;
  1949. }
  1950. done:
  1951. dp_srng_access_end(int_ctx, soc, hal_ring_hdl);
  1952. for (mac_id = 0; mac_id < MAX_PDEV_CNT; mac_id++) {
  1953. if (rx_bufs_reaped[mac_id]) {
  1954. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_id];
  1955. rx_desc_pool = &soc->rx_desc_buf[mac_id];
  1956. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  1957. rx_desc_pool, rx_bufs_reaped[mac_id],
  1958. &head[mac_id], &tail[mac_id]);
  1959. rx_bufs_used += rx_bufs_reaped[mac_id];
  1960. }
  1961. }
  1962. nbuf = nbuf_head;
  1963. while (nbuf) {
  1964. struct dp_peer *peer;
  1965. uint16_t peer_id;
  1966. uint8_t err_code;
  1967. uint8_t *tlv_hdr;
  1968. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  1969. /*
  1970. * retrieve the wbm desc info from nbuf TLV, so we can
  1971. * handle error cases appropriately
  1972. */
  1973. hal_rx_wbm_err_info_get_from_tlv(rx_tlv_hdr, &wbm_err_info);
  1974. peer_id = hal_rx_mpdu_start_sw_peer_id_get(soc->hal_soc,
  1975. rx_tlv_hdr);
  1976. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_RX_ERR);
  1977. if (!peer)
  1978. dp_info_rl("peer is null peer_id%u err_src%u err_rsn%u",
  1979. peer_id, wbm_err_info.wbm_err_src,
  1980. wbm_err_info.reo_psh_rsn);
  1981. /* Set queue_mapping in nbuf to 0 */
  1982. dp_set_rx_queue(nbuf, 0);
  1983. next = nbuf->next;
  1984. /*
  1985. * Form the SG for msdu continued buffers
  1986. * QCN9000 has this support
  1987. */
  1988. if (qdf_nbuf_is_rx_chfrag_cont(nbuf)) {
  1989. nbuf = dp_rx_sg_create(soc, nbuf);
  1990. next = nbuf->next;
  1991. /*
  1992. * SG error handling is not done correctly,
  1993. * drop SG frames for now.
  1994. */
  1995. qdf_nbuf_free(nbuf);
  1996. dp_info_rl("scattered msdu dropped");
  1997. nbuf = next;
  1998. if (peer)
  1999. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  2000. continue;
  2001. }
  2002. if (wbm_err_info.wbm_err_src == HAL_RX_WBM_ERR_SRC_REO) {
  2003. if (wbm_err_info.reo_psh_rsn
  2004. == HAL_RX_WBM_REO_PSH_RSN_ERROR) {
  2005. DP_STATS_INC(soc,
  2006. rx.err.reo_error
  2007. [wbm_err_info.reo_err_code], 1);
  2008. /* increment @pdev level */
  2009. pool_id = wbm_err_info.pool_id;
  2010. dp_pdev = dp_get_pdev_for_lmac_id(soc, pool_id);
  2011. if (dp_pdev)
  2012. DP_STATS_INC(dp_pdev, err.reo_error,
  2013. 1);
  2014. switch (wbm_err_info.reo_err_code) {
  2015. /*
  2016. * Handling for packets which have NULL REO
  2017. * queue descriptor
  2018. */
  2019. case HAL_REO_ERR_QUEUE_DESC_ADDR_0:
  2020. pool_id = wbm_err_info.pool_id;
  2021. dp_rx_null_q_desc_handle(soc, nbuf,
  2022. rx_tlv_hdr,
  2023. pool_id, peer);
  2024. break;
  2025. /* TODO */
  2026. /* Add per error code accounting */
  2027. case HAL_REO_ERR_REGULAR_FRAME_2K_JUMP:
  2028. pool_id = wbm_err_info.pool_id;
  2029. if (hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  2030. rx_tlv_hdr)) {
  2031. peer_id =
  2032. hal_rx_mpdu_start_sw_peer_id_get(soc->hal_soc,
  2033. rx_tlv_hdr);
  2034. tid =
  2035. hal_rx_mpdu_start_tid_get(hal_soc, rx_tlv_hdr);
  2036. }
  2037. QDF_NBUF_CB_RX_PKT_LEN(nbuf) =
  2038. hal_rx_msdu_start_msdu_len_get(
  2039. rx_tlv_hdr);
  2040. nbuf->next = NULL;
  2041. dp_2k_jump_handle(soc, nbuf,
  2042. rx_tlv_hdr,
  2043. peer_id, tid);
  2044. break;
  2045. case HAL_REO_ERR_REGULAR_FRAME_OOR:
  2046. if (hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  2047. rx_tlv_hdr)) {
  2048. peer_id =
  2049. hal_rx_mpdu_start_sw_peer_id_get(soc->hal_soc,
  2050. rx_tlv_hdr);
  2051. tid =
  2052. hal_rx_mpdu_start_tid_get(hal_soc, rx_tlv_hdr);
  2053. }
  2054. QDF_NBUF_CB_RX_PKT_LEN(nbuf) =
  2055. hal_rx_msdu_start_msdu_len_get(
  2056. rx_tlv_hdr);
  2057. nbuf->next = NULL;
  2058. dp_rx_oor_handle(soc, nbuf,
  2059. rx_tlv_hdr,
  2060. NULL,
  2061. peer_id, tid);
  2062. break;
  2063. case HAL_REO_ERR_BAR_FRAME_2K_JUMP:
  2064. case HAL_REO_ERR_BAR_FRAME_OOR:
  2065. if (peer)
  2066. dp_rx_err_handle_bar(soc,
  2067. peer,
  2068. nbuf);
  2069. qdf_nbuf_free(nbuf);
  2070. break;
  2071. default:
  2072. dp_info_rl("Got pkt with REO ERROR: %d",
  2073. wbm_err_info.reo_err_code);
  2074. qdf_nbuf_free(nbuf);
  2075. }
  2076. } else if (wbm_err_info.reo_psh_rsn
  2077. == HAL_RX_WBM_REO_PSH_RSN_ROUTE)
  2078. dp_rx_err_route_hdl(soc, nbuf, peer,
  2079. rx_tlv_hdr,
  2080. HAL_RX_WBM_ERR_SRC_REO);
  2081. } else if (wbm_err_info.wbm_err_src ==
  2082. HAL_RX_WBM_ERR_SRC_RXDMA) {
  2083. if (wbm_err_info.rxdma_psh_rsn
  2084. == HAL_RX_WBM_RXDMA_PSH_RSN_ERROR) {
  2085. DP_STATS_INC(soc,
  2086. rx.err.rxdma_error
  2087. [wbm_err_info.rxdma_err_code], 1);
  2088. /* increment @pdev level */
  2089. pool_id = wbm_err_info.pool_id;
  2090. dp_pdev = dp_get_pdev_for_lmac_id(soc, pool_id);
  2091. if (dp_pdev)
  2092. DP_STATS_INC(dp_pdev,
  2093. err.rxdma_error, 1);
  2094. switch (wbm_err_info.rxdma_err_code) {
  2095. case HAL_RXDMA_ERR_UNENCRYPTED:
  2096. case HAL_RXDMA_ERR_WIFI_PARSE:
  2097. pool_id = wbm_err_info.pool_id;
  2098. dp_rx_process_rxdma_err(soc, nbuf,
  2099. rx_tlv_hdr,
  2100. peer,
  2101. wbm_err_info.
  2102. rxdma_err_code,
  2103. pool_id);
  2104. break;
  2105. case HAL_RXDMA_ERR_TKIP_MIC:
  2106. dp_rx_process_mic_error(soc, nbuf,
  2107. rx_tlv_hdr,
  2108. peer);
  2109. if (peer)
  2110. DP_STATS_INC(peer, rx.err.mic_err, 1);
  2111. break;
  2112. case HAL_RXDMA_ERR_DECRYPT:
  2113. if (peer) {
  2114. DP_STATS_INC(peer, rx.err.
  2115. decrypt_err, 1);
  2116. qdf_nbuf_free(nbuf);
  2117. break;
  2118. }
  2119. if (!dp_handle_rxdma_decrypt_err()) {
  2120. qdf_nbuf_free(nbuf);
  2121. break;
  2122. }
  2123. pool_id = wbm_err_info.pool_id;
  2124. err_code = wbm_err_info.rxdma_err_code;
  2125. tlv_hdr = rx_tlv_hdr;
  2126. dp_rx_process_rxdma_err(soc, nbuf,
  2127. tlv_hdr, NULL,
  2128. err_code,
  2129. pool_id);
  2130. break;
  2131. default:
  2132. qdf_nbuf_free(nbuf);
  2133. dp_err_rl("RXDMA error %d",
  2134. wbm_err_info.rxdma_err_code);
  2135. }
  2136. } else if (wbm_err_info.rxdma_psh_rsn
  2137. == HAL_RX_WBM_RXDMA_PSH_RSN_ROUTE)
  2138. dp_rx_err_route_hdl(soc, nbuf, peer,
  2139. rx_tlv_hdr,
  2140. HAL_RX_WBM_ERR_SRC_RXDMA);
  2141. } else {
  2142. /* Should not come here */
  2143. qdf_assert(0);
  2144. }
  2145. if (peer)
  2146. dp_peer_unref_delete(peer, DP_MOD_ID_RX_ERR);
  2147. nbuf = next;
  2148. }
  2149. return rx_bufs_used; /* Assume no scale factor for now */
  2150. }
  2151. #endif /* QCA_HOST_MODE_WIFI_DISABLED */
  2152. /**
  2153. * dup_desc_dbg() - dump and assert if duplicate rx desc found
  2154. *
  2155. * @soc: core DP main context
  2156. * @rxdma_dst_ring_desc: void pointer to monitor link descriptor buf addr info
  2157. * @rx_desc: void pointer to rx descriptor
  2158. *
  2159. * Return: void
  2160. */
  2161. static void dup_desc_dbg(struct dp_soc *soc,
  2162. hal_rxdma_desc_t rxdma_dst_ring_desc,
  2163. void *rx_desc)
  2164. {
  2165. DP_STATS_INC(soc, rx.err.hal_rxdma_err_dup, 1);
  2166. dp_rx_dump_info_and_assert(
  2167. soc,
  2168. soc->rx_rel_ring.hal_srng,
  2169. hal_rxdma_desc_to_hal_ring_desc(rxdma_dst_ring_desc),
  2170. rx_desc);
  2171. }
  2172. /**
  2173. * dp_rx_err_mpdu_pop() - extract the MSDU's from link descs
  2174. *
  2175. * @soc: core DP main context
  2176. * @mac_id: mac id which is one of 3 mac_ids
  2177. * @rxdma_dst_ring_desc: void pointer to monitor link descriptor buf addr info
  2178. * @head: head of descs list to be freed
  2179. * @tail: tail of decs list to be freed
  2180. * Return: number of msdu in MPDU to be popped
  2181. */
  2182. static inline uint32_t
  2183. dp_rx_err_mpdu_pop(struct dp_soc *soc, uint32_t mac_id,
  2184. hal_rxdma_desc_t rxdma_dst_ring_desc,
  2185. union dp_rx_desc_list_elem_t **head,
  2186. union dp_rx_desc_list_elem_t **tail)
  2187. {
  2188. void *rx_msdu_link_desc;
  2189. qdf_nbuf_t msdu;
  2190. qdf_nbuf_t last;
  2191. struct hal_rx_msdu_list msdu_list;
  2192. uint16_t num_msdus;
  2193. struct hal_buf_info buf_info;
  2194. uint32_t rx_bufs_used = 0;
  2195. uint32_t msdu_cnt;
  2196. uint32_t i;
  2197. uint8_t push_reason;
  2198. uint8_t rxdma_error_code = 0;
  2199. uint8_t bm_action = HAL_BM_ACTION_PUT_IN_IDLE_LIST;
  2200. struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  2201. uint32_t rx_link_buf_info[HAL_RX_BUFFINFO_NUM_DWORDS];
  2202. hal_rxdma_desc_t ring_desc;
  2203. struct rx_desc_pool *rx_desc_pool;
  2204. if (!pdev) {
  2205. dp_rx_err_debug("%pK: pdev is null for mac_id = %d",
  2206. soc, mac_id);
  2207. return rx_bufs_used;
  2208. }
  2209. msdu = 0;
  2210. last = NULL;
  2211. hal_rx_reo_ent_buf_paddr_get(rxdma_dst_ring_desc, &buf_info,
  2212. &msdu_cnt);
  2213. push_reason =
  2214. hal_rx_reo_ent_rxdma_push_reason_get(rxdma_dst_ring_desc);
  2215. if (push_reason == HAL_RX_WBM_RXDMA_PSH_RSN_ERROR) {
  2216. rxdma_error_code =
  2217. hal_rx_reo_ent_rxdma_error_code_get(rxdma_dst_ring_desc);
  2218. }
  2219. do {
  2220. rx_msdu_link_desc =
  2221. dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  2222. qdf_assert_always(rx_msdu_link_desc);
  2223. hal_rx_msdu_list_get(soc->hal_soc, rx_msdu_link_desc,
  2224. &msdu_list, &num_msdus);
  2225. if (msdu_list.sw_cookie[0] != HAL_RX_COOKIE_SPECIAL) {
  2226. /* if the msdus belongs to NSS offloaded radio &&
  2227. * the rbm is not SW1_BM then return the msdu_link
  2228. * descriptor without freeing the msdus (nbufs). let
  2229. * these buffers be given to NSS completion ring for
  2230. * NSS to free them.
  2231. * else iterate through the msdu link desc list and
  2232. * free each msdu in the list.
  2233. */
  2234. if (msdu_list.rbm[0] != HAL_RX_BUF_RBM_SW3_BM &&
  2235. wlan_cfg_get_dp_pdev_nss_enabled(
  2236. pdev->wlan_cfg_ctx))
  2237. bm_action = HAL_BM_ACTION_RELEASE_MSDU_LIST;
  2238. else {
  2239. for (i = 0; i < num_msdus; i++) {
  2240. struct dp_rx_desc *rx_desc =
  2241. dp_rx_cookie_2_va_rxdma_buf(soc,
  2242. msdu_list.sw_cookie[i]);
  2243. qdf_assert_always(rx_desc);
  2244. msdu = rx_desc->nbuf;
  2245. /*
  2246. * this is a unlikely scenario
  2247. * where the host is reaping
  2248. * a descriptor which
  2249. * it already reaped just a while ago
  2250. * but is yet to replenish
  2251. * it back to HW.
  2252. * In this case host will dump
  2253. * the last 128 descriptors
  2254. * including the software descriptor
  2255. * rx_desc and assert.
  2256. */
  2257. ring_desc = rxdma_dst_ring_desc;
  2258. if (qdf_unlikely(!rx_desc->in_use)) {
  2259. dup_desc_dbg(soc,
  2260. ring_desc,
  2261. rx_desc);
  2262. continue;
  2263. }
  2264. rx_desc_pool = &soc->
  2265. rx_desc_buf[rx_desc->pool_id];
  2266. dp_ipa_handle_rx_buf_smmu_mapping(
  2267. soc, msdu,
  2268. rx_desc_pool->buf_size,
  2269. false);
  2270. qdf_nbuf_unmap_nbytes_single(
  2271. soc->osdev, msdu,
  2272. QDF_DMA_FROM_DEVICE,
  2273. rx_desc_pool->buf_size);
  2274. rx_desc->unmapped = 1;
  2275. dp_rx_err_debug("%pK: msdu_nbuf=%pK ",
  2276. soc, msdu);
  2277. dp_rx_buffer_pool_nbuf_free(soc, msdu,
  2278. rx_desc->pool_id);
  2279. rx_bufs_used++;
  2280. dp_rx_add_to_free_desc_list(head,
  2281. tail, rx_desc);
  2282. }
  2283. }
  2284. } else {
  2285. rxdma_error_code = HAL_RXDMA_ERR_WAR;
  2286. }
  2287. /*
  2288. * Store the current link buffer into to the local structure
  2289. * to be used for release purpose.
  2290. */
  2291. hal_rxdma_buff_addr_info_set(rx_link_buf_info, buf_info.paddr,
  2292. buf_info.sw_cookie, buf_info.rbm);
  2293. hal_rx_mon_next_link_desc_get(rx_msdu_link_desc, &buf_info);
  2294. dp_rx_link_desc_return_by_addr(soc,
  2295. (hal_buff_addrinfo_t)
  2296. rx_link_buf_info,
  2297. bm_action);
  2298. } while (buf_info.paddr);
  2299. DP_STATS_INC(soc, rx.err.rxdma_error[rxdma_error_code], 1);
  2300. if (pdev)
  2301. DP_STATS_INC(pdev, err.rxdma_error, 1);
  2302. if (rxdma_error_code == HAL_RXDMA_ERR_DECRYPT) {
  2303. dp_rx_err_err("%pK: Packet received with Decrypt error", soc);
  2304. }
  2305. return rx_bufs_used;
  2306. }
  2307. uint32_t
  2308. dp_rxdma_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
  2309. uint32_t mac_id, uint32_t quota)
  2310. {
  2311. struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  2312. hal_rxdma_desc_t rxdma_dst_ring_desc;
  2313. hal_soc_handle_t hal_soc;
  2314. void *err_dst_srng;
  2315. union dp_rx_desc_list_elem_t *head = NULL;
  2316. union dp_rx_desc_list_elem_t *tail = NULL;
  2317. struct dp_srng *dp_rxdma_srng;
  2318. struct rx_desc_pool *rx_desc_pool;
  2319. uint32_t work_done = 0;
  2320. uint32_t rx_bufs_used = 0;
  2321. if (!pdev)
  2322. return 0;
  2323. err_dst_srng = soc->rxdma_err_dst_ring[mac_id].hal_srng;
  2324. if (!err_dst_srng) {
  2325. dp_rx_err_err("%pK: HAL Monitor Destination Ring Init Failed -- %pK",
  2326. soc, err_dst_srng);
  2327. return 0;
  2328. }
  2329. hal_soc = soc->hal_soc;
  2330. qdf_assert(hal_soc);
  2331. if (qdf_unlikely(dp_srng_access_start(int_ctx, soc, err_dst_srng))) {
  2332. dp_rx_err_err("%pK: HAL Monitor Destination Ring Init Failed -- %pK",
  2333. soc, err_dst_srng);
  2334. return 0;
  2335. }
  2336. while (qdf_likely(quota-- && (rxdma_dst_ring_desc =
  2337. hal_srng_dst_get_next(hal_soc, err_dst_srng)))) {
  2338. rx_bufs_used += dp_rx_err_mpdu_pop(soc, mac_id,
  2339. rxdma_dst_ring_desc,
  2340. &head, &tail);
  2341. }
  2342. dp_srng_access_end(int_ctx, soc, err_dst_srng);
  2343. if (rx_bufs_used) {
  2344. if (wlan_cfg_per_pdev_lmac_ring(soc->wlan_cfg_ctx))
  2345. dp_rxdma_srng = &soc->rx_refill_buf_ring[mac_id];
  2346. else
  2347. dp_rxdma_srng = &soc->rx_refill_buf_ring[pdev->lmac_id];
  2348. rx_desc_pool = &soc->rx_desc_buf[mac_id];
  2349. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  2350. rx_desc_pool, rx_bufs_used, &head, &tail);
  2351. work_done += rx_bufs_used;
  2352. }
  2353. return work_done;
  2354. }
  2355. #ifndef QCA_HOST_MODE_WIFI_DISABLED
  2356. static inline uint32_t
  2357. dp_wbm_int_err_mpdu_pop(struct dp_soc *soc, uint32_t mac_id,
  2358. hal_rxdma_desc_t rxdma_dst_ring_desc,
  2359. union dp_rx_desc_list_elem_t **head,
  2360. union dp_rx_desc_list_elem_t **tail)
  2361. {
  2362. void *rx_msdu_link_desc;
  2363. qdf_nbuf_t msdu;
  2364. qdf_nbuf_t last;
  2365. struct hal_rx_msdu_list msdu_list;
  2366. uint16_t num_msdus;
  2367. struct hal_buf_info buf_info;
  2368. uint32_t rx_bufs_used = 0, msdu_cnt, i;
  2369. uint32_t rx_link_buf_info[HAL_RX_BUFFINFO_NUM_DWORDS];
  2370. msdu = 0;
  2371. last = NULL;
  2372. hal_rx_reo_ent_buf_paddr_get(rxdma_dst_ring_desc, &buf_info,
  2373. &msdu_cnt);
  2374. do {
  2375. rx_msdu_link_desc =
  2376. dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  2377. if (!rx_msdu_link_desc) {
  2378. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_NULL_LINK_DESC], 1);
  2379. break;
  2380. }
  2381. hal_rx_msdu_list_get(soc->hal_soc, rx_msdu_link_desc,
  2382. &msdu_list, &num_msdus);
  2383. if (msdu_list.sw_cookie[0] != HAL_RX_COOKIE_SPECIAL) {
  2384. for (i = 0; i < num_msdus; i++) {
  2385. struct dp_rx_desc *rx_desc =
  2386. dp_rx_cookie_2_va_rxdma_buf(
  2387. soc,
  2388. msdu_list.sw_cookie[i]);
  2389. qdf_assert_always(rx_desc);
  2390. msdu = rx_desc->nbuf;
  2391. qdf_nbuf_unmap_single(soc->osdev, msdu,
  2392. QDF_DMA_FROM_DEVICE);
  2393. dp_rx_buffer_pool_nbuf_free(soc, msdu,
  2394. rx_desc->pool_id);
  2395. rx_bufs_used++;
  2396. dp_rx_add_to_free_desc_list(head,
  2397. tail, rx_desc);
  2398. }
  2399. }
  2400. /*
  2401. * Store the current link buffer into to the local structure
  2402. * to be used for release purpose.
  2403. */
  2404. hal_rxdma_buff_addr_info_set(rx_link_buf_info, buf_info.paddr,
  2405. buf_info.sw_cookie, buf_info.rbm);
  2406. hal_rx_mon_next_link_desc_get(rx_msdu_link_desc, &buf_info);
  2407. dp_rx_link_desc_return_by_addr(soc, (hal_buff_addrinfo_t)
  2408. rx_link_buf_info,
  2409. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  2410. } while (buf_info.paddr);
  2411. return rx_bufs_used;
  2412. }
  2413. /*
  2414. *
  2415. * dp_handle_wbm_internal_error() - handles wbm_internal_error case
  2416. *
  2417. * @soc: core DP main context
  2418. * @hal_desc: hal descriptor
  2419. * @buf_type: indicates if the buffer is of type link disc or msdu
  2420. * Return: None
  2421. *
  2422. * wbm_internal_error is seen in following scenarios :
  2423. *
  2424. * 1. Null pointers detected in WBM_RELEASE_RING descriptors
  2425. * 2. Null pointers detected during delinking process
  2426. *
  2427. * Some null pointer cases:
  2428. *
  2429. * a. MSDU buffer pointer is NULL
  2430. * b. Next_MSDU_Link_Desc pointer is NULL, with no last msdu flag
  2431. * c. MSDU buffer pointer is NULL or Next_Link_Desc pointer is NULL
  2432. */
  2433. void
  2434. dp_handle_wbm_internal_error(struct dp_soc *soc, void *hal_desc,
  2435. uint32_t buf_type)
  2436. {
  2437. struct hal_buf_info buf_info = {0};
  2438. struct dp_rx_desc *rx_desc = NULL;
  2439. struct rx_desc_pool *rx_desc_pool;
  2440. uint32_t rx_buf_cookie;
  2441. uint32_t rx_bufs_reaped = 0;
  2442. union dp_rx_desc_list_elem_t *head = NULL;
  2443. union dp_rx_desc_list_elem_t *tail = NULL;
  2444. uint8_t pool_id;
  2445. hal_rx_reo_buf_paddr_get(hal_desc, &buf_info);
  2446. if (!buf_info.paddr) {
  2447. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_NULL_BUFFER], 1);
  2448. return;
  2449. }
  2450. rx_buf_cookie = HAL_RX_REO_BUF_COOKIE_GET(hal_desc);
  2451. pool_id = DP_RX_DESC_COOKIE_POOL_ID_GET(rx_buf_cookie);
  2452. if (buf_type == HAL_WBM_RELEASE_RING_2_BUFFER_TYPE) {
  2453. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_NULL_MSDU_BUFF], 1);
  2454. rx_desc = dp_rx_cookie_2_va_rxdma_buf(soc, rx_buf_cookie);
  2455. if (rx_desc && rx_desc->nbuf) {
  2456. rx_desc_pool = &soc->rx_desc_buf[rx_desc->pool_id];
  2457. dp_ipa_handle_rx_buf_smmu_mapping(
  2458. soc, rx_desc->nbuf,
  2459. rx_desc_pool->buf_size,
  2460. false);
  2461. qdf_nbuf_unmap_nbytes_single(soc->osdev, rx_desc->nbuf,
  2462. QDF_DMA_FROM_DEVICE,
  2463. rx_desc_pool->buf_size);
  2464. rx_desc->unmapped = 1;
  2465. dp_rx_buffer_pool_nbuf_free(soc, rx_desc->nbuf,
  2466. rx_desc->pool_id);
  2467. dp_rx_add_to_free_desc_list(&head,
  2468. &tail,
  2469. rx_desc);
  2470. rx_bufs_reaped++;
  2471. }
  2472. } else if (buf_type == HAL_WBM_RELEASE_RING_2_DESC_TYPE) {
  2473. rx_bufs_reaped = dp_wbm_int_err_mpdu_pop(soc, pool_id,
  2474. hal_desc,
  2475. &head, &tail);
  2476. }
  2477. if (rx_bufs_reaped) {
  2478. struct rx_desc_pool *rx_desc_pool;
  2479. struct dp_srng *dp_rxdma_srng;
  2480. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_BUFF_REAPED], 1);
  2481. dp_rxdma_srng = &soc->rx_refill_buf_ring[pool_id];
  2482. rx_desc_pool = &soc->rx_desc_buf[pool_id];
  2483. dp_rx_buffers_replenish(soc, pool_id, dp_rxdma_srng,
  2484. rx_desc_pool,
  2485. rx_bufs_reaped,
  2486. &head, &tail);
  2487. }
  2488. }
  2489. #endif /* QCA_HOST_MODE_WIFI_DISABLED */