dp_tx_capture.c 81 KB

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