dp_rx_defrag.c 50 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845
  1. /*
  2. * Copyright (c) 2017-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 "hal_api.h"
  23. #include "qdf_trace.h"
  24. #include "qdf_nbuf.h"
  25. #include "dp_internal.h"
  26. #include "dp_rx_defrag.h"
  27. #include <enet.h> /* LLC_SNAP_HDR_LEN */
  28. #include "dp_rx_defrag.h"
  29. #include "dp_ipa.h"
  30. const struct dp_rx_defrag_cipher dp_f_ccmp = {
  31. "AES-CCM",
  32. IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN + IEEE80211_WEP_EXTIVLEN,
  33. IEEE80211_WEP_MICLEN,
  34. 0,
  35. };
  36. const struct dp_rx_defrag_cipher dp_f_tkip = {
  37. "TKIP",
  38. IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN + IEEE80211_WEP_EXTIVLEN,
  39. IEEE80211_WEP_CRCLEN,
  40. IEEE80211_WEP_MICLEN,
  41. };
  42. const struct dp_rx_defrag_cipher dp_f_wep = {
  43. "WEP",
  44. IEEE80211_WEP_IVLEN + IEEE80211_WEP_KIDLEN,
  45. IEEE80211_WEP_CRCLEN,
  46. 0,
  47. };
  48. /*
  49. * dp_rx_defrag_frames_free(): Free fragment chain
  50. * @frames: Fragment chain
  51. *
  52. * Iterates through the fragment chain and frees them
  53. * Returns: None
  54. */
  55. static void dp_rx_defrag_frames_free(qdf_nbuf_t frames)
  56. {
  57. qdf_nbuf_t next, frag = frames;
  58. while (frag) {
  59. next = qdf_nbuf_next(frag);
  60. qdf_nbuf_free(frag);
  61. frag = next;
  62. }
  63. }
  64. /*
  65. * dp_rx_clear_saved_desc_info(): Clears descriptor info
  66. * @peer: Pointer to the peer data structure
  67. * @tid: Transmit ID (TID)
  68. *
  69. * Saves MPDU descriptor info and MSDU link pointer from REO
  70. * ring descriptor. The cache is created per peer, per TID
  71. *
  72. * Returns: None
  73. */
  74. static void dp_rx_clear_saved_desc_info(struct dp_peer *peer, unsigned tid)
  75. {
  76. if (peer->rx_tid[tid].dst_ring_desc)
  77. qdf_mem_free(peer->rx_tid[tid].dst_ring_desc);
  78. peer->rx_tid[tid].dst_ring_desc = NULL;
  79. peer->rx_tid[tid].head_frag_desc = NULL;
  80. }
  81. static void dp_rx_return_head_frag_desc(struct dp_peer *peer,
  82. unsigned int tid)
  83. {
  84. struct dp_soc *soc;
  85. struct dp_pdev *pdev;
  86. struct dp_srng *dp_rxdma_srng;
  87. struct rx_desc_pool *rx_desc_pool;
  88. union dp_rx_desc_list_elem_t *head = NULL;
  89. union dp_rx_desc_list_elem_t *tail = NULL;
  90. pdev = peer->vdev->pdev;
  91. soc = pdev->soc;
  92. if (peer->rx_tid[tid].head_frag_desc) {
  93. dp_rxdma_srng = &pdev->rx_refill_buf_ring;
  94. rx_desc_pool = &soc->rx_desc_buf[pdev->pdev_id];
  95. dp_rx_add_to_free_desc_list(&head, &tail,
  96. peer->rx_tid[tid].head_frag_desc);
  97. dp_rx_buffers_replenish(soc, 0, dp_rxdma_srng, rx_desc_pool,
  98. 1, &head, &tail);
  99. }
  100. if (peer->rx_tid[tid].dst_ring_desc) {
  101. if (dp_rx_link_desc_return(soc,
  102. peer->rx_tid[tid].dst_ring_desc,
  103. HAL_BM_ACTION_PUT_IN_IDLE_LIST) !=
  104. QDF_STATUS_SUCCESS)
  105. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  106. "%s: Failed to return link desc", __func__);
  107. }
  108. }
  109. /*
  110. * dp_rx_reorder_flush_frag(): Flush the frag list
  111. * @peer: Pointer to the peer data structure
  112. * @tid: Transmit ID (TID)
  113. *
  114. * Flush the per-TID frag list
  115. *
  116. * Returns: None
  117. */
  118. void dp_rx_reorder_flush_frag(struct dp_peer *peer,
  119. unsigned int tid)
  120. {
  121. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO_HIGH,
  122. FL("Flushing TID %d"), tid);
  123. if (!peer) {
  124. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  125. "%s: NULL peer", __func__);
  126. return;
  127. }
  128. dp_rx_return_head_frag_desc(peer, tid);
  129. dp_rx_defrag_cleanup(peer, tid);
  130. }
  131. /*
  132. * dp_rx_defrag_waitlist_flush(): Flush SOC defrag wait list
  133. * @soc: DP SOC
  134. *
  135. * Flush fragments of all waitlisted TID's
  136. *
  137. * Returns: None
  138. */
  139. void dp_rx_defrag_waitlist_flush(struct dp_soc *soc)
  140. {
  141. struct dp_rx_tid *rx_reorder = NULL;
  142. struct dp_rx_tid *tmp;
  143. uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
  144. TAILQ_HEAD(, dp_rx_tid) temp_list;
  145. TAILQ_INIT(&temp_list);
  146. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG,
  147. FL("Current time %u"), now_ms);
  148. qdf_spin_lock_bh(&soc->rx.defrag.defrag_lock);
  149. TAILQ_FOREACH_SAFE(rx_reorder, &soc->rx.defrag.waitlist,
  150. defrag_waitlist_elem, tmp) {
  151. uint32_t tid;
  152. if (rx_reorder->defrag_timeout_ms > now_ms)
  153. break;
  154. tid = rx_reorder->tid;
  155. if (tid >= DP_MAX_TIDS) {
  156. qdf_assert(0);
  157. continue;
  158. }
  159. TAILQ_REMOVE(&soc->rx.defrag.waitlist, rx_reorder,
  160. defrag_waitlist_elem);
  161. DP_STATS_DEC(soc, rx.rx_frag_wait, 1);
  162. /* Move to temp list and clean-up later */
  163. TAILQ_INSERT_TAIL(&temp_list, rx_reorder,
  164. defrag_waitlist_elem);
  165. }
  166. if (rx_reorder) {
  167. soc->rx.defrag.next_flush_ms =
  168. rx_reorder->defrag_timeout_ms;
  169. } else {
  170. soc->rx.defrag.next_flush_ms =
  171. now_ms + soc->rx.defrag.timeout_ms;
  172. }
  173. qdf_spin_unlock_bh(&soc->rx.defrag.defrag_lock);
  174. TAILQ_FOREACH_SAFE(rx_reorder, &temp_list,
  175. defrag_waitlist_elem, tmp) {
  176. struct dp_peer *peer, *temp_peer = NULL;
  177. qdf_spin_lock_bh(&rx_reorder->tid_lock);
  178. TAILQ_REMOVE(&temp_list, rx_reorder,
  179. defrag_waitlist_elem);
  180. /* get address of current peer */
  181. peer =
  182. container_of(rx_reorder, struct dp_peer,
  183. rx_tid[rx_reorder->tid]);
  184. qdf_spin_unlock_bh(&rx_reorder->tid_lock);
  185. temp_peer = dp_peer_find_by_id(soc, peer->peer_ids[0]);
  186. if (temp_peer == peer) {
  187. qdf_spin_lock_bh(&rx_reorder->tid_lock);
  188. dp_rx_reorder_flush_frag(peer, rx_reorder->tid);
  189. qdf_spin_unlock_bh(&rx_reorder->tid_lock);
  190. }
  191. if (temp_peer)
  192. dp_peer_unref_del_find_by_id(temp_peer);
  193. }
  194. }
  195. /*
  196. * dp_rx_defrag_waitlist_add(): Update per-PDEV defrag wait list
  197. * @peer: Pointer to the peer data structure
  198. * @tid: Transmit ID (TID)
  199. *
  200. * Appends per-tid fragments to global fragment wait list
  201. *
  202. * Returns: None
  203. */
  204. static void dp_rx_defrag_waitlist_add(struct dp_peer *peer, unsigned tid)
  205. {
  206. struct dp_soc *psoc = peer->vdev->pdev->soc;
  207. struct dp_rx_tid *rx_reorder = &peer->rx_tid[tid];
  208. dp_debug("Adding TID %u to waitlist for peer %pK at MAC address %pM",
  209. tid, peer, peer->mac_addr.raw);
  210. /* TODO: use LIST macros instead of TAIL macros */
  211. qdf_spin_lock_bh(&psoc->rx.defrag.defrag_lock);
  212. if (TAILQ_EMPTY(&psoc->rx.defrag.waitlist))
  213. psoc->rx.defrag.next_flush_ms = rx_reorder->defrag_timeout_ms;
  214. TAILQ_INSERT_TAIL(&psoc->rx.defrag.waitlist, rx_reorder,
  215. defrag_waitlist_elem);
  216. DP_STATS_INC(psoc, rx.rx_frag_wait, 1);
  217. qdf_spin_unlock_bh(&psoc->rx.defrag.defrag_lock);
  218. }
  219. /*
  220. * dp_rx_defrag_waitlist_remove(): Remove fragments from waitlist
  221. * @peer: Pointer to the peer data structure
  222. * @tid: Transmit ID (TID)
  223. *
  224. * Remove fragments from waitlist
  225. *
  226. * Returns: None
  227. */
  228. void dp_rx_defrag_waitlist_remove(struct dp_peer *peer, unsigned tid)
  229. {
  230. struct dp_pdev *pdev = peer->vdev->pdev;
  231. struct dp_soc *soc = pdev->soc;
  232. struct dp_rx_tid *rx_reorder;
  233. struct dp_rx_tid *tmp;
  234. dp_debug("Removing TID %u to waitlist for peer %pK at MAC address %pM",
  235. tid, peer, peer->mac_addr.raw);
  236. if (tid >= DP_MAX_TIDS) {
  237. dp_err("TID out of bounds: %d", tid);
  238. qdf_assert_always(0);
  239. }
  240. qdf_spin_lock_bh(&soc->rx.defrag.defrag_lock);
  241. TAILQ_FOREACH_SAFE(rx_reorder, &soc->rx.defrag.waitlist,
  242. defrag_waitlist_elem, tmp) {
  243. struct dp_peer *peer_on_waitlist;
  244. /* get address of current peer */
  245. peer_on_waitlist =
  246. container_of(rx_reorder, struct dp_peer,
  247. rx_tid[rx_reorder->tid]);
  248. /* Ensure it is TID for same peer */
  249. if (peer_on_waitlist == peer && rx_reorder->tid == tid) {
  250. TAILQ_REMOVE(&soc->rx.defrag.waitlist,
  251. rx_reorder, defrag_waitlist_elem);
  252. DP_STATS_DEC(soc, rx.rx_frag_wait, 1);
  253. }
  254. }
  255. qdf_spin_unlock_bh(&soc->rx.defrag.defrag_lock);
  256. }
  257. /*
  258. * dp_rx_defrag_fraglist_insert(): Create a per-sequence fragment list
  259. * @peer: Pointer to the peer data structure
  260. * @tid: Transmit ID (TID)
  261. * @head_addr: Pointer to head list
  262. * @tail_addr: Pointer to tail list
  263. * @frag: Incoming fragment
  264. * @all_frag_present: Flag to indicate whether all fragments are received
  265. *
  266. * Build a per-tid, per-sequence fragment list.
  267. *
  268. * Returns: Success, if inserted
  269. */
  270. static QDF_STATUS dp_rx_defrag_fraglist_insert(struct dp_peer *peer, unsigned tid,
  271. qdf_nbuf_t *head_addr, qdf_nbuf_t *tail_addr, qdf_nbuf_t frag,
  272. uint8_t *all_frag_present)
  273. {
  274. qdf_nbuf_t next;
  275. qdf_nbuf_t prev = NULL;
  276. qdf_nbuf_t cur;
  277. uint16_t head_fragno, cur_fragno, next_fragno;
  278. uint8_t last_morefrag = 1, count = 0;
  279. struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
  280. uint8_t *rx_desc_info;
  281. qdf_assert(frag);
  282. qdf_assert(head_addr);
  283. qdf_assert(tail_addr);
  284. *all_frag_present = 0;
  285. rx_desc_info = qdf_nbuf_data(frag);
  286. cur_fragno = dp_rx_frag_get_mpdu_frag_number(rx_desc_info);
  287. /* If this is the first fragment */
  288. if (!(*head_addr)) {
  289. *head_addr = *tail_addr = frag;
  290. qdf_nbuf_set_next(*tail_addr, NULL);
  291. rx_tid->curr_frag_num = cur_fragno;
  292. goto insert_done;
  293. }
  294. /* In sequence fragment */
  295. if (cur_fragno > rx_tid->curr_frag_num) {
  296. qdf_nbuf_set_next(*tail_addr, frag);
  297. *tail_addr = frag;
  298. qdf_nbuf_set_next(*tail_addr, NULL);
  299. rx_tid->curr_frag_num = cur_fragno;
  300. } else {
  301. /* Out of sequence fragment */
  302. cur = *head_addr;
  303. rx_desc_info = qdf_nbuf_data(cur);
  304. head_fragno = dp_rx_frag_get_mpdu_frag_number(rx_desc_info);
  305. if (cur_fragno == head_fragno) {
  306. qdf_nbuf_free(frag);
  307. goto insert_fail;
  308. } else if (head_fragno > cur_fragno) {
  309. qdf_nbuf_set_next(frag, cur);
  310. cur = frag;
  311. *head_addr = frag; /* head pointer to be updated */
  312. } else {
  313. while ((cur_fragno > head_fragno) && cur) {
  314. prev = cur;
  315. cur = qdf_nbuf_next(cur);
  316. rx_desc_info = qdf_nbuf_data(cur);
  317. head_fragno =
  318. dp_rx_frag_get_mpdu_frag_number(
  319. rx_desc_info);
  320. }
  321. if (cur_fragno == head_fragno) {
  322. qdf_nbuf_free(frag);
  323. goto insert_fail;
  324. }
  325. qdf_nbuf_set_next(prev, frag);
  326. qdf_nbuf_set_next(frag, cur);
  327. }
  328. }
  329. next = qdf_nbuf_next(*head_addr);
  330. rx_desc_info = qdf_nbuf_data(*tail_addr);
  331. last_morefrag = dp_rx_frag_get_more_frag_bit(rx_desc_info);
  332. /* TODO: optimize the loop */
  333. if (!last_morefrag) {
  334. /* Check if all fragments are present */
  335. do {
  336. rx_desc_info = qdf_nbuf_data(next);
  337. next_fragno =
  338. dp_rx_frag_get_mpdu_frag_number(rx_desc_info);
  339. count++;
  340. if (next_fragno != count)
  341. break;
  342. next = qdf_nbuf_next(next);
  343. } while (next);
  344. if (!next) {
  345. *all_frag_present = 1;
  346. return QDF_STATUS_SUCCESS;
  347. }
  348. }
  349. insert_done:
  350. return QDF_STATUS_SUCCESS;
  351. insert_fail:
  352. return QDF_STATUS_E_FAILURE;
  353. }
  354. /*
  355. * dp_rx_defrag_tkip_decap(): decap tkip encrypted fragment
  356. * @msdu: Pointer to the fragment
  357. * @hdrlen: 802.11 header length (mostly useful in 4 addr frames)
  358. *
  359. * decap tkip encrypted fragment
  360. *
  361. * Returns: QDF_STATUS
  362. */
  363. static QDF_STATUS dp_rx_defrag_tkip_decap(qdf_nbuf_t msdu, uint16_t hdrlen)
  364. {
  365. uint8_t *ivp, *orig_hdr;
  366. int rx_desc_len = sizeof(struct rx_pkt_tlvs);
  367. /* start of 802.11 header info */
  368. orig_hdr = (uint8_t *)(qdf_nbuf_data(msdu) + rx_desc_len);
  369. /* TKIP header is located post 802.11 header */
  370. ivp = orig_hdr + hdrlen;
  371. if (!(ivp[IEEE80211_WEP_IVLEN] & IEEE80211_WEP_EXTIV)) {
  372. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  373. "IEEE80211_WEP_EXTIV is missing in TKIP fragment");
  374. return QDF_STATUS_E_DEFRAG_ERROR;
  375. }
  376. qdf_nbuf_trim_tail(msdu, dp_f_tkip.ic_trailer);
  377. return QDF_STATUS_SUCCESS;
  378. }
  379. /*
  380. * dp_rx_defrag_ccmp_demic(): Remove MIC information from CCMP fragment
  381. * @nbuf: Pointer to the fragment buffer
  382. * @hdrlen: 802.11 header length (mostly useful in 4 addr frames)
  383. *
  384. * Remove MIC information from CCMP fragment
  385. *
  386. * Returns: QDF_STATUS
  387. */
  388. static QDF_STATUS dp_rx_defrag_ccmp_demic(qdf_nbuf_t nbuf, uint16_t hdrlen)
  389. {
  390. uint8_t *ivp, *orig_hdr;
  391. int rx_desc_len = sizeof(struct rx_pkt_tlvs);
  392. /* start of the 802.11 header */
  393. orig_hdr = (uint8_t *)(qdf_nbuf_data(nbuf) + rx_desc_len);
  394. /* CCMP header is located after 802.11 header */
  395. ivp = orig_hdr + hdrlen;
  396. if (!(ivp[IEEE80211_WEP_IVLEN] & IEEE80211_WEP_EXTIV))
  397. return QDF_STATUS_E_DEFRAG_ERROR;
  398. qdf_nbuf_trim_tail(nbuf, dp_f_ccmp.ic_trailer);
  399. return QDF_STATUS_SUCCESS;
  400. }
  401. /*
  402. * dp_rx_defrag_ccmp_decap(): decap CCMP encrypted fragment
  403. * @nbuf: Pointer to the fragment
  404. * @hdrlen: length of the header information
  405. *
  406. * decap CCMP encrypted fragment
  407. *
  408. * Returns: QDF_STATUS
  409. */
  410. static QDF_STATUS dp_rx_defrag_ccmp_decap(qdf_nbuf_t nbuf, uint16_t hdrlen)
  411. {
  412. uint8_t *ivp, *origHdr;
  413. int rx_desc_len = sizeof(struct rx_pkt_tlvs);
  414. origHdr = (uint8_t *) (qdf_nbuf_data(nbuf) + rx_desc_len);
  415. ivp = origHdr + hdrlen;
  416. if (!(ivp[IEEE80211_WEP_IVLEN] & IEEE80211_WEP_EXTIV))
  417. return QDF_STATUS_E_DEFRAG_ERROR;
  418. /* Let's pull the header later */
  419. return QDF_STATUS_SUCCESS;
  420. }
  421. /*
  422. * dp_rx_defrag_wep_decap(): decap WEP encrypted fragment
  423. * @msdu: Pointer to the fragment
  424. * @hdrlen: length of the header information
  425. *
  426. * decap WEP encrypted fragment
  427. *
  428. * Returns: QDF_STATUS
  429. */
  430. static QDF_STATUS dp_rx_defrag_wep_decap(qdf_nbuf_t msdu, uint16_t hdrlen)
  431. {
  432. uint8_t *origHdr;
  433. int rx_desc_len = sizeof(struct rx_pkt_tlvs);
  434. origHdr = (uint8_t *) (qdf_nbuf_data(msdu) + rx_desc_len);
  435. qdf_mem_move(origHdr + dp_f_wep.ic_header, origHdr, hdrlen);
  436. qdf_nbuf_trim_tail(msdu, dp_f_wep.ic_trailer);
  437. return QDF_STATUS_SUCCESS;
  438. }
  439. /*
  440. * dp_rx_defrag_hdrsize(): Calculate the header size of the received fragment
  441. * @soc: soc handle
  442. * @nbuf: Pointer to the fragment
  443. *
  444. * Calculate the header size of the received fragment
  445. *
  446. * Returns: header size (uint16_t)
  447. */
  448. static uint16_t dp_rx_defrag_hdrsize(struct dp_soc *soc, qdf_nbuf_t nbuf)
  449. {
  450. uint8_t *rx_tlv_hdr = qdf_nbuf_data(nbuf);
  451. uint16_t size = sizeof(struct ieee80211_frame);
  452. uint16_t fc = 0;
  453. uint32_t to_ds, fr_ds;
  454. uint8_t frm_ctrl_valid;
  455. uint16_t frm_ctrl_field;
  456. to_ds = hal_rx_mpdu_get_to_ds(soc->hal_soc, rx_tlv_hdr);
  457. fr_ds = hal_rx_mpdu_get_fr_ds(soc->hal_soc, rx_tlv_hdr);
  458. frm_ctrl_valid =
  459. hal_rx_get_mpdu_frame_control_valid(soc->hal_soc,
  460. rx_tlv_hdr);
  461. frm_ctrl_field = hal_rx_get_frame_ctrl_field(rx_tlv_hdr);
  462. if (to_ds && fr_ds)
  463. size += QDF_MAC_ADDR_SIZE;
  464. if (frm_ctrl_valid) {
  465. fc = frm_ctrl_field;
  466. /* use 1-st byte for validation */
  467. if (DP_RX_DEFRAG_IEEE80211_QOS_HAS_SEQ(fc & 0xff)) {
  468. size += sizeof(uint16_t);
  469. /* use 2-nd byte for validation */
  470. if (((fc & 0xff00) >> 8) & IEEE80211_FC1_ORDER)
  471. size += sizeof(struct ieee80211_htc);
  472. }
  473. }
  474. return size;
  475. }
  476. /*
  477. * dp_rx_defrag_michdr(): Calculate a pseudo MIC header
  478. * @wh0: Pointer to the wireless header of the fragment
  479. * @hdr: Array to hold the pseudo header
  480. *
  481. * Calculate a pseudo MIC header
  482. *
  483. * Returns: None
  484. */
  485. static void dp_rx_defrag_michdr(const struct ieee80211_frame *wh0,
  486. uint8_t hdr[])
  487. {
  488. const struct ieee80211_frame_addr4 *wh =
  489. (const struct ieee80211_frame_addr4 *)wh0;
  490. switch (wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) {
  491. case IEEE80211_FC1_DIR_NODS:
  492. DP_RX_DEFRAG_IEEE80211_ADDR_COPY(hdr, wh->i_addr1); /* DA */
  493. DP_RX_DEFRAG_IEEE80211_ADDR_COPY(hdr + QDF_MAC_ADDR_SIZE,
  494. wh->i_addr2);
  495. break;
  496. case IEEE80211_FC1_DIR_TODS:
  497. DP_RX_DEFRAG_IEEE80211_ADDR_COPY(hdr, wh->i_addr3); /* DA */
  498. DP_RX_DEFRAG_IEEE80211_ADDR_COPY(hdr + QDF_MAC_ADDR_SIZE,
  499. wh->i_addr2);
  500. break;
  501. case IEEE80211_FC1_DIR_FROMDS:
  502. DP_RX_DEFRAG_IEEE80211_ADDR_COPY(hdr, wh->i_addr1); /* DA */
  503. DP_RX_DEFRAG_IEEE80211_ADDR_COPY(hdr + QDF_MAC_ADDR_SIZE,
  504. wh->i_addr3);
  505. break;
  506. case IEEE80211_FC1_DIR_DSTODS:
  507. DP_RX_DEFRAG_IEEE80211_ADDR_COPY(hdr, wh->i_addr3); /* DA */
  508. DP_RX_DEFRAG_IEEE80211_ADDR_COPY(hdr + QDF_MAC_ADDR_SIZE,
  509. wh->i_addr4);
  510. break;
  511. }
  512. /*
  513. * Bit 7 is QDF_IEEE80211_FC0_SUBTYPE_QOS for data frame, but
  514. * it could also be set for deauth, disassoc, action, etc. for
  515. * a mgt type frame. It comes into picture for MFP.
  516. */
  517. if (wh->i_fc[0] & QDF_IEEE80211_FC0_SUBTYPE_QOS) {
  518. if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) ==
  519. IEEE80211_FC1_DIR_DSTODS) {
  520. const struct ieee80211_qosframe_addr4 *qwh =
  521. (const struct ieee80211_qosframe_addr4 *)wh;
  522. hdr[12] = qwh->i_qos[0] & IEEE80211_QOS_TID;
  523. } else {
  524. const struct ieee80211_qosframe *qwh =
  525. (const struct ieee80211_qosframe *)wh;
  526. hdr[12] = qwh->i_qos[0] & IEEE80211_QOS_TID;
  527. }
  528. } else {
  529. hdr[12] = 0;
  530. }
  531. hdr[13] = hdr[14] = hdr[15] = 0; /* reserved */
  532. }
  533. /*
  534. * dp_rx_defrag_mic(): Calculate MIC header
  535. * @key: Pointer to the key
  536. * @wbuf: fragment buffer
  537. * @off: Offset
  538. * @data_len: Data length
  539. * @mic: Array to hold MIC
  540. *
  541. * Calculate a pseudo MIC header
  542. *
  543. * Returns: QDF_STATUS
  544. */
  545. static QDF_STATUS dp_rx_defrag_mic(const uint8_t *key, qdf_nbuf_t wbuf,
  546. uint16_t off, uint16_t data_len, uint8_t mic[])
  547. {
  548. uint8_t hdr[16] = { 0, };
  549. uint32_t l, r;
  550. const uint8_t *data;
  551. uint32_t space;
  552. int rx_desc_len = sizeof(struct rx_pkt_tlvs);
  553. dp_rx_defrag_michdr((struct ieee80211_frame *)(qdf_nbuf_data(wbuf)
  554. + rx_desc_len), hdr);
  555. l = dp_rx_get_le32(key);
  556. r = dp_rx_get_le32(key + 4);
  557. /* Michael MIC pseudo header: DA, SA, 3 x 0, Priority */
  558. l ^= dp_rx_get_le32(hdr);
  559. dp_rx_michael_block(l, r);
  560. l ^= dp_rx_get_le32(&hdr[4]);
  561. dp_rx_michael_block(l, r);
  562. l ^= dp_rx_get_le32(&hdr[8]);
  563. dp_rx_michael_block(l, r);
  564. l ^= dp_rx_get_le32(&hdr[12]);
  565. dp_rx_michael_block(l, r);
  566. /* first buffer has special handling */
  567. data = (uint8_t *)qdf_nbuf_data(wbuf) + off;
  568. space = qdf_nbuf_len(wbuf) - off;
  569. for (;; ) {
  570. if (space > data_len)
  571. space = data_len;
  572. /* collect 32-bit blocks from current buffer */
  573. while (space >= sizeof(uint32_t)) {
  574. l ^= dp_rx_get_le32(data);
  575. dp_rx_michael_block(l, r);
  576. data += sizeof(uint32_t);
  577. space -= sizeof(uint32_t);
  578. data_len -= sizeof(uint32_t);
  579. }
  580. if (data_len < sizeof(uint32_t))
  581. break;
  582. wbuf = qdf_nbuf_next(wbuf);
  583. if (!wbuf)
  584. return QDF_STATUS_E_DEFRAG_ERROR;
  585. if (space != 0) {
  586. const uint8_t *data_next;
  587. /*
  588. * Block straddles buffers, split references.
  589. */
  590. data_next =
  591. (uint8_t *)qdf_nbuf_data(wbuf) + off;
  592. if ((qdf_nbuf_len(wbuf)) <
  593. sizeof(uint32_t) - space) {
  594. return QDF_STATUS_E_DEFRAG_ERROR;
  595. }
  596. switch (space) {
  597. case 1:
  598. l ^= dp_rx_get_le32_split(data[0],
  599. data_next[0], data_next[1],
  600. data_next[2]);
  601. data = data_next + 3;
  602. space = (qdf_nbuf_len(wbuf) - off) - 3;
  603. break;
  604. case 2:
  605. l ^= dp_rx_get_le32_split(data[0], data[1],
  606. data_next[0], data_next[1]);
  607. data = data_next + 2;
  608. space = (qdf_nbuf_len(wbuf) - off) - 2;
  609. break;
  610. case 3:
  611. l ^= dp_rx_get_le32_split(data[0], data[1],
  612. data[2], data_next[0]);
  613. data = data_next + 1;
  614. space = (qdf_nbuf_len(wbuf) - off) - 1;
  615. break;
  616. }
  617. dp_rx_michael_block(l, r);
  618. data_len -= sizeof(uint32_t);
  619. } else {
  620. /*
  621. * Setup for next buffer.
  622. */
  623. data = (uint8_t *)qdf_nbuf_data(wbuf) + off;
  624. space = qdf_nbuf_len(wbuf) - off;
  625. }
  626. }
  627. /* Last block and padding (0x5a, 4..7 x 0) */
  628. switch (data_len) {
  629. case 0:
  630. l ^= dp_rx_get_le32_split(0x5a, 0, 0, 0);
  631. break;
  632. case 1:
  633. l ^= dp_rx_get_le32_split(data[0], 0x5a, 0, 0);
  634. break;
  635. case 2:
  636. l ^= dp_rx_get_le32_split(data[0], data[1], 0x5a, 0);
  637. break;
  638. case 3:
  639. l ^= dp_rx_get_le32_split(data[0], data[1], data[2], 0x5a);
  640. break;
  641. }
  642. dp_rx_michael_block(l, r);
  643. dp_rx_michael_block(l, r);
  644. dp_rx_put_le32(mic, l);
  645. dp_rx_put_le32(mic + 4, r);
  646. return QDF_STATUS_SUCCESS;
  647. }
  648. /*
  649. * dp_rx_defrag_tkip_demic(): Remove MIC header from the TKIP frame
  650. * @key: Pointer to the key
  651. * @msdu: fragment buffer
  652. * @hdrlen: Length of the header information
  653. *
  654. * Remove MIC information from the TKIP frame
  655. *
  656. * Returns: QDF_STATUS
  657. */
  658. static QDF_STATUS dp_rx_defrag_tkip_demic(const uint8_t *key,
  659. qdf_nbuf_t msdu, uint16_t hdrlen)
  660. {
  661. QDF_STATUS status;
  662. uint32_t pktlen = 0;
  663. uint8_t mic[IEEE80211_WEP_MICLEN];
  664. uint8_t mic0[IEEE80211_WEP_MICLEN];
  665. qdf_nbuf_t prev = NULL, next;
  666. next = msdu;
  667. while (next) {
  668. pktlen += (qdf_nbuf_len(next) - hdrlen);
  669. prev = next;
  670. dp_debug("%s pktlen %u", __func__,
  671. (uint32_t)(qdf_nbuf_len(next) - hdrlen));
  672. next = qdf_nbuf_next(next);
  673. }
  674. if (!prev) {
  675. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  676. "%s Defrag chaining failed !\n", __func__);
  677. return QDF_STATUS_E_DEFRAG_ERROR;
  678. }
  679. qdf_nbuf_copy_bits(prev, qdf_nbuf_len(prev) - dp_f_tkip.ic_miclen,
  680. dp_f_tkip.ic_miclen, (caddr_t)mic0);
  681. qdf_nbuf_trim_tail(prev, dp_f_tkip.ic_miclen);
  682. pktlen -= dp_f_tkip.ic_miclen;
  683. status = dp_rx_defrag_mic(key, msdu, hdrlen,
  684. pktlen, mic);
  685. if (QDF_IS_STATUS_ERROR(status))
  686. return status;
  687. if (qdf_mem_cmp(mic, mic0, dp_f_tkip.ic_miclen))
  688. return QDF_STATUS_E_DEFRAG_ERROR;
  689. return QDF_STATUS_SUCCESS;
  690. }
  691. /*
  692. * dp_rx_frag_pull_hdr(): Pulls the RXTLV & the 802.11 headers
  693. * @nbuf: buffer pointer
  694. * @hdrsize: size of the header to be pulled
  695. *
  696. * Pull the RXTLV & the 802.11 headers
  697. *
  698. * Returns: None
  699. */
  700. static void dp_rx_frag_pull_hdr(qdf_nbuf_t nbuf, uint16_t hdrsize)
  701. {
  702. qdf_nbuf_pull_head(nbuf,
  703. RX_PKT_TLVS_LEN + hdrsize);
  704. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG,
  705. "%s: final pktlen %d .11len %d",
  706. __func__, (uint32_t)qdf_nbuf_len(nbuf), hdrsize);
  707. }
  708. /*
  709. * dp_rx_construct_fraglist(): Construct a nbuf fraglist
  710. * @peer: Pointer to the peer
  711. * @head: Pointer to list of fragments
  712. * @hdrsize: Size of the header to be pulled
  713. *
  714. * Construct a nbuf fraglist
  715. *
  716. * Returns: None
  717. */
  718. static void
  719. dp_rx_construct_fraglist(struct dp_peer *peer,
  720. qdf_nbuf_t head, uint16_t hdrsize)
  721. {
  722. qdf_nbuf_t msdu = qdf_nbuf_next(head);
  723. qdf_nbuf_t rx_nbuf = msdu;
  724. uint32_t len = 0;
  725. while (msdu) {
  726. dp_rx_frag_pull_hdr(msdu, hdrsize);
  727. len += qdf_nbuf_len(msdu);
  728. msdu = qdf_nbuf_next(msdu);
  729. }
  730. qdf_nbuf_append_ext_list(head, rx_nbuf, len);
  731. qdf_nbuf_set_next(head, NULL);
  732. qdf_nbuf_set_is_frag(head, 1);
  733. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG,
  734. "%s: head len %d ext len %d data len %d ",
  735. __func__,
  736. (uint32_t)qdf_nbuf_len(head),
  737. (uint32_t)qdf_nbuf_len(rx_nbuf),
  738. (uint32_t)(head->data_len));
  739. }
  740. /**
  741. * dp_rx_defrag_err() - rx err handler
  742. * @pdev: handle to pdev object
  743. * @vdev_id: vdev id
  744. * @peer_mac_addr: peer mac address
  745. * @tid: TID
  746. * @tsf32: TSF
  747. * @err_type: error type
  748. * @rx_frame: rx frame
  749. * @pn: PN Number
  750. * @key_id: key id
  751. *
  752. * This function handles rx error and send MIC error notification
  753. *
  754. * Return: None
  755. */
  756. static void dp_rx_defrag_err(struct dp_vdev *vdev, qdf_nbuf_t nbuf)
  757. {
  758. struct ol_if_ops *tops = NULL;
  759. struct dp_pdev *pdev = vdev->pdev;
  760. int rx_desc_len = sizeof(struct rx_pkt_tlvs);
  761. uint8_t *orig_hdr;
  762. struct ieee80211_frame *wh;
  763. struct cdp_rx_mic_err_info mic_failure_info;
  764. orig_hdr = (uint8_t *)(qdf_nbuf_data(nbuf) + rx_desc_len);
  765. wh = (struct ieee80211_frame *)orig_hdr;
  766. qdf_copy_macaddr((struct qdf_mac_addr *)&mic_failure_info.da_mac_addr,
  767. (struct qdf_mac_addr *)&wh->i_addr1);
  768. qdf_copy_macaddr((struct qdf_mac_addr *)&mic_failure_info.ta_mac_addr,
  769. (struct qdf_mac_addr *)&wh->i_addr2);
  770. mic_failure_info.key_id = 0;
  771. mic_failure_info.multicast =
  772. IEEE80211_IS_MULTICAST(wh->i_addr1);
  773. qdf_mem_zero(mic_failure_info.tsc, MIC_SEQ_CTR_SIZE);
  774. mic_failure_info.frame_type = cdp_rx_frame_type_802_11;
  775. mic_failure_info.data = (uint8_t *)wh;
  776. mic_failure_info.vdev_id = vdev->vdev_id;
  777. tops = pdev->soc->cdp_soc.ol_ops;
  778. if (tops->rx_mic_error)
  779. tops->rx_mic_error(pdev->soc->ctrl_psoc, pdev->pdev_id,
  780. &mic_failure_info);
  781. }
  782. /*
  783. * dp_rx_defrag_nwifi_to_8023(): Transcap 802.11 to 802.3
  784. * @soc: dp soc handle
  785. * @nbuf: Pointer to the fragment buffer
  786. * @hdrsize: Size of headers
  787. *
  788. * Transcap the fragment from 802.11 to 802.3
  789. *
  790. * Returns: None
  791. */
  792. static void
  793. dp_rx_defrag_nwifi_to_8023(struct dp_soc *soc,
  794. qdf_nbuf_t nbuf, uint16_t hdrsize)
  795. {
  796. struct llc_snap_hdr_t *llchdr;
  797. struct ethernet_hdr_t *eth_hdr;
  798. uint8_t ether_type[2];
  799. uint16_t fc = 0;
  800. union dp_align_mac_addr mac_addr;
  801. uint8_t *rx_desc_info = qdf_mem_malloc(RX_PKT_TLVS_LEN);
  802. if (!rx_desc_info) {
  803. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  804. "%s: Memory alloc failed ! ", __func__);
  805. QDF_ASSERT(0);
  806. return;
  807. }
  808. qdf_mem_copy(rx_desc_info, qdf_nbuf_data(nbuf), RX_PKT_TLVS_LEN);
  809. llchdr = (struct llc_snap_hdr_t *)(qdf_nbuf_data(nbuf) +
  810. RX_PKT_TLVS_LEN + hdrsize);
  811. qdf_mem_copy(ether_type, llchdr->ethertype, 2);
  812. qdf_nbuf_pull_head(nbuf, (RX_PKT_TLVS_LEN + hdrsize +
  813. sizeof(struct llc_snap_hdr_t) -
  814. sizeof(struct ethernet_hdr_t)));
  815. eth_hdr = (struct ethernet_hdr_t *)(qdf_nbuf_data(nbuf));
  816. if (hal_rx_get_mpdu_frame_control_valid(soc->hal_soc,
  817. rx_desc_info))
  818. fc = hal_rx_get_frame_ctrl_field(rx_desc_info);
  819. dp_debug("%s: frame control type: 0x%x", __func__, fc);
  820. switch (((fc & 0xff00) >> 8) & IEEE80211_FC1_DIR_MASK) {
  821. case IEEE80211_FC1_DIR_NODS:
  822. hal_rx_mpdu_get_addr1(soc->hal_soc, rx_desc_info,
  823. &mac_addr.raw[0]);
  824. qdf_mem_copy(eth_hdr->dest_addr, &mac_addr.raw[0],
  825. QDF_MAC_ADDR_SIZE);
  826. hal_rx_mpdu_get_addr2(soc->hal_soc, rx_desc_info,
  827. &mac_addr.raw[0]);
  828. qdf_mem_copy(eth_hdr->src_addr, &mac_addr.raw[0],
  829. QDF_MAC_ADDR_SIZE);
  830. break;
  831. case IEEE80211_FC1_DIR_TODS:
  832. hal_rx_mpdu_get_addr3(soc->hal_soc, rx_desc_info,
  833. &mac_addr.raw[0]);
  834. qdf_mem_copy(eth_hdr->dest_addr, &mac_addr.raw[0],
  835. QDF_MAC_ADDR_SIZE);
  836. hal_rx_mpdu_get_addr2(soc->hal_soc, rx_desc_info,
  837. &mac_addr.raw[0]);
  838. qdf_mem_copy(eth_hdr->src_addr, &mac_addr.raw[0],
  839. QDF_MAC_ADDR_SIZE);
  840. break;
  841. case IEEE80211_FC1_DIR_FROMDS:
  842. hal_rx_mpdu_get_addr1(soc->hal_soc, rx_desc_info,
  843. &mac_addr.raw[0]);
  844. qdf_mem_copy(eth_hdr->dest_addr, &mac_addr.raw[0],
  845. QDF_MAC_ADDR_SIZE);
  846. hal_rx_mpdu_get_addr3(soc->hal_soc, rx_desc_info,
  847. &mac_addr.raw[0]);
  848. qdf_mem_copy(eth_hdr->src_addr, &mac_addr.raw[0],
  849. QDF_MAC_ADDR_SIZE);
  850. break;
  851. case IEEE80211_FC1_DIR_DSTODS:
  852. hal_rx_mpdu_get_addr3(soc->hal_soc, rx_desc_info,
  853. &mac_addr.raw[0]);
  854. qdf_mem_copy(eth_hdr->dest_addr, &mac_addr.raw[0],
  855. QDF_MAC_ADDR_SIZE);
  856. hal_rx_mpdu_get_addr4(soc->hal_soc, rx_desc_info,
  857. &mac_addr.raw[0]);
  858. qdf_mem_copy(eth_hdr->src_addr, &mac_addr.raw[0],
  859. QDF_MAC_ADDR_SIZE);
  860. break;
  861. default:
  862. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  863. "%s: Unknown frame control type: 0x%x", __func__, fc);
  864. }
  865. qdf_mem_copy(eth_hdr->ethertype, ether_type,
  866. sizeof(ether_type));
  867. qdf_nbuf_push_head(nbuf, RX_PKT_TLVS_LEN);
  868. qdf_mem_copy(qdf_nbuf_data(nbuf), rx_desc_info, RX_PKT_TLVS_LEN);
  869. qdf_mem_free(rx_desc_info);
  870. }
  871. /*
  872. * dp_rx_defrag_reo_reinject(): Reinject the fragment chain back into REO
  873. * @peer: Pointer to the peer
  874. * @tid: Transmit Identifier
  875. * @head: Buffer to be reinjected back
  876. *
  877. * Reinject the fragment chain back into REO
  878. *
  879. * Returns: QDF_STATUS
  880. */
  881. static QDF_STATUS dp_rx_defrag_reo_reinject(struct dp_peer *peer,
  882. unsigned int tid, qdf_nbuf_t head)
  883. {
  884. struct dp_pdev *pdev = peer->vdev->pdev;
  885. struct dp_soc *soc = pdev->soc;
  886. struct hal_buf_info buf_info;
  887. void *link_desc_va;
  888. void *msdu0, *msdu_desc_info;
  889. void *ent_ring_desc, *ent_mpdu_desc_info, *ent_qdesc_addr;
  890. void *dst_mpdu_desc_info, *dst_qdesc_addr;
  891. qdf_dma_addr_t paddr;
  892. uint32_t nbuf_len, seq_no, dst_ind;
  893. uint32_t *mpdu_wrd;
  894. uint32_t ret, cookie;
  895. hal_ring_desc_t dst_ring_desc =
  896. peer->rx_tid[tid].dst_ring_desc;
  897. hal_ring_handle_t hal_srng = soc->reo_reinject_ring.hal_srng;
  898. struct dp_rx_desc *rx_desc = peer->rx_tid[tid].head_frag_desc;
  899. head = dp_ipa_handle_rx_reo_reinject(soc, head);
  900. if (qdf_unlikely(!head)) {
  901. dp_err_rl("IPA RX REO reinject failed");
  902. return QDF_STATUS_E_FAILURE;
  903. }
  904. ent_ring_desc = hal_srng_src_get_next(soc->hal_soc, hal_srng);
  905. if (!ent_ring_desc) {
  906. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  907. "HAL src ring next entry NULL");
  908. return QDF_STATUS_E_FAILURE;
  909. }
  910. hal_rx_reo_buf_paddr_get(dst_ring_desc, &buf_info);
  911. link_desc_va = dp_rx_cookie_2_link_desc_va(soc, &buf_info);
  912. qdf_assert(link_desc_va);
  913. msdu0 = hal_rx_msdu0_buffer_addr_lsb(soc->hal_soc, link_desc_va);
  914. nbuf_len = qdf_nbuf_len(head) - RX_PKT_TLVS_LEN;
  915. HAL_RX_UNIFORM_HDR_SET(link_desc_va, OWNER, UNI_DESC_OWNER_SW);
  916. HAL_RX_UNIFORM_HDR_SET(link_desc_va, BUFFER_TYPE,
  917. UNI_DESC_BUF_TYPE_RX_MSDU_LINK);
  918. /* msdu reconfig */
  919. msdu_desc_info = hal_rx_msdu_desc_info_ptr_get(soc->hal_soc, msdu0);
  920. dst_ind = hal_rx_msdu_reo_dst_ind_get(soc->hal_soc, link_desc_va);
  921. qdf_mem_zero(msdu_desc_info, sizeof(struct rx_msdu_desc_info));
  922. HAL_RX_MSDU_DESC_INFO_SET(msdu_desc_info,
  923. FIRST_MSDU_IN_MPDU_FLAG, 1);
  924. HAL_RX_MSDU_DESC_INFO_SET(msdu_desc_info,
  925. LAST_MSDU_IN_MPDU_FLAG, 1);
  926. HAL_RX_MSDU_DESC_INFO_SET(msdu_desc_info,
  927. MSDU_CONTINUATION, 0x0);
  928. HAL_RX_MSDU_DESC_INFO_SET(msdu_desc_info,
  929. REO_DESTINATION_INDICATION, dst_ind);
  930. HAL_RX_MSDU_DESC_INFO_SET(msdu_desc_info,
  931. MSDU_LENGTH, nbuf_len);
  932. HAL_RX_MSDU_DESC_INFO_SET(msdu_desc_info,
  933. SA_IS_VALID, 1);
  934. HAL_RX_MSDU_DESC_INFO_SET(msdu_desc_info,
  935. DA_IS_VALID, 1);
  936. /* change RX TLV's */
  937. hal_rx_msdu_start_msdu_len_set(
  938. qdf_nbuf_data(head), nbuf_len);
  939. cookie = HAL_RX_BUF_COOKIE_GET(msdu0);
  940. /* map the nbuf before reinject it into HW */
  941. ret = qdf_nbuf_map_single(soc->osdev, head,
  942. QDF_DMA_FROM_DEVICE);
  943. if (qdf_unlikely(ret == QDF_STATUS_E_FAILURE)) {
  944. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  945. "%s: nbuf map failed !", __func__);
  946. return QDF_STATUS_E_FAILURE;
  947. }
  948. /*
  949. * As part of rx frag handler bufffer was unmapped and rx desc
  950. * unmapped is set to 1. So again for defrag reinject frame reset
  951. * it back to 0.
  952. */
  953. rx_desc->unmapped = 0;
  954. dp_ipa_handle_rx_buf_smmu_mapping(soc, head, true);
  955. paddr = qdf_nbuf_get_frag_paddr(head, 0);
  956. ret = check_x86_paddr(soc, &head, &paddr, pdev);
  957. if (ret == QDF_STATUS_E_FAILURE) {
  958. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  959. "%s: x86 check failed !", __func__);
  960. return QDF_STATUS_E_FAILURE;
  961. }
  962. hal_rxdma_buff_addr_info_set(msdu0, paddr, cookie, DP_DEFRAG_RBM);
  963. /* Lets fill entrance ring now !!! */
  964. if (qdf_unlikely(hal_srng_access_start(soc->hal_soc, hal_srng))) {
  965. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  966. "HAL RING Access For REO entrance SRNG Failed: %pK",
  967. hal_srng);
  968. return QDF_STATUS_E_FAILURE;
  969. }
  970. paddr = (uint64_t)buf_info.paddr;
  971. /* buf addr */
  972. hal_rxdma_buff_addr_info_set(ent_ring_desc, paddr,
  973. buf_info.sw_cookie,
  974. HAL_RX_BUF_RBM_WBM_IDLE_DESC_LIST);
  975. /* mpdu desc info */
  976. ent_mpdu_desc_info = hal_ent_mpdu_desc_info(soc->hal_soc,
  977. ent_ring_desc);
  978. dst_mpdu_desc_info = hal_dst_mpdu_desc_info(soc->hal_soc,
  979. dst_ring_desc);
  980. qdf_mem_copy(ent_mpdu_desc_info, dst_mpdu_desc_info,
  981. sizeof(struct rx_mpdu_desc_info));
  982. qdf_mem_zero(ent_mpdu_desc_info, sizeof(uint32_t));
  983. mpdu_wrd = (uint32_t *)dst_mpdu_desc_info;
  984. seq_no = HAL_RX_MPDU_SEQUENCE_NUMBER_GET(mpdu_wrd);
  985. HAL_RX_MPDU_DESC_INFO_SET(ent_mpdu_desc_info,
  986. MSDU_COUNT, 0x1);
  987. HAL_RX_MPDU_DESC_INFO_SET(ent_mpdu_desc_info,
  988. MPDU_SEQUENCE_NUMBER, seq_no);
  989. /* unset frag bit */
  990. HAL_RX_MPDU_DESC_INFO_SET(ent_mpdu_desc_info,
  991. FRAGMENT_FLAG, 0x0);
  992. /* set sa/da valid bits */
  993. HAL_RX_MPDU_DESC_INFO_SET(ent_mpdu_desc_info,
  994. SA_IS_VALID, 0x1);
  995. HAL_RX_MPDU_DESC_INFO_SET(ent_mpdu_desc_info,
  996. DA_IS_VALID, 0x1);
  997. HAL_RX_MPDU_DESC_INFO_SET(ent_mpdu_desc_info,
  998. RAW_MPDU, 0x0);
  999. /* qdesc addr */
  1000. ent_qdesc_addr = (uint8_t *)ent_ring_desc +
  1001. REO_ENTRANCE_RING_4_RX_REO_QUEUE_DESC_ADDR_31_0_OFFSET;
  1002. dst_qdesc_addr = (uint8_t *)dst_ring_desc +
  1003. REO_DESTINATION_RING_6_RX_REO_QUEUE_DESC_ADDR_31_0_OFFSET;
  1004. qdf_mem_copy(ent_qdesc_addr, dst_qdesc_addr, 8);
  1005. HAL_RX_FLD_SET(ent_ring_desc, REO_ENTRANCE_RING_5,
  1006. REO_DESTINATION_INDICATION, dst_ind);
  1007. hal_srng_access_end(soc->hal_soc, hal_srng);
  1008. DP_STATS_INC(soc, rx.reo_reinject, 1);
  1009. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_DEBUG,
  1010. "%s: reinjection done !", __func__);
  1011. return QDF_STATUS_SUCCESS;
  1012. }
  1013. /*
  1014. * dp_rx_defrag(): Defragment the fragment chain
  1015. * @peer: Pointer to the peer
  1016. * @tid: Transmit Identifier
  1017. * @frag_list_head: Pointer to head list
  1018. * @frag_list_tail: Pointer to tail list
  1019. *
  1020. * Defragment the fragment chain
  1021. *
  1022. * Returns: QDF_STATUS
  1023. */
  1024. static QDF_STATUS dp_rx_defrag(struct dp_peer *peer, unsigned tid,
  1025. qdf_nbuf_t frag_list_head, qdf_nbuf_t frag_list_tail)
  1026. {
  1027. qdf_nbuf_t tmp_next, prev;
  1028. qdf_nbuf_t cur = frag_list_head, msdu;
  1029. uint32_t index, tkip_demic = 0;
  1030. uint16_t hdr_space;
  1031. uint8_t key[DEFRAG_IEEE80211_KEY_LEN];
  1032. struct dp_vdev *vdev = peer->vdev;
  1033. struct dp_soc *soc = vdev->pdev->soc;
  1034. uint8_t status = 0;
  1035. hdr_space = dp_rx_defrag_hdrsize(soc, cur);
  1036. index = hal_rx_msdu_is_wlan_mcast(cur) ?
  1037. dp_sec_mcast : dp_sec_ucast;
  1038. /* Remove FCS from all fragments */
  1039. while (cur) {
  1040. tmp_next = qdf_nbuf_next(cur);
  1041. qdf_nbuf_set_next(cur, NULL);
  1042. qdf_nbuf_trim_tail(cur, DEFRAG_IEEE80211_FCS_LEN);
  1043. prev = cur;
  1044. qdf_nbuf_set_next(cur, tmp_next);
  1045. cur = tmp_next;
  1046. }
  1047. cur = frag_list_head;
  1048. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
  1049. "%s: index %d Security type: %d", __func__,
  1050. index, peer->security[index].sec_type);
  1051. switch (peer->security[index].sec_type) {
  1052. case cdp_sec_type_tkip:
  1053. tkip_demic = 1;
  1054. case cdp_sec_type_tkip_nomic:
  1055. while (cur) {
  1056. tmp_next = qdf_nbuf_next(cur);
  1057. if (dp_rx_defrag_tkip_decap(cur, hdr_space)) {
  1058. QDF_TRACE(QDF_MODULE_ID_TXRX,
  1059. QDF_TRACE_LEVEL_ERROR,
  1060. "dp_rx_defrag: TKIP decap failed");
  1061. return QDF_STATUS_E_DEFRAG_ERROR;
  1062. }
  1063. cur = tmp_next;
  1064. }
  1065. /* If success, increment header to be stripped later */
  1066. hdr_space += dp_f_tkip.ic_header;
  1067. break;
  1068. case cdp_sec_type_aes_ccmp:
  1069. while (cur) {
  1070. tmp_next = qdf_nbuf_next(cur);
  1071. if (dp_rx_defrag_ccmp_demic(cur, hdr_space)) {
  1072. QDF_TRACE(QDF_MODULE_ID_TXRX,
  1073. QDF_TRACE_LEVEL_ERROR,
  1074. "dp_rx_defrag: CCMP demic failed");
  1075. return QDF_STATUS_E_DEFRAG_ERROR;
  1076. }
  1077. if (dp_rx_defrag_ccmp_decap(cur, hdr_space)) {
  1078. QDF_TRACE(QDF_MODULE_ID_TXRX,
  1079. QDF_TRACE_LEVEL_ERROR,
  1080. "dp_rx_defrag: CCMP decap failed");
  1081. return QDF_STATUS_E_DEFRAG_ERROR;
  1082. }
  1083. cur = tmp_next;
  1084. }
  1085. /* If success, increment header to be stripped later */
  1086. hdr_space += dp_f_ccmp.ic_header;
  1087. break;
  1088. case cdp_sec_type_wep40:
  1089. case cdp_sec_type_wep104:
  1090. case cdp_sec_type_wep128:
  1091. while (cur) {
  1092. tmp_next = qdf_nbuf_next(cur);
  1093. if (dp_rx_defrag_wep_decap(cur, hdr_space)) {
  1094. QDF_TRACE(QDF_MODULE_ID_TXRX,
  1095. QDF_TRACE_LEVEL_ERROR,
  1096. "dp_rx_defrag: WEP decap failed");
  1097. return QDF_STATUS_E_DEFRAG_ERROR;
  1098. }
  1099. cur = tmp_next;
  1100. }
  1101. /* If success, increment header to be stripped later */
  1102. hdr_space += dp_f_wep.ic_header;
  1103. break;
  1104. default:
  1105. QDF_TRACE(QDF_MODULE_ID_TXRX,
  1106. QDF_TRACE_LEVEL_ERROR,
  1107. "dp_rx_defrag: Did not match any security type");
  1108. break;
  1109. }
  1110. if (tkip_demic) {
  1111. msdu = frag_list_head;
  1112. qdf_mem_copy(key,
  1113. &peer->security[index].michael_key[0],
  1114. IEEE80211_WEP_MICLEN);
  1115. status = dp_rx_defrag_tkip_demic(key, msdu,
  1116. RX_PKT_TLVS_LEN +
  1117. hdr_space);
  1118. if (status) {
  1119. dp_rx_defrag_err(vdev, frag_list_head);
  1120. QDF_TRACE(QDF_MODULE_ID_TXRX,
  1121. QDF_TRACE_LEVEL_ERROR,
  1122. "%s: TKIP demic failed status %d",
  1123. __func__, status);
  1124. return QDF_STATUS_E_DEFRAG_ERROR;
  1125. }
  1126. }
  1127. /* Convert the header to 802.3 header */
  1128. dp_rx_defrag_nwifi_to_8023(soc, frag_list_head, hdr_space);
  1129. dp_rx_construct_fraglist(peer, frag_list_head, hdr_space);
  1130. return QDF_STATUS_SUCCESS;
  1131. }
  1132. /*
  1133. * dp_rx_defrag_cleanup(): Clean up activities
  1134. * @peer: Pointer to the peer
  1135. * @tid: Transmit Identifier
  1136. *
  1137. * Returns: None
  1138. */
  1139. void dp_rx_defrag_cleanup(struct dp_peer *peer, unsigned tid)
  1140. {
  1141. struct dp_rx_reorder_array_elem *rx_reorder_array_elem =
  1142. peer->rx_tid[tid].array;
  1143. if (rx_reorder_array_elem) {
  1144. /* Free up nbufs */
  1145. dp_rx_defrag_frames_free(rx_reorder_array_elem->head);
  1146. rx_reorder_array_elem->head = NULL;
  1147. rx_reorder_array_elem->tail = NULL;
  1148. } else {
  1149. dp_info("Cleanup self peer %pK and TID %u at MAC address %pM",
  1150. peer, tid, peer->mac_addr.raw);
  1151. }
  1152. /* Free up saved ring descriptors */
  1153. dp_rx_clear_saved_desc_info(peer, tid);
  1154. peer->rx_tid[tid].defrag_timeout_ms = 0;
  1155. peer->rx_tid[tid].curr_frag_num = 0;
  1156. peer->rx_tid[tid].curr_seq_num = 0;
  1157. }
  1158. /*
  1159. * dp_rx_defrag_save_info_from_ring_desc(): Save info from REO ring descriptor
  1160. * @ring_desc: Pointer to the dst ring descriptor
  1161. * @peer: Pointer to the peer
  1162. * @tid: Transmit Identifier
  1163. *
  1164. * Returns: None
  1165. */
  1166. static QDF_STATUS
  1167. dp_rx_defrag_save_info_from_ring_desc(hal_ring_desc_t ring_desc,
  1168. struct dp_rx_desc *rx_desc,
  1169. struct dp_peer *peer,
  1170. unsigned int tid)
  1171. {
  1172. void *dst_ring_desc = qdf_mem_malloc(
  1173. sizeof(struct reo_destination_ring));
  1174. if (!dst_ring_desc) {
  1175. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1176. "%s: Memory alloc failed !", __func__);
  1177. QDF_ASSERT(0);
  1178. return QDF_STATUS_E_NOMEM;
  1179. }
  1180. qdf_mem_copy(dst_ring_desc, ring_desc,
  1181. sizeof(struct reo_destination_ring));
  1182. peer->rx_tid[tid].dst_ring_desc = dst_ring_desc;
  1183. peer->rx_tid[tid].head_frag_desc = rx_desc;
  1184. return QDF_STATUS_SUCCESS;
  1185. }
  1186. /*
  1187. * dp_rx_defrag_store_fragment(): Store incoming fragments
  1188. * @soc: Pointer to the SOC data structure
  1189. * @ring_desc: Pointer to the ring descriptor
  1190. * @mpdu_desc_info: MPDU descriptor info
  1191. * @tid: Traffic Identifier
  1192. * @rx_desc: Pointer to rx descriptor
  1193. * @rx_bfs: Number of bfs consumed
  1194. *
  1195. * Returns: QDF_STATUS
  1196. */
  1197. static QDF_STATUS
  1198. dp_rx_defrag_store_fragment(struct dp_soc *soc,
  1199. hal_ring_desc_t ring_desc,
  1200. union dp_rx_desc_list_elem_t **head,
  1201. union dp_rx_desc_list_elem_t **tail,
  1202. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  1203. unsigned int tid, struct dp_rx_desc *rx_desc,
  1204. uint32_t *rx_bfs)
  1205. {
  1206. struct dp_rx_reorder_array_elem *rx_reorder_array_elem;
  1207. struct dp_pdev *pdev;
  1208. struct dp_peer *peer = NULL;
  1209. uint16_t peer_id;
  1210. uint8_t fragno, more_frag, all_frag_present = 0;
  1211. uint16_t rxseq = mpdu_desc_info->mpdu_seq;
  1212. QDF_STATUS status;
  1213. struct dp_rx_tid *rx_tid;
  1214. uint8_t mpdu_sequence_control_valid;
  1215. uint8_t mpdu_frame_control_valid;
  1216. qdf_nbuf_t frag = rx_desc->nbuf;
  1217. uint32_t msdu_len;
  1218. if (qdf_nbuf_len(frag) > 0) {
  1219. dp_info("Dropping unexpected packet with skb_len: %d,"
  1220. "data len: %d, cookie: %d",
  1221. (uint32_t)qdf_nbuf_len(frag), frag->data_len,
  1222. rx_desc->cookie);
  1223. DP_STATS_INC(soc, rx.rx_frag_err_len_error, 1);
  1224. goto discard_frag;
  1225. }
  1226. msdu_len = hal_rx_msdu_start_msdu_len_get(rx_desc->rx_buf_start);
  1227. qdf_nbuf_set_pktlen(frag, (msdu_len + RX_PKT_TLVS_LEN));
  1228. qdf_nbuf_append_ext_list(frag, NULL, 0);
  1229. /* Check if the packet is from a valid peer */
  1230. peer_id = DP_PEER_METADATA_PEER_ID_GET(
  1231. mpdu_desc_info->peer_meta_data);
  1232. peer = dp_peer_find_by_id(soc, peer_id);
  1233. if (!peer) {
  1234. /* We should not receive anything from unknown peer
  1235. * however, that might happen while we are in the monitor mode.
  1236. * We don't need to handle that here
  1237. */
  1238. dp_info_rl("Unknown peer with peer_id %d, dropping fragment",
  1239. peer_id);
  1240. DP_STATS_INC(soc, rx.rx_frag_err_no_peer, 1);
  1241. goto discard_frag;
  1242. }
  1243. if (tid >= DP_MAX_TIDS) {
  1244. dp_info("TID out of bounds: %d", tid);
  1245. qdf_assert_always(0);
  1246. }
  1247. pdev = peer->vdev->pdev;
  1248. rx_tid = &peer->rx_tid[tid];
  1249. mpdu_sequence_control_valid =
  1250. hal_rx_get_mpdu_sequence_control_valid(soc->hal_soc,
  1251. rx_desc->rx_buf_start);
  1252. /* Invalid MPDU sequence control field, MPDU is of no use */
  1253. if (!mpdu_sequence_control_valid) {
  1254. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1255. "Invalid MPDU seq control field, dropping MPDU");
  1256. qdf_assert(0);
  1257. goto discard_frag;
  1258. }
  1259. mpdu_frame_control_valid =
  1260. hal_rx_get_mpdu_frame_control_valid(soc->hal_soc,
  1261. rx_desc->rx_buf_start);
  1262. /* Invalid frame control field */
  1263. if (!mpdu_frame_control_valid) {
  1264. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1265. "Invalid frame control field, dropping MPDU");
  1266. qdf_assert(0);
  1267. goto discard_frag;
  1268. }
  1269. /* Current mpdu sequence */
  1270. more_frag = dp_rx_frag_get_more_frag_bit(rx_desc->rx_buf_start);
  1271. /* HW does not populate the fragment number as of now
  1272. * need to get from the 802.11 header
  1273. */
  1274. fragno = dp_rx_frag_get_mpdu_frag_number(rx_desc->rx_buf_start);
  1275. rx_reorder_array_elem = peer->rx_tid[tid].array;
  1276. if (!rx_reorder_array_elem) {
  1277. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1278. "Rcvd Fragmented pkt before peer_tid is setup");
  1279. goto discard_frag;
  1280. }
  1281. /*
  1282. * !more_frag: no more fragments to be delivered
  1283. * !frag_no: packet is not fragmented
  1284. * !rx_reorder_array_elem->head: no saved fragments so far
  1285. */
  1286. if ((!more_frag) && (!fragno) && (!rx_reorder_array_elem->head)) {
  1287. /* We should not get into this situation here.
  1288. * It means an unfragmented packet with fragment flag
  1289. * is delivered over the REO exception ring.
  1290. * Typically it follows normal rx path.
  1291. */
  1292. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1293. "Rcvd unfragmented pkt on REO Err srng, dropping");
  1294. qdf_assert(0);
  1295. goto discard_frag;
  1296. }
  1297. /* Check if the fragment is for the same sequence or a different one */
  1298. if (rx_reorder_array_elem->head) {
  1299. if (rxseq != rx_tid->curr_seq_num) {
  1300. /* Drop stored fragments if out of sequence
  1301. * fragment is received
  1302. */
  1303. dp_rx_reorder_flush_frag(peer, tid);
  1304. DP_STATS_INC(soc, rx.rx_frag_err, 1);
  1305. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1306. "%s mismatch, dropping earlier sequence ",
  1307. (rxseq == rx_tid->curr_seq_num)
  1308. ? "address"
  1309. : "seq number");
  1310. /*
  1311. * The sequence number for this fragment becomes the
  1312. * new sequence number to be processed
  1313. */
  1314. rx_tid->curr_seq_num = rxseq;
  1315. }
  1316. } else {
  1317. /* Start of a new sequence */
  1318. dp_rx_defrag_cleanup(peer, tid);
  1319. rx_tid->curr_seq_num = rxseq;
  1320. }
  1321. /*
  1322. * If the earlier sequence was dropped, this will be the fresh start.
  1323. * Else, continue with next fragment in a given sequence
  1324. */
  1325. status = dp_rx_defrag_fraglist_insert(peer, tid, &rx_reorder_array_elem->head,
  1326. &rx_reorder_array_elem->tail, frag,
  1327. &all_frag_present);
  1328. /*
  1329. * Currently, we can have only 6 MSDUs per-MPDU, if the current
  1330. * packet sequence has more than 6 MSDUs for some reason, we will
  1331. * have to use the next MSDU link descriptor and chain them together
  1332. * before reinjection
  1333. */
  1334. if ((fragno == 0) && (status == QDF_STATUS_SUCCESS) &&
  1335. (rx_reorder_array_elem->head == frag)) {
  1336. qdf_assert_always(ring_desc);
  1337. status = dp_rx_defrag_save_info_from_ring_desc(ring_desc,
  1338. rx_desc, peer, tid);
  1339. if (status != QDF_STATUS_SUCCESS) {
  1340. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1341. "%s: Unable to store ring desc !", __func__);
  1342. goto discard_frag;
  1343. }
  1344. } else {
  1345. dp_rx_add_to_free_desc_list(head, tail, rx_desc);
  1346. *rx_bfs = 1;
  1347. /* Return the non-head link desc */
  1348. if (ring_desc &&
  1349. dp_rx_link_desc_return(soc, ring_desc,
  1350. HAL_BM_ACTION_PUT_IN_IDLE_LIST) !=
  1351. QDF_STATUS_SUCCESS)
  1352. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1353. "%s: Failed to return link desc", __func__);
  1354. }
  1355. if (pdev->soc->rx.flags.defrag_timeout_check)
  1356. dp_rx_defrag_waitlist_remove(peer, tid);
  1357. /* Yet to receive more fragments for this sequence number */
  1358. if (!all_frag_present) {
  1359. uint32_t now_ms =
  1360. qdf_system_ticks_to_msecs(qdf_system_ticks());
  1361. peer->rx_tid[tid].defrag_timeout_ms =
  1362. now_ms + pdev->soc->rx.defrag.timeout_ms;
  1363. dp_rx_defrag_waitlist_add(peer, tid);
  1364. dp_peer_unref_del_find_by_id(peer);
  1365. return QDF_STATUS_SUCCESS;
  1366. }
  1367. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
  1368. "All fragments received for sequence: %d", rxseq);
  1369. /* Process the fragments */
  1370. status = dp_rx_defrag(peer, tid, rx_reorder_array_elem->head,
  1371. rx_reorder_array_elem->tail);
  1372. if (QDF_IS_STATUS_ERROR(status)) {
  1373. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1374. "Fragment processing failed");
  1375. dp_rx_add_to_free_desc_list(head, tail,
  1376. peer->rx_tid[tid].head_frag_desc);
  1377. *rx_bfs = 1;
  1378. if (dp_rx_link_desc_return(soc,
  1379. peer->rx_tid[tid].dst_ring_desc,
  1380. HAL_BM_ACTION_PUT_IN_IDLE_LIST) !=
  1381. QDF_STATUS_SUCCESS)
  1382. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1383. "%s: Failed to return link desc",
  1384. __func__);
  1385. dp_rx_defrag_cleanup(peer, tid);
  1386. goto end;
  1387. }
  1388. /* Re-inject the fragments back to REO for further processing */
  1389. status = dp_rx_defrag_reo_reinject(peer, tid,
  1390. rx_reorder_array_elem->head);
  1391. if (QDF_IS_STATUS_SUCCESS(status)) {
  1392. rx_reorder_array_elem->head = NULL;
  1393. rx_reorder_array_elem->tail = NULL;
  1394. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
  1395. "Fragmented sequence successfully reinjected");
  1396. } else {
  1397. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1398. "Fragmented sequence reinjection failed");
  1399. dp_rx_return_head_frag_desc(peer, tid);
  1400. }
  1401. dp_rx_defrag_cleanup(peer, tid);
  1402. dp_peer_unref_del_find_by_id(peer);
  1403. return QDF_STATUS_SUCCESS;
  1404. discard_frag:
  1405. qdf_nbuf_free(frag);
  1406. dp_rx_add_to_free_desc_list(head, tail, rx_desc);
  1407. if (dp_rx_link_desc_return(soc, ring_desc,
  1408. HAL_BM_ACTION_PUT_IN_IDLE_LIST) !=
  1409. QDF_STATUS_SUCCESS)
  1410. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1411. "%s: Failed to return link desc", __func__);
  1412. *rx_bfs = 1;
  1413. end:
  1414. if (peer)
  1415. dp_peer_unref_del_find_by_id(peer);
  1416. DP_STATS_INC(soc, rx.rx_frag_err, 1);
  1417. return QDF_STATUS_E_DEFRAG_ERROR;
  1418. }
  1419. /**
  1420. * dp_rx_frag_handle() - Handles fragmented Rx frames
  1421. *
  1422. * @soc: core txrx main context
  1423. * @ring_desc: opaque pointer to the REO error ring descriptor
  1424. * @mpdu_desc_info: MPDU descriptor information from ring descriptor
  1425. * @head: head of the local descriptor free-list
  1426. * @tail: tail of the local descriptor free-list
  1427. * @quota: No. of units (packets) that can be serviced in one shot.
  1428. *
  1429. * This function implements RX 802.11 fragmentation handling
  1430. * The handling is mostly same as legacy fragmentation handling.
  1431. * If required, this function can re-inject the frames back to
  1432. * REO ring (with proper setting to by-pass fragmentation check
  1433. * but use duplicate detection / re-ordering and routing these frames
  1434. * to a different core.
  1435. *
  1436. * Return: uint32_t: No. of elements processed
  1437. */
  1438. uint32_t dp_rx_frag_handle(struct dp_soc *soc, hal_ring_desc_t ring_desc,
  1439. struct hal_rx_mpdu_desc_info *mpdu_desc_info,
  1440. struct dp_rx_desc *rx_desc,
  1441. uint8_t *mac_id,
  1442. uint32_t quota)
  1443. {
  1444. uint32_t rx_bufs_used = 0;
  1445. qdf_nbuf_t msdu = NULL;
  1446. uint32_t tid;
  1447. int rx_bfs = 0;
  1448. struct dp_pdev *pdev;
  1449. QDF_STATUS status = QDF_STATUS_SUCCESS;
  1450. qdf_assert(soc);
  1451. qdf_assert(mpdu_desc_info);
  1452. qdf_assert(rx_desc);
  1453. dp_debug("Number of MSDUs to process, num_msdus: %d",
  1454. mpdu_desc_info->msdu_count);
  1455. if (qdf_unlikely(mpdu_desc_info->msdu_count == 0)) {
  1456. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1457. "Not sufficient MSDUs to process");
  1458. return rx_bufs_used;
  1459. }
  1460. /* all buffers in MSDU link belong to same pdev */
  1461. pdev = soc->pdev_list[rx_desc->pool_id];
  1462. *mac_id = rx_desc->pool_id;
  1463. msdu = rx_desc->nbuf;
  1464. qdf_nbuf_unmap_single(soc->osdev, msdu, QDF_DMA_FROM_DEVICE);
  1465. rx_desc->unmapped = 1;
  1466. rx_desc->rx_buf_start = qdf_nbuf_data(msdu);
  1467. tid = hal_rx_mpdu_start_tid_get(soc->hal_soc, rx_desc->rx_buf_start);
  1468. /* Process fragment-by-fragment */
  1469. status = dp_rx_defrag_store_fragment(soc, ring_desc,
  1470. &pdev->free_list_head,
  1471. &pdev->free_list_tail,
  1472. mpdu_desc_info,
  1473. tid, rx_desc, &rx_bfs);
  1474. if (rx_bfs)
  1475. rx_bufs_used++;
  1476. if (!QDF_IS_STATUS_SUCCESS(status))
  1477. dp_info_rl("Rx Defrag err seq#:0x%x msdu_count:%d flags:%d",
  1478. mpdu_desc_info->mpdu_seq,
  1479. mpdu_desc_info->msdu_count,
  1480. mpdu_desc_info->mpdu_flags);
  1481. return rx_bufs_used;
  1482. }
  1483. QDF_STATUS dp_rx_defrag_add_last_frag(struct dp_soc *soc,
  1484. struct dp_peer *peer, uint16_t tid,
  1485. uint16_t rxseq, qdf_nbuf_t nbuf)
  1486. {
  1487. struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
  1488. struct dp_rx_reorder_array_elem *rx_reorder_array_elem;
  1489. uint8_t all_frag_present;
  1490. uint32_t msdu_len;
  1491. QDF_STATUS status;
  1492. rx_reorder_array_elem = peer->rx_tid[tid].array;
  1493. /*
  1494. * HW may fill in unexpected peer_id in RX PKT TLV,
  1495. * if this peer_id related peer is valid by coincidence,
  1496. * but actually this peer won't do dp_peer_rx_init(like SAP vdev
  1497. * self peer), then invalid access to rx_reorder_array_elem happened.
  1498. */
  1499. if (!rx_reorder_array_elem) {
  1500. dp_verbose_debug(
  1501. "peer id:%d mac:" QDF_MAC_ADDR_STR "drop rx frame!",
  1502. peer->peer_ids[0],
  1503. QDF_MAC_ADDR_ARRAY(peer->mac_addr.raw));
  1504. DP_STATS_INC(soc, rx.err.defrag_peer_uninit, 1);
  1505. qdf_nbuf_free(nbuf);
  1506. goto fail;
  1507. }
  1508. if (rx_reorder_array_elem->head &&
  1509. rxseq != rx_tid->curr_seq_num) {
  1510. /* Drop stored fragments if out of sequence
  1511. * fragment is received
  1512. */
  1513. dp_rx_reorder_flush_frag(peer, tid);
  1514. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1515. "%s: No list found for TID %d Seq# %d",
  1516. __func__, tid, rxseq);
  1517. qdf_nbuf_free(nbuf);
  1518. goto fail;
  1519. }
  1520. msdu_len = hal_rx_msdu_start_msdu_len_get(qdf_nbuf_data(nbuf));
  1521. qdf_nbuf_set_pktlen(nbuf, (msdu_len + RX_PKT_TLVS_LEN));
  1522. status = dp_rx_defrag_fraglist_insert(peer, tid,
  1523. &rx_reorder_array_elem->head,
  1524. &rx_reorder_array_elem->tail, nbuf,
  1525. &all_frag_present);
  1526. if (QDF_IS_STATUS_ERROR(status)) {
  1527. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1528. "%s Fragment insert failed", __func__);
  1529. goto fail;
  1530. }
  1531. if (soc->rx.flags.defrag_timeout_check)
  1532. dp_rx_defrag_waitlist_remove(peer, tid);
  1533. if (!all_frag_present) {
  1534. uint32_t now_ms =
  1535. qdf_system_ticks_to_msecs(qdf_system_ticks());
  1536. peer->rx_tid[tid].defrag_timeout_ms =
  1537. now_ms + soc->rx.defrag.timeout_ms;
  1538. dp_rx_defrag_waitlist_add(peer, tid);
  1539. return QDF_STATUS_SUCCESS;
  1540. }
  1541. status = dp_rx_defrag(peer, tid, rx_reorder_array_elem->head,
  1542. rx_reorder_array_elem->tail);
  1543. if (QDF_IS_STATUS_ERROR(status)) {
  1544. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1545. "%s Fragment processing failed", __func__);
  1546. dp_rx_return_head_frag_desc(peer, tid);
  1547. dp_rx_defrag_cleanup(peer, tid);
  1548. goto fail;
  1549. }
  1550. /* Re-inject the fragments back to REO for further processing */
  1551. status = dp_rx_defrag_reo_reinject(peer, tid,
  1552. rx_reorder_array_elem->head);
  1553. if (QDF_IS_STATUS_SUCCESS(status)) {
  1554. rx_reorder_array_elem->head = NULL;
  1555. rx_reorder_array_elem->tail = NULL;
  1556. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_INFO,
  1557. "%s: Frag seq successfully reinjected",
  1558. __func__);
  1559. } else {
  1560. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1561. "%s: Frag seq reinjection failed", __func__);
  1562. dp_rx_return_head_frag_desc(peer, tid);
  1563. }
  1564. dp_rx_defrag_cleanup(peer, tid);
  1565. return QDF_STATUS_SUCCESS;
  1566. fail:
  1567. return QDF_STATUS_E_DEFRAG_ERROR;
  1568. }