dp_rx.c 73 KB

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