dp_rx_err.c 56 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053
  1. /*
  2. * Copyright (c) 2016-2019 The Linux Foundation. All rights reserved.
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for
  5. * any purpose with or without fee is hereby granted, provided that the
  6. * above copyright notice and this permission notice appear in all
  7. * copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16. * PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #include "hal_hw_headers.h"
  19. #include "dp_types.h"
  20. #include "dp_rx.h"
  21. #include "dp_peer.h"
  22. #include "dp_internal.h"
  23. #include "hal_api.h"
  24. #include "qdf_trace.h"
  25. #include "qdf_nbuf.h"
  26. #include "dp_rx_defrag.h"
  27. #ifdef FEATURE_WDS
  28. #include "dp_txrx_wds.h"
  29. #endif
  30. #include <enet.h> /* LLC_SNAP_HDR_LEN */
  31. #include "qdf_net_types.h"
  32. /* Max buffer in invalid peer SG list*/
  33. #define DP_MAX_INVALID_BUFFERS 10
  34. /**
  35. * dp_rx_mcast_echo_check() - check if the mcast pkt is a loop
  36. * back on same vap or a different vap.
  37. *
  38. * @soc: core DP main context
  39. * @peer: dp peer handler
  40. * @rx_tlv_hdr: start of the rx TLV header
  41. * @nbuf: pkt buffer
  42. *
  43. * Return: bool (true if it is a looped back pkt else false)
  44. *
  45. */
  46. static inline bool dp_rx_mcast_echo_check(struct dp_soc *soc,
  47. struct dp_peer *peer,
  48. uint8_t *rx_tlv_hdr,
  49. qdf_nbuf_t nbuf)
  50. {
  51. struct dp_vdev *vdev = peer->vdev;
  52. struct dp_ast_entry *ase = NULL;
  53. uint16_t sa_idx = 0;
  54. uint8_t *data;
  55. /*
  56. * Multicast Echo Check is required only if vdev is STA and
  57. * received pkt is a multicast/broadcast pkt. otherwise
  58. * skip the MEC check.
  59. */
  60. if (vdev->opmode != wlan_op_mode_sta)
  61. return false;
  62. if (!hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc, rx_tlv_hdr))
  63. return false;
  64. data = qdf_nbuf_data(nbuf);
  65. /*
  66. * if the received pkts src mac addr matches with vdev
  67. * mac address then drop the pkt as it is looped back
  68. */
  69. if (!(qdf_mem_cmp(&data[QDF_MAC_ADDR_SIZE],
  70. vdev->mac_addr.raw,
  71. QDF_MAC_ADDR_SIZE)))
  72. return true;
  73. /*
  74. * In case of qwrap isolation mode, donot drop loopback packets.
  75. * In isolation mode, all packets from the wired stations need to go
  76. * to rootap and loop back to reach the wireless stations and
  77. * vice-versa.
  78. */
  79. if (qdf_unlikely(vdev->isolation_vdev))
  80. return false;
  81. /* if the received pkts src mac addr matches with the
  82. * wired PCs MAC addr which is behind the STA or with
  83. * wireless STAs MAC addr which are behind the Repeater,
  84. * then drop the pkt as it is looped back
  85. */
  86. qdf_spin_lock_bh(&soc->ast_lock);
  87. if (hal_rx_msdu_end_sa_is_valid_get(soc->hal_soc, rx_tlv_hdr)) {
  88. sa_idx = hal_rx_msdu_end_sa_idx_get(soc->hal_soc, rx_tlv_hdr);
  89. if ((sa_idx < 0) ||
  90. (sa_idx >= wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx))) {
  91. qdf_spin_unlock_bh(&soc->ast_lock);
  92. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  93. "invalid sa_idx: %d", sa_idx);
  94. qdf_assert_always(0);
  95. }
  96. ase = soc->ast_table[sa_idx];
  97. if (!ase) {
  98. /* We do not get a peer map event for STA and without
  99. * this event we don't know what is STA's sa_idx.
  100. * For this reason the AST is still not associated to
  101. * any index postion in ast_table.
  102. * In these kind of scenarios where sa is valid but
  103. * ast is not in ast_table, we use the below API to get
  104. * AST entry for STA's own mac_address.
  105. */
  106. ase = dp_peer_ast_list_find(soc, peer,
  107. &data[QDF_MAC_ADDR_SIZE]);
  108. if (ase) {
  109. ase->ast_idx = sa_idx;
  110. soc->ast_table[sa_idx] = ase;
  111. ase->is_mapped = TRUE;
  112. }
  113. }
  114. } else {
  115. ase = dp_peer_ast_hash_find_by_pdevid(soc,
  116. &data[QDF_MAC_ADDR_SIZE],
  117. vdev->pdev->pdev_id);
  118. }
  119. if (ase) {
  120. if (ase->pdev_id != vdev->pdev->pdev_id) {
  121. qdf_spin_unlock_bh(&soc->ast_lock);
  122. QDF_TRACE(QDF_MODULE_ID_DP,
  123. QDF_TRACE_LEVEL_INFO,
  124. "Detected DBDC Root AP %pM, %d %d",
  125. &data[QDF_MAC_ADDR_SIZE], vdev->pdev->pdev_id,
  126. ase->pdev_id);
  127. return false;
  128. }
  129. if ((ase->type == CDP_TXRX_AST_TYPE_MEC) ||
  130. (ase->peer != peer)) {
  131. qdf_spin_unlock_bh(&soc->ast_lock);
  132. QDF_TRACE(QDF_MODULE_ID_DP,
  133. QDF_TRACE_LEVEL_INFO,
  134. "received pkt with same src mac %pM",
  135. &data[QDF_MAC_ADDR_SIZE]);
  136. return true;
  137. }
  138. }
  139. qdf_spin_unlock_bh(&soc->ast_lock);
  140. return false;
  141. }
  142. /**
  143. * dp_rx_link_desc_return_by_addr - Return a MPDU link descriptor to
  144. * (WBM) by address
  145. *
  146. * @soc: core DP main context
  147. * @link_desc_addr: link descriptor addr
  148. *
  149. * Return: QDF_STATUS
  150. */
  151. QDF_STATUS
  152. dp_rx_link_desc_return_by_addr(struct dp_soc *soc,
  153. hal_buff_addrinfo_t link_desc_addr,
  154. uint8_t bm_action)
  155. {
  156. struct dp_srng *wbm_desc_rel_ring = &soc->wbm_desc_rel_ring;
  157. hal_ring_handle_t wbm_rel_srng = wbm_desc_rel_ring->hal_srng;
  158. hal_soc_handle_t hal_soc = soc->hal_soc;
  159. QDF_STATUS status = QDF_STATUS_E_FAILURE;
  160. void *src_srng_desc;
  161. if (!wbm_rel_srng) {
  162. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  163. "WBM RELEASE RING not initialized");
  164. return status;
  165. }
  166. if (qdf_unlikely(hal_srng_access_start(hal_soc, wbm_rel_srng))) {
  167. /* TODO */
  168. /*
  169. * Need API to convert from hal_ring pointer to
  170. * Ring Type / Ring Id combo
  171. */
  172. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  173. FL("HAL RING Access For WBM Release SRNG Failed - %pK"),
  174. wbm_rel_srng);
  175. DP_STATS_INC(soc, rx.err.hal_ring_access_fail, 1);
  176. goto done;
  177. }
  178. src_srng_desc = hal_srng_src_get_next(hal_soc, wbm_rel_srng);
  179. if (qdf_likely(src_srng_desc)) {
  180. /* Return link descriptor through WBM ring (SW2WBM)*/
  181. hal_rx_msdu_link_desc_set(hal_soc,
  182. src_srng_desc, link_desc_addr, bm_action);
  183. status = QDF_STATUS_SUCCESS;
  184. } else {
  185. struct hal_srng *srng = (struct hal_srng *)wbm_rel_srng;
  186. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  187. FL("WBM Release Ring (Id %d) Full"), srng->ring_id);
  188. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  189. "HP 0x%x Reap HP 0x%x TP 0x%x Cached TP 0x%x",
  190. *srng->u.src_ring.hp_addr, srng->u.src_ring.reap_hp,
  191. *srng->u.src_ring.tp_addr, srng->u.src_ring.cached_tp);
  192. }
  193. done:
  194. hal_srng_access_end(hal_soc, wbm_rel_srng);
  195. return status;
  196. }
  197. /**
  198. * dp_rx_link_desc_return() - Return a MPDU link descriptor to HW
  199. * (WBM), following error handling
  200. *
  201. * @soc: core DP main context
  202. * @ring_desc: opaque pointer to the REO error ring descriptor
  203. *
  204. * Return: QDF_STATUS
  205. */
  206. QDF_STATUS
  207. dp_rx_link_desc_return(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  208. uint8_t bm_action)
  209. {
  210. void *buf_addr_info = HAL_RX_REO_BUF_ADDR_INFO_GET(ring_desc);
  211. return dp_rx_link_desc_return_by_addr(soc, buf_addr_info, bm_action);
  212. }
  213. /**
  214. * dp_rx_msdus_drop() - Drops all MSDU's per MPDU
  215. *
  216. * @soc: core txrx main context
  217. * @ring_desc: opaque pointer to the REO error ring descriptor
  218. * @mpdu_desc_info: MPDU descriptor information from ring descriptor
  219. * @head: head of the local descriptor free-list
  220. * @tail: tail of the local descriptor free-list
  221. * @quota: No. of units (packets) that can be serviced in one shot.
  222. *
  223. * This function is used to drop all MSDU in an MPDU
  224. *
  225. * Return: uint32_t: No. of elements processed
  226. */
  227. static uint32_t
  228. dp_rx_msdus_drop(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  229. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  230. uint8_t *mac_id,
  231. uint32_t quota)
  232. {
  233. uint32_t rx_bufs_used = 0;
  234. void *link_desc_va;
  235. struct hal_buf_info buf_info;
  236. struct dp_pdev *pdev;
  237. struct hal_rx_msdu_list msdu_list; /* MSDU's per MPDU */
  238. int i;
  239. uint8_t *rx_tlv_hdr;
  240. uint32_t tid;
  241. hal_rx_reo_buf_paddr_get(ring_desc, &buf_info);
  242. link_desc_va = dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  243. /* No UNMAP required -- this is "malloc_consistent" memory */
  244. hal_rx_msdu_list_get(soc->hal_soc, link_desc_va, &msdu_list,
  245. &mpdu_desc_info->msdu_count);
  246. for (i = 0; (i < mpdu_desc_info->msdu_count) && quota--; i++) {
  247. struct dp_rx_desc *rx_desc =
  248. dp_rx_cookie_2_va_rxdma_buf(soc,
  249. msdu_list.sw_cookie[i]);
  250. qdf_assert_always(rx_desc);
  251. /* all buffers from a MSDU link link belong to same pdev */
  252. *mac_id = rx_desc->pool_id;
  253. pdev = soc->pdev_list[rx_desc->pool_id];
  254. if (!dp_rx_desc_check_magic(rx_desc)) {
  255. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  256. FL("Invalid rx_desc cookie=%d"),
  257. msdu_list.sw_cookie[i]);
  258. return rx_bufs_used;
  259. }
  260. qdf_nbuf_unmap_single(soc->osdev,
  261. rx_desc->nbuf, QDF_DMA_FROM_DEVICE);
  262. rx_desc->rx_buf_start = qdf_nbuf_data(rx_desc->nbuf);
  263. rx_bufs_used++;
  264. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc,
  265. rx_desc->rx_buf_start);
  266. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  267. "Packet received with PN error for tid :%d", tid);
  268. rx_tlv_hdr = qdf_nbuf_data(rx_desc->nbuf);
  269. if (hal_rx_encryption_info_valid(soc->hal_soc, rx_tlv_hdr))
  270. hal_rx_print_pn(soc->hal_soc, rx_tlv_hdr);
  271. /* Just free the buffers */
  272. qdf_nbuf_free(rx_desc->nbuf);
  273. dp_rx_add_to_free_desc_list(&pdev->free_list_head,
  274. &pdev->free_list_tail, rx_desc);
  275. }
  276. /* Return link descriptor through WBM ring (SW2WBM)*/
  277. dp_rx_link_desc_return(soc, ring_desc, HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  278. return rx_bufs_used;
  279. }
  280. /**
  281. * dp_rx_pn_error_handle() - Handles PN check errors
  282. *
  283. * @soc: core txrx main context
  284. * @ring_desc: opaque pointer to the REO error ring descriptor
  285. * @mpdu_desc_info: MPDU descriptor information from ring descriptor
  286. * @head: head of the local descriptor free-list
  287. * @tail: tail of the local descriptor free-list
  288. * @quota: No. of units (packets) that can be serviced in one shot.
  289. *
  290. * This function implements PN error handling
  291. * If the peer is configured to ignore the PN check errors
  292. * or if DP feels, that this frame is still OK, the frame can be
  293. * re-injected back to REO to use some of the other features
  294. * of REO e.g. duplicate detection/routing to other cores
  295. *
  296. * Return: uint32_t: No. of elements processed
  297. */
  298. static uint32_t
  299. dp_rx_pn_error_handle(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  300. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  301. uint8_t *mac_id,
  302. uint32_t quota)
  303. {
  304. uint16_t peer_id;
  305. uint32_t rx_bufs_used = 0;
  306. struct dp_peer *peer;
  307. bool peer_pn_policy = false;
  308. peer_id = DP_PEER_METADATA_PEER_ID_GET(
  309. mpdu_desc_info->peer_meta_data);
  310. peer = dp_peer_find_by_id(soc, peer_id);
  311. if (qdf_likely(peer)) {
  312. /*
  313. * TODO: Check for peer specific policies & set peer_pn_policy
  314. */
  315. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  316. "discard rx due to PN error for peer %pK "
  317. "(%02x:%02x:%02x:%02x:%02x:%02x)",
  318. peer,
  319. peer->mac_addr.raw[0], peer->mac_addr.raw[1],
  320. peer->mac_addr.raw[2], peer->mac_addr.raw[3],
  321. peer->mac_addr.raw[4], peer->mac_addr.raw[5]);
  322. dp_peer_unref_del_find_by_id(peer);
  323. }
  324. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  325. "Packet received with PN error");
  326. /* No peer PN policy -- definitely drop */
  327. if (!peer_pn_policy)
  328. rx_bufs_used = dp_rx_msdus_drop(soc, ring_desc,
  329. mpdu_desc_info,
  330. mac_id, quota);
  331. return rx_bufs_used;
  332. }
  333. /**
  334. * dp_rx_2k_jump_handle() - Handles Sequence Number Jump by 2K
  335. *
  336. * @soc: core txrx main context
  337. * @ring_desc: opaque pointer to the REO error ring descriptor
  338. * @mpdu_desc_info: MPDU descriptor information from ring descriptor
  339. * @head: head of the local descriptor free-list
  340. * @tail: tail of the local descriptor free-list
  341. * @quota: No. of units (packets) that can be serviced in one shot.
  342. *
  343. * This function implements the error handling when sequence number
  344. * of the MPDU jumps suddenly by 2K.Today there are 2 cases that
  345. * need to be handled:
  346. * A) CSN (Current Sequence Number) = Last Valid SN (LSN) + 2K
  347. * B) CSN = LSN + 2K, but falls within a "BA sized window" of the SSN
  348. * For case A) the protocol stack is invoked to generate DELBA/DEAUTH frame
  349. * For case B), the frame is normally dropped, no more action is taken
  350. *
  351. * Return: uint32_t: No. of elements processed
  352. */
  353. static uint32_t
  354. dp_rx_2k_jump_handle(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  355. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  356. uint8_t *mac_id, uint32_t quota)
  357. {
  358. return dp_rx_msdus_drop(soc, ring_desc, mpdu_desc_info,
  359. mac_id, quota);
  360. }
  361. #ifdef DP_INVALID_PEER_ASSERT
  362. #define DP_PDEV_INVALID_PEER_MSDU_CHECK(head, tail) \
  363. do { \
  364. qdf_assert_always(!(head)); \
  365. qdf_assert_always(!(tail)); \
  366. } while (0)
  367. #else
  368. #define DP_PDEV_INVALID_PEER_MSDU_CHECK(head, tail) /* no op */
  369. #endif
  370. /**
  371. * dp_rx_chain_msdus() - Function to chain all msdus of a mpdu
  372. * to pdev invalid peer list
  373. *
  374. * @soc: core DP main context
  375. * @nbuf: Buffer pointer
  376. * @rx_tlv_hdr: start of rx tlv header
  377. * @mac_id: mac id
  378. *
  379. * Return: bool: true for last msdu of mpdu
  380. */
  381. static bool
  382. dp_rx_chain_msdus(struct dp_soc *soc, qdf_nbuf_t nbuf, uint8_t *rx_tlv_hdr,
  383. uint8_t mac_id)
  384. {
  385. bool mpdu_done = false;
  386. qdf_nbuf_t curr_nbuf = NULL;
  387. qdf_nbuf_t tmp_nbuf = NULL;
  388. /* TODO: Currently only single radio is supported, hence
  389. * pdev hard coded to '0' index
  390. */
  391. struct dp_pdev *dp_pdev = soc->pdev_list[mac_id];
  392. /* if invalid peer SG list has max values free the buffers in list
  393. * and treat current buffer as start of list
  394. *
  395. * current logic to detect the last buffer from attn_tlv is not reliable
  396. * in OFDMA UL scenario hence add max buffers check to avoid list pile
  397. * up
  398. */
  399. if (!dp_pdev->first_nbuf ||
  400. QDF_NBUF_CB_RX_NUM_ELEMENTS_IN_LIST
  401. (dp_pdev->invalid_peer_head_msdu) >= DP_MAX_INVALID_BUFFERS) {
  402. qdf_nbuf_set_rx_chfrag_start(nbuf, 1);
  403. dp_pdev->ppdu_id = hal_rx_hw_desc_get_ppduid_get(soc->hal_soc,
  404. rx_tlv_hdr);
  405. dp_pdev->first_nbuf = true;
  406. /* If the new nbuf received is the first msdu of the
  407. * amsdu and there are msdus in the invalid peer msdu
  408. * list, then let us free all the msdus of the invalid
  409. * peer msdu list.
  410. * This scenario can happen when we start receiving
  411. * new a-msdu even before the previous a-msdu is completely
  412. * received.
  413. */
  414. curr_nbuf = dp_pdev->invalid_peer_head_msdu;
  415. while (curr_nbuf) {
  416. tmp_nbuf = curr_nbuf->next;
  417. qdf_nbuf_free(curr_nbuf);
  418. curr_nbuf = tmp_nbuf;
  419. }
  420. dp_pdev->invalid_peer_head_msdu = NULL;
  421. dp_pdev->invalid_peer_tail_msdu = NULL;
  422. hal_rx_mon_hw_desc_get_mpdu_status(soc->hal_soc, rx_tlv_hdr,
  423. &(dp_pdev->ppdu_info.rx_status));
  424. }
  425. if (dp_pdev->ppdu_id == hal_rx_attn_phy_ppdu_id_get(rx_tlv_hdr) &&
  426. hal_rx_attn_msdu_done_get(rx_tlv_hdr)) {
  427. qdf_nbuf_set_rx_chfrag_end(nbuf, 1);
  428. qdf_assert_always(dp_pdev->first_nbuf == true);
  429. dp_pdev->first_nbuf = false;
  430. mpdu_done = true;
  431. }
  432. /*
  433. * For MCL, invalid_peer_head_msdu and invalid_peer_tail_msdu
  434. * should be NULL here, add the checking for debugging purpose
  435. * in case some corner case.
  436. */
  437. DP_PDEV_INVALID_PEER_MSDU_CHECK(dp_pdev->invalid_peer_head_msdu,
  438. dp_pdev->invalid_peer_tail_msdu);
  439. DP_RX_LIST_APPEND(dp_pdev->invalid_peer_head_msdu,
  440. dp_pdev->invalid_peer_tail_msdu,
  441. nbuf);
  442. return mpdu_done;
  443. }
  444. static
  445. void dp_rx_wbm_err_handle_bar(struct dp_soc *soc,
  446. struct dp_peer *peer,
  447. qdf_nbuf_t nbuf)
  448. {
  449. uint8_t *rx_tlv_hdr;
  450. unsigned char type, subtype;
  451. uint16_t start_seq_num;
  452. uint32_t tid;
  453. struct ieee80211_frame_bar *bar;
  454. /*
  455. * 1. Is this a BAR frame. If not Discard it.
  456. * 2. If it is, get the peer id, tid, ssn
  457. * 2a Do a tid update
  458. */
  459. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  460. bar = (struct ieee80211_frame_bar *)(rx_tlv_hdr +
  461. sizeof(struct rx_pkt_tlvs));
  462. type = bar->i_fc[0] & IEEE80211_FC0_TYPE_MASK;
  463. subtype = bar->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK;
  464. if (!(type == IEEE80211_FC0_TYPE_CTL &&
  465. subtype == QDF_IEEE80211_FC0_SUBTYPE_BAR)) {
  466. dp_err_rl("Not a BAR frame!");
  467. return;
  468. }
  469. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc, rx_tlv_hdr);
  470. qdf_assert_always(tid < DP_MAX_TIDS);
  471. start_seq_num = le16toh(bar->i_seq) >> IEEE80211_SEQ_SEQ_SHIFT;
  472. dp_info_rl("tid %u window_size %u start_seq_num %u",
  473. tid, peer->rx_tid[tid].ba_win_size, start_seq_num);
  474. dp_rx_tid_update_wifi3(peer, tid,
  475. peer->rx_tid[tid].ba_win_size,
  476. start_seq_num);
  477. }
  478. /**
  479. * dp_2k_jump_handle() - Function to handle 2k jump exception
  480. * on WBM ring
  481. *
  482. * @soc: core DP main context
  483. * @nbuf: buffer pointer
  484. * @rx_tlv_hdr: start of rx tlv header
  485. * @peer_id: peer id of first msdu
  486. * @tid: Tid for which exception occurred
  487. *
  488. * This function handles 2k jump violations arising out
  489. * of receiving aggregates in non BA case. This typically
  490. * may happen if aggregates are received on a QOS enabled TID
  491. * while Rx window size is still initialized to value of 2. Or
  492. * it may also happen if negotiated window size is 1 but peer
  493. * sends aggregates.
  494. *
  495. */
  496. void
  497. dp_2k_jump_handle(struct dp_soc *soc,
  498. qdf_nbuf_t nbuf,
  499. uint8_t *rx_tlv_hdr,
  500. uint16_t peer_id,
  501. uint8_t tid)
  502. {
  503. uint32_t ppdu_id;
  504. struct dp_peer *peer = NULL;
  505. struct dp_rx_tid *rx_tid = NULL;
  506. peer = dp_peer_find_by_id(soc, peer_id);
  507. if (!peer || peer->delete_in_progress) {
  508. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  509. "peer not found");
  510. goto free_nbuf;
  511. }
  512. rx_tid = &peer->rx_tid[tid];
  513. if (qdf_unlikely(!rx_tid)) {
  514. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  515. "rx_tid is NULL!!");
  516. goto free_nbuf;
  517. }
  518. qdf_spin_lock_bh(&rx_tid->tid_lock);
  519. ppdu_id = hal_rx_attn_phy_ppdu_id_get(rx_tlv_hdr);
  520. /*
  521. * If BA session is created and a non-aggregate packet is
  522. * landing here then the issue is with sequence number mismatch.
  523. * Proceed with delba even in that case
  524. */
  525. if (rx_tid->ppdu_id_2k != ppdu_id &&
  526. rx_tid->ba_status != DP_RX_BA_ACTIVE) {
  527. rx_tid->ppdu_id_2k = ppdu_id;
  528. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  529. goto free_nbuf;
  530. }
  531. if (!rx_tid->delba_tx_status) {
  532. rx_tid->delba_tx_retry++;
  533. rx_tid->delba_tx_status = 1;
  534. rx_tid->delba_rcode =
  535. IEEE80211_REASON_QOS_SETUP_REQUIRED;
  536. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  537. if (soc->cdp_soc.ol_ops->send_delba)
  538. soc->cdp_soc.ol_ops->send_delba(
  539. peer->vdev->pdev->soc->ctrl_psoc,
  540. peer->vdev->vdev_id,
  541. peer->mac_addr.raw,
  542. tid,
  543. rx_tid->delba_rcode);
  544. } else {
  545. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  546. }
  547. free_nbuf:
  548. if (peer)
  549. dp_peer_unref_del_find_by_id(peer);
  550. qdf_nbuf_free(nbuf);
  551. return;
  552. }
  553. #if defined(QCA_WIFI_QCA6390) || defined(QCA_WIFI_QCA6490)
  554. /**
  555. * dp_rx_null_q_handle_invalid_peer_id_exception() - to find exception
  556. * @soc: pointer to dp_soc struct
  557. * @pool_id: Pool id to find dp_pdev
  558. * @rx_tlv_hdr: TLV header of received packet
  559. * @nbuf: SKB
  560. *
  561. * In certain types of packets if peer_id is not correct then
  562. * driver may not be able find. Try finding peer by addr_2 of
  563. * received MPDU. If you find the peer then most likely sw_peer_id &
  564. * ast_idx is corrupted.
  565. *
  566. * Return: True if you find the peer by addr_2 of received MPDU else false
  567. */
  568. static bool
  569. dp_rx_null_q_handle_invalid_peer_id_exception(struct dp_soc *soc,
  570. uint8_t pool_id,
  571. uint8_t *rx_tlv_hdr,
  572. qdf_nbuf_t nbuf)
  573. {
  574. struct dp_peer *peer = NULL;
  575. uint8_t *rx_pkt_hdr = hal_rx_pkt_hdr_get(rx_tlv_hdr);
  576. struct dp_pdev *pdev = soc->pdev_list[pool_id];
  577. struct ieee80211_frame *wh = (struct ieee80211_frame *)rx_pkt_hdr;
  578. /*
  579. * WAR- In certain types of packets if peer_id is not correct then
  580. * driver may not be able find. Try finding peer by addr_2 of
  581. * received MPDU
  582. */
  583. if (wh)
  584. peer = dp_find_peer_by_addr((struct cdp_pdev *)pdev,
  585. wh->i_addr2);
  586. if (peer) {
  587. dp_verbose_debug("MPDU sw_peer_id & ast_idx is corrupted");
  588. hal_rx_dump_pkt_tlvs(soc->hal_soc, rx_tlv_hdr,
  589. QDF_TRACE_LEVEL_DEBUG);
  590. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer_id,
  591. 1, qdf_nbuf_len(nbuf));
  592. qdf_nbuf_free(nbuf);
  593. return true;
  594. }
  595. return false;
  596. }
  597. /**
  598. * dp_rx_null_q_check_pkt_len_exception() - Check for pktlen validity
  599. * @soc: DP SOC context
  600. * @pkt_len: computed length of the pkt from caller in bytes
  601. *
  602. * Return: true if pktlen > RX_BUFFER_SIZE, else return false
  603. *
  604. */
  605. static inline
  606. bool dp_rx_null_q_check_pkt_len_exception(struct dp_soc *soc, uint32_t pkt_len)
  607. {
  608. if (qdf_unlikely(pkt_len > RX_BUFFER_SIZE)) {
  609. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_pkt_len,
  610. 1, pkt_len);
  611. return true;
  612. } else {
  613. return false;
  614. }
  615. }
  616. #else
  617. static inline bool
  618. dp_rx_null_q_handle_invalid_peer_id_exception(struct dp_soc *soc,
  619. uint8_t pool_id,
  620. uint8_t *rx_tlv_hdr,
  621. qdf_nbuf_t nbuf)
  622. {
  623. return false;
  624. }
  625. static inline
  626. bool dp_rx_null_q_check_pkt_len_exception(struct dp_soc *soc, uint32_t pkt_len)
  627. {
  628. return false;
  629. }
  630. #endif
  631. /**
  632. * dp_rx_null_q_desc_handle() - Function to handle NULL Queue
  633. * descriptor violation on either a
  634. * REO or WBM ring
  635. *
  636. * @soc: core DP main context
  637. * @nbuf: buffer pointer
  638. * @rx_tlv_hdr: start of rx tlv header
  639. * @pool_id: mac id
  640. * @peer: peer handle
  641. *
  642. * This function handles NULL queue descriptor violations arising out
  643. * a missing REO queue for a given peer or a given TID. This typically
  644. * may happen if a packet is received on a QOS enabled TID before the
  645. * ADDBA negotiation for that TID, when the TID queue is setup. Or
  646. * it may also happen for MC/BC frames if they are not routed to the
  647. * non-QOS TID queue, in the absence of any other default TID queue.
  648. * This error can show up both in a REO destination or WBM release ring.
  649. *
  650. * Return: QDF_STATUS_SUCCESS, if nbuf handled successfully. QDF status code
  651. * if nbuf could not be handled or dropped.
  652. */
  653. static QDF_STATUS
  654. dp_rx_null_q_desc_handle(struct dp_soc *soc, qdf_nbuf_t nbuf,
  655. uint8_t *rx_tlv_hdr, uint8_t pool_id,
  656. struct dp_peer *peer)
  657. {
  658. uint32_t pkt_len, l2_hdr_offset;
  659. uint16_t msdu_len;
  660. struct dp_vdev *vdev;
  661. uint8_t tid;
  662. qdf_ether_header_t *eh;
  663. qdf_nbuf_set_rx_chfrag_start(nbuf,
  664. hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  665. rx_tlv_hdr));
  666. qdf_nbuf_set_rx_chfrag_end(nbuf,
  667. hal_rx_msdu_end_last_msdu_get(soc->hal_soc,
  668. rx_tlv_hdr));
  669. qdf_nbuf_set_da_mcbc(nbuf, hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
  670. rx_tlv_hdr));
  671. qdf_nbuf_set_da_valid(nbuf,
  672. hal_rx_msdu_end_da_is_valid_get(soc->hal_soc,
  673. rx_tlv_hdr));
  674. qdf_nbuf_set_sa_valid(nbuf,
  675. hal_rx_msdu_end_sa_is_valid_get(soc->hal_soc,
  676. rx_tlv_hdr));
  677. l2_hdr_offset = hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc,
  678. rx_tlv_hdr);
  679. msdu_len = hal_rx_msdu_start_msdu_len_get(rx_tlv_hdr);
  680. pkt_len = msdu_len + l2_hdr_offset + RX_PKT_TLVS_LEN;
  681. if (qdf_likely(!qdf_nbuf_is_frag(nbuf))) {
  682. if (dp_rx_null_q_check_pkt_len_exception(soc, pkt_len))
  683. goto drop_nbuf;
  684. /* Set length in nbuf */
  685. qdf_nbuf_set_pktlen(nbuf,
  686. qdf_min(pkt_len, (uint32_t)RX_BUFFER_SIZE));
  687. qdf_assert_always(nbuf->data == rx_tlv_hdr);
  688. }
  689. /*
  690. * Check if DMA completed -- msdu_done is the last bit
  691. * to be written
  692. */
  693. if (!hal_rx_attn_msdu_done_get(rx_tlv_hdr)) {
  694. dp_err_rl("MSDU DONE failure");
  695. hal_rx_dump_pkt_tlvs(soc->hal_soc, rx_tlv_hdr,
  696. QDF_TRACE_LEVEL_INFO);
  697. qdf_assert(0);
  698. }
  699. if (!peer &&
  700. dp_rx_null_q_handle_invalid_peer_id_exception(soc, pool_id,
  701. rx_tlv_hdr, nbuf))
  702. return QDF_STATUS_E_FAILURE;
  703. if (!peer) {
  704. bool mpdu_done = false;
  705. struct dp_pdev *pdev = soc->pdev_list[pool_id];
  706. dp_err_rl("peer is NULL");
  707. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  708. qdf_nbuf_len(nbuf));
  709. mpdu_done = dp_rx_chain_msdus(soc, nbuf, rx_tlv_hdr, pool_id);
  710. /* Trigger invalid peer handler wrapper */
  711. dp_rx_process_invalid_peer_wrapper(soc,
  712. pdev->invalid_peer_head_msdu,
  713. mpdu_done, pool_id);
  714. if (mpdu_done) {
  715. pdev->invalid_peer_head_msdu = NULL;
  716. pdev->invalid_peer_tail_msdu = NULL;
  717. }
  718. return QDF_STATUS_E_FAILURE;
  719. }
  720. vdev = peer->vdev;
  721. if (!vdev) {
  722. dp_err_rl("Null vdev!");
  723. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  724. goto drop_nbuf;
  725. }
  726. /*
  727. * Advance the packet start pointer by total size of
  728. * pre-header TLV's
  729. */
  730. if (qdf_nbuf_is_frag(nbuf))
  731. qdf_nbuf_pull_head(nbuf, RX_PKT_TLVS_LEN);
  732. else
  733. qdf_nbuf_pull_head(nbuf, (l2_hdr_offset + RX_PKT_TLVS_LEN));
  734. if (dp_rx_mcast_echo_check(soc, peer, rx_tlv_hdr, nbuf)) {
  735. /* this is a looped back MCBC pkt, drop it */
  736. DP_STATS_INC_PKT(peer, rx.mec_drop, 1, qdf_nbuf_len(nbuf));
  737. goto drop_nbuf;
  738. }
  739. /*
  740. * In qwrap mode if the received packet matches with any of the vdev
  741. * mac addresses, drop it. Donot receive multicast packets originated
  742. * from any proxysta.
  743. */
  744. if (check_qwrap_multicast_loopback(vdev, nbuf)) {
  745. DP_STATS_INC_PKT(peer, rx.mec_drop, 1, qdf_nbuf_len(nbuf));
  746. goto drop_nbuf;
  747. }
  748. if (qdf_unlikely((peer->nawds_enabled == true) &&
  749. hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
  750. rx_tlv_hdr))) {
  751. dp_err_rl("free buffer for multicast packet");
  752. DP_STATS_INC(peer, rx.nawds_mcast_drop, 1);
  753. goto drop_nbuf;
  754. }
  755. if (!dp_wds_rx_policy_check(rx_tlv_hdr, vdev, peer)) {
  756. dp_err_rl("mcast Policy Check Drop pkt");
  757. goto drop_nbuf;
  758. }
  759. /* WDS Source Port Learning */
  760. if (qdf_likely(vdev->rx_decap_type == htt_cmn_pkt_type_ethernet &&
  761. vdev->wds_enabled))
  762. dp_rx_wds_srcport_learn(soc, rx_tlv_hdr, peer, nbuf);
  763. if (hal_rx_is_unicast(soc->hal_soc, rx_tlv_hdr)) {
  764. tid = hal_rx_tid_get(soc->hal_soc, rx_tlv_hdr);
  765. if (!peer->rx_tid[tid].hw_qdesc_vaddr_unaligned)
  766. dp_rx_tid_setup_wifi3(peer, tid, 1, IEEE80211_SEQ_MAX);
  767. /* IEEE80211_SEQ_MAX indicates invalid start_seq */
  768. }
  769. if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw)) {
  770. qdf_nbuf_set_next(nbuf, NULL);
  771. dp_rx_deliver_raw(vdev, nbuf, peer);
  772. } else {
  773. if (vdev->osif_rx) {
  774. qdf_nbuf_set_next(nbuf, NULL);
  775. DP_STATS_INC_PKT(peer, rx.to_stack, 1,
  776. qdf_nbuf_len(nbuf));
  777. /*
  778. * Update the protocol tag in SKB based on
  779. * CCE metadata
  780. */
  781. dp_rx_update_protocol_tag(soc, vdev, nbuf, rx_tlv_hdr,
  782. EXCEPTION_DEST_RING_ID,
  783. true, true);
  784. /* Update the flow tag in SKB based on FSE metadata */
  785. dp_rx_update_flow_tag(soc, vdev, nbuf,
  786. rx_tlv_hdr, true);
  787. if (qdf_unlikely(hal_rx_msdu_end_da_is_mcbc_get(
  788. soc->hal_soc, rx_tlv_hdr) &&
  789. (vdev->rx_decap_type ==
  790. htt_cmn_pkt_type_ethernet))) {
  791. eh = (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
  792. DP_STATS_INC_PKT(peer, rx.multicast, 1,
  793. qdf_nbuf_len(nbuf));
  794. if (QDF_IS_ADDR_BROADCAST(eh->ether_dhost)) {
  795. DP_STATS_INC_PKT(peer, rx.bcast, 1,
  796. qdf_nbuf_len(nbuf));
  797. }
  798. }
  799. vdev->osif_rx(vdev->osif_vdev, nbuf);
  800. } else {
  801. dp_err_rl("INVALID osif_rx. vdev %pK", vdev);
  802. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  803. goto drop_nbuf;
  804. }
  805. }
  806. return QDF_STATUS_SUCCESS;
  807. drop_nbuf:
  808. qdf_nbuf_free(nbuf);
  809. return QDF_STATUS_E_FAILURE;
  810. }
  811. /**
  812. * dp_rx_process_rxdma_err() - Function to deliver rxdma unencrypted_err
  813. * frames to OS or wifi parse errors.
  814. * @soc: core DP main context
  815. * @nbuf: buffer pointer
  816. * @rx_tlv_hdr: start of rx tlv header
  817. * @peer: peer reference
  818. * @err_code: rxdma err code
  819. * @mac_id: mac_id which is one of 3 mac_ids(Assuming mac_id and
  820. * pool_id has same mapping)
  821. *
  822. * Return: None
  823. */
  824. void
  825. dp_rx_process_rxdma_err(struct dp_soc *soc, qdf_nbuf_t nbuf,
  826. uint8_t *rx_tlv_hdr, struct dp_peer *peer,
  827. uint8_t err_code, uint8_t mac_id)
  828. {
  829. uint32_t pkt_len, l2_hdr_offset;
  830. uint16_t msdu_len;
  831. struct dp_vdev *vdev;
  832. qdf_ether_header_t *eh;
  833. bool is_broadcast;
  834. /*
  835. * Check if DMA completed -- msdu_done is the last bit
  836. * to be written
  837. */
  838. if (!hal_rx_attn_msdu_done_get(rx_tlv_hdr)) {
  839. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  840. FL("MSDU DONE failure"));
  841. hal_rx_dump_pkt_tlvs(soc->hal_soc, rx_tlv_hdr,
  842. QDF_TRACE_LEVEL_INFO);
  843. qdf_assert(0);
  844. }
  845. l2_hdr_offset = hal_rx_msdu_end_l3_hdr_padding_get(soc->hal_soc,
  846. rx_tlv_hdr);
  847. msdu_len = hal_rx_msdu_start_msdu_len_get(rx_tlv_hdr);
  848. pkt_len = msdu_len + l2_hdr_offset + RX_PKT_TLVS_LEN;
  849. /* Set length in nbuf */
  850. qdf_nbuf_set_pktlen(nbuf, pkt_len);
  851. qdf_nbuf_set_next(nbuf, NULL);
  852. qdf_nbuf_set_rx_chfrag_start(nbuf, 1);
  853. qdf_nbuf_set_rx_chfrag_end(nbuf, 1);
  854. if (!peer) {
  855. QDF_TRACE_ERROR_RL(QDF_MODULE_ID_DP, "peer is NULL");
  856. DP_STATS_INC_PKT(soc, rx.err.rx_invalid_peer, 1,
  857. qdf_nbuf_len(nbuf));
  858. /* Trigger invalid peer handler wrapper */
  859. dp_rx_process_invalid_peer_wrapper(soc, nbuf, true, mac_id);
  860. return;
  861. }
  862. vdev = peer->vdev;
  863. if (!vdev) {
  864. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  865. FL("INVALID vdev %pK OR osif_rx"), vdev);
  866. /* Drop & free packet */
  867. qdf_nbuf_free(nbuf);
  868. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  869. return;
  870. }
  871. /*
  872. * Advance the packet start pointer by total size of
  873. * pre-header TLV's
  874. */
  875. qdf_nbuf_pull_head(nbuf, l2_hdr_offset + RX_PKT_TLVS_LEN);
  876. if (err_code == HAL_RXDMA_ERR_WIFI_PARSE) {
  877. uint8_t *pkt_type;
  878. pkt_type = qdf_nbuf_data(nbuf) + (2 * QDF_MAC_ADDR_SIZE);
  879. if (*(uint16_t *)pkt_type == htons(QDF_ETH_TYPE_8021Q)) {
  880. if (*(uint16_t *)(pkt_type + DP_SKIP_VLAN) ==
  881. htons(QDF_LLC_STP)) {
  882. DP_STATS_INC(vdev->pdev, vlan_tag_stp_cnt, 1);
  883. goto process_mesh;
  884. } else {
  885. goto process_rx;
  886. }
  887. }
  888. }
  889. if (vdev->rx_decap_type == htt_cmn_pkt_type_raw)
  890. goto process_mesh;
  891. /*
  892. * WAPI cert AP sends rekey frames as unencrypted.
  893. * Thus RXDMA will report unencrypted frame error.
  894. * To pass WAPI cert case, SW needs to pass unencrypted
  895. * rekey frame to stack.
  896. */
  897. if (qdf_nbuf_is_ipv4_wapi_pkt(nbuf)) {
  898. goto process_rx;
  899. }
  900. /*
  901. * In dynamic WEP case rekey frames are not encrypted
  902. * similar to WAPI. Allow EAPOL when 8021+wep is enabled and
  903. * key install is already done
  904. */
  905. if ((vdev->sec_type == cdp_sec_type_wep104) &&
  906. (qdf_nbuf_is_ipv4_eapol_pkt(nbuf)))
  907. goto process_rx;
  908. process_mesh:
  909. if (!vdev->mesh_vdev && err_code == HAL_RXDMA_ERR_UNENCRYPTED) {
  910. qdf_nbuf_free(nbuf);
  911. DP_STATS_INC(soc, rx.err.invalid_vdev, 1);
  912. return;
  913. }
  914. if (vdev->mesh_vdev) {
  915. if (dp_rx_filter_mesh_packets(vdev, nbuf, rx_tlv_hdr)
  916. == QDF_STATUS_SUCCESS) {
  917. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO_MED,
  918. FL("mesh pkt filtered"));
  919. DP_STATS_INC(vdev->pdev, dropped.mesh_filter, 1);
  920. qdf_nbuf_free(nbuf);
  921. return;
  922. }
  923. dp_rx_fill_mesh_stats(vdev, nbuf, rx_tlv_hdr, peer);
  924. }
  925. process_rx:
  926. if (qdf_unlikely(hal_rx_msdu_end_da_is_mcbc_get(soc->hal_soc,
  927. rx_tlv_hdr) &&
  928. (vdev->rx_decap_type ==
  929. htt_cmn_pkt_type_ethernet))) {
  930. eh = (qdf_ether_header_t *)qdf_nbuf_data(nbuf);
  931. is_broadcast = (QDF_IS_ADDR_BROADCAST
  932. (eh->ether_dhost)) ? 1 : 0 ;
  933. DP_STATS_INC_PKT(peer, rx.multicast, 1, qdf_nbuf_len(nbuf));
  934. if (is_broadcast) {
  935. DP_STATS_INC_PKT(peer, rx.bcast, 1,
  936. qdf_nbuf_len(nbuf));
  937. }
  938. }
  939. if (qdf_unlikely(vdev->rx_decap_type == htt_cmn_pkt_type_raw)) {
  940. dp_rx_deliver_raw(vdev, nbuf, peer);
  941. } else {
  942. /* Update the protocol tag in SKB based on CCE metadata */
  943. dp_rx_update_protocol_tag(soc, vdev, nbuf, rx_tlv_hdr,
  944. EXCEPTION_DEST_RING_ID, true, true);
  945. /* Update the flow tag in SKB based on FSE metadata */
  946. dp_rx_update_flow_tag(soc, vdev, nbuf, rx_tlv_hdr, true);
  947. DP_STATS_INC(peer, rx.to_stack.num, 1);
  948. vdev->osif_rx(vdev->osif_vdev, nbuf);
  949. }
  950. return;
  951. }
  952. /**
  953. * dp_rx_process_mic_error(): Function to pass mic error indication to umac
  954. * @soc: core DP main context
  955. * @nbuf: buffer pointer
  956. * @rx_tlv_hdr: start of rx tlv header
  957. * @peer: peer handle
  958. *
  959. * return: void
  960. */
  961. void dp_rx_process_mic_error(struct dp_soc *soc, qdf_nbuf_t nbuf,
  962. uint8_t *rx_tlv_hdr, struct dp_peer *peer)
  963. {
  964. struct dp_vdev *vdev = NULL;
  965. struct dp_pdev *pdev = NULL;
  966. struct ol_if_ops *tops = NULL;
  967. uint16_t rx_seq, fragno;
  968. uint8_t is_raw;
  969. unsigned int tid;
  970. QDF_STATUS status;
  971. struct cdp_rx_mic_err_info mic_failure_info;
  972. if (!hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  973. rx_tlv_hdr))
  974. return;
  975. if (!peer) {
  976. dp_err_rl("peer not found");
  977. goto fail;
  978. }
  979. vdev = peer->vdev;
  980. if (!vdev) {
  981. dp_err_rl("VDEV not found");
  982. goto fail;
  983. }
  984. pdev = vdev->pdev;
  985. if (!pdev) {
  986. dp_err_rl("PDEV not found");
  987. goto fail;
  988. }
  989. is_raw = HAL_IS_DECAP_FORMAT_RAW(soc->hal_soc, qdf_nbuf_data(nbuf));
  990. if (is_raw) {
  991. fragno = dp_rx_frag_get_mpdu_frag_number(qdf_nbuf_data(nbuf));
  992. /* Can get only last fragment */
  993. if (fragno) {
  994. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc,
  995. qdf_nbuf_data(nbuf));
  996. rx_seq = hal_rx_get_rx_sequence(soc->hal_soc,
  997. qdf_nbuf_data(nbuf));
  998. status = dp_rx_defrag_add_last_frag(soc, peer,
  999. tid, rx_seq, nbuf);
  1000. dp_info_rl("Frag pkt seq# %d frag# %d consumed "
  1001. "status %d !", rx_seq, fragno, status);
  1002. return;
  1003. }
  1004. }
  1005. if (hal_rx_mpdu_get_addr1(soc->hal_soc, qdf_nbuf_data(nbuf),
  1006. &mic_failure_info.da_mac_addr.bytes[0])) {
  1007. dp_err_rl("Failed to get da_mac_addr");
  1008. goto fail;
  1009. }
  1010. if (hal_rx_mpdu_get_addr2(soc->hal_soc, qdf_nbuf_data(nbuf),
  1011. &mic_failure_info.ta_mac_addr.bytes[0])) {
  1012. dp_err_rl("Failed to get ta_mac_addr");
  1013. goto fail;
  1014. }
  1015. mic_failure_info.key_id = 0;
  1016. mic_failure_info.multicast =
  1017. IEEE80211_IS_MULTICAST(mic_failure_info.da_mac_addr.bytes);
  1018. qdf_mem_zero(mic_failure_info.tsc, MIC_SEQ_CTR_SIZE);
  1019. mic_failure_info.frame_type = cdp_rx_frame_type_802_11;
  1020. mic_failure_info.data = NULL;
  1021. mic_failure_info.vdev_id = vdev->vdev_id;
  1022. tops = pdev->soc->cdp_soc.ol_ops;
  1023. if (tops->rx_mic_error)
  1024. tops->rx_mic_error(soc->ctrl_psoc, pdev->pdev_id,
  1025. &mic_failure_info);
  1026. fail:
  1027. qdf_nbuf_free(nbuf);
  1028. return;
  1029. }
  1030. uint32_t
  1031. dp_rx_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
  1032. hal_ring_handle_t hal_ring_hdl, uint32_t quota)
  1033. {
  1034. hal_ring_desc_t ring_desc;
  1035. hal_soc_handle_t hal_soc;
  1036. uint32_t count = 0;
  1037. uint32_t rx_bufs_used = 0;
  1038. uint32_t rx_bufs_reaped[MAX_PDEV_CNT] = { 0 };
  1039. uint8_t mac_id = 0;
  1040. uint8_t buf_type;
  1041. uint8_t error, rbm;
  1042. struct hal_rx_mpdu_desc_info mpdu_desc_info;
  1043. struct hal_buf_info hbi;
  1044. struct dp_pdev *dp_pdev;
  1045. struct dp_srng *dp_rxdma_srng;
  1046. struct rx_desc_pool *rx_desc_pool;
  1047. uint32_t cookie = 0;
  1048. void *link_desc_va;
  1049. struct hal_rx_msdu_list msdu_list; /* MSDU's per MPDU */
  1050. uint16_t num_msdus;
  1051. struct dp_rx_desc *rx_desc = NULL;
  1052. /* Debug -- Remove later */
  1053. qdf_assert(soc && hal_ring_hdl);
  1054. hal_soc = soc->hal_soc;
  1055. /* Debug -- Remove later */
  1056. qdf_assert(hal_soc);
  1057. if (qdf_unlikely(dp_srng_access_start(int_ctx, soc, hal_ring_hdl))) {
  1058. /* TODO */
  1059. /*
  1060. * Need API to convert from hal_ring pointer to
  1061. * Ring Type / Ring Id combo
  1062. */
  1063. DP_STATS_INC(soc, rx.err.hal_ring_access_fail, 1);
  1064. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1065. FL("HAL RING Access Failed -- %pK"), hal_ring_hdl);
  1066. goto done;
  1067. }
  1068. while (qdf_likely(quota-- && (ring_desc =
  1069. hal_srng_dst_get_next(hal_soc,
  1070. hal_ring_hdl)))) {
  1071. DP_STATS_INC(soc, rx.err_ring_pkts, 1);
  1072. error = HAL_RX_ERROR_STATUS_GET(ring_desc);
  1073. qdf_assert(error == HAL_REO_ERROR_DETECTED);
  1074. buf_type = HAL_RX_REO_BUF_TYPE_GET(ring_desc);
  1075. /*
  1076. * For REO error ring, expect only MSDU LINK DESC
  1077. */
  1078. qdf_assert_always(buf_type == HAL_RX_REO_MSDU_LINK_DESC_TYPE);
  1079. cookie = HAL_RX_REO_BUF_COOKIE_GET(ring_desc);
  1080. /*
  1081. * check for the magic number in the sw cookie
  1082. */
  1083. qdf_assert_always((cookie >> LINK_DESC_ID_SHIFT) &
  1084. LINK_DESC_ID_START);
  1085. /*
  1086. * Check if the buffer is to be processed on this processor
  1087. */
  1088. rbm = hal_rx_ret_buf_manager_get(ring_desc);
  1089. hal_rx_reo_buf_paddr_get(ring_desc, &hbi);
  1090. link_desc_va = dp_rx_cookie_2_link_desc_va(soc, &hbi);
  1091. hal_rx_msdu_list_get(soc->hal_soc, link_desc_va, &msdu_list,
  1092. &num_msdus);
  1093. if (qdf_unlikely((msdu_list.rbm[0] != DP_WBM2SW_RBM) &&
  1094. (msdu_list.rbm[0] !=
  1095. HAL_RX_BUF_RBM_WBM_IDLE_DESC_LIST) &&
  1096. (msdu_list.rbm[0] != DP_DEFRAG_RBM))) {
  1097. /* TODO */
  1098. /* Call appropriate handler */
  1099. if (!wlan_cfg_get_dp_soc_nss_cfg(soc->wlan_cfg_ctx)) {
  1100. DP_STATS_INC(soc, rx.err.invalid_rbm, 1);
  1101. QDF_TRACE(QDF_MODULE_ID_DP,
  1102. QDF_TRACE_LEVEL_ERROR,
  1103. FL("Invalid RBM %d"),
  1104. msdu_list.rbm[0]);
  1105. }
  1106. /* Return link descriptor through WBM ring (SW2WBM)*/
  1107. dp_rx_link_desc_return(soc, ring_desc,
  1108. HAL_BM_ACTION_RELEASE_MSDU_LIST);
  1109. continue;
  1110. }
  1111. rx_desc = dp_rx_cookie_2_va_rxdma_buf(soc,
  1112. msdu_list.sw_cookie[0]);
  1113. qdf_assert_always(rx_desc);
  1114. mac_id = rx_desc->pool_id;
  1115. /* Get the MPDU DESC info */
  1116. hal_rx_mpdu_desc_info_get(ring_desc, &mpdu_desc_info);
  1117. if (mpdu_desc_info.mpdu_flags & HAL_MPDU_F_FRAGMENT) {
  1118. /*
  1119. * We only handle one msdu per link desc for fragmented
  1120. * case. We drop the msdus and release the link desc
  1121. * back if there are more than one msdu in link desc.
  1122. */
  1123. if (qdf_unlikely(num_msdus > 1)) {
  1124. count = dp_rx_msdus_drop(soc, ring_desc,
  1125. &mpdu_desc_info,
  1126. &mac_id, quota);
  1127. rx_bufs_reaped[mac_id] += count;
  1128. continue;
  1129. }
  1130. count = dp_rx_frag_handle(soc,
  1131. ring_desc, &mpdu_desc_info,
  1132. rx_desc, &mac_id, quota);
  1133. rx_bufs_reaped[mac_id] += count;
  1134. DP_STATS_INC(soc, rx.rx_frags, 1);
  1135. continue;
  1136. }
  1137. if (hal_rx_reo_is_pn_error(ring_desc)) {
  1138. /* TOD0 */
  1139. DP_STATS_INC(soc,
  1140. rx.err.
  1141. reo_error[HAL_REO_ERR_PN_CHECK_FAILED],
  1142. 1);
  1143. /* increment @pdev level */
  1144. dp_pdev = dp_get_pdev_for_mac_id(soc, mac_id);
  1145. if (dp_pdev)
  1146. DP_STATS_INC(dp_pdev, err.reo_error, 1);
  1147. count = dp_rx_pn_error_handle(soc,
  1148. ring_desc,
  1149. &mpdu_desc_info, &mac_id,
  1150. quota);
  1151. rx_bufs_reaped[mac_id] += count;
  1152. continue;
  1153. }
  1154. if (hal_rx_reo_is_2k_jump(ring_desc)) {
  1155. /* TOD0 */
  1156. DP_STATS_INC(soc,
  1157. rx.err.
  1158. reo_error[HAL_REO_ERR_REGULAR_FRAME_2K_JUMP],
  1159. 1);
  1160. /* increment @pdev level */
  1161. dp_pdev = dp_get_pdev_for_mac_id(soc, mac_id);
  1162. if (dp_pdev)
  1163. DP_STATS_INC(dp_pdev, err.reo_error, 1);
  1164. count = dp_rx_2k_jump_handle(soc,
  1165. ring_desc, &mpdu_desc_info,
  1166. &mac_id, quota);
  1167. rx_bufs_reaped[mac_id] += count;
  1168. continue;
  1169. }
  1170. }
  1171. done:
  1172. dp_srng_access_end(int_ctx, soc, hal_ring_hdl);
  1173. if (soc->rx.flags.defrag_timeout_check) {
  1174. uint32_t now_ms =
  1175. qdf_system_ticks_to_msecs(qdf_system_ticks());
  1176. if (now_ms >= soc->rx.defrag.next_flush_ms)
  1177. dp_rx_defrag_waitlist_flush(soc);
  1178. }
  1179. for (mac_id = 0; mac_id < MAX_PDEV_CNT; mac_id++) {
  1180. if (rx_bufs_reaped[mac_id]) {
  1181. dp_pdev = soc->pdev_list[mac_id];
  1182. dp_rxdma_srng = &dp_pdev->rx_refill_buf_ring;
  1183. rx_desc_pool = &soc->rx_desc_buf[mac_id];
  1184. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  1185. rx_desc_pool,
  1186. rx_bufs_reaped[mac_id],
  1187. &dp_pdev->free_list_head,
  1188. &dp_pdev->free_list_tail);
  1189. rx_bufs_used += rx_bufs_reaped[mac_id];
  1190. }
  1191. }
  1192. return rx_bufs_used; /* Assume no scale factor for now */
  1193. }
  1194. uint32_t
  1195. dp_rx_wbm_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
  1196. hal_ring_handle_t hal_ring_hdl, uint32_t quota)
  1197. {
  1198. hal_ring_desc_t ring_desc;
  1199. hal_soc_handle_t hal_soc;
  1200. struct dp_rx_desc *rx_desc;
  1201. union dp_rx_desc_list_elem_t *head[MAX_PDEV_CNT] = { NULL };
  1202. union dp_rx_desc_list_elem_t *tail[MAX_PDEV_CNT] = { NULL };
  1203. uint32_t rx_bufs_used = 0;
  1204. uint32_t rx_bufs_reaped[MAX_PDEV_CNT] = { 0 };
  1205. uint8_t buf_type, rbm;
  1206. uint32_t rx_buf_cookie;
  1207. uint8_t mac_id;
  1208. struct dp_pdev *dp_pdev;
  1209. struct dp_srng *dp_rxdma_srng;
  1210. struct rx_desc_pool *rx_desc_pool;
  1211. uint8_t *rx_tlv_hdr;
  1212. qdf_nbuf_t nbuf_head = NULL;
  1213. qdf_nbuf_t nbuf_tail = NULL;
  1214. qdf_nbuf_t nbuf, next;
  1215. struct hal_wbm_err_desc_info wbm_err_info = { 0 };
  1216. uint8_t pool_id;
  1217. uint8_t tid = 0;
  1218. /* Debug -- Remove later */
  1219. qdf_assert(soc && hal_ring_hdl);
  1220. hal_soc = soc->hal_soc;
  1221. /* Debug -- Remove later */
  1222. qdf_assert(hal_soc);
  1223. if (qdf_unlikely(dp_srng_access_start(int_ctx, soc, hal_ring_hdl))) {
  1224. /* TODO */
  1225. /*
  1226. * Need API to convert from hal_ring pointer to
  1227. * Ring Type / Ring Id combo
  1228. */
  1229. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1230. FL("HAL RING Access Failed -- %pK"), hal_ring_hdl);
  1231. goto done;
  1232. }
  1233. while (qdf_likely(quota-- && (ring_desc =
  1234. hal_srng_dst_get_next(hal_soc,
  1235. hal_ring_hdl)))) {
  1236. /* XXX */
  1237. buf_type = HAL_RX_WBM_BUF_TYPE_GET(ring_desc);
  1238. /*
  1239. * For WBM ring, expect only MSDU buffers
  1240. */
  1241. qdf_assert_always(buf_type == HAL_RX_WBM_BUF_TYPE_REL_BUF);
  1242. qdf_assert((HAL_RX_WBM_ERR_SRC_GET(ring_desc)
  1243. == HAL_RX_WBM_ERR_SRC_RXDMA) ||
  1244. (HAL_RX_WBM_ERR_SRC_GET(ring_desc)
  1245. == HAL_RX_WBM_ERR_SRC_REO));
  1246. /*
  1247. * Check if the buffer is to be processed on this processor
  1248. */
  1249. rbm = hal_rx_ret_buf_manager_get(ring_desc);
  1250. if (qdf_unlikely(rbm != HAL_RX_BUF_RBM_SW3_BM)) {
  1251. /* TODO */
  1252. /* Call appropriate handler */
  1253. DP_STATS_INC(soc, rx.err.invalid_rbm, 1);
  1254. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1255. FL("Invalid RBM %d"), rbm);
  1256. continue;
  1257. }
  1258. rx_buf_cookie = HAL_RX_WBM_BUF_COOKIE_GET(ring_desc);
  1259. rx_desc = dp_rx_cookie_2_va_rxdma_buf(soc, rx_buf_cookie);
  1260. qdf_assert_always(rx_desc);
  1261. if (!dp_rx_desc_check_magic(rx_desc)) {
  1262. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1263. FL("Invalid rx_desc cookie=%d"),
  1264. rx_buf_cookie);
  1265. continue;
  1266. }
  1267. /*
  1268. * this is a unlikely scenario where the host is reaping
  1269. * a descriptor which it already reaped just a while ago
  1270. * but is yet to replenish it back to HW.
  1271. * In this case host will dump the last 128 descriptors
  1272. * including the software descriptor rx_desc and assert.
  1273. */
  1274. if (qdf_unlikely(!rx_desc->in_use)) {
  1275. DP_STATS_INC(soc, rx.err.hal_wbm_rel_dup, 1);
  1276. dp_rx_dump_info_and_assert(soc, hal_ring_hdl,
  1277. ring_desc, rx_desc);
  1278. }
  1279. nbuf = rx_desc->nbuf;
  1280. qdf_nbuf_unmap_single(soc->osdev, nbuf, QDF_DMA_FROM_DEVICE);
  1281. /*
  1282. * save the wbm desc info in nbuf TLV. We will need this
  1283. * info when we do the actual nbuf processing
  1284. */
  1285. hal_rx_wbm_err_info_get(ring_desc, &wbm_err_info, hal_soc);
  1286. wbm_err_info.pool_id = rx_desc->pool_id;
  1287. hal_rx_wbm_err_info_set_in_tlv(qdf_nbuf_data(nbuf),
  1288. &wbm_err_info);
  1289. rx_bufs_reaped[rx_desc->pool_id]++;
  1290. DP_RX_LIST_APPEND(nbuf_head, nbuf_tail, rx_desc->nbuf);
  1291. dp_rx_add_to_free_desc_list(&head[rx_desc->pool_id],
  1292. &tail[rx_desc->pool_id],
  1293. rx_desc);
  1294. }
  1295. done:
  1296. dp_srng_access_end(int_ctx, soc, hal_ring_hdl);
  1297. for (mac_id = 0; mac_id < MAX_PDEV_CNT; mac_id++) {
  1298. if (rx_bufs_reaped[mac_id]) {
  1299. dp_pdev = soc->pdev_list[mac_id];
  1300. dp_rxdma_srng = &dp_pdev->rx_refill_buf_ring;
  1301. rx_desc_pool = &soc->rx_desc_buf[mac_id];
  1302. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  1303. rx_desc_pool, rx_bufs_reaped[mac_id],
  1304. &head[mac_id], &tail[mac_id]);
  1305. rx_bufs_used += rx_bufs_reaped[mac_id];
  1306. }
  1307. }
  1308. nbuf = nbuf_head;
  1309. while (nbuf) {
  1310. struct dp_peer *peer;
  1311. uint16_t peer_id;
  1312. uint8_t e_code;
  1313. uint8_t *tlv_hdr;
  1314. rx_tlv_hdr = qdf_nbuf_data(nbuf);
  1315. /*
  1316. * retrieve the wbm desc info from nbuf TLV, so we can
  1317. * handle error cases appropriately
  1318. */
  1319. hal_rx_wbm_err_info_get_from_tlv(rx_tlv_hdr, &wbm_err_info);
  1320. peer_id = hal_rx_mpdu_start_sw_peer_id_get(soc->hal_soc,
  1321. rx_tlv_hdr);
  1322. peer = dp_peer_find_by_id(soc, peer_id);
  1323. if (!peer)
  1324. dp_err_rl("peer is null! peer_id %u err_src %u err_rsn %u",
  1325. peer_id, wbm_err_info.wbm_err_src,
  1326. wbm_err_info.reo_psh_rsn);
  1327. /* Set queue_mapping in nbuf to 0 */
  1328. dp_set_rx_queue(nbuf, 0);
  1329. next = nbuf->next;
  1330. if (wbm_err_info.wbm_err_src == HAL_RX_WBM_ERR_SRC_REO) {
  1331. if (wbm_err_info.reo_psh_rsn
  1332. == HAL_RX_WBM_REO_PSH_RSN_ERROR) {
  1333. DP_STATS_INC(soc,
  1334. rx.err.reo_error
  1335. [wbm_err_info.reo_err_code], 1);
  1336. /* increment @pdev level */
  1337. pool_id = wbm_err_info.pool_id;
  1338. dp_pdev = dp_get_pdev_for_mac_id(soc, pool_id);
  1339. if (dp_pdev)
  1340. DP_STATS_INC(dp_pdev, err.reo_error,
  1341. 1);
  1342. switch (wbm_err_info.reo_err_code) {
  1343. /*
  1344. * Handling for packets which have NULL REO
  1345. * queue descriptor
  1346. */
  1347. case HAL_REO_ERR_QUEUE_DESC_ADDR_0:
  1348. pool_id = wbm_err_info.pool_id;
  1349. dp_rx_null_q_desc_handle(soc, nbuf,
  1350. rx_tlv_hdr,
  1351. pool_id, peer);
  1352. nbuf = next;
  1353. if (peer)
  1354. dp_peer_unref_del_find_by_id(
  1355. peer);
  1356. continue;
  1357. /* TODO */
  1358. /* Add per error code accounting */
  1359. case HAL_REO_ERR_REGULAR_FRAME_2K_JUMP:
  1360. pool_id = wbm_err_info.pool_id;
  1361. if (hal_rx_msdu_end_first_msdu_get(soc->hal_soc,
  1362. rx_tlv_hdr)) {
  1363. peer_id =
  1364. hal_rx_mpdu_start_sw_peer_id_get(soc->hal_soc,
  1365. rx_tlv_hdr);
  1366. tid =
  1367. hal_rx_mpdu_start_tid_get(hal_soc, rx_tlv_hdr);
  1368. }
  1369. dp_2k_jump_handle(soc, nbuf, rx_tlv_hdr,
  1370. peer_id, tid);
  1371. nbuf = next;
  1372. if (peer)
  1373. dp_peer_unref_del_find_by_id(
  1374. peer);
  1375. continue;
  1376. case HAL_REO_ERR_BAR_FRAME_2K_JUMP:
  1377. case HAL_REO_ERR_BAR_FRAME_OOR:
  1378. if (peer)
  1379. dp_rx_wbm_err_handle_bar(soc,
  1380. peer,
  1381. nbuf);
  1382. break;
  1383. default:
  1384. dp_err_rl("Got pkt with REO ERROR: %d",
  1385. wbm_err_info.reo_err_code);
  1386. break;
  1387. }
  1388. }
  1389. } else if (wbm_err_info.wbm_err_src ==
  1390. HAL_RX_WBM_ERR_SRC_RXDMA) {
  1391. if (wbm_err_info.rxdma_psh_rsn
  1392. == HAL_RX_WBM_RXDMA_PSH_RSN_ERROR) {
  1393. DP_STATS_INC(soc,
  1394. rx.err.rxdma_error
  1395. [wbm_err_info.rxdma_err_code], 1);
  1396. /* increment @pdev level */
  1397. pool_id = wbm_err_info.pool_id;
  1398. dp_pdev = dp_get_pdev_for_mac_id(soc, pool_id);
  1399. if (dp_pdev)
  1400. DP_STATS_INC(dp_pdev,
  1401. err.rxdma_error, 1);
  1402. switch (wbm_err_info.rxdma_err_code) {
  1403. case HAL_RXDMA_ERR_UNENCRYPTED:
  1404. case HAL_RXDMA_ERR_WIFI_PARSE:
  1405. pool_id = wbm_err_info.pool_id;
  1406. dp_rx_process_rxdma_err(soc, nbuf,
  1407. rx_tlv_hdr,
  1408. peer,
  1409. wbm_err_info.
  1410. rxdma_err_code,
  1411. pool_id);
  1412. nbuf = next;
  1413. if (peer)
  1414. dp_peer_unref_del_find_by_id(peer);
  1415. continue;
  1416. case HAL_RXDMA_ERR_TKIP_MIC:
  1417. dp_rx_process_mic_error(soc, nbuf,
  1418. rx_tlv_hdr,
  1419. peer);
  1420. nbuf = next;
  1421. if (peer) {
  1422. DP_STATS_INC(peer, rx.err.mic_err, 1);
  1423. dp_peer_unref_del_find_by_id(
  1424. peer);
  1425. }
  1426. continue;
  1427. case HAL_RXDMA_ERR_DECRYPT:
  1428. pool_id = wbm_err_info.pool_id;
  1429. e_code = wbm_err_info.rxdma_err_code;
  1430. tlv_hdr = rx_tlv_hdr;
  1431. if (peer) {
  1432. DP_STATS_INC(peer, rx.err.
  1433. decrypt_err, 1);
  1434. } else {
  1435. dp_rx_process_rxdma_err(soc,
  1436. nbuf,
  1437. tlv_hdr,
  1438. NULL,
  1439. e_code,
  1440. pool_id
  1441. );
  1442. nbuf = next;
  1443. continue;
  1444. }
  1445. QDF_TRACE(QDF_MODULE_ID_DP,
  1446. QDF_TRACE_LEVEL_DEBUG,
  1447. "Packet received with Decrypt error");
  1448. break;
  1449. default:
  1450. dp_err_rl("RXDMA error %d",
  1451. wbm_err_info.rxdma_err_code);
  1452. }
  1453. }
  1454. } else {
  1455. /* Should not come here */
  1456. qdf_assert(0);
  1457. }
  1458. if (peer)
  1459. dp_peer_unref_del_find_by_id(peer);
  1460. hal_rx_dump_pkt_tlvs(hal_soc, rx_tlv_hdr,
  1461. QDF_TRACE_LEVEL_DEBUG);
  1462. qdf_nbuf_free(nbuf);
  1463. nbuf = next;
  1464. }
  1465. return rx_bufs_used; /* Assume no scale factor for now */
  1466. }
  1467. /**
  1468. * dup_desc_dbg() - dump and assert if duplicate rx desc found
  1469. *
  1470. * @soc: core DP main context
  1471. * @rxdma_dst_ring_desc: void pointer to monitor link descriptor buf addr info
  1472. * @rx_desc: void pointer to rx descriptor
  1473. *
  1474. * Return: void
  1475. */
  1476. static void dup_desc_dbg(struct dp_soc *soc,
  1477. hal_rxdma_desc_t rxdma_dst_ring_desc,
  1478. void *rx_desc)
  1479. {
  1480. DP_STATS_INC(soc, rx.err.hal_rxdma_err_dup, 1);
  1481. dp_rx_dump_info_and_assert(
  1482. soc,
  1483. soc->rx_rel_ring.hal_srng,
  1484. hal_rxdma_desc_to_hal_ring_desc(rxdma_dst_ring_desc),
  1485. rx_desc);
  1486. }
  1487. /**
  1488. * dp_rx_err_mpdu_pop() - extract the MSDU's from link descs
  1489. *
  1490. * @soc: core DP main context
  1491. * @mac_id: mac id which is one of 3 mac_ids
  1492. * @rxdma_dst_ring_desc: void pointer to monitor link descriptor buf addr info
  1493. * @head: head of descs list to be freed
  1494. * @tail: tail of decs list to be freed
  1495. * Return: number of msdu in MPDU to be popped
  1496. */
  1497. static inline uint32_t
  1498. dp_rx_err_mpdu_pop(struct dp_soc *soc, uint32_t mac_id,
  1499. hal_rxdma_desc_t rxdma_dst_ring_desc,
  1500. union dp_rx_desc_list_elem_t **head,
  1501. union dp_rx_desc_list_elem_t **tail)
  1502. {
  1503. void *rx_msdu_link_desc;
  1504. qdf_nbuf_t msdu;
  1505. qdf_nbuf_t last;
  1506. struct hal_rx_msdu_list msdu_list;
  1507. uint16_t num_msdus;
  1508. struct hal_buf_info buf_info;
  1509. uint32_t rx_bufs_used = 0;
  1510. uint32_t msdu_cnt;
  1511. uint32_t i;
  1512. uint8_t push_reason;
  1513. uint8_t rxdma_error_code = 0;
  1514. uint8_t bm_action = HAL_BM_ACTION_PUT_IN_IDLE_LIST;
  1515. struct dp_pdev *pdev = dp_get_pdev_for_mac_id(soc, mac_id);
  1516. uint32_t rx_link_buf_info[HAL_RX_BUFFINFO_NUM_DWORDS];
  1517. hal_rxdma_desc_t ring_desc;
  1518. msdu = 0;
  1519. last = NULL;
  1520. hal_rx_reo_ent_buf_paddr_get(rxdma_dst_ring_desc, &buf_info,
  1521. &msdu_cnt);
  1522. push_reason =
  1523. hal_rx_reo_ent_rxdma_push_reason_get(rxdma_dst_ring_desc);
  1524. if (push_reason == HAL_RX_WBM_RXDMA_PSH_RSN_ERROR) {
  1525. rxdma_error_code =
  1526. hal_rx_reo_ent_rxdma_error_code_get(rxdma_dst_ring_desc);
  1527. }
  1528. do {
  1529. rx_msdu_link_desc =
  1530. dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  1531. qdf_assert(rx_msdu_link_desc);
  1532. hal_rx_msdu_list_get(soc->hal_soc, rx_msdu_link_desc,
  1533. &msdu_list, &num_msdus);
  1534. if (msdu_list.sw_cookie[0] != HAL_RX_COOKIE_SPECIAL) {
  1535. /* if the msdus belongs to NSS offloaded radio &&
  1536. * the rbm is not SW1_BM then return the msdu_link
  1537. * descriptor without freeing the msdus (nbufs). let
  1538. * these buffers be given to NSS completion ring for
  1539. * NSS to free them.
  1540. * else iterate through the msdu link desc list and
  1541. * free each msdu in the list.
  1542. */
  1543. if (msdu_list.rbm[0] != HAL_RX_BUF_RBM_SW3_BM &&
  1544. wlan_cfg_get_dp_pdev_nss_enabled(
  1545. pdev->wlan_cfg_ctx))
  1546. bm_action = HAL_BM_ACTION_RELEASE_MSDU_LIST;
  1547. else {
  1548. for (i = 0; i < num_msdus; i++) {
  1549. struct dp_rx_desc *rx_desc =
  1550. dp_rx_cookie_2_va_rxdma_buf(soc,
  1551. msdu_list.sw_cookie[i]);
  1552. qdf_assert_always(rx_desc);
  1553. msdu = rx_desc->nbuf;
  1554. /*
  1555. * this is a unlikely scenario
  1556. * where the host is reaping
  1557. * a descriptor which
  1558. * it already reaped just a while ago
  1559. * but is yet to replenish
  1560. * it back to HW.
  1561. * In this case host will dump
  1562. * the last 128 descriptors
  1563. * including the software descriptor
  1564. * rx_desc and assert.
  1565. */
  1566. ring_desc = rxdma_dst_ring_desc;
  1567. if (qdf_unlikely(!rx_desc->in_use)) {
  1568. dup_desc_dbg(soc,
  1569. ring_desc,
  1570. rx_desc);
  1571. continue;
  1572. }
  1573. qdf_nbuf_unmap_single(soc->osdev, msdu,
  1574. QDF_DMA_FROM_DEVICE);
  1575. QDF_TRACE(QDF_MODULE_ID_DP,
  1576. QDF_TRACE_LEVEL_DEBUG,
  1577. "[%s][%d] msdu_nbuf=%pK ",
  1578. __func__, __LINE__, msdu);
  1579. qdf_nbuf_free(msdu);
  1580. rx_bufs_used++;
  1581. dp_rx_add_to_free_desc_list(head,
  1582. tail, rx_desc);
  1583. }
  1584. }
  1585. } else {
  1586. rxdma_error_code = HAL_RXDMA_ERR_WAR;
  1587. }
  1588. /*
  1589. * Store the current link buffer into to the local structure
  1590. * to be used for release purpose.
  1591. */
  1592. hal_rxdma_buff_addr_info_set(rx_link_buf_info, buf_info.paddr,
  1593. buf_info.sw_cookie, buf_info.rbm);
  1594. hal_rx_mon_next_link_desc_get(rx_msdu_link_desc, &buf_info);
  1595. dp_rx_link_desc_return_by_addr(soc,
  1596. (hal_buff_addrinfo_t)
  1597. rx_link_buf_info,
  1598. bm_action);
  1599. } while (buf_info.paddr);
  1600. DP_STATS_INC(soc, rx.err.rxdma_error[rxdma_error_code], 1);
  1601. if (pdev)
  1602. DP_STATS_INC(pdev, err.rxdma_error, 1);
  1603. if (rxdma_error_code == HAL_RXDMA_ERR_DECRYPT) {
  1604. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1605. "Packet received with Decrypt error");
  1606. }
  1607. return rx_bufs_used;
  1608. }
  1609. uint32_t
  1610. dp_rxdma_err_process(struct dp_intr *int_ctx, struct dp_soc *soc,
  1611. uint32_t mac_id, uint32_t quota)
  1612. {
  1613. struct dp_pdev *pdev = dp_get_pdev_for_mac_id(soc, mac_id);
  1614. int mac_for_pdev = dp_get_mac_id_for_mac(soc, mac_id);
  1615. hal_rxdma_desc_t rxdma_dst_ring_desc;
  1616. hal_soc_handle_t hal_soc;
  1617. void *err_dst_srng;
  1618. union dp_rx_desc_list_elem_t *head = NULL;
  1619. union dp_rx_desc_list_elem_t *tail = NULL;
  1620. struct dp_srng *dp_rxdma_srng;
  1621. struct rx_desc_pool *rx_desc_pool;
  1622. uint32_t work_done = 0;
  1623. uint32_t rx_bufs_used = 0;
  1624. if (!pdev)
  1625. return 0;
  1626. err_dst_srng = pdev->rxdma_err_dst_ring[mac_for_pdev].hal_srng;
  1627. if (!err_dst_srng) {
  1628. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1629. "%s %d : HAL Monitor Destination Ring Init \
  1630. Failed -- %pK",
  1631. __func__, __LINE__, err_dst_srng);
  1632. return 0;
  1633. }
  1634. hal_soc = soc->hal_soc;
  1635. qdf_assert(hal_soc);
  1636. if (qdf_unlikely(dp_srng_access_start(int_ctx, soc, err_dst_srng))) {
  1637. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1638. "%s %d : HAL Monitor Destination Ring Init \
  1639. Failed -- %pK",
  1640. __func__, __LINE__, err_dst_srng);
  1641. return 0;
  1642. }
  1643. while (qdf_likely(quota-- && (rxdma_dst_ring_desc =
  1644. hal_srng_dst_get_next(hal_soc, err_dst_srng)))) {
  1645. rx_bufs_used += dp_rx_err_mpdu_pop(soc, mac_id,
  1646. rxdma_dst_ring_desc,
  1647. &head, &tail);
  1648. }
  1649. dp_srng_access_end(int_ctx, soc, err_dst_srng);
  1650. if (rx_bufs_used) {
  1651. dp_rxdma_srng = &pdev->rx_refill_buf_ring;
  1652. rx_desc_pool = &soc->rx_desc_buf[mac_id];
  1653. dp_rx_buffers_replenish(soc, mac_id, dp_rxdma_srng,
  1654. rx_desc_pool, rx_bufs_used, &head, &tail);
  1655. work_done += rx_bufs_used;
  1656. }
  1657. return work_done;
  1658. }
  1659. static inline uint32_t
  1660. dp_wbm_int_err_mpdu_pop(struct dp_soc *soc, uint32_t mac_id,
  1661. hal_rxdma_desc_t rxdma_dst_ring_desc,
  1662. union dp_rx_desc_list_elem_t **head,
  1663. union dp_rx_desc_list_elem_t **tail)
  1664. {
  1665. void *rx_msdu_link_desc;
  1666. qdf_nbuf_t msdu;
  1667. qdf_nbuf_t last;
  1668. struct hal_rx_msdu_list msdu_list;
  1669. uint16_t num_msdus;
  1670. struct hal_buf_info buf_info;
  1671. uint32_t rx_bufs_used = 0, msdu_cnt, i;
  1672. uint32_t rx_link_buf_info[HAL_RX_BUFFINFO_NUM_DWORDS];
  1673. msdu = 0;
  1674. last = NULL;
  1675. hal_rx_reo_ent_buf_paddr_get(rxdma_dst_ring_desc, &buf_info,
  1676. &msdu_cnt);
  1677. do {
  1678. rx_msdu_link_desc =
  1679. dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  1680. if (!rx_msdu_link_desc) {
  1681. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_NULL_LINK_DESC], 1);
  1682. break;
  1683. }
  1684. hal_rx_msdu_list_get(soc->hal_soc, rx_msdu_link_desc,
  1685. &msdu_list, &num_msdus);
  1686. if (msdu_list.sw_cookie[0] != HAL_RX_COOKIE_SPECIAL) {
  1687. for (i = 0; i < num_msdus; i++) {
  1688. struct dp_rx_desc *rx_desc =
  1689. dp_rx_cookie_2_va_rxdma_buf(
  1690. soc,
  1691. msdu_list.sw_cookie[i]);
  1692. qdf_assert_always(rx_desc);
  1693. msdu = rx_desc->nbuf;
  1694. qdf_nbuf_unmap_single(soc->osdev, msdu,
  1695. QDF_DMA_FROM_DEVICE);
  1696. qdf_nbuf_free(msdu);
  1697. rx_bufs_used++;
  1698. dp_rx_add_to_free_desc_list(head,
  1699. tail, rx_desc);
  1700. }
  1701. }
  1702. /*
  1703. * Store the current link buffer into to the local structure
  1704. * to be used for release purpose.
  1705. */
  1706. hal_rxdma_buff_addr_info_set(rx_link_buf_info, buf_info.paddr,
  1707. buf_info.sw_cookie, buf_info.rbm);
  1708. hal_rx_mon_next_link_desc_get(rx_msdu_link_desc, &buf_info);
  1709. dp_rx_link_desc_return_by_addr(soc, (hal_buff_addrinfo_t)
  1710. rx_link_buf_info,
  1711. HAL_BM_ACTION_PUT_IN_IDLE_LIST);
  1712. } while (buf_info.paddr);
  1713. return rx_bufs_used;
  1714. }
  1715. /*
  1716. *
  1717. * dp_handle_wbm_internal_error() - handles wbm_internal_error case
  1718. *
  1719. * @soc: core DP main context
  1720. * @hal_desc: hal descriptor
  1721. * @buf_type: indicates if the buffer is of type link disc or msdu
  1722. * Return: None
  1723. *
  1724. * wbm_internal_error is seen in following scenarios :
  1725. *
  1726. * 1. Null pointers detected in WBM_RELEASE_RING descriptors
  1727. * 2. Null pointers detected during delinking process
  1728. *
  1729. * Some null pointer cases:
  1730. *
  1731. * a. MSDU buffer pointer is NULL
  1732. * b. Next_MSDU_Link_Desc pointer is NULL, with no last msdu flag
  1733. * c. MSDU buffer pointer is NULL or Next_Link_Desc pointer is NULL
  1734. */
  1735. void
  1736. dp_handle_wbm_internal_error(struct dp_soc *soc, void *hal_desc,
  1737. uint32_t buf_type)
  1738. {
  1739. struct hal_buf_info buf_info = {0};
  1740. struct dp_pdev *dp_pdev;
  1741. struct dp_rx_desc *rx_desc = NULL;
  1742. uint32_t rx_buf_cookie;
  1743. uint32_t rx_bufs_reaped = 0;
  1744. union dp_rx_desc_list_elem_t *head = NULL;
  1745. union dp_rx_desc_list_elem_t *tail = NULL;
  1746. uint8_t pool_id;
  1747. hal_rx_reo_buf_paddr_get(hal_desc, &buf_info);
  1748. if (!buf_info.paddr) {
  1749. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_NULL_BUFFER], 1);
  1750. return;
  1751. }
  1752. rx_buf_cookie = HAL_RX_REO_BUF_COOKIE_GET(hal_desc);
  1753. pool_id = DP_RX_DESC_COOKIE_POOL_ID_GET(rx_buf_cookie);
  1754. if (buf_type == HAL_WBM_RELEASE_RING_2_BUFFER_TYPE) {
  1755. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_NULL_MSDU_BUFF], 1);
  1756. rx_desc = dp_rx_cookie_2_va_rxdma_buf(soc, rx_buf_cookie);
  1757. if (rx_desc && rx_desc->nbuf) {
  1758. qdf_nbuf_unmap_single(soc->osdev, rx_desc->nbuf,
  1759. QDF_DMA_FROM_DEVICE);
  1760. rx_desc->unmapped = 1;
  1761. qdf_nbuf_free(rx_desc->nbuf);
  1762. dp_rx_add_to_free_desc_list(&head,
  1763. &tail,
  1764. rx_desc);
  1765. rx_bufs_reaped++;
  1766. }
  1767. } else if (buf_type == HAL_WBM_RELEASE_RING_2_DESC_TYPE) {
  1768. rx_bufs_reaped = dp_wbm_int_err_mpdu_pop(soc, pool_id,
  1769. hal_desc,
  1770. &head, &tail);
  1771. }
  1772. if (rx_bufs_reaped) {
  1773. struct rx_desc_pool *rx_desc_pool;
  1774. struct dp_srng *dp_rxdma_srng;
  1775. DP_STATS_INC(soc, tx.wbm_internal_error[WBM_INT_ERROR_REO_BUFF_REAPED], 1);
  1776. dp_pdev = soc->pdev_list[pool_id];
  1777. dp_rxdma_srng = &dp_pdev->rx_refill_buf_ring;
  1778. rx_desc_pool = &soc->rx_desc_buf[pool_id];
  1779. dp_rx_buffers_replenish(soc, pool_id, dp_rxdma_srng,
  1780. rx_desc_pool,
  1781. rx_bufs_reaped,
  1782. &head, &tail);
  1783. }
  1784. }