dp_tx_capture.c 70 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514
  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 <htt.h>
  19. #include "qdf_trace.h"
  20. #include "qdf_nbuf.h"
  21. #include "dp_peer.h"
  22. #include "dp_types.h"
  23. #include "dp_internal.h"
  24. #include "dp_rx_mon.h"
  25. #include "htt_ppdu_stats.h"
  26. #include "dp_htt.h"
  27. #include "qdf_mem.h" /* qdf_mem_malloc,free */
  28. #include "cdp_txrx_cmn_struct.h"
  29. #include <enet.h>
  30. #include "dp_tx_capture.h"
  31. #define MAX_MONITOR_HEADER (512)
  32. #define MAX_DUMMY_FRM_BODY (128)
  33. /* Macros to handle sequence number bitmaps */
  34. /* Size (in bits) of a segment of sequence number bitmap */
  35. #define SEQ_SEG_SZ_BITS(_seqarr) (sizeof(_seqarr[0]) << 3)
  36. /* Array index of a segment of sequence number bitmap */
  37. #define SEQ_SEG_INDEX(_seqarr, _seqno) ((_seqno) / SEQ_SEG_SZ_BITS(_seqarr))
  38. /* Bit mask of a seqno within a segment of sequence bitmap */
  39. #define SEQ_SEG_MSK(_seqseg, _index) \
  40. (1 << ((_index) & ((sizeof(_seqseg) << 3) - 1)))
  41. /* Check seqno bit in a segment of sequence bitmap */
  42. #define SEQ_SEG_BIT(_seqseg, _index) \
  43. ((_seqseg) & SEQ_SEG_MSK((_seqseg), _index))
  44. /* Segment of sequence bitmap containing a given sequence number */
  45. #define SEQ_SEG(_seqarr, _seqno) \
  46. (_seqarr[(_seqno) / (sizeof(_seqarr[0]) << 3)])
  47. /* Check seqno bit in the sequence bitmap */
  48. #define SEQ_BIT(_seqarr, _seqno) \
  49. SEQ_SEG_BIT(SEQ_SEG(_seqarr, (_seqno)), (_seqno))
  50. #ifdef WLAN_TX_PKT_CAPTURE_ENH
  51. /*
  52. * dp_tx_capture_htt_frame_counter: increment counter for htt_frame_type
  53. * pdev: DP pdev handle
  54. * htt_frame_type: htt frame type received from fw
  55. *
  56. * return: void
  57. */
  58. void dp_tx_capture_htt_frame_counter(struct dp_pdev *pdev,
  59. uint32_t htt_frame_type)
  60. {
  61. if (htt_frame_type >= TX_CAP_HTT_MAX_FTYPE)
  62. return;
  63. pdev->tx_capture.htt_frame_type[htt_frame_type]++;
  64. }
  65. /*
  66. * dp_tx_cature_stats: print tx capture stats
  67. * @pdev: DP PDEV handle
  68. *
  69. * return: void
  70. */
  71. void dp_print_pdev_tx_capture_stats(struct dp_pdev *pdev)
  72. {
  73. struct dp_pdev_tx_capture *ptr_tx_cap;
  74. uint8_t i = 0, j = 0;
  75. ptr_tx_cap = &(pdev->tx_capture);
  76. DP_PRINT_STATS("tx capture stats\n");
  77. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  78. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  79. if (ptr_tx_cap->ctl_mgmt_q[i][j].qlen)
  80. DP_PRINT_STATS(" ctl_mgmt_q[%d][%d] = queue_len[%d]\n",
  81. i, j, ptr_tx_cap->ctl_mgmt_q[i][j].qlen);
  82. }
  83. }
  84. for (i = 0; i < TX_CAP_HTT_MAX_FTYPE; i++) {
  85. if (!ptr_tx_cap->htt_frame_type[i])
  86. continue;
  87. DP_PRINT_STATS(" sgen htt frame type[%d] = %d",
  88. i, ptr_tx_cap->htt_frame_type[i]);
  89. }
  90. }
  91. /**
  92. * dp_peer_or_pdev_tx_cap_enabled - Returns status of tx_cap_enabled
  93. * based on global per-pdev setting or per-peer setting
  94. * @pdev: Datapath pdev handle
  95. * @peer: Datapath peer
  96. *
  97. * Return: true if feature is enabled on a per-pdev basis or if
  98. * enabled for the given peer when per-peer mode is set, false otherwise
  99. */
  100. inline bool
  101. dp_peer_or_pdev_tx_cap_enabled(struct dp_pdev *pdev,
  102. struct dp_peer *peer)
  103. {
  104. if ((pdev->tx_capture_enabled ==
  105. CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS) ||
  106. ((pdev->tx_capture_enabled ==
  107. CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) &&
  108. peer->tx_cap_enabled))
  109. return true;
  110. return false;
  111. }
  112. /*
  113. * dp_peer_tid_queue_init() – Initialize ppdu stats queue per TID
  114. * @peer: Datapath peer
  115. *
  116. */
  117. void dp_peer_tid_queue_init(struct dp_peer *peer)
  118. {
  119. int tid;
  120. struct dp_tx_tid *tx_tid;
  121. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  122. tx_tid = &peer->tx_capture.tx_tid[tid];
  123. tx_tid->tid = tid;
  124. qdf_nbuf_queue_init(&tx_tid->msdu_comp_q);
  125. qdf_nbuf_queue_init(&tx_tid->pending_ppdu_q);
  126. tx_tid->max_ppdu_id = 0;
  127. /* spinlock create */
  128. qdf_spinlock_create(&tx_tid->tid_lock);
  129. }
  130. }
  131. /*
  132. * dp_peer_tid_queue_cleanup() – remove ppdu stats queue per TID
  133. * @peer: Datapath peer
  134. *
  135. */
  136. void dp_peer_tid_queue_cleanup(struct dp_peer *peer)
  137. {
  138. int tid;
  139. struct dp_tx_tid *tx_tid;
  140. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  141. tx_tid = &peer->tx_capture.tx_tid[tid];
  142. qdf_spin_lock_bh(&tx_tid->tid_lock);
  143. qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
  144. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  145. /* spinlock destroy */
  146. qdf_spinlock_destroy(&tx_tid->tid_lock);
  147. tx_tid->max_ppdu_id = 0;
  148. }
  149. }
  150. /*
  151. * dp_peer_update_80211_hdr: update 80211 hdr
  152. * @vdev: DP VDEV
  153. * @peer: DP PEER
  154. *
  155. * return: void
  156. */
  157. void dp_peer_update_80211_hdr(struct dp_vdev *vdev, struct dp_peer *peer)
  158. {
  159. struct ieee80211_frame *ptr_wh;
  160. ptr_wh = &peer->tx_capture.tx_wifi_hdr;
  161. /* i_addr1 - Receiver mac address */
  162. /* i_addr2 - Transmitter mac address */
  163. /* i_addr3 - Destination mac address */
  164. qdf_mem_copy(ptr_wh->i_addr1,
  165. peer->mac_addr.raw,
  166. QDF_MAC_ADDR_SIZE);
  167. qdf_mem_copy(ptr_wh->i_addr3,
  168. peer->mac_addr.raw,
  169. QDF_MAC_ADDR_SIZE);
  170. qdf_mem_copy(ptr_wh->i_addr2,
  171. vdev->mac_addr.raw,
  172. QDF_MAC_ADDR_SIZE);
  173. }
  174. /*
  175. * dp_deliver_mgmt_frm: Process
  176. * @pdev: DP PDEV handle
  177. * @nbuf: buffer containing the htt_ppdu_stats_tx_mgmtctrl_payload_tlv
  178. *
  179. * return: void
  180. */
  181. void dp_deliver_mgmt_frm(struct dp_pdev *pdev, qdf_nbuf_t nbuf)
  182. {
  183. uint32_t ppdu_id;
  184. if (pdev->tx_sniffer_enable || pdev->mcopy_mode) {
  185. dp_wdi_event_handler(WDI_EVENT_TX_MGMT_CTRL, pdev->soc,
  186. nbuf, HTT_INVALID_PEER,
  187. WDI_NO_VAL, pdev->pdev_id);
  188. return;
  189. }
  190. if (pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS ||
  191. pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) {
  192. /* invoke WDI event handler here send mgmt pkt here */
  193. struct ieee80211_frame *wh;
  194. uint8_t type, subtype;
  195. ppdu_id = *(uint32_t *)qdf_nbuf_data(nbuf);
  196. wh = (struct ieee80211_frame *)(qdf_nbuf_data(nbuf) +
  197. sizeof(uint32_t));
  198. type = (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) >>
  199. IEEE80211_FC0_TYPE_SHIFT;
  200. subtype = (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) >>
  201. IEEE80211_FC0_SUBTYPE_SHIFT;
  202. qdf_spin_lock_bh(
  203. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  204. qdf_nbuf_queue_add(&pdev->tx_capture.ctl_mgmt_q[type][subtype],
  205. nbuf);
  206. qdf_spin_unlock_bh(
  207. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  208. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  209. "dlvr mgmt frm(0x%08x): fc 0x%x %x, dur 0x%x%x\n",
  210. ppdu_id, wh->i_fc[1], wh->i_fc[0],
  211. wh->i_dur[1], wh->i_dur[0]);
  212. }
  213. }
  214. /**
  215. * dp_tx_ppdu_stats_attach - Initialize Tx PPDU stats and enhanced capture
  216. * @pdev: DP PDEV
  217. *
  218. * Return: none
  219. */
  220. void dp_tx_ppdu_stats_attach(struct dp_pdev *pdev)
  221. {
  222. int i, j;
  223. /* Work queue setup for HTT stats and tx capture handling */
  224. qdf_create_work(0, &pdev->tx_capture.ppdu_stats_work,
  225. dp_tx_ppdu_stats_process,
  226. pdev);
  227. pdev->tx_capture.ppdu_stats_workqueue =
  228. qdf_alloc_unbound_workqueue("ppdu_stats_work_queue");
  229. STAILQ_INIT(&pdev->tx_capture.ppdu_stats_queue);
  230. STAILQ_INIT(&pdev->tx_capture.ppdu_stats_defer_queue);
  231. qdf_spinlock_create(&pdev->tx_capture.ppdu_stats_lock);
  232. pdev->tx_capture.ppdu_stats_queue_depth = 0;
  233. pdev->tx_capture.ppdu_stats_next_sched = 0;
  234. pdev->tx_capture.ppdu_stats_defer_queue_depth = 0;
  235. pdev->tx_capture.ppdu_dropped = 0;
  236. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  237. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  238. qdf_nbuf_queue_init(
  239. &pdev->tx_capture.ctl_mgmt_q[i][j]);
  240. qdf_spinlock_create(
  241. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  242. }
  243. }
  244. }
  245. /**
  246. * dp_tx_ppdu_stats_detach - Cleanup Tx PPDU stats and enhanced capture
  247. * @pdev: DP PDEV
  248. *
  249. * Return: none
  250. */
  251. void dp_tx_ppdu_stats_detach(struct dp_pdev *pdev)
  252. {
  253. struct ppdu_info *ppdu_info, *tmp_ppdu_info = NULL;
  254. int i, j;
  255. if (!pdev || !pdev->tx_capture.ppdu_stats_workqueue)
  256. return;
  257. qdf_flush_workqueue(0, pdev->tx_capture.ppdu_stats_workqueue);
  258. qdf_destroy_workqueue(0, pdev->tx_capture.ppdu_stats_workqueue);
  259. qdf_spinlock_destroy(&pdev->tx_capture.ppdu_stats_lock);
  260. STAILQ_FOREACH_SAFE(ppdu_info,
  261. &pdev->tx_capture.ppdu_stats_queue,
  262. ppdu_info_queue_elem, tmp_ppdu_info) {
  263. STAILQ_REMOVE(&pdev->tx_capture.ppdu_stats_queue,
  264. ppdu_info, ppdu_info, ppdu_info_queue_elem);
  265. qdf_nbuf_free(ppdu_info->nbuf);
  266. qdf_mem_free(ppdu_info);
  267. }
  268. STAILQ_FOREACH_SAFE(ppdu_info,
  269. &pdev->tx_capture.ppdu_stats_defer_queue,
  270. ppdu_info_queue_elem, tmp_ppdu_info) {
  271. STAILQ_REMOVE(&pdev->tx_capture.ppdu_stats_defer_queue,
  272. ppdu_info, ppdu_info, ppdu_info_queue_elem);
  273. qdf_nbuf_free(ppdu_info->nbuf);
  274. qdf_mem_free(ppdu_info);
  275. }
  276. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  277. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  278. qdf_spin_lock_bh(
  279. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  280. qdf_nbuf_queue_free(
  281. &pdev->tx_capture.ctl_mgmt_q[i][j]);
  282. qdf_spin_unlock_bh(
  283. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  284. qdf_spinlock_destroy(
  285. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  286. }
  287. }
  288. }
  289. /**
  290. * dp_update_msdu_to_list(): Function to queue msdu from wbm
  291. * @pdev: dp_pdev
  292. * @peer: dp_peer
  293. * @ts: hal tx completion status
  294. * @netbuf: msdu
  295. *
  296. * return: status
  297. */
  298. QDF_STATUS
  299. dp_update_msdu_to_list(struct dp_soc *soc,
  300. struct dp_pdev *pdev,
  301. struct dp_peer *peer,
  302. struct hal_tx_completion_status *ts,
  303. qdf_nbuf_t netbuf)
  304. {
  305. struct dp_tx_tid *tx_tid;
  306. struct msdu_completion_info *msdu_comp_info;
  307. if (!peer) {
  308. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  309. "%s: %d peer NULL !", __func__, __LINE__);
  310. return QDF_STATUS_E_FAILURE;
  311. }
  312. if (ts->tid > DP_MAX_TIDS) {
  313. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  314. "%s: %d peer_id %d, tid %d > NON_QOS_TID!",
  315. __func__, __LINE__, ts->peer_id, ts->tid);
  316. return QDF_STATUS_E_FAILURE;
  317. }
  318. tx_tid = &peer->tx_capture.tx_tid[ts->tid];
  319. if (!tx_tid) {
  320. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  321. "%s: %d tid[%d] NULL !", __func__, __LINE__, ts->tid);
  322. return QDF_STATUS_E_FAILURE;
  323. }
  324. qdf_nbuf_unmap(soc->osdev, netbuf, QDF_DMA_TO_DEVICE);
  325. if (!qdf_nbuf_push_head(netbuf, sizeof(struct msdu_completion_info))) {
  326. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  327. FL("No headroom"));
  328. return QDF_STATUS_E_NOMEM;
  329. }
  330. msdu_comp_info = (struct msdu_completion_info *)qdf_nbuf_data(netbuf);
  331. /* copy msdu_completion_info to control buffer */
  332. msdu_comp_info->ppdu_id = ts->ppdu_id;
  333. msdu_comp_info->peer_id = ts->peer_id;
  334. msdu_comp_info->tid = ts->tid;
  335. msdu_comp_info->first_msdu = ts->first_msdu;
  336. msdu_comp_info->last_msdu = ts->last_msdu;
  337. msdu_comp_info->msdu_part_of_amsdu = ts->msdu_part_of_amsdu;
  338. msdu_comp_info->transmit_cnt = ts->transmit_cnt;
  339. msdu_comp_info->tsf = ts->tsf;
  340. msdu_comp_info->status = ts->status;
  341. /* update max ppdu_id */
  342. tx_tid->max_ppdu_id = ts->ppdu_id;
  343. pdev->tx_capture.last_msdu_id = ts->ppdu_id;
  344. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  345. "msdu_completion: ppdu_id[%d] peer_id[%d] tid[%d] rel_src[%d] status[%d] tsf[%u] A[%d] CNT[%d]",
  346. ts->ppdu_id, ts->peer_id, ts->tid, ts->release_src,
  347. ts->status, ts->tsf, ts->msdu_part_of_amsdu,
  348. ts->transmit_cnt);
  349. /* lock here */
  350. qdf_spin_lock_bh(&tx_tid->tid_lock);
  351. /* add nbuf to tail queue per peer tid */
  352. qdf_nbuf_queue_add(&tx_tid->msdu_comp_q, netbuf);
  353. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  354. return QDF_STATUS_SUCCESS;
  355. }
  356. /**
  357. * dp_tx_add_to_comp_queue() - add completion msdu to queue
  358. * @soc: DP Soc handle
  359. * @tx_desc: software Tx descriptor
  360. * @ts : Tx completion status from HAL/HTT descriptor
  361. * @peer: DP peer
  362. *
  363. * Return: none
  364. */
  365. QDF_STATUS dp_tx_add_to_comp_queue(struct dp_soc *soc,
  366. struct dp_tx_desc_s *desc,
  367. struct hal_tx_completion_status *ts,
  368. struct dp_peer *peer)
  369. {
  370. int ret = QDF_STATUS_E_FAILURE;
  371. if ((desc->pdev->tx_capture_enabled != CDP_TX_ENH_CAPTURE_DISABLED) &&
  372. ((ts->status == HAL_TX_TQM_RR_FRAME_ACKED) ||
  373. (ts->status == HAL_TX_TQM_RR_REM_CMD_TX) ||
  374. ((ts->status == HAL_TX_TQM_RR_REM_CMD_AGED) && ts->transmit_cnt))) {
  375. ret = dp_update_msdu_to_list(soc, desc->pdev,
  376. peer, ts, desc->nbuf);
  377. }
  378. return ret;
  379. }
  380. /**
  381. * dp_process_ppdu_stats_update_failed_bitmap(): update failed bitmap
  382. * @pdev: dp_pdev
  383. * @data: tx completion ppdu desc
  384. * @ppdu_id: ppdu id
  385. * @size: size of bitmap
  386. *
  387. * return: status
  388. */
  389. void dp_process_ppdu_stats_update_failed_bitmap(struct dp_pdev *pdev,
  390. void *data,
  391. uint32_t ppdu_id,
  392. uint32_t size)
  393. {
  394. struct cdp_tx_completion_ppdu_user *user;
  395. uint32_t mpdu_tried;
  396. uint32_t ba_seq_no;
  397. uint32_t start_seq;
  398. uint32_t num_mpdu;
  399. uint32_t diff;
  400. uint32_t carry = 0;
  401. uint32_t bitmask = 0;
  402. uint32_t i;
  403. uint32_t k;
  404. uint32_t ba_bitmap = 0;
  405. int last_set_bit;
  406. user = (struct cdp_tx_completion_ppdu_user *)data;
  407. /* get number of mpdu from ppdu_desc */
  408. mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;
  409. ba_seq_no = user->ba_seq_no;
  410. start_seq = user->start_seq;
  411. num_mpdu = user->num_mpdu;
  412. /* assumption: number of mpdu will be less than 32 */
  413. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  414. "ppdu_id[%d] ba_seq_no[%d] start_seq_no[%d] mpdu_tried[%d]",
  415. ppdu_id, ba_seq_no, start_seq, mpdu_tried);
  416. for (i = 0; i < size; i++) {
  417. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  418. "ppdu_id[%d] ba_bitmap[%x] enqueue_bitmap[%x]",
  419. ppdu_id, user->ba_bitmap[i], user->enq_bitmap[i]);
  420. }
  421. /* Handle sequence no. wraparound */
  422. if (start_seq <= ba_seq_no) {
  423. diff = ba_seq_no - start_seq;
  424. /* Sequence delta of more than 2048 is considered wraparound
  425. * and we extend start_seq to be more than ba_seq just to
  426. * adjust failed_bitmap
  427. */
  428. if (qdf_unlikely(diff > (IEEE80211_SEQ_MAX / 2))) {
  429. diff = (start_seq - ba_seq_no) &
  430. (IEEE80211_SEQ_MAX - 1);
  431. start_seq = ba_seq_no + diff;
  432. }
  433. } else {
  434. diff = start_seq - ba_seq_no;
  435. /* Sequence delta of more than 2048 is considered wraparound
  436. * and we extend ba_seq to be more than start_seq just to
  437. * adjust failed_bitmap
  438. */
  439. if (qdf_unlikely(diff > (IEEE80211_SEQ_MAX / 2))) {
  440. diff = (ba_seq_no - start_seq) &
  441. (IEEE80211_SEQ_MAX - 1);
  442. ba_seq_no = start_seq + diff;
  443. }
  444. }
  445. /* Adjust failed_bitmap to start from same seq_no as enq_bitmap */
  446. last_set_bit = 0;
  447. if (start_seq <= ba_seq_no) {
  448. bitmask = (1 << diff) - 1;
  449. for (i = 0; i < size; i++) {
  450. ba_bitmap = user->ba_bitmap[i];
  451. user->failed_bitmap[i] = (ba_bitmap << diff);
  452. user->failed_bitmap[i] |= (bitmask & carry);
  453. carry = ((ba_bitmap & (bitmask << (32 - diff))) >>
  454. (32 - diff));
  455. user->failed_bitmap[i] = user->enq_bitmap[i] &
  456. user->failed_bitmap[i];
  457. if (user->enq_bitmap[i]) {
  458. last_set_bit = i * 32 +
  459. qdf_fls(user->enq_bitmap[i]) - 1;
  460. }
  461. }
  462. } else {
  463. /* array index */
  464. k = diff >> 5;
  465. diff = diff & 0x1F;
  466. bitmask = (1 << diff) - 1;
  467. for (i = 0; i < size; i++, k++) {
  468. ba_bitmap = user->ba_bitmap[k];
  469. user->failed_bitmap[i] = ba_bitmap >> diff;
  470. /* get next ba_bitmap */
  471. ba_bitmap = user->ba_bitmap[k + 1];
  472. carry = (ba_bitmap & bitmask);
  473. user->failed_bitmap[i] |=
  474. ((carry & bitmask) << (32 - diff));
  475. user->failed_bitmap[i] = user->enq_bitmap[i] &
  476. user->failed_bitmap[i];
  477. if (user->enq_bitmap[i]) {
  478. last_set_bit = i * 32 +
  479. qdf_fls(user->enq_bitmap[i]) - 1;
  480. }
  481. }
  482. }
  483. user->last_enq_seq = user->start_seq + last_set_bit;
  484. user->ba_size = user->last_enq_seq - user->start_seq + 1;
  485. }
  486. /*
  487. * dp_soc_set_txrx_ring_map_single()
  488. * @dp_soc: DP handler for soc
  489. *
  490. * Return: Void
  491. */
  492. static void dp_soc_set_txrx_ring_map_single(struct dp_soc *soc)
  493. {
  494. uint32_t i;
  495. for (i = 0; i < WLAN_CFG_INT_NUM_CONTEXTS; i++) {
  496. soc->tx_ring_map[i] =
  497. dp_cpu_ring_map[DP_SINGLE_TX_RING_MAP][i];
  498. }
  499. }
  500. /*
  501. * dp_iterate_free_peer_msdu_q()- API to free msdu queue
  502. * @pdev_handle: DP_PDEV handle
  503. *
  504. * Return: void
  505. */
  506. static void dp_iterate_free_peer_msdu_q(void *pdev_hdl)
  507. {
  508. struct dp_pdev *pdev = (struct dp_pdev *)pdev_hdl;
  509. struct dp_soc *soc = pdev->soc;
  510. struct dp_vdev *vdev = NULL;
  511. struct dp_peer *peer = NULL;
  512. qdf_spin_lock_bh(&soc->peer_ref_mutex);
  513. qdf_spin_lock_bh(&pdev->vdev_list_lock);
  514. DP_PDEV_ITERATE_VDEV_LIST(pdev, vdev) {
  515. DP_VDEV_ITERATE_PEER_LIST(vdev, peer) {
  516. int tid;
  517. struct dp_tx_tid *tx_tid;
  518. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  519. qdf_nbuf_t ppdu_nbuf = NULL;
  520. struct cdp_tx_completion_ppdu *ppdu_desc =
  521. NULL;
  522. int i;
  523. tx_tid = &peer->tx_capture.tx_tid[tid];
  524. /* spinlock hold */
  525. qdf_spin_lock_bh(&tx_tid->tid_lock);
  526. qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
  527. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  528. while ((ppdu_nbuf = qdf_nbuf_queue_remove(
  529. &tx_tid->pending_ppdu_q))) {
  530. ppdu_desc =
  531. (struct cdp_tx_completion_ppdu *)
  532. qdf_nbuf_data(ppdu_nbuf);
  533. if (!ppdu_desc->mpdus) {
  534. qdf_nbuf_free(ppdu_nbuf);
  535. continue;
  536. }
  537. for (i = 0; i <
  538. ppdu_desc->user[0].ba_size; i++) {
  539. if (!ppdu_desc->mpdus[i])
  540. continue;
  541. qdf_nbuf_free(
  542. ppdu_desc->mpdus[i]);
  543. }
  544. qdf_mem_free(ppdu_desc->mpdus);
  545. ppdu_desc->mpdus = NULL;
  546. qdf_nbuf_free(ppdu_nbuf);
  547. }
  548. }
  549. }
  550. }
  551. qdf_spin_unlock_bh(&pdev->vdev_list_lock);
  552. qdf_spin_unlock_bh(&soc->peer_ref_mutex);
  553. }
  554. /*
  555. * dp_config_enh_tx_capture()- API to enable/disable enhanced tx capture
  556. * @pdev_handle: DP_PDEV handle
  557. * @val: user provided value
  558. *
  559. * Return: QDF_STATUS
  560. */
  561. QDF_STATUS
  562. dp_config_enh_tx_capture(struct cdp_pdev *pdev_handle, uint8_t val)
  563. {
  564. struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
  565. int i, j;
  566. qdf_spin_lock(&pdev->tx_capture.config_lock);
  567. pdev->tx_capture_enabled = val;
  568. if (pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS ||
  569. pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) {
  570. dp_soc_set_txrx_ring_map_single(pdev->soc);
  571. if (!pdev->pktlog_ppdu_stats)
  572. dp_h2t_cfg_stats_msg_send(pdev,
  573. DP_PPDU_STATS_CFG_SNIFFER,
  574. pdev->pdev_id);
  575. } else {
  576. dp_soc_set_txrx_ring_map(pdev->soc);
  577. dp_h2t_cfg_stats_msg_send(pdev,
  578. DP_PPDU_STATS_CFG_ENH_STATS,
  579. pdev->pdev_id);
  580. dp_iterate_free_peer_msdu_q(pdev);
  581. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  582. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  583. qdf_spin_lock_bh(
  584. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  585. qdf_nbuf_queue_free(
  586. &pdev->tx_capture.ctl_mgmt_q[i][j]);
  587. qdf_spin_unlock_bh(
  588. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  589. }
  590. }
  591. }
  592. qdf_spin_unlock(&pdev->tx_capture.config_lock);
  593. return QDF_STATUS_SUCCESS;
  594. }
  595. /**
  596. * get_number_of_1s(): Function to get number of 1s
  597. * @value: value to find
  598. *
  599. * return: number of 1s
  600. */
  601. static
  602. inline uint32_t get_number_of_1s(uint32_t value)
  603. {
  604. uint32_t shift[] = {1, 2, 4, 8, 16};
  605. uint32_t magic_number[] = { 0x55555555, 0x33333333, 0x0F0F0F0F,
  606. 0x00FF00FF, 0x0000FFFF};
  607. uint8_t k = 0;
  608. for (; k <= 4; k++) {
  609. value = (value & magic_number[k]) +
  610. ((value >> shift[k]) & magic_number[k]);
  611. }
  612. return value;
  613. }
  614. /**
  615. * dp_tx_print_bitmap(): Function to print bitmap
  616. * @pdev: dp_pdev
  617. * @ppdu_desc: ppdu completion descriptor
  618. * @user_inder: user index
  619. * @ppdu_id: ppdu id
  620. *
  621. * return: status
  622. */
  623. static
  624. QDF_STATUS dp_tx_print_bitmap(struct dp_pdev *pdev,
  625. struct cdp_tx_completion_ppdu *ppdu_desc,
  626. uint32_t user_index,
  627. uint32_t ppdu_id)
  628. {
  629. struct cdp_tx_completion_ppdu_user *user;
  630. uint8_t i;
  631. uint32_t mpdu_tried;
  632. uint32_t ba_seq_no;
  633. uint32_t start_seq;
  634. uint32_t num_mpdu;
  635. uint32_t fail_num_mpdu = 0;
  636. user = &ppdu_desc->user[user_index];
  637. /* get number of mpdu from ppdu_desc */
  638. mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;
  639. ba_seq_no = user->ba_seq_no;
  640. start_seq = user->start_seq;
  641. num_mpdu = user->mpdu_success;
  642. if (user->tid > DP_MAX_TIDS) {
  643. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  644. "%s: ppdu[%d] peer_id[%d] TID[%d] > NON_QOS_TID!",
  645. __func__, ppdu_id, user->peer_id, user->tid);
  646. return QDF_STATUS_E_FAILURE;
  647. }
  648. if (mpdu_tried != num_mpdu) {
  649. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  650. "%s: ppdu[%d] peer[%d] tid[%d] ba[%d] start[%d] mpdu_tri[%d] num_mpdu[%d] is_mcast[%d]",
  651. __func__, ppdu_id, user->peer_id, user->tid,
  652. ba_seq_no, start_seq, mpdu_tried,
  653. num_mpdu, user->is_mcast);
  654. for (i = 0; i < CDP_BA_256_BIT_MAP_SIZE_DWORDS; i++) {
  655. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  656. QDF_TRACE_LEVEL_INFO,
  657. "ppdu_id[%d] ba_bitmap[0x%x] enqueue_bitmap[0x%x] failed_bitmap[0x%x]",
  658. ppdu_id, user->ba_bitmap[i],
  659. user->enq_bitmap[i],
  660. user->failed_bitmap[i]);
  661. fail_num_mpdu +=
  662. get_number_of_1s(user->failed_bitmap[i]);
  663. }
  664. }
  665. if (fail_num_mpdu == num_mpdu && num_mpdu)
  666. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  667. "%s: %d ppdu_id[%d] num_mpdu[%d, %d]",
  668. __func__, __LINE__, ppdu_id, num_mpdu, fail_num_mpdu);
  669. return QDF_STATUS_SUCCESS;
  670. }
  671. static uint32_t dp_tx_update_80211_hdr(struct dp_pdev *pdev,
  672. struct dp_peer *peer,
  673. void *data,
  674. qdf_nbuf_t nbuf,
  675. uint16_t ether_type,
  676. uint8_t *src_addr)
  677. {
  678. struct cdp_tx_completion_ppdu *ppdu_desc;
  679. struct ieee80211_frame *ptr_wh;
  680. struct ieee80211_qoscntl *ptr_qoscntl;
  681. uint32_t mpdu_buf_len;
  682. uint8_t *ptr_hdr;
  683. uint16_t eth_type = qdf_htons(ether_type);
  684. ppdu_desc = (struct cdp_tx_completion_ppdu *)data;
  685. ptr_wh = &peer->tx_capture.tx_wifi_hdr;
  686. ptr_qoscntl = &peer->tx_capture.tx_qoscntl;
  687. /*
  688. * update framectrl only for first ppdu_id
  689. * rest of mpdu will have same frame ctrl
  690. * mac address and duration
  691. */
  692. if (ppdu_desc->ppdu_id != peer->tx_capture.tx_wifi_ppdu_id) {
  693. ptr_wh->i_fc[1] = (ppdu_desc->frame_ctrl & 0xFF00) >> 8;
  694. ptr_wh->i_fc[0] = (ppdu_desc->frame_ctrl & 0xFF);
  695. ptr_wh->i_dur[1] = (ppdu_desc->tx_duration & 0xFF00) >> 8;
  696. ptr_wh->i_dur[0] = (ppdu_desc->tx_duration & 0xFF);
  697. ptr_qoscntl->i_qos[1] = (ppdu_desc->user[0].qos_ctrl &
  698. 0xFF00) >> 8;
  699. ptr_qoscntl->i_qos[0] = (ppdu_desc->user[0].qos_ctrl & 0xFF);
  700. /* Update Addr 3 (SA) with SA derived from ether packet */
  701. qdf_mem_copy(ptr_wh->i_addr3, src_addr, QDF_MAC_ADDR_SIZE);
  702. peer->tx_capture.tx_wifi_ppdu_id = ppdu_desc->ppdu_id;
  703. }
  704. mpdu_buf_len = sizeof(struct ieee80211_frame) + LLC_SNAP_HDR_LEN;
  705. if (qdf_likely(ppdu_desc->user[0].tid != DP_NON_QOS_TID))
  706. mpdu_buf_len += sizeof(struct ieee80211_qoscntl);
  707. nbuf->protocol = qdf_htons(ETH_P_802_2);
  708. /* update ieee80211_frame header */
  709. if (!qdf_nbuf_push_head(nbuf, mpdu_buf_len)) {
  710. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  711. FL("No headroom"));
  712. return QDF_STATUS_E_NOMEM;
  713. }
  714. ptr_hdr = (void *)qdf_nbuf_data(nbuf);
  715. qdf_mem_copy(ptr_hdr, ptr_wh, sizeof(struct ieee80211_frame));
  716. ptr_hdr = ptr_hdr + (sizeof(struct ieee80211_frame));
  717. /* update qoscntl header */
  718. if (qdf_likely(ppdu_desc->user[0].tid != DP_NON_QOS_TID)) {
  719. qdf_mem_copy(ptr_hdr, ptr_qoscntl,
  720. sizeof(struct ieee80211_qoscntl));
  721. ptr_hdr = ptr_hdr + sizeof(struct ieee80211_qoscntl);
  722. }
  723. /* update LLC */
  724. *ptr_hdr = LLC_SNAP_LSAP;
  725. *(ptr_hdr + 1) = LLC_SNAP_LSAP;
  726. *(ptr_hdr + 2) = LLC_UI;
  727. *(ptr_hdr + 3) = 0x00;
  728. *(ptr_hdr + 4) = 0x00;
  729. *(ptr_hdr + 5) = 0x00;
  730. *(ptr_hdr + 6) = (eth_type & 0xFF00) >> 8;
  731. *(ptr_hdr + 7) = (eth_type & 0xFF);
  732. qdf_nbuf_trim_tail(nbuf, qdf_nbuf_len(nbuf) - mpdu_buf_len);
  733. return 0;
  734. }
  735. /**
  736. * dp_tx_mon_restitch_mpdu(): Function to restitch msdu to mpdu
  737. * @pdev: dp_pdev
  738. * @peer: dp_peer
  739. * @head_msdu: head msdu queue
  740. *
  741. * return: status
  742. */
  743. static uint32_t
  744. dp_tx_mon_restitch_mpdu(struct dp_pdev *pdev, struct dp_peer *peer,
  745. struct cdp_tx_completion_ppdu *ppdu_desc,
  746. qdf_nbuf_queue_t *head_msdu,
  747. qdf_nbuf_queue_t *mpdu_q)
  748. {
  749. qdf_nbuf_t curr_nbuf = NULL;
  750. qdf_nbuf_t first_nbuf = NULL;
  751. qdf_nbuf_t prev_nbuf = NULL;
  752. qdf_nbuf_t mpdu_nbuf = NULL;
  753. struct msdu_completion_info *ptr_msdu_info = NULL;
  754. uint8_t first_msdu = 0;
  755. uint8_t last_msdu = 0;
  756. uint32_t frag_list_sum_len = 0;
  757. uint8_t first_msdu_not_seen = 1;
  758. uint16_t ether_type = 0;
  759. qdf_ether_header_t *eh = NULL;
  760. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  761. while (curr_nbuf) {
  762. ptr_msdu_info =
  763. (struct msdu_completion_info *)qdf_nbuf_data(curr_nbuf);
  764. first_msdu = ptr_msdu_info->first_msdu;
  765. last_msdu = ptr_msdu_info->last_msdu;
  766. eh = (qdf_ether_header_t *)(curr_nbuf->data +
  767. sizeof(struct msdu_completion_info));
  768. ether_type = eh->ether_type;
  769. /* pull msdu_completion_info added in pre header */
  770. qdf_nbuf_pull_head(curr_nbuf,
  771. sizeof(struct msdu_completion_info));
  772. if (first_msdu && first_msdu_not_seen) {
  773. first_nbuf = curr_nbuf;
  774. frag_list_sum_len = 0;
  775. first_msdu_not_seen = 0;
  776. /* pull ethernet header from first MSDU alone */
  777. qdf_nbuf_pull_head(curr_nbuf,
  778. sizeof(qdf_ether_header_t));
  779. mpdu_nbuf = qdf_nbuf_alloc(pdev->soc->osdev,
  780. MAX_MONITOR_HEADER,
  781. MAX_MONITOR_HEADER,
  782. 4, FALSE);
  783. if (!mpdu_nbuf) {
  784. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  785. QDF_TRACE_LEVEL_FATAL,
  786. "MPDU head allocation failed !!!");
  787. goto free_ppdu_desc_mpdu_q;
  788. }
  789. dp_tx_update_80211_hdr(pdev, peer,
  790. ppdu_desc, mpdu_nbuf,
  791. ether_type, eh->ether_shost);
  792. /* update first buffer to previous buffer */
  793. prev_nbuf = curr_nbuf;
  794. } else if (first_msdu && !first_msdu_not_seen) {
  795. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  796. QDF_TRACE_LEVEL_FATAL,
  797. "!!!!! NO LAST MSDU\n");
  798. /*
  799. * no last msdu in a mpdu
  800. * handle this case
  801. */
  802. qdf_nbuf_free(curr_nbuf);
  803. /*
  804. * No last msdu found because WBM comes out
  805. * of order, free the pkt
  806. */
  807. goto free_ppdu_desc_mpdu_q;
  808. } else if (!first_msdu && first_msdu_not_seen) {
  809. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  810. QDF_TRACE_LEVEL_FATAL,
  811. "!!!!! NO FIRST MSDU\n");
  812. /*
  813. * no first msdu in a mpdu
  814. * handle this case
  815. */
  816. qdf_nbuf_free(curr_nbuf);
  817. /*
  818. * no first msdu found beacuse WBM comes out
  819. * of order, free the pkt
  820. */
  821. goto free_ppdu_desc_mpdu_q;
  822. } else {
  823. /* update current buffer to previous buffer next */
  824. prev_nbuf->next = curr_nbuf;
  825. /* move the previous buffer to next buffer */
  826. prev_nbuf = prev_nbuf->next;
  827. }
  828. frag_list_sum_len += qdf_nbuf_len(curr_nbuf);
  829. if (last_msdu) {
  830. /*
  831. * first nbuf will hold list of msdu
  832. * stored in prev_nbuf
  833. */
  834. qdf_nbuf_append_ext_list(mpdu_nbuf,
  835. first_nbuf,
  836. frag_list_sum_len);
  837. /* add mpdu to mpdu queue */
  838. qdf_nbuf_queue_add(mpdu_q, mpdu_nbuf);
  839. first_nbuf = NULL;
  840. mpdu_nbuf = NULL;
  841. /* next msdu will start with first msdu */
  842. first_msdu_not_seen = 1;
  843. goto check_for_next_msdu;
  844. }
  845. /* get next msdu from the head_msdu */
  846. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  847. if (!curr_nbuf) {
  848. /* msdu missed in list */
  849. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  850. QDF_TRACE_LEVEL_FATAL,
  851. "!!!! WAITING for msdu but list empty !!!!");
  852. }
  853. continue;
  854. check_for_next_msdu:
  855. if (qdf_nbuf_is_queue_empty(head_msdu))
  856. return 0;
  857. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  858. }
  859. return 0;
  860. free_ppdu_desc_mpdu_q:
  861. /* free already chained msdu pkt */
  862. while (first_nbuf) {
  863. curr_nbuf = first_nbuf;
  864. first_nbuf = first_nbuf->next;
  865. qdf_nbuf_free(curr_nbuf);
  866. }
  867. /* free allocated mpdu hdr */
  868. if (mpdu_nbuf)
  869. qdf_nbuf_free(mpdu_nbuf);
  870. /* free queued remaining msdu pkt per ppdu */
  871. qdf_nbuf_queue_free(head_msdu);
  872. /* free queued mpdu per ppdu */
  873. qdf_nbuf_queue_free(mpdu_q);
  874. return 0;
  875. }
  876. /**
  877. * dp_tx_msdu_dequeue(): Function to dequeue msdu from peer based tid
  878. * @peer: dp_peer
  879. * @ppdu_id: ppdu_id
  880. * @tid: tid
  881. * @num_msdu: number of msdu
  882. * @head: head queue
  883. * @start_tsf: start tsf from ppdu_desc
  884. * @end_tsf: end tsf from ppdu_desc
  885. *
  886. * return: status
  887. */
  888. static
  889. uint32_t dp_tx_msdu_dequeue(struct dp_peer *peer, uint32_t ppdu_id,
  890. uint16_t tid, uint32_t num_msdu,
  891. qdf_nbuf_queue_t *head,
  892. qdf_nbuf_queue_t *head_xretries,
  893. uint32_t start_tsf, uint32_t end_tsf)
  894. {
  895. struct dp_tx_tid *tx_tid = NULL;
  896. uint32_t msdu_ppdu_id;
  897. qdf_nbuf_t curr_msdu = NULL;
  898. qdf_nbuf_t prev_msdu = NULL;
  899. struct msdu_completion_info *ptr_msdu_info = NULL;
  900. uint32_t wbm_tsf;
  901. uint32_t matched = 0;
  902. if (qdf_unlikely(!peer))
  903. return 0;
  904. tx_tid = &peer->tx_capture.tx_tid[tid];
  905. if (qdf_unlikely(!tx_tid))
  906. return 0;
  907. if (qdf_nbuf_is_queue_empty(&tx_tid->msdu_comp_q))
  908. return 0;
  909. /* lock here */
  910. qdf_spin_lock_bh(&tx_tid->tid_lock);
  911. curr_msdu = qdf_nbuf_queue_first(&tx_tid->msdu_comp_q);
  912. while (curr_msdu) {
  913. if (qdf_nbuf_queue_len(head) == num_msdu) {
  914. matched = 1;
  915. break;
  916. }
  917. ptr_msdu_info =
  918. (struct msdu_completion_info *)qdf_nbuf_data(curr_msdu);
  919. msdu_ppdu_id = ptr_msdu_info->ppdu_id;
  920. wbm_tsf = ptr_msdu_info->tsf;
  921. if ((ptr_msdu_info->status == HAL_TX_TQM_RR_REM_CMD_TX) ||
  922. (ptr_msdu_info->status == HAL_TX_TQM_RR_REM_CMD_AGED)) {
  923. /* Frames removed due to excessive retries */
  924. qdf_nbuf_queue_remove(&tx_tid->msdu_comp_q);
  925. qdf_nbuf_queue_add(head_xretries, curr_msdu);
  926. curr_msdu = qdf_nbuf_queue_first(
  927. &tx_tid->msdu_comp_q);
  928. prev_msdu = NULL;
  929. continue;
  930. }
  931. if (wbm_tsf > end_tsf) {
  932. /* PPDU being matched is older than MSDU at head of
  933. * completion queue. Return matched=1 to skip PPDU
  934. */
  935. matched = 1;
  936. break;
  937. }
  938. if (wbm_tsf && (wbm_tsf < start_tsf)) {
  939. /* remove the aged packet */
  940. qdf_nbuf_queue_remove(&tx_tid->msdu_comp_q);
  941. qdf_nbuf_free(curr_msdu);
  942. curr_msdu = qdf_nbuf_queue_first(
  943. &tx_tid->msdu_comp_q);
  944. prev_msdu = NULL;
  945. continue;
  946. }
  947. if (msdu_ppdu_id == ppdu_id) {
  948. if (qdf_likely(!prev_msdu)) {
  949. /* remove head */
  950. qdf_nbuf_queue_remove(&tx_tid->msdu_comp_q);
  951. /* add msdu to head queue */
  952. qdf_nbuf_queue_add(head, curr_msdu);
  953. /* get next msdu from msdu_comp_q */
  954. curr_msdu = qdf_nbuf_queue_first(
  955. &tx_tid->msdu_comp_q);
  956. continue;
  957. } else {
  958. /* update prev_msdu next to current msdu next */
  959. prev_msdu->next = curr_msdu->next;
  960. /* set current msdu next as NULL */
  961. curr_msdu->next = NULL;
  962. /* decrement length */
  963. ((qdf_nbuf_queue_t *)(
  964. &tx_tid->msdu_comp_q))->qlen--;
  965. /* add msdu to head queue */
  966. qdf_nbuf_queue_add(head, curr_msdu);
  967. /* set previous msdu to current msdu */
  968. curr_msdu = prev_msdu->next;
  969. continue;
  970. }
  971. }
  972. prev_msdu = curr_msdu;
  973. curr_msdu = prev_msdu->next;
  974. }
  975. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  976. return matched;
  977. }
  978. /**
  979. * get_mpdu_clone_from_next_ppdu(): Function to clone missing mpdu from
  980. * next ppdu
  981. * @nbuf_ppdu_desc_list: nbuf list
  982. * @ppdu_desc_cnt: ppdu_desc_cnt
  983. * @missed_seq_no:
  984. * @ppdu_id: ppdu_id
  985. * @mpdu_info: cdp_tx_indication_mpdu_info
  986. *
  987. * return: void
  988. */
  989. static
  990. qdf_nbuf_t get_mpdu_clone_from_next_ppdu(qdf_nbuf_t nbuf_ppdu_desc_list[],
  991. uint32_t ppdu_desc_cnt,
  992. uint16_t missed_seq_no,
  993. uint16_t peer_id, uint32_t ppdu_id)
  994. {
  995. uint32_t i = 0;
  996. uint32_t found = 0;
  997. uint32_t seq_no = 0;
  998. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  999. qdf_nbuf_t mpdu = NULL;
  1000. for (i = 1; i < ppdu_desc_cnt; i++) {
  1001. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1002. qdf_nbuf_data(nbuf_ppdu_desc_list[i]);
  1003. /* check if seq number is between the range */
  1004. if ((peer_id == ppdu_desc->user[0].peer_id) &&
  1005. ((missed_seq_no >= ppdu_desc->user[0].start_seq) &&
  1006. (missed_seq_no <= ppdu_desc->user[0].last_enq_seq))) {
  1007. seq_no = ppdu_desc->user[0].start_seq;
  1008. if (SEQ_BIT(ppdu_desc->user[0].failed_bitmap,
  1009. (missed_seq_no - seq_no))) {
  1010. found = 1;
  1011. break;
  1012. }
  1013. }
  1014. }
  1015. if (found == 0) {
  1016. /* mpdu not found in sched cmd id */
  1017. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  1018. "%s: missed seq_no[%d] ppdu_id[%d] [%d] not found!!!",
  1019. __func__, missed_seq_no, ppdu_id, ppdu_desc_cnt);
  1020. return NULL;
  1021. }
  1022. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  1023. "%s: seq_no[%d] missed ppdu_id[%d] m[%d] found in ppdu_id[%d]!!",
  1024. __func__,
  1025. missed_seq_no, ppdu_id,
  1026. (missed_seq_no - seq_no), ppdu_desc->ppdu_id);
  1027. mpdu = qdf_nbuf_queue_first(&ppdu_desc->mpdu_q);
  1028. if (!mpdu) {
  1029. /* bitmap shows it found sequence number, but
  1030. * MPDU not found in PPDU
  1031. */
  1032. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  1033. "%s: missed seq_no[%d] ppdu_id[%d] [%d] found but queue empty!!!",
  1034. __func__, missed_seq_no, ppdu_id, ppdu_desc_cnt);
  1035. return NULL;
  1036. }
  1037. for (i = 0; i < (missed_seq_no - seq_no); i++) {
  1038. mpdu = mpdu->next;
  1039. if (!mpdu) {
  1040. /*
  1041. * bitmap shows it found sequence number,
  1042. * but queue empty, do we need to allocate
  1043. * skb and send instead of NULL ?
  1044. * add counter here:
  1045. */
  1046. return NULL;
  1047. }
  1048. }
  1049. return qdf_nbuf_copy_expand(mpdu, MAX_MONITOR_HEADER, 0);
  1050. }
  1051. /**
  1052. * dp_tx_update_user_mpdu_info(): Function to update mpdu info
  1053. * from ppdu_desc
  1054. * @ppdu_id: ppdu_id
  1055. * @mpdu_info: cdp_tx_indication_mpdu_info
  1056. * @user: cdp_tx_completion_ppdu_user
  1057. *
  1058. * return: void
  1059. */
  1060. static void
  1061. dp_tx_update_user_mpdu_info(uint32_t ppdu_id,
  1062. struct cdp_tx_indication_mpdu_info *mpdu_info,
  1063. struct cdp_tx_completion_ppdu_user *user)
  1064. {
  1065. mpdu_info->ppdu_id = ppdu_id;
  1066. mpdu_info->frame_ctrl = user->frame_ctrl;
  1067. mpdu_info->qos_ctrl = user->qos_ctrl;
  1068. mpdu_info->tid = user->tid;
  1069. mpdu_info->ltf_size = user->ltf_size;
  1070. mpdu_info->he_re = user->he_re;
  1071. mpdu_info->txbf = user->txbf;
  1072. mpdu_info->bw = user->bw;
  1073. mpdu_info->nss = user->nss;
  1074. mpdu_info->mcs = user->mcs;
  1075. mpdu_info->preamble = user->preamble;
  1076. mpdu_info->gi = user->gi;
  1077. mpdu_info->ack_rssi = user->ack_rssi[0];
  1078. mpdu_info->tx_rate = user->tx_rate;
  1079. mpdu_info->ldpc = user->ldpc;
  1080. mpdu_info->ppdu_cookie = user->ppdu_cookie;
  1081. mpdu_info->long_retries = user->long_retries;
  1082. mpdu_info->short_retries = user->short_retries;
  1083. mpdu_info->completion_status = user->completion_status;
  1084. qdf_mem_copy(mpdu_info->mac_address, user->mac_addr, 6);
  1085. mpdu_info->ba_start_seq = user->ba_seq_no;
  1086. qdf_mem_copy(mpdu_info->ba_bitmap, user->ba_bitmap,
  1087. CDP_BA_256_BIT_MAP_SIZE_DWORDS * sizeof(uint32_t));
  1088. }
  1089. static inline
  1090. void dp_tx_update_sequence_number(qdf_nbuf_t nbuf, uint32_t seq_no)
  1091. {
  1092. struct ieee80211_frame *ptr_wh = NULL;
  1093. uint16_t wh_seq = 0;
  1094. if (!nbuf)
  1095. return;
  1096. /* update sequence number in frame header */
  1097. ptr_wh = (struct ieee80211_frame *)qdf_nbuf_data(nbuf);
  1098. wh_seq = (seq_no & 0xFFF) << 4;
  1099. qdf_mem_copy(ptr_wh->i_seq, &wh_seq, sizeof(uint16_t));
  1100. }
  1101. static inline
  1102. void dp_update_frame_ctrl_from_frame_type(void *desc)
  1103. {
  1104. struct cdp_tx_completion_ppdu *ppdu_desc = desc;
  1105. /* frame control is not set properly, sometimes it is zero */
  1106. switch (ppdu_desc->htt_frame_type) {
  1107. case HTT_STATS_FTYPE_SGEN_NDPA:
  1108. case HTT_STATS_FTYPE_SGEN_NDP:
  1109. case HTT_STATS_FTYPE_SGEN_AX_NDPA:
  1110. case HTT_STATS_FTYPE_SGEN_AX_NDP:
  1111. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_NDPA |
  1112. IEEE80211_FC0_TYPE_CTL);
  1113. break;
  1114. case HTT_STATS_FTYPE_SGEN_BRP:
  1115. case HTT_STATS_FTYPE_SGEN_MU_BRP:
  1116. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_BRPOLL |
  1117. IEEE80211_FC0_TYPE_CTL);
  1118. break;
  1119. case HTT_STATS_FTYPE_SGEN_RTS:
  1120. case HTT_STATS_FTYPE_SGEN_MU_RTS:
  1121. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_RTS |
  1122. IEEE80211_FC0_TYPE_CTL);
  1123. break;
  1124. case HTT_STATS_FTYPE_SGEN_CTS:
  1125. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_CTS |
  1126. IEEE80211_FC0_TYPE_CTL);
  1127. break;
  1128. case HTT_STATS_FTYPE_SGEN_CFEND:
  1129. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_CF_END |
  1130. IEEE80211_FC0_TYPE_CTL);
  1131. break;
  1132. case HTT_STATS_FTYPE_SGEN_MU_TRIG:
  1133. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_TRIGGER |
  1134. IEEE80211_FC0_TYPE_CTL);
  1135. break;
  1136. case HTT_STATS_FTYPE_SGEN_BAR:
  1137. case HTT_STATS_FTYPE_SGEN_MU_BAR:
  1138. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_BAR |
  1139. IEEE80211_FC0_TYPE_CTL);
  1140. break;
  1141. }
  1142. }
  1143. static inline
  1144. QDF_STATUS dp_send_dummy_mpdu_info_to_stack(struct dp_pdev *pdev,
  1145. void *desc)
  1146. {
  1147. struct dp_peer *peer;
  1148. struct cdp_tx_completion_ppdu *ppdu_desc = desc;
  1149. struct cdp_tx_completion_ppdu_user *user = &ppdu_desc->user[0];
  1150. struct ieee80211_ctlframe_addr2 *wh_min;
  1151. uint16_t frame_ctrl_le, duration_le;
  1152. struct cdp_tx_indication_info tx_capture_info;
  1153. struct cdp_tx_indication_mpdu_info *mpdu_info;
  1154. uint8_t type, subtype;
  1155. qdf_mem_set(&tx_capture_info,
  1156. sizeof(struct cdp_tx_indication_info),
  1157. 0);
  1158. tx_capture_info.mpdu_nbuf =
  1159. qdf_nbuf_alloc(pdev->soc->osdev,
  1160. MAX_MONITOR_HEADER + MAX_DUMMY_FRM_BODY,
  1161. MAX_MONITOR_HEADER,
  1162. 4, FALSE);
  1163. if (!tx_capture_info.mpdu_nbuf)
  1164. return QDF_STATUS_E_ABORTED;
  1165. mpdu_info = &tx_capture_info.mpdu_info;
  1166. mpdu_info->resp_type = ppdu_desc->resp_type;
  1167. mpdu_info->mprot_type = ppdu_desc->mprot_type;
  1168. mpdu_info->rts_success = ppdu_desc->rts_success;
  1169. mpdu_info->rts_failure = ppdu_desc->rts_failure;
  1170. /* update cdp_tx_indication_mpdu_info */
  1171. dp_tx_update_user_mpdu_info(ppdu_desc->bar_ppdu_id,
  1172. &tx_capture_info.mpdu_info,
  1173. &ppdu_desc->user[0]);
  1174. mpdu_info->ppdu_id = ppdu_desc->ppdu_id;
  1175. mpdu_info->channel_num = pdev->operating_channel;
  1176. mpdu_info->channel = ppdu_desc->channel;
  1177. mpdu_info->frame_type = ppdu_desc->frame_type;
  1178. mpdu_info->ppdu_start_timestamp = ppdu_desc->ppdu_start_timestamp;
  1179. mpdu_info->ppdu_end_timestamp = ppdu_desc->ppdu_end_timestamp;
  1180. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  1181. mpdu_info->seq_no = user->start_seq;
  1182. qdf_mem_copy(mpdu_info->mac_address, user->mac_addr, QDF_MAC_ADDR_SIZE);
  1183. mpdu_info->ba_start_seq = user->ba_seq_no;
  1184. qdf_mem_copy(mpdu_info->ba_bitmap, user->ba_bitmap,
  1185. CDP_BA_256_BIT_MAP_SIZE_DWORDS * sizeof(uint32_t));
  1186. mpdu_info->frame_ctrl = ppdu_desc->frame_ctrl;
  1187. type = (ppdu_desc->frame_ctrl & IEEE80211_FC0_TYPE_MASK);
  1188. subtype = (ppdu_desc->frame_ctrl & IEEE80211_FC0_SUBTYPE_MASK);
  1189. if (type == IEEE80211_FC0_TYPE_CTL &&
  1190. subtype == IEEE80211_FC0_SUBTYPE_BAR) {
  1191. mpdu_info->frame_ctrl = (IEEE80211_FC0_SUBTYPE_BAR |
  1192. IEEE80211_FC0_TYPE_CTL);
  1193. mpdu_info->ppdu_id = ppdu_desc->bar_ppdu_id;
  1194. mpdu_info->ppdu_start_timestamp =
  1195. ppdu_desc->bar_ppdu_start_timestamp;
  1196. mpdu_info->ppdu_end_timestamp =
  1197. ppdu_desc->bar_ppdu_end_timestamp;
  1198. mpdu_info->tx_duration = ppdu_desc->bar_tx_duration;
  1199. }
  1200. wh_min = (struct ieee80211_ctlframe_addr2 *)
  1201. qdf_nbuf_data(
  1202. tx_capture_info.mpdu_nbuf);
  1203. qdf_mem_zero(wh_min, MAX_DUMMY_FRM_BODY);
  1204. frame_ctrl_le =
  1205. qdf_cpu_to_le16(mpdu_info->frame_ctrl);
  1206. duration_le =
  1207. qdf_cpu_to_le16(ppdu_desc->bar_tx_duration);
  1208. wh_min->i_fc[1] = (frame_ctrl_le & 0xFF00) >> 8;
  1209. wh_min->i_fc[0] = (frame_ctrl_le & 0xFF);
  1210. wh_min->i_aidordur[1] = (duration_le & 0xFF00) >> 8;
  1211. wh_min->i_aidordur[0] = (duration_le & 0xFF);
  1212. qdf_mem_copy(wh_min->i_addr1,
  1213. mpdu_info->mac_address,
  1214. QDF_MAC_ADDR_SIZE);
  1215. peer = dp_peer_find_by_id(pdev->soc, user->peer_id);
  1216. if (peer) {
  1217. struct dp_vdev *vdev = NULL;
  1218. vdev = peer->vdev;
  1219. if (vdev)
  1220. qdf_mem_copy(wh_min->i_addr2,
  1221. vdev->mac_addr.raw,
  1222. QDF_MAC_ADDR_SIZE);
  1223. dp_peer_unref_del_find_by_id(peer);
  1224. }
  1225. qdf_nbuf_set_pktlen(tx_capture_info.mpdu_nbuf,
  1226. sizeof(*wh_min));
  1227. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1228. QDF_TRACE_LEVEL_DEBUG,
  1229. "HTT_FTYPE[%d] frm(0x%08x): fc %x %x, dur 0x%x%x\n",
  1230. ppdu_desc->htt_frame_type, mpdu_info->ppdu_id,
  1231. wh_min->i_fc[1], wh_min->i_fc[0],
  1232. wh_min->i_aidordur[1], wh_min->i_aidordur[0]);
  1233. /*
  1234. * send MPDU to osif layer
  1235. */
  1236. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  1237. &tx_capture_info, HTT_INVALID_PEER,
  1238. WDI_NO_VAL, pdev->pdev_id);
  1239. if (tx_capture_info.mpdu_nbuf)
  1240. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  1241. return QDF_STATUS_SUCCESS;
  1242. }
  1243. /**
  1244. * dp_send_mpdu_info_to_stack(): Function to deliver mpdu info to stack
  1245. * to upper layer
  1246. * @pdev: DP pdev handle
  1247. * @nbuf_ppdu_desc_list: ppdu_desc_list per sched cmd id
  1248. * @ppdu_desc_cnt: number of ppdu_desc_cnt
  1249. *
  1250. * return: status
  1251. */
  1252. static
  1253. void dp_send_mpdu_info_to_stack(struct dp_pdev *pdev,
  1254. struct cdp_tx_completion_ppdu
  1255. *ppdu_desc)
  1256. {
  1257. struct cdp_tx_indication_info tx_capture_info;
  1258. struct cdp_tx_indication_mpdu_info *mpdu_info;
  1259. int i;
  1260. uint32_t seq_no, start_seq;
  1261. uint32_t ppdu_id = ppdu_desc->ppdu_id;
  1262. qdf_mem_set(&tx_capture_info,
  1263. sizeof(struct cdp_tx_indication_info),
  1264. 0);
  1265. mpdu_info = &tx_capture_info.mpdu_info;
  1266. mpdu_info->channel = ppdu_desc->channel;
  1267. mpdu_info->frame_type = ppdu_desc->frame_type;
  1268. mpdu_info->ppdu_start_timestamp =
  1269. ppdu_desc->ppdu_start_timestamp;
  1270. mpdu_info->ppdu_end_timestamp =
  1271. ppdu_desc->ppdu_end_timestamp;
  1272. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  1273. mpdu_info->num_msdu = ppdu_desc->num_msdu;
  1274. mpdu_info->resp_type = ppdu_desc->resp_type;
  1275. mpdu_info->mprot_type = ppdu_desc->mprot_type;
  1276. mpdu_info->rts_success = ppdu_desc->rts_success;
  1277. mpdu_info->rts_failure = ppdu_desc->rts_failure;
  1278. /* update cdp_tx_indication_mpdu_info */
  1279. dp_tx_update_user_mpdu_info(ppdu_id,
  1280. &tx_capture_info.mpdu_info,
  1281. &ppdu_desc->user[0]);
  1282. tx_capture_info.mpdu_info.channel_num =
  1283. pdev->operating_channel;
  1284. start_seq = ppdu_desc->user[0].start_seq;
  1285. for (i = 0; i < ppdu_desc->user[0].ba_size; i++) {
  1286. if (qdf_likely(ppdu_desc->user[0].tid !=
  1287. DP_NON_QOS_TID) &&
  1288. !(SEQ_BIT(ppdu_desc->user[0].enq_bitmap, i))) {
  1289. continue;
  1290. }
  1291. seq_no = start_seq + i;
  1292. if (!ppdu_desc->mpdus[i])
  1293. continue;
  1294. tx_capture_info.mpdu_nbuf = ppdu_desc->mpdus[i];
  1295. ppdu_desc->mpdus[i] = NULL;
  1296. mpdu_info->seq_no = seq_no;
  1297. dp_tx_update_sequence_number(tx_capture_info.mpdu_nbuf, seq_no);
  1298. /*
  1299. * send MPDU to osif layer
  1300. * do we need to update mpdu_info before tranmit
  1301. * get current mpdu_nbuf
  1302. */
  1303. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  1304. &tx_capture_info,
  1305. HTT_INVALID_PEER,
  1306. WDI_NO_VAL, pdev->pdev_id);
  1307. if (tx_capture_info.mpdu_nbuf)
  1308. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  1309. }
  1310. }
  1311. static void
  1312. dp_tx_mon_proc_xretries(struct dp_pdev *pdev, struct dp_peer *peer,
  1313. uint16_t tid)
  1314. {
  1315. struct dp_tx_tid *tx_tid = &peer->tx_capture.tx_tid[tid];
  1316. struct cdp_tx_completion_ppdu *ppdu_desc;
  1317. struct cdp_tx_completion_ppdu *xretry_ppdu;
  1318. qdf_nbuf_t ppdu_nbuf;
  1319. qdf_nbuf_t mpdu_nbuf;
  1320. uint32_t mpdu_tried = 0;
  1321. int i;
  1322. uint32_t seq_no;
  1323. xretry_ppdu = &tx_tid->xretry_ppdu;
  1324. if (qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q)) {
  1325. qdf_nbuf_queue_free(&xretry_ppdu->mpdu_q);
  1326. return;
  1327. }
  1328. if (qdf_nbuf_is_queue_empty(&xretry_ppdu->mpdu_q))
  1329. return;
  1330. ppdu_nbuf = qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q);
  1331. while (ppdu_nbuf) {
  1332. struct msdu_completion_info *ptr_msdu_info = NULL;
  1333. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1334. qdf_nbuf_data(ppdu_nbuf);
  1335. if (ppdu_desc->pending_retries) {
  1336. uint32_t start_seq = ppdu_desc->user[0].start_seq;
  1337. mpdu_tried = ppdu_desc->user[0].mpdu_tried_ucast +
  1338. ppdu_desc->user[0].mpdu_tried_mcast;
  1339. mpdu_nbuf = qdf_nbuf_queue_first(&xretry_ppdu->mpdu_q);
  1340. for (i = 0; (mpdu_tried > 0) && mpdu_nbuf; i++) {
  1341. if (!(SEQ_BIT(ppdu_desc->user[0].enq_bitmap,
  1342. i)))
  1343. continue;
  1344. mpdu_tried--;
  1345. /* missed seq number */
  1346. seq_no = start_seq + i;
  1347. if (SEQ_BIT(ppdu_desc->user[0].failed_bitmap, i))
  1348. continue;
  1349. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1350. QDF_TRACE_LEVEL_INFO,
  1351. "%s: fill seqno %d from xretries",
  1352. __func__, seq_no);
  1353. ptr_msdu_info = (struct msdu_completion_info *)
  1354. (qdf_nbuf_data(qdf_nbuf_get_ext_list(
  1355. mpdu_nbuf)) -
  1356. (sizeof(struct msdu_completion_info) +
  1357. sizeof(qdf_ether_header_t)));
  1358. ptr_msdu_info->transmit_cnt--;
  1359. SEQ_SEG(ppdu_desc->user[0].failed_bitmap, i) |=
  1360. SEQ_SEG_MSK(ppdu_desc->user[0].failed_bitmap[0],
  1361. i);
  1362. ppdu_desc->pending_retries--;
  1363. if (ptr_msdu_info->transmit_cnt == 0) {
  1364. ppdu_desc->mpdus[seq_no - start_seq] =
  1365. mpdu_nbuf;
  1366. qdf_nbuf_queue_remove(
  1367. &xretry_ppdu->mpdu_q);
  1368. mpdu_nbuf = qdf_nbuf_queue_first(
  1369. &xretry_ppdu->mpdu_q);
  1370. } else {
  1371. ppdu_desc->mpdus[seq_no - start_seq] =
  1372. qdf_nbuf_copy_expand(mpdu_nbuf,
  1373. MAX_MONITOR_HEADER,
  1374. 0);
  1375. mpdu_nbuf =
  1376. qdf_nbuf_queue_next(mpdu_nbuf);
  1377. }
  1378. }
  1379. }
  1380. if ((ppdu_desc->pending_retries == 0) && (ppdu_nbuf ==
  1381. qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q))) {
  1382. qdf_nbuf_queue_remove(&tx_tid->pending_ppdu_q);
  1383. /* Deliver PPDU */
  1384. dp_send_mpdu_info_to_stack(pdev, ppdu_desc);
  1385. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  1386. qdf_mem_free(ppdu_desc->mpdus);
  1387. ppdu_desc->mpdus = NULL;
  1388. qdf_nbuf_free(ppdu_nbuf);
  1389. ppdu_nbuf = qdf_nbuf_queue_first(
  1390. &tx_tid->pending_ppdu_q);
  1391. } else {
  1392. ppdu_nbuf = qdf_nbuf_queue_next(ppdu_nbuf);
  1393. }
  1394. }
  1395. qdf_nbuf_queue_free(&xretry_ppdu->mpdu_q);
  1396. }
  1397. #define MAX_PENDING_PPDUS 32
  1398. static void
  1399. dp_tx_mon_proc_pending_ppdus(struct dp_pdev *pdev, struct dp_tx_tid *tx_tid,
  1400. qdf_nbuf_t nbuf_ppdu_desc_list[], uint32_t
  1401. ppdu_desc_cnt, qdf_nbuf_queue_t *head_ppdu,
  1402. uint32_t peer_id)
  1403. {
  1404. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  1405. struct cdp_tx_completion_ppdu *cur_ppdu_desc = NULL;
  1406. qdf_nbuf_t pend_ppdu;
  1407. uint32_t ppdu_cnt;
  1408. uint32_t failed_seq;
  1409. uint32_t cur_index, cur_start_seq, cur_last_seq;
  1410. int i, k;
  1411. bool last_pend_ppdu = false;
  1412. qdf_nbuf_t tmp_nbuf;
  1413. pend_ppdu = qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q);
  1414. if (!pend_ppdu) {
  1415. for (ppdu_cnt = 0; ppdu_cnt < ppdu_desc_cnt; ppdu_cnt++) {
  1416. if (!nbuf_ppdu_desc_list[ppdu_cnt])
  1417. continue;
  1418. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1419. qdf_nbuf_data(
  1420. nbuf_ppdu_desc_list[ppdu_cnt]);
  1421. if (!ppdu_desc || (peer_id !=
  1422. ppdu_desc->user[0].peer_id) || (tx_tid->tid !=
  1423. ppdu_desc->user[0].tid))
  1424. continue;
  1425. if ((ppdu_desc->pending_retries == 0) &&
  1426. qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q) &&
  1427. qdf_nbuf_is_queue_empty(head_ppdu)) {
  1428. dp_send_mpdu_info_to_stack(pdev, ppdu_desc);
  1429. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  1430. qdf_mem_free(ppdu_desc->mpdus);
  1431. ppdu_desc->mpdus = NULL;
  1432. tmp_nbuf = nbuf_ppdu_desc_list[ppdu_cnt];
  1433. nbuf_ppdu_desc_list[ppdu_cnt] = NULL;
  1434. qdf_nbuf_free(tmp_nbuf);
  1435. } else {
  1436. qdf_nbuf_queue_add(head_ppdu,
  1437. nbuf_ppdu_desc_list[ppdu_cnt]);
  1438. nbuf_ppdu_desc_list[ppdu_cnt] = NULL;
  1439. }
  1440. }
  1441. return;
  1442. }
  1443. while (pend_ppdu) {
  1444. qdf_nbuf_t mpdu_nbuf;
  1445. /* Find missing mpdus from current schedule list */
  1446. ppdu_cnt = 0;
  1447. if (!nbuf_ppdu_desc_list[ppdu_cnt]) {
  1448. ppdu_cnt++;
  1449. if (ppdu_cnt < ppdu_desc_cnt)
  1450. continue;
  1451. break;
  1452. }
  1453. ppdu_desc = (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(
  1454. pend_ppdu);
  1455. cur_ppdu_desc = (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(
  1456. nbuf_ppdu_desc_list[ppdu_cnt]);
  1457. if (pend_ppdu == qdf_nbuf_queue_last(
  1458. &tx_tid->pending_ppdu_q)) {
  1459. last_pend_ppdu = true;
  1460. qdf_nbuf_queue_add(head_ppdu,
  1461. nbuf_ppdu_desc_list[ppdu_cnt]);
  1462. nbuf_ppdu_desc_list[ppdu_cnt] = NULL;
  1463. }
  1464. cur_index = 0;
  1465. cur_start_seq = cur_ppdu_desc->user[0].start_seq;
  1466. cur_last_seq = cur_ppdu_desc->user[0].last_enq_seq;
  1467. if (qdf_unlikely(ppdu_desc->user[0].ba_size >
  1468. CDP_BA_256_BIT_MAP_SIZE_DWORDS *
  1469. SEQ_SEG_SZ_BITS(ppdu_desc->user[0].failed_bitmap))) {
  1470. qdf_assert_always(0);
  1471. return;
  1472. }
  1473. for (i = 0; (i < ppdu_desc->user[0].ba_size) && cur_ppdu_desc;
  1474. i++) {
  1475. if (!(i & (SEQ_SEG_SZ_BITS(
  1476. ppdu_desc->user[0].failed_bitmap) - 1))) {
  1477. k =
  1478. SEQ_SEG_INDEX(ppdu_desc->user[0].failed_bitmap,
  1479. i);
  1480. failed_seq =
  1481. ppdu_desc->user[0].failed_bitmap[k] ^
  1482. ppdu_desc->user[0].enq_bitmap[k];
  1483. }
  1484. /* Skip to next bitmap segment if there are no
  1485. * more holes in current segment
  1486. */
  1487. if (!failed_seq) {
  1488. i = ((k + 1) *
  1489. SEQ_SEG_SZ_BITS(ppdu_desc->user[0].failed_bitmap))
  1490. - 1;
  1491. continue;
  1492. }
  1493. if (!(SEQ_SEG_BIT(failed_seq, i)))
  1494. continue;
  1495. failed_seq ^= SEQ_SEG_MSK(failed_seq, i);
  1496. mpdu_nbuf = cur_ppdu_desc->mpdus[cur_index];
  1497. if (mpdu_nbuf) {
  1498. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1499. QDF_TRACE_LEVEL_INFO,
  1500. "%s: fill seqno %d (%d) from swretries",
  1501. __func__,
  1502. ppdu_desc->user[0].start_seq + i,
  1503. ppdu_desc->ppdu_id);
  1504. ppdu_desc->mpdus[i] =
  1505. qdf_nbuf_copy_expand(mpdu_nbuf,
  1506. MAX_MONITOR_HEADER, 0);
  1507. ppdu_desc->user[0].failed_bitmap[k] |=
  1508. SEQ_SEG_MSK(ppdu_desc->user[0].failed_bitmap[k],
  1509. i);
  1510. ppdu_desc->pending_retries--;
  1511. }
  1512. cur_index++;
  1513. /* Skip through empty slots in current PPDU */
  1514. while (!(SEQ_BIT(cur_ppdu_desc->user[0].enq_bitmap,
  1515. cur_index))) {
  1516. struct cdp_tx_completion_ppdu *next_ppdu = NULL;
  1517. cur_index++;
  1518. if (cur_index <= (cur_last_seq -
  1519. cur_start_seq))
  1520. continue;
  1521. cur_ppdu_desc = NULL;
  1522. /* Check if subsequent PPDUs in this schedule
  1523. * has higher sequence numbers enqueued
  1524. */
  1525. while (ppdu_cnt < (ppdu_desc_cnt - 1)) {
  1526. ppdu_cnt++;
  1527. if (!nbuf_ppdu_desc_list[ppdu_cnt])
  1528. continue;
  1529. next_ppdu =
  1530. (struct cdp_tx_completion_ppdu *)
  1531. qdf_nbuf_data(
  1532. nbuf_ppdu_desc_list[
  1533. ppdu_cnt]);
  1534. if (!next_ppdu || (peer_id !=
  1535. next_ppdu->user[0].peer_id))
  1536. continue;
  1537. if (last_pend_ppdu) {
  1538. qdf_nbuf_queue_add(head_ppdu,
  1539. nbuf_ppdu_desc_list[ppdu_cnt]);
  1540. nbuf_ppdu_desc_list[ppdu_cnt] =
  1541. NULL;
  1542. }
  1543. if (next_ppdu->user[0].last_enq_seq >
  1544. cur_last_seq) {
  1545. cur_ppdu_desc = next_ppdu;
  1546. break;
  1547. }
  1548. }
  1549. if (!cur_ppdu_desc)
  1550. break;
  1551. /* Start from seq. no following cur_last_seq
  1552. * since everything before is already populated
  1553. * from previous PPDU
  1554. */
  1555. cur_start_seq =
  1556. cur_ppdu_desc->user[0].start_seq;
  1557. cur_index = (cur_last_seq >= cur_start_seq) ?
  1558. cur_last_seq - cur_start_seq + 1 : 0;
  1559. cur_last_seq =
  1560. cur_ppdu_desc->user[0].last_enq_seq;
  1561. }
  1562. }
  1563. if ((pend_ppdu ==
  1564. qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q)) &&
  1565. (ppdu_desc->pending_retries == 0)) {
  1566. qdf_nbuf_queue_remove(&tx_tid->pending_ppdu_q);
  1567. dp_send_mpdu_info_to_stack(pdev, ppdu_desc);
  1568. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  1569. qdf_mem_free(ppdu_desc->mpdus);
  1570. ppdu_desc->mpdus = NULL;
  1571. qdf_nbuf_free(pend_ppdu);
  1572. pend_ppdu = qdf_nbuf_queue_first(
  1573. &tx_tid->pending_ppdu_q);
  1574. } else {
  1575. pend_ppdu = qdf_nbuf_queue_next(pend_ppdu);
  1576. }
  1577. }
  1578. }
  1579. /**
  1580. * dp_check_ppdu_and_deliver(): Check PPDUs for any holes and deliver
  1581. * to upper layer if complete
  1582. * @pdev: DP pdev handle
  1583. * @nbuf_ppdu_desc_list: ppdu_desc_list per sched cmd id
  1584. * @ppdu_desc_cnt: number of ppdu_desc_cnt
  1585. *
  1586. * return: status
  1587. */
  1588. static void
  1589. dp_check_ppdu_and_deliver(struct dp_pdev *pdev,
  1590. qdf_nbuf_t nbuf_ppdu_desc_list[],
  1591. uint32_t ppdu_desc_cnt)
  1592. {
  1593. uint32_t ppdu_id;
  1594. uint32_t desc_cnt;
  1595. qdf_nbuf_t tmp_nbuf;
  1596. struct dp_tx_tid *tx_tid = NULL;
  1597. int i;
  1598. for (desc_cnt = 0; desc_cnt < ppdu_desc_cnt; desc_cnt++) {
  1599. struct cdp_tx_completion_ppdu *ppdu_desc;
  1600. uint32_t num_mpdu;
  1601. uint16_t start_seq, seq_no = 0;
  1602. int i;
  1603. uint32_t len;
  1604. qdf_nbuf_t mpdu_nbuf;
  1605. struct dp_peer *peer;
  1606. if (!nbuf_ppdu_desc_list[desc_cnt])
  1607. continue;
  1608. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1609. qdf_nbuf_data(nbuf_ppdu_desc_list[desc_cnt]);
  1610. ppdu_id = ppdu_desc->ppdu_id;
  1611. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_CTRL ||
  1612. ppdu_desc->htt_frame_type ==
  1613. HTT_STATS_FTYPE_SGEN_QOS_NULL) {
  1614. struct cdp_tx_indication_info tx_capture_info;
  1615. struct cdp_tx_indication_mpdu_info *mpdu_info;
  1616. qdf_nbuf_t mgmt_ctl_nbuf;
  1617. uint8_t type, subtype;
  1618. qdf_mem_set(&tx_capture_info,
  1619. sizeof(struct cdp_tx_indication_info),
  1620. 0);
  1621. mpdu_info = &tx_capture_info.mpdu_info;
  1622. mpdu_info->channel = ppdu_desc->channel;
  1623. mpdu_info->frame_type = ppdu_desc->frame_type;
  1624. mpdu_info->ppdu_start_timestamp =
  1625. ppdu_desc->ppdu_start_timestamp;
  1626. mpdu_info->ppdu_end_timestamp =
  1627. ppdu_desc->ppdu_end_timestamp;
  1628. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  1629. mpdu_info->seq_no = seq_no;
  1630. mpdu_info->num_msdu = ppdu_desc->num_msdu;
  1631. mpdu_info->resp_type = ppdu_desc->resp_type;
  1632. mpdu_info->mprot_type = ppdu_desc->mprot_type;
  1633. mpdu_info->rts_success = ppdu_desc->rts_success;
  1634. mpdu_info->rts_failure = ppdu_desc->rts_failure;
  1635. /* update cdp_tx_indication_mpdu_info */
  1636. dp_tx_update_user_mpdu_info(ppdu_id,
  1637. &tx_capture_info.mpdu_info,
  1638. &ppdu_desc->user[0]);
  1639. tx_capture_info.mpdu_info.channel_num =
  1640. pdev->operating_channel;
  1641. if (!ppdu_desc->frame_ctrl)
  1642. dp_update_frame_ctrl_from_frame_type(ppdu_desc);
  1643. type = (ppdu_desc->frame_ctrl &
  1644. IEEE80211_FC0_TYPE_MASK) >>
  1645. IEEE80211_FC0_TYPE_SHIFT;
  1646. subtype = (ppdu_desc->frame_ctrl &
  1647. IEEE80211_FC0_SUBTYPE_MASK) >>
  1648. IEEE80211_FC0_SUBTYPE_SHIFT;
  1649. qdf_spin_lock_bh(
  1650. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  1651. mgmt_ctl_nbuf = qdf_nbuf_queue_remove(
  1652. &pdev->tx_capture.ctl_mgmt_q[type][subtype]);
  1653. qdf_spin_unlock_bh(
  1654. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  1655. if (mgmt_ctl_nbuf) {
  1656. struct ieee80211_frame *wh;
  1657. uint16_t duration_le, seq_le;
  1658. tx_capture_info.mpdu_nbuf =
  1659. qdf_nbuf_alloc(pdev->soc->osdev,
  1660. MAX_MONITOR_HEADER, MAX_MONITOR_HEADER,
  1661. 4, FALSE);
  1662. if (!tx_capture_info.mpdu_nbuf) {
  1663. qdf_nbuf_free(mgmt_ctl_nbuf);
  1664. goto free_ppdu_desc;
  1665. }
  1666. /* pull ppdu_id from the packet */
  1667. tx_capture_info.mpdu_info.ppdu_id =
  1668. *(uint32_t *)qdf_nbuf_data(mgmt_ctl_nbuf);
  1669. qdf_nbuf_pull_head(mgmt_ctl_nbuf, sizeof(uint32_t));
  1670. wh = (struct ieee80211_frame *)qdf_nbuf_data(mgmt_ctl_nbuf);
  1671. if (subtype != IEEE80211_FC0_SUBTYPE_BEACON) {
  1672. duration_le = qdf_cpu_to_le16(
  1673. ppdu_desc->tx_duration);
  1674. wh->i_dur[1] =
  1675. (duration_le & 0xFF00) >> 8;
  1676. wh->i_dur[0] = duration_le & 0xFF;
  1677. seq_le = qdf_cpu_to_le16(
  1678. ppdu_desc->user[0].start_seq <<
  1679. IEEE80211_SEQ_SEQ_SHIFT);
  1680. wh->i_seq[1] = (seq_le & 0xFF00) >> 8;
  1681. wh->i_seq[0] = seq_le & 0xFF;
  1682. }
  1683. qdf_nbuf_append_ext_list(
  1684. tx_capture_info.mpdu_nbuf,
  1685. mgmt_ctl_nbuf,
  1686. qdf_nbuf_len(mgmt_ctl_nbuf));
  1687. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1688. QDF_TRACE_LEVEL_DEBUG,
  1689. "ctrl/mgmt frm(0x%08x): fc 0x%x 0x%x\n",
  1690. tx_capture_info.mpdu_info.ppdu_id,
  1691. wh->i_fc[1], wh->i_fc[0]);
  1692. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1693. QDF_TRACE_LEVEL_DEBUG,
  1694. "desc->ppdu_id 0x%08x\n", ppdu_id);
  1695. } else {
  1696. dp_send_dummy_mpdu_info_to_stack(pdev,
  1697. ppdu_desc);
  1698. goto free_ppdu_desc;
  1699. }
  1700. /*
  1701. * send MPDU to osif layer
  1702. */
  1703. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  1704. &tx_capture_info, HTT_INVALID_PEER,
  1705. WDI_NO_VAL, pdev->pdev_id);
  1706. if (tx_capture_info.mpdu_nbuf)
  1707. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  1708. free_ppdu_desc:
  1709. tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
  1710. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  1711. qdf_nbuf_free(tmp_nbuf);
  1712. continue;
  1713. }
  1714. if (qdf_nbuf_is_queue_empty(&ppdu_desc->mpdu_q)) {
  1715. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR)
  1716. dp_send_dummy_mpdu_info_to_stack(pdev,
  1717. ppdu_desc);
  1718. tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
  1719. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  1720. qdf_nbuf_free(tmp_nbuf);
  1721. continue;
  1722. }
  1723. peer = dp_peer_find_by_id(pdev->soc,
  1724. ppdu_desc->user[0].peer_id);
  1725. if (!peer) {
  1726. tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
  1727. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  1728. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  1729. qdf_nbuf_free(tmp_nbuf);
  1730. continue;
  1731. }
  1732. tx_tid = &peer->tx_capture.tx_tid[ppdu_desc->user[0].tid];
  1733. ppdu_id = ppdu_desc->ppdu_id;
  1734. /* find mpdu tried is same as success mpdu */
  1735. num_mpdu = ppdu_desc->user[0].mpdu_success;
  1736. /* get length */
  1737. len = qdf_nbuf_queue_len(&ppdu_desc->mpdu_q);
  1738. /* ba_size is updated in BA bitmap TLVs, which are not received
  1739. * in case of non-QoS TID.
  1740. */
  1741. if (qdf_unlikely(ppdu_desc->user[0].tid == DP_NON_QOS_TID)) {
  1742. ppdu_desc->user[0].ba_size = 1;
  1743. ppdu_desc->user[0].last_enq_seq =
  1744. ppdu_desc->user[0].start_seq;
  1745. }
  1746. /* find list of missing sequence */
  1747. ppdu_desc->mpdus = qdf_mem_malloc(sizeof(qdf_nbuf_t) *
  1748. ppdu_desc->user[0].ba_size);
  1749. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR)
  1750. dp_send_dummy_mpdu_info_to_stack(pdev,
  1751. ppdu_desc);
  1752. if (qdf_unlikely(!ppdu_desc->mpdus)) {
  1753. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1754. QDF_TRACE_LEVEL_FATAL,
  1755. "%s: ppdu_desc->mpdus allocation failed",
  1756. __func__);
  1757. tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
  1758. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  1759. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  1760. qdf_nbuf_free(tmp_nbuf);
  1761. dp_peer_unref_del_find_by_id(peer);
  1762. continue;
  1763. }
  1764. if (qdf_unlikely(ppdu_desc->user[0].ba_size >
  1765. CDP_BA_256_BIT_MAP_SIZE_DWORDS *
  1766. SEQ_SEG_SZ_BITS(ppdu_desc->user[0].failed_bitmap))) {
  1767. dp_peer_unref_del_find_by_id(peer);
  1768. qdf_assert_always(0);
  1769. return;
  1770. }
  1771. /* Fill seq holes within current schedule list */
  1772. start_seq = ppdu_desc->user[0].start_seq;
  1773. for (i = 0; i < ppdu_desc->user[0].ba_size; i++) {
  1774. if (qdf_likely(ppdu_desc->user[0].tid !=
  1775. DP_NON_QOS_TID) &&
  1776. !(SEQ_BIT(ppdu_desc->user[0].enq_bitmap, i)))
  1777. continue;
  1778. /* missed seq number */
  1779. seq_no = start_seq + i;
  1780. /* Fill failed MPDUs in AMPDU if they're available in
  1781. * subsequent PPDUs in current burst schedule. This
  1782. * is not applicable for non-QoS TIDs (no AMPDUs)
  1783. */
  1784. if (qdf_likely(ppdu_desc->user[0].tid !=
  1785. DP_NON_QOS_TID) &&
  1786. !(SEQ_BIT(ppdu_desc->user[0].failed_bitmap, i))) {
  1787. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1788. QDF_TRACE_LEVEL_DEBUG,
  1789. "%s:find seq %d in next ppdu %d",
  1790. __func__, seq_no,
  1791. ppdu_desc_cnt);
  1792. mpdu_nbuf = get_mpdu_clone_from_next_ppdu(
  1793. nbuf_ppdu_desc_list +
  1794. desc_cnt,
  1795. ppdu_desc_cnt -
  1796. desc_cnt, seq_no,
  1797. ppdu_desc->user[0].peer_id,
  1798. ppdu_id);
  1799. /* check mpdu_nbuf NULL */
  1800. if (!mpdu_nbuf) {
  1801. ppdu_desc->pending_retries++;
  1802. continue;
  1803. }
  1804. ppdu_desc->mpdus[seq_no - start_seq] =
  1805. mpdu_nbuf;
  1806. SEQ_SEG(ppdu_desc->user[0].failed_bitmap, i) |=
  1807. SEQ_SEG_MSK(ppdu_desc->user[0].failed_bitmap[0],
  1808. i);
  1809. } else {
  1810. /* any error case we need to handle */
  1811. ppdu_desc->mpdus[seq_no - start_seq] =
  1812. qdf_nbuf_queue_remove(
  1813. &ppdu_desc->mpdu_q);
  1814. }
  1815. }
  1816. dp_peer_unref_del_find_by_id(peer);
  1817. if ((ppdu_desc->pending_retries == 0) &&
  1818. qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q)) {
  1819. dp_send_mpdu_info_to_stack(pdev, ppdu_desc);
  1820. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  1821. qdf_mem_free(ppdu_desc->mpdus);
  1822. ppdu_desc->mpdus = NULL;
  1823. tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
  1824. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  1825. qdf_nbuf_free(tmp_nbuf);
  1826. }
  1827. }
  1828. for (i = 0; i < ppdu_desc_cnt; i++) {
  1829. uint32_t pending_ppdus;
  1830. struct cdp_tx_completion_ppdu *cur_ppdu_desc;
  1831. struct dp_peer *peer;
  1832. qdf_nbuf_queue_t head_ppdu;
  1833. if (!nbuf_ppdu_desc_list[i])
  1834. continue;
  1835. cur_ppdu_desc = (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(
  1836. nbuf_ppdu_desc_list[i]);
  1837. if (!cur_ppdu_desc)
  1838. continue;
  1839. peer = dp_peer_find_by_id(pdev->soc,
  1840. cur_ppdu_desc->user[0].peer_id);
  1841. if (!peer) {
  1842. tmp_nbuf = nbuf_ppdu_desc_list[i];
  1843. nbuf_ppdu_desc_list[i] = NULL;
  1844. qdf_nbuf_queue_free(&cur_ppdu_desc->mpdu_q);
  1845. qdf_mem_free(cur_ppdu_desc->mpdus);
  1846. qdf_nbuf_free(tmp_nbuf);
  1847. continue;
  1848. }
  1849. tx_tid = &peer->tx_capture.tx_tid[cur_ppdu_desc->user[0].tid];
  1850. qdf_nbuf_queue_init(&head_ppdu);
  1851. dp_tx_mon_proc_pending_ppdus(pdev, tx_tid,
  1852. nbuf_ppdu_desc_list + i,
  1853. ppdu_desc_cnt - i, &head_ppdu,
  1854. cur_ppdu_desc->user[0].peer_id);
  1855. if (qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q)) {
  1856. while ((tmp_nbuf = qdf_nbuf_queue_first(&head_ppdu))) {
  1857. cur_ppdu_desc =
  1858. (struct cdp_tx_completion_ppdu *)
  1859. qdf_nbuf_data(tmp_nbuf);
  1860. if (cur_ppdu_desc->pending_retries)
  1861. break;
  1862. dp_send_mpdu_info_to_stack(pdev, cur_ppdu_desc);
  1863. qdf_nbuf_queue_free(&cur_ppdu_desc->mpdu_q);
  1864. qdf_mem_free(cur_ppdu_desc->mpdus);
  1865. cur_ppdu_desc->mpdus = NULL;
  1866. qdf_nbuf_queue_remove(&head_ppdu);
  1867. qdf_nbuf_free(tmp_nbuf);
  1868. }
  1869. }
  1870. qdf_nbuf_queue_append(&tx_tid->pending_ppdu_q, &head_ppdu);
  1871. dp_tx_mon_proc_xretries(pdev, peer, tx_tid->tid);
  1872. dp_peer_unref_del_find_by_id(peer);
  1873. pending_ppdus = qdf_nbuf_queue_len(&tx_tid->pending_ppdu_q);
  1874. if (pending_ppdus > MAX_PENDING_PPDUS) {
  1875. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1876. QDF_TRACE_LEVEL_FATAL,
  1877. "pending ppdus (%d, %d) : %d\n",
  1878. cur_ppdu_desc->user[0].peer_id,
  1879. tx_tid->tid, pending_ppdus);
  1880. }
  1881. }
  1882. }
  1883. /**
  1884. * dp_tx_ppdu_stats_process - Deferred PPDU stats handler
  1885. * @context: Opaque work context (PDEV)
  1886. *
  1887. * Return: none
  1888. */
  1889. void dp_tx_ppdu_stats_process(void *context)
  1890. {
  1891. uint32_t curr_sched_cmdid;
  1892. uint32_t last_ppdu_id;
  1893. uint32_t ppdu_cnt;
  1894. uint32_t ppdu_desc_cnt = 0;
  1895. struct dp_pdev *pdev = (struct dp_pdev *)context;
  1896. struct ppdu_info *ppdu_info, *tmp_ppdu_info = NULL;
  1897. uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
  1898. struct ppdu_info *sched_ppdu_info = NULL;
  1899. STAILQ_HEAD(, ppdu_info) sched_ppdu_queue;
  1900. struct ppdu_info *sched_ppdu_list_last_ptr;
  1901. qdf_nbuf_t *nbuf_ppdu_desc_list;
  1902. qdf_nbuf_t tmp_nbuf;
  1903. struct dp_pdev_tx_capture *ptr_tx_cap = &pdev->tx_capture;
  1904. qdf_nbuf_queue_t head_xretries;
  1905. STAILQ_INIT(&sched_ppdu_queue);
  1906. /* Move the PPDU entries to defer list */
  1907. qdf_spin_lock_bh(&ptr_tx_cap->ppdu_stats_lock);
  1908. STAILQ_CONCAT(&ptr_tx_cap->ppdu_stats_defer_queue,
  1909. &ptr_tx_cap->ppdu_stats_queue);
  1910. ptr_tx_cap->ppdu_stats_defer_queue_depth +=
  1911. ptr_tx_cap->ppdu_stats_queue_depth;
  1912. ptr_tx_cap->ppdu_stats_queue_depth = 0;
  1913. qdf_spin_unlock_bh(&ptr_tx_cap->ppdu_stats_lock);
  1914. while (!STAILQ_EMPTY(&ptr_tx_cap->ppdu_stats_defer_queue)) {
  1915. ppdu_info =
  1916. STAILQ_FIRST(&ptr_tx_cap->ppdu_stats_defer_queue);
  1917. curr_sched_cmdid = ppdu_info->sched_cmdid;
  1918. ppdu_cnt = 0;
  1919. STAILQ_FOREACH_SAFE(ppdu_info,
  1920. &ptr_tx_cap->ppdu_stats_defer_queue,
  1921. ppdu_info_queue_elem, tmp_ppdu_info) {
  1922. if (curr_sched_cmdid != ppdu_info->sched_cmdid)
  1923. break;
  1924. sched_ppdu_list_last_ptr = ppdu_info;
  1925. ppdu_cnt++;
  1926. }
  1927. if (ppdu_info && (curr_sched_cmdid == ppdu_info->sched_cmdid) &&
  1928. ptr_tx_cap->ppdu_stats_next_sched < now_ms)
  1929. break;
  1930. last_ppdu_id = sched_ppdu_list_last_ptr->ppdu_id;
  1931. STAILQ_FIRST(&sched_ppdu_queue) =
  1932. STAILQ_FIRST(&ptr_tx_cap->ppdu_stats_defer_queue);
  1933. STAILQ_REMOVE_HEAD_UNTIL(&ptr_tx_cap->ppdu_stats_defer_queue,
  1934. sched_ppdu_list_last_ptr,
  1935. ppdu_info_queue_elem);
  1936. STAILQ_NEXT(sched_ppdu_list_last_ptr,
  1937. ppdu_info_queue_elem) = NULL;
  1938. ptr_tx_cap->ppdu_stats_defer_queue_depth -= ppdu_cnt;
  1939. nbuf_ppdu_desc_list =
  1940. (qdf_nbuf_t *) qdf_mem_malloc(sizeof(qdf_nbuf_t) *
  1941. ppdu_cnt);
  1942. /*
  1943. * if there is no memory allocated we need to free sched ppdu
  1944. * list, no ppdu stats will be updated.
  1945. */
  1946. if (!nbuf_ppdu_desc_list) {
  1947. STAILQ_FOREACH_SAFE(sched_ppdu_info,
  1948. &sched_ppdu_queue,
  1949. ppdu_info_queue_elem,
  1950. tmp_ppdu_info) {
  1951. ppdu_info = sched_ppdu_info;
  1952. tmp_nbuf = ppdu_info->nbuf;
  1953. qdf_mem_free(ppdu_info);
  1954. qdf_nbuf_free(tmp_nbuf);
  1955. }
  1956. continue;
  1957. }
  1958. qdf_spin_lock(&ptr_tx_cap->config_lock);
  1959. ppdu_desc_cnt = 0;
  1960. STAILQ_FOREACH_SAFE(sched_ppdu_info,
  1961. &sched_ppdu_queue,
  1962. ppdu_info_queue_elem, tmp_ppdu_info) {
  1963. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  1964. struct dp_peer *peer = NULL;
  1965. qdf_nbuf_t nbuf;
  1966. uint32_t retries = 0;
  1967. uint32_t ret = 0;
  1968. qdf_nbuf_queue_t head_msdu;
  1969. uint32_t start_tsf = 0;
  1970. uint32_t end_tsf = 0;
  1971. uint16_t tid = 0;
  1972. uint32_t num_msdu = 0;
  1973. uint32_t qlen = 0;
  1974. qdf_nbuf_queue_init(&head_msdu);
  1975. qdf_nbuf_queue_init(&head_xretries);
  1976. ppdu_info = sched_ppdu_info;
  1977. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1978. qdf_nbuf_data(ppdu_info->nbuf);
  1979. pdev->tx_ppdu_proc++;
  1980. dp_ppdu_desc_user_stats_update(pdev, ppdu_info);
  1981. /*
  1982. * While processing/corelating Tx buffers, we should
  1983. * hold the entire PPDU list for the give sched_cmdid
  1984. * instead of freeing below.
  1985. */
  1986. nbuf = ppdu_info->nbuf;
  1987. qdf_mem_free(ppdu_info);
  1988. qdf_assert_always(nbuf);
  1989. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1990. qdf_nbuf_data(nbuf);
  1991. /* send WDI event */
  1992. if (pdev->tx_capture_enabled ==
  1993. CDP_TX_ENH_CAPTURE_DISABLED) {
  1994. /**
  1995. * Deliver PPDU stats only for valid (acked)
  1996. * data frames if sniffer mode is not enabled.
  1997. * If sniffer mode is enabled,
  1998. * PPDU stats for all frames including
  1999. * mgmt/control frames should be delivered
  2000. * to upper layer
  2001. */
  2002. if (pdev->tx_sniffer_enable ||
  2003. pdev->mcopy_mode) {
  2004. dp_wdi_event_handler(
  2005. WDI_EVENT_TX_PPDU_DESC,
  2006. pdev->soc,
  2007. nbuf,
  2008. HTT_INVALID_PEER,
  2009. WDI_NO_VAL,
  2010. pdev->pdev_id);
  2011. } else {
  2012. if (ppdu_desc->num_mpdu != 0 &&
  2013. ppdu_desc->num_users != 0 &&
  2014. (ppdu_desc->frame_ctrl &
  2015. HTT_FRAMECTRL_DATATYPE)) {
  2016. dp_wdi_event_handler(
  2017. WDI_EVENT_TX_PPDU_DESC,
  2018. pdev->soc,
  2019. nbuf,
  2020. HTT_INVALID_PEER,
  2021. WDI_NO_VAL,
  2022. pdev->pdev_id);
  2023. } else {
  2024. qdf_nbuf_free(nbuf);
  2025. }
  2026. }
  2027. continue;
  2028. }
  2029. peer = dp_peer_find_by_id(pdev->soc,
  2030. ppdu_desc->user[0].peer_id);
  2031. /**
  2032. * peer can be NULL
  2033. */
  2034. if (!peer) {
  2035. qdf_nbuf_free(nbuf);
  2036. continue;
  2037. }
  2038. if ((ppdu_desc->frame_type == CDP_PPDU_FTYPE_DATA) ||
  2039. (ppdu_desc->num_mpdu &&
  2040. ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR)) {
  2041. /**
  2042. * check whether it is bss peer,
  2043. * if bss_peer no need to process further
  2044. * check whether tx_capture feature is enabled
  2045. * for this peer or globally for all peers
  2046. */
  2047. if (peer->bss_peer ||
  2048. !dp_peer_or_pdev_tx_cap_enabled(pdev,
  2049. peer)) {
  2050. dp_peer_unref_del_find_by_id(peer);
  2051. qdf_nbuf_free(nbuf);
  2052. continue;
  2053. }
  2054. /* print the bit map */
  2055. dp_tx_print_bitmap(pdev, ppdu_desc,
  2056. 0, ppdu_desc->ppdu_id);
  2057. if (ppdu_desc->user[0].tid > DP_MAX_TIDS) {
  2058. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2059. QDF_TRACE_LEVEL_ERROR,
  2060. "%s: ppdu[%d] peer_id[%d] TID[%d] > NON_QOS_TID!",
  2061. __func__,
  2062. ppdu_desc->ppdu_id,
  2063. ppdu_desc->user[0].peer_id,
  2064. ppdu_desc->user[0].tid);
  2065. dp_peer_unref_del_find_by_id(peer);
  2066. qdf_nbuf_free(nbuf);
  2067. continue;
  2068. }
  2069. /* Non-QOS frames are being indicated with TID 0
  2070. * in WBM completion path, an hence we should
  2071. * TID 0 to reap MSDUs from completion path
  2072. */
  2073. if (qdf_unlikely(ppdu_desc->user[0].tid ==
  2074. DP_NON_QOS_TID))
  2075. tid = 0;
  2076. else
  2077. tid = ppdu_desc->user[0].tid;
  2078. dequeue_msdu_again:
  2079. num_msdu = ppdu_desc->user[0].num_msdu;
  2080. start_tsf = ppdu_desc->ppdu_start_timestamp;
  2081. end_tsf = ppdu_desc->ppdu_end_timestamp;
  2082. /*
  2083. * retrieve msdu buffer based on ppdu_id & tid
  2084. * based msdu queue and store it in local queue
  2085. * sometimes, wbm comes later than per ppdu
  2086. * stats. Assumption: all packets are SU,
  2087. * and packets comes in order
  2088. */
  2089. ret = dp_tx_msdu_dequeue(peer,
  2090. ppdu_desc->ppdu_id,
  2091. tid, num_msdu,
  2092. &head_msdu,
  2093. &head_xretries,
  2094. start_tsf, end_tsf);
  2095. if (!ret && (++retries < 2)) {
  2096. /* wait for wbm to complete */
  2097. qdf_mdelay(2);
  2098. goto dequeue_msdu_again;
  2099. }
  2100. if (!qdf_nbuf_is_queue_empty(&head_xretries)) {
  2101. struct dp_tx_tid *tx_tid =
  2102. &peer->tx_capture.tx_tid[tid];
  2103. struct cdp_tx_completion_ppdu
  2104. *xretry_ppdu =
  2105. &tx_tid->xretry_ppdu;
  2106. xretry_ppdu->ppdu_id =
  2107. peer->tx_capture.tx_wifi_ppdu_id;
  2108. /* Restitch MPDUs from xretry MSDUs */
  2109. dp_tx_mon_restitch_mpdu(pdev, peer,
  2110. xretry_ppdu,
  2111. &head_xretries,
  2112. &xretry_ppdu->mpdu_q);
  2113. }
  2114. if (!qdf_nbuf_is_queue_empty(&head_msdu)) {
  2115. /*
  2116. * now head_msdu hold - msdu list for
  2117. * that particular ppdu_id, restitch
  2118. * mpdu from msdu and create a mpdu
  2119. * queue
  2120. */
  2121. dp_tx_mon_restitch_mpdu(pdev, peer,
  2122. ppdu_desc,
  2123. &head_msdu,
  2124. &ppdu_desc->mpdu_q);
  2125. /*
  2126. * sanity: free local head msdu queue
  2127. * do we need this ?
  2128. */
  2129. qdf_nbuf_queue_free(&head_msdu);
  2130. qlen =
  2131. qdf_nbuf_queue_len(&ppdu_desc->mpdu_q);
  2132. if (!qlen) {
  2133. qdf_nbuf_free(nbuf);
  2134. dp_peer_unref_del_find_by_id(peer);
  2135. continue;
  2136. }
  2137. }
  2138. nbuf_ppdu_desc_list[ppdu_desc_cnt++] = nbuf;
  2139. /* print ppdu_desc info for debugging purpose */
  2140. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2141. QDF_TRACE_LEVEL_INFO,
  2142. "%s: ppdu[%d], p_id[%d], tid[%d], n_mpdu[%d %d] n_msdu[%d] retr[%d] qlen[%d] s_tsf[%u] dur[%u] seq[%d] [%d %d]",
  2143. __func__, ppdu_desc->ppdu_id,
  2144. ppdu_desc->user[0].peer_id,
  2145. ppdu_desc->user[0].tid,
  2146. ppdu_desc->num_mpdu,
  2147. ppdu_desc->user[0].mpdu_success,
  2148. ppdu_desc->num_msdu, retries,
  2149. qlen,
  2150. ppdu_desc->ppdu_start_timestamp,
  2151. ppdu_desc->tx_duration,
  2152. ppdu_desc->user[0].start_seq,
  2153. ppdu_cnt,
  2154. ppdu_desc_cnt);
  2155. } else {
  2156. /*
  2157. * other packet frame also added to
  2158. * descriptor list
  2159. */
  2160. nbuf_ppdu_desc_list[ppdu_desc_cnt++] = nbuf;
  2161. }
  2162. dp_peer_unref_del_find_by_id(peer);
  2163. }
  2164. /*
  2165. * At this point we have mpdu queued per ppdu_desc
  2166. * based on packet capture flags send mpdu info to upper stack
  2167. */
  2168. if (ppdu_desc_cnt) {
  2169. dp_check_ppdu_and_deliver(pdev, nbuf_ppdu_desc_list,
  2170. ppdu_desc_cnt);
  2171. }
  2172. qdf_spin_unlock(&ptr_tx_cap->config_lock);
  2173. qdf_mem_free(nbuf_ppdu_desc_list);
  2174. }
  2175. }
  2176. /**
  2177. * dp_ppdu_desc_deliver(): Function to deliver Tx PPDU status descriptor
  2178. * to upper layer
  2179. * @pdev: DP pdev handle
  2180. * @ppdu_info: per PPDU TLV descriptor
  2181. *
  2182. * return: void
  2183. */
  2184. void dp_ppdu_desc_deliver(struct dp_pdev *pdev,
  2185. struct ppdu_info *ppdu_info)
  2186. {
  2187. uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
  2188. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  2189. TAILQ_REMOVE(&pdev->ppdu_info_list, ppdu_info, ppdu_info_list_elem);
  2190. pdev->list_depth--;
  2191. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2192. qdf_nbuf_data(ppdu_info->nbuf);
  2193. qdf_spin_lock_bh(&pdev->tx_capture.ppdu_stats_lock);
  2194. if (qdf_unlikely(!pdev->tx_capture_enabled &&
  2195. (pdev->tx_capture.ppdu_stats_queue_depth +
  2196. pdev->tx_capture.ppdu_stats_defer_queue_depth) >
  2197. DP_TX_PPDU_PROC_MAX_DEPTH)) {
  2198. qdf_nbuf_free(ppdu_info->nbuf);
  2199. qdf_mem_free(ppdu_info);
  2200. pdev->tx_capture.ppdu_dropped++;
  2201. } else {
  2202. STAILQ_INSERT_TAIL(&pdev->tx_capture.ppdu_stats_queue,
  2203. ppdu_info, ppdu_info_queue_elem);
  2204. pdev->tx_capture.ppdu_stats_queue_depth++;
  2205. }
  2206. qdf_spin_unlock_bh(&pdev->tx_capture.ppdu_stats_lock);
  2207. if ((pdev->tx_capture.ppdu_stats_queue_depth >
  2208. DP_TX_PPDU_PROC_THRESHOLD) ||
  2209. (pdev->tx_capture.ppdu_stats_next_sched <= now_ms)) {
  2210. qdf_queue_work(0, pdev->tx_capture.ppdu_stats_workqueue,
  2211. &pdev->tx_capture.ppdu_stats_work);
  2212. pdev->tx_capture.ppdu_stats_next_sched =
  2213. now_ms + DP_TX_PPDU_PROC_TIMEOUT;
  2214. }
  2215. }
  2216. #endif