dp_rx_err.c 74 KB

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