dp_tx_capture.c 122 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434
  1. /*
  2. * Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for
  5. * any purpose with or without fee is hereby granted, provided that the
  6. * above copyright notice and this permission notice appear in all
  7. * copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16. * PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #include <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 "htt_ppdu_stats.h"
  25. #include "dp_htt.h"
  26. #include "qdf_mem.h" /* qdf_mem_malloc,free */
  27. #include "cdp_txrx_cmn_struct.h"
  28. #include <enet.h>
  29. #include "dp_tx_capture.h"
  30. #define MAX_MONITOR_HEADER (512)
  31. #define MAX_DUMMY_FRM_BODY (128)
  32. #define DP_BA_ACK_FRAME_SIZE (sizeof(struct ieee80211_ctlframe_addr2) + 36)
  33. #define DP_ACK_FRAME_SIZE (sizeof(struct ieee80211_frame_min_one))
  34. #define DP_CTS_FRAME_SIZE (sizeof(struct ieee80211_frame_min_one))
  35. #define DP_ACKNOACK_FRAME_SIZE (sizeof(struct ieee80211_frame) + 16)
  36. #define DP_MAX_MPDU_64 64
  37. #define DP_NUM_WORDS_PER_PPDU_BITMAP_64 (DP_MAX_MPDU_64 >> 5)
  38. #define DP_NUM_BYTES_PER_PPDU_BITMAP_64 (DP_MAX_MPDU_64 >> 3)
  39. #define DP_NUM_BYTES_PER_PPDU_BITMAP (HAL_RX_MAX_MPDU >> 3)
  40. #define DP_IEEE80211_BAR_CTL_TID_S 12
  41. #define DP_IEEE80211_BAR_CTL_TID_M 0xf
  42. #define DP_IEEE80211_BAR_CTL_POLICY_S 0
  43. #define DP_IEEE80211_BAR_CTL_POLICY_M 0x1
  44. #define DP_IEEE80211_BA_S_SEQ_S 4
  45. #define DP_IEEE80211_BAR_CTL_COMBA 0x0004
  46. #define INVALID_PPDU_ID 0xFFFF
  47. #define MAX_END_TSF 0xFFFFFFFF
  48. #define DP_IEEE80211_CATEGORY_VHT (21)
  49. #define DP_NOACK_SOUNDING_TOKEN_POS (4)
  50. #define DP_NOACK_STOKEN_POS_SHIFT (2)
  51. #define DP_NDPA_TOKEN_POS (16)
  52. /* Macros to handle sequence number bitmaps */
  53. /* HW generated rts frame flag */
  54. #define SEND_WIFIRTS_LEGACY_E 1
  55. /* HW generated 11 AC static bw flag */
  56. #define SEND_WIFIRTS_11AC_STATIC_BW_E 2
  57. /* HW generated 11 AC dynamic bw flag */
  58. #define SEND_WIFIRTS_11AC_DYNAMIC_BW_E 3
  59. /* HW generated cts frame flag */
  60. #define SEND_WIFICTS2SELF_E 4
  61. /* Size (in bits) of a segment of sequence number bitmap */
  62. #define SEQ_SEG_SZ_BITS(_seqarr) (sizeof(_seqarr[0]) << 3)
  63. /* Array index of a segment of sequence number bitmap */
  64. #define SEQ_SEG_INDEX(_seqarr, _seqno) ((_seqno) / SEQ_SEG_SZ_BITS(_seqarr))
  65. /* Bit mask of a seqno within a segment of sequence bitmap */
  66. #define SEQ_SEG_MSK(_seqseg, _index) \
  67. (1 << ((_index) & ((sizeof(_seqseg) << 3) - 1)))
  68. /* Check seqno bit in a segment of sequence bitmap */
  69. #define SEQ_SEG_BIT(_seqseg, _index) \
  70. ((_seqseg) & SEQ_SEG_MSK((_seqseg), _index))
  71. /* Segment of sequence bitmap containing a given sequence number */
  72. #define SEQ_SEG(_seqarr, _seqno) \
  73. (_seqarr[(_seqno) / (sizeof(_seqarr[0]) << 3)])
  74. /* Check seqno bit in the sequence bitmap */
  75. #define SEQ_BIT(_seqarr, _seqno) \
  76. SEQ_SEG_BIT(SEQ_SEG(_seqarr, (_seqno)), (_seqno))
  77. /* Lower 32 mask for timestamp us as completion path has 32 bits timestamp */
  78. #define LOWER_32_MASK 0xFFFFFFFF
  79. /* Maximum time taken to enqueue next mgmt pkt */
  80. #define MAX_MGMT_ENQ_DELAY 10000
  81. /* Schedule id counter mask in ppdu_id */
  82. #define SCH_ID_MASK 0xFF
  83. #ifdef WLAN_TX_PKT_CAPTURE_ENH
  84. /**
  85. * dp_tx_cap_peer_find_by_id() - Returns peer object given the peer id
  86. * if delete_in_progress in not set for peer
  87. *
  88. * @soc : core DP soc context
  89. * @peer_id : peer id from peer object can be retrieved
  90. *
  91. * Return: struct dp_peer*: Pointer to DP peer object
  92. */
  93. static inline
  94. struct dp_peer *dp_tx_cap_peer_find_by_id(struct dp_soc *soc,
  95. uint16_t peer_id)
  96. {
  97. struct dp_peer *peer;
  98. qdf_spin_lock_bh(&soc->peer_ref_mutex);
  99. peer = __dp_peer_find_by_id(soc, peer_id);
  100. if (!peer || (peer && peer->delete_in_progress)) {
  101. qdf_spin_unlock_bh(&soc->peer_ref_mutex);
  102. return NULL;
  103. }
  104. qdf_atomic_inc(&peer->ref_cnt);
  105. qdf_spin_unlock_bh(&soc->peer_ref_mutex);
  106. return peer;
  107. }
  108. /**
  109. * dp_tx_cap_peer_unref_del() - dec ref and del peer if ref count is
  110. * taken by dp_tx_cap_peer_find_by_id
  111. * @peer: peer context
  112. *
  113. * Return: none
  114. */
  115. static inline void dp_tx_cap_peer_unref_del(struct dp_peer *peer)
  116. {
  117. dp_peer_unref_delete(peer);
  118. }
  119. /*
  120. * dp_tx_capture_htt_frame_counter: increment counter for htt_frame_type
  121. * pdev: DP pdev handle
  122. * htt_frame_type: htt frame type received from fw
  123. *
  124. * return: void
  125. */
  126. void dp_tx_capture_htt_frame_counter(struct dp_pdev *pdev,
  127. uint32_t htt_frame_type)
  128. {
  129. if (htt_frame_type >= TX_CAP_HTT_MAX_FTYPE)
  130. return;
  131. pdev->tx_capture.htt_frame_type[htt_frame_type]++;
  132. }
  133. void dp_print_tid_qlen_per_peer(void *pdev_hdl)
  134. {
  135. struct dp_pdev *pdev = (struct dp_pdev *)pdev_hdl;
  136. struct dp_soc *soc = pdev->soc;
  137. struct dp_vdev *vdev = NULL;
  138. struct dp_peer *peer = NULL;
  139. struct dp_pdev_tx_capture *ptr_tx_cap;
  140. ptr_tx_cap = &(pdev->tx_capture);
  141. DP_PRINT_STATS("pending peer msdu and ppdu:");
  142. qdf_spin_lock_bh(&soc->peer_ref_mutex);
  143. qdf_spin_lock_bh(&pdev->vdev_list_lock);
  144. DP_PDEV_ITERATE_VDEV_LIST(pdev, vdev) {
  145. DP_VDEV_ITERATE_PEER_LIST(vdev, peer) {
  146. int tid;
  147. struct dp_tx_tid *tx_tid;
  148. uint32_t msdu_len;
  149. uint32_t ppdu_len;
  150. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  151. tx_tid = &peer->tx_capture.tx_tid[tid];
  152. msdu_len =
  153. qdf_nbuf_queue_len(&tx_tid->msdu_comp_q);
  154. ppdu_len =
  155. qdf_nbuf_queue_len(&tx_tid->pending_ppdu_q);
  156. if (!msdu_len && !ppdu_len)
  157. continue;
  158. DP_PRINT_STATS(" peer_id[%d] tid[%d] msdu_comp_q[%d] pending_ppdu_q[%d]",
  159. peer->peer_ids[0], tid,
  160. msdu_len, ppdu_len);
  161. }
  162. }
  163. }
  164. qdf_spin_unlock_bh(&pdev->vdev_list_lock);
  165. qdf_spin_unlock_bh(&soc->peer_ref_mutex);
  166. }
  167. /*
  168. * dp_tx_cature_stats: print tx capture stats
  169. * @pdev: DP PDEV handle
  170. *
  171. * return: void
  172. */
  173. void dp_print_pdev_tx_capture_stats(struct dp_pdev *pdev)
  174. {
  175. struct dp_pdev_tx_capture *ptr_tx_cap;
  176. uint8_t i = 0, j = 0;
  177. ptr_tx_cap = &(pdev->tx_capture);
  178. DP_PRINT_STATS("tx capture stats:");
  179. DP_PRINT_STATS(" mgmt control enqueue stats:");
  180. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  181. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  182. if (ptr_tx_cap->ctl_mgmt_q[i][j].qlen)
  183. DP_PRINT_STATS(" ctl_mgmt_q[%d][%d] = queue_len[%d]",
  184. i, j, ptr_tx_cap->ctl_mgmt_q[i][j].qlen);
  185. }
  186. }
  187. DP_PRINT_STATS(" mgmt control retry queue stats:");
  188. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  189. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  190. if (ptr_tx_cap->retries_ctl_mgmt_q[i][j].qlen)
  191. DP_PRINT_STATS(" retries_ctl_mgmt_q[%d][%d] = queue_len[%d]",
  192. i, j,
  193. ptr_tx_cap->retries_ctl_mgmt_q[i][j].qlen);
  194. }
  195. }
  196. dp_print_tid_qlen_per_peer(pdev);
  197. for (i = 0; i < TX_CAP_HTT_MAX_FTYPE; i++) {
  198. if (!ptr_tx_cap->htt_frame_type[i])
  199. continue;
  200. DP_PRINT_STATS(" sgen htt frame type[%d] = %d",
  201. i, ptr_tx_cap->htt_frame_type[i]);
  202. }
  203. }
  204. /**
  205. * dp_peer_or_pdev_tx_cap_enabled - Returns status of tx_cap_enabled
  206. * based on global per-pdev setting or per-peer setting
  207. * @pdev: Datapath pdev handle
  208. * @peer: Datapath peer
  209. * @mac_addr: peer mac address
  210. *
  211. * Return: true if feature is enabled on a per-pdev basis or if
  212. * enabled for the given peer when per-peer mode is set, false otherwise
  213. */
  214. inline bool
  215. dp_peer_or_pdev_tx_cap_enabled(struct dp_pdev *pdev,
  216. struct dp_peer *peer, uint8_t *mac_addr)
  217. {
  218. if (pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS) {
  219. return true;
  220. } else if (pdev->tx_capture_enabled ==
  221. CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) {
  222. if (peer && peer->tx_cap_enabled)
  223. return true;
  224. /* do search based on mac address */
  225. return is_dp_peer_mgmt_pkt_filter(pdev,
  226. HTT_INVALID_PEER,
  227. mac_addr);
  228. }
  229. return false;
  230. }
  231. /*
  232. * dp_peer_tid_queue_init() – Initialize ppdu stats queue per TID
  233. * @peer: Datapath peer
  234. *
  235. */
  236. void dp_peer_tid_queue_init(struct dp_peer *peer)
  237. {
  238. int tid;
  239. struct dp_tx_tid *tx_tid;
  240. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  241. tx_tid = &peer->tx_capture.tx_tid[tid];
  242. tx_tid->tid = tid;
  243. qdf_nbuf_queue_init(&tx_tid->msdu_comp_q);
  244. qdf_nbuf_queue_init(&tx_tid->pending_ppdu_q);
  245. tx_tid->max_ppdu_id = 0;
  246. /* spinlock create */
  247. qdf_spinlock_create(&tx_tid->tid_lock);
  248. }
  249. }
  250. static
  251. void dp_peer_tx_cap_tid_queue_flush(struct dp_peer *peer)
  252. {
  253. int tid;
  254. struct dp_tx_tid *tx_tid;
  255. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  256. tx_tid = &peer->tx_capture.tx_tid[tid];
  257. qdf_spin_lock_bh(&tx_tid->tid_lock);
  258. qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
  259. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  260. tx_tid->max_ppdu_id = 0;
  261. }
  262. }
  263. /*
  264. * dp_peer_tid_queue_cleanup() – remove ppdu stats queue per TID
  265. * @peer: Datapath peer
  266. *
  267. */
  268. void dp_peer_tid_queue_cleanup(struct dp_peer *peer)
  269. {
  270. int tid;
  271. struct dp_tx_tid *tx_tid;
  272. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  273. tx_tid = &peer->tx_capture.tx_tid[tid];
  274. qdf_spin_lock_bh(&tx_tid->tid_lock);
  275. qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
  276. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  277. /* spinlock destroy */
  278. qdf_spinlock_destroy(&tx_tid->tid_lock);
  279. tx_tid->max_ppdu_id = 0;
  280. }
  281. }
  282. /*
  283. * dp_peer_update_80211_hdr: update 80211 hdr
  284. * @vdev: DP VDEV
  285. * @peer: DP PEER
  286. *
  287. * return: void
  288. */
  289. void dp_peer_update_80211_hdr(struct dp_vdev *vdev, struct dp_peer *peer)
  290. {
  291. struct ieee80211_frame *ptr_wh;
  292. ptr_wh = &peer->tx_capture.tx_wifi_hdr;
  293. /* i_addr1 - Receiver mac address */
  294. /* i_addr2 - Transmitter mac address */
  295. /* i_addr3 - Destination mac address */
  296. qdf_mem_copy(ptr_wh->i_addr1,
  297. peer->mac_addr.raw,
  298. QDF_MAC_ADDR_SIZE);
  299. qdf_mem_copy(ptr_wh->i_addr3,
  300. peer->mac_addr.raw,
  301. QDF_MAC_ADDR_SIZE);
  302. qdf_mem_copy(ptr_wh->i_addr2,
  303. vdev->mac_addr.raw,
  304. QDF_MAC_ADDR_SIZE);
  305. }
  306. /*
  307. * dp_deliver_mgmt_frm: Process
  308. * @pdev: DP PDEV handle
  309. * @nbuf: buffer containing the htt_ppdu_stats_tx_mgmtctrl_payload_tlv
  310. *
  311. * return: void
  312. */
  313. void dp_deliver_mgmt_frm(struct dp_pdev *pdev, qdf_nbuf_t nbuf)
  314. {
  315. if (pdev->tx_sniffer_enable || pdev->mcopy_mode) {
  316. dp_wdi_event_handler(WDI_EVENT_TX_MGMT_CTRL, pdev->soc,
  317. nbuf, HTT_INVALID_PEER,
  318. WDI_NO_VAL, pdev->pdev_id);
  319. return;
  320. }
  321. if (pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS ||
  322. pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) {
  323. /* invoke WDI event handler here send mgmt pkt here */
  324. struct ieee80211_frame *wh;
  325. uint8_t type, subtype;
  326. struct cdp_tx_mgmt_comp_info *ptr_mgmt_hdr;
  327. ptr_mgmt_hdr = (struct cdp_tx_mgmt_comp_info *)
  328. qdf_nbuf_data(nbuf);
  329. wh = (struct ieee80211_frame *)(qdf_nbuf_data(nbuf) +
  330. sizeof(struct cdp_tx_mgmt_comp_info));
  331. type = (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) >>
  332. IEEE80211_FC0_TYPE_SHIFT;
  333. subtype = (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) >>
  334. IEEE80211_FC0_SUBTYPE_SHIFT;
  335. if (!ptr_mgmt_hdr->ppdu_id || !ptr_mgmt_hdr->tx_tsf ||
  336. (!type && !subtype)) {
  337. /*
  338. * if either ppdu_id and tx_tsf are zero then
  339. * storing the payload won't be useful
  340. * in constructing the packet
  341. * Hence freeing the packet
  342. */
  343. qdf_nbuf_free(nbuf);
  344. return;
  345. }
  346. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, NULL, wh->i_addr1)) {
  347. qdf_nbuf_free(nbuf);
  348. return;
  349. }
  350. qdf_spin_lock_bh(
  351. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  352. qdf_nbuf_queue_add(&pdev->tx_capture.ctl_mgmt_q[type][subtype],
  353. nbuf);
  354. qdf_spin_unlock_bh(
  355. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  356. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  357. "dlvr mgmt frm(0x%08x): fc 0x%x %x, dur 0x%x%x\n",
  358. ptr_mgmt_hdr->ppdu_id, wh->i_fc[1], wh->i_fc[0],
  359. wh->i_dur[1], wh->i_dur[0]);
  360. } else {
  361. qdf_nbuf_free(nbuf);
  362. return;
  363. }
  364. }
  365. static inline int dp_peer_compare_mac_addr(void *addr1, void *addr2)
  366. {
  367. union dp_align_mac_addr *mac_addr1 = (union dp_align_mac_addr *)addr1;
  368. union dp_align_mac_addr *mac_addr2 = (union dp_align_mac_addr *)addr2;
  369. return !((mac_addr1->align4.bytes_abcd == mac_addr2->align4.bytes_abcd)
  370. & (mac_addr1->align4.bytes_ef == mac_addr2->align4.bytes_ef));
  371. }
  372. /*
  373. * dp_peer_tx_cap_search: filter mgmt pkt based on peer and mac address
  374. * @pdev: DP PDEV handle
  375. * @peer_id: DP PEER ID
  376. * @mac_addr: pointer to mac address
  377. *
  378. * return: true on matched and false on not found
  379. */
  380. static
  381. bool dp_peer_tx_cap_search(struct dp_pdev *pdev,
  382. uint16_t peer_id, uint8_t *mac_addr)
  383. {
  384. struct dp_pdev_tx_capture *tx_capture;
  385. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  386. uint8_t i = 0;
  387. bool found = false;
  388. tx_capture = &pdev->tx_capture;
  389. /* search based on mac address */
  390. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  391. uint8_t *peer_mac_addr;
  392. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  393. if (ptr_peer_mgmt_list->avail)
  394. continue;
  395. peer_mac_addr = ptr_peer_mgmt_list->mac_addr;
  396. if (!dp_peer_compare_mac_addr(mac_addr,
  397. peer_mac_addr)) {
  398. found = true;
  399. break;
  400. }
  401. }
  402. return found;
  403. }
  404. /*
  405. * dp_peer_tx_cap_add_filter: add peer filter mgmt pkt based on peer
  406. * and mac address
  407. * @pdev: DP PDEV handle
  408. * @peer_id: DP PEER ID
  409. * @mac_addr: pointer to mac address
  410. *
  411. * return: true on added and false on not failed
  412. */
  413. bool dp_peer_tx_cap_add_filter(struct dp_pdev *pdev,
  414. uint16_t peer_id, uint8_t *mac_addr)
  415. {
  416. struct dp_pdev_tx_capture *tx_capture;
  417. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  418. uint8_t i = 0;
  419. bool status = false;
  420. tx_capture = &pdev->tx_capture;
  421. if (dp_peer_tx_cap_search(pdev, peer_id, mac_addr)) {
  422. /* mac address and peer_id already there */
  423. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  424. "%s: %d peer_id[%d] mac_addr[%pM] already there\n",
  425. __func__, __LINE__, peer_id, mac_addr);
  426. return status;
  427. }
  428. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  429. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  430. if (!ptr_peer_mgmt_list->avail)
  431. continue;
  432. qdf_mem_copy(ptr_peer_mgmt_list->mac_addr,
  433. mac_addr, QDF_MAC_ADDR_SIZE);
  434. ptr_peer_mgmt_list->avail = false;
  435. ptr_peer_mgmt_list->peer_id = peer_id;
  436. status = true;
  437. break;
  438. }
  439. return status;
  440. }
  441. /*
  442. * dp_peer_tx_cap_del_all_filter: delete all peer filter mgmt pkt based on peer
  443. * and mac address
  444. * @pdev: DP PDEV handle
  445. * @peer_id: DP PEER ID
  446. * @mac_addr: pointer to mac address
  447. *
  448. * return: void
  449. */
  450. void dp_peer_tx_cap_del_all_filter(struct dp_pdev *pdev)
  451. {
  452. struct dp_pdev_tx_capture *tx_capture;
  453. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  454. uint8_t i = 0;
  455. tx_capture = &pdev->tx_capture;
  456. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  457. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  458. ptr_peer_mgmt_list->avail = true;
  459. ptr_peer_mgmt_list->peer_id = HTT_INVALID_PEER;
  460. qdf_mem_zero(ptr_peer_mgmt_list->mac_addr, QDF_MAC_ADDR_SIZE);
  461. }
  462. }
  463. /*
  464. * dp_peer_tx_cap_del_filter: delete peer filter mgmt pkt based on peer
  465. * and mac address
  466. * @pdev: DP PDEV handle
  467. * @peer_id: DP PEER ID
  468. * @mac_addr: pointer to mac address
  469. *
  470. * return: true on added and false on not failed
  471. */
  472. bool dp_peer_tx_cap_del_filter(struct dp_pdev *pdev,
  473. uint16_t peer_id, uint8_t *mac_addr)
  474. {
  475. struct dp_pdev_tx_capture *tx_capture;
  476. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  477. uint8_t i = 0;
  478. bool status = false;
  479. tx_capture = &pdev->tx_capture;
  480. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  481. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  482. if (!dp_peer_compare_mac_addr(mac_addr,
  483. ptr_peer_mgmt_list->mac_addr) &&
  484. (!ptr_peer_mgmt_list->avail)) {
  485. ptr_peer_mgmt_list->avail = true;
  486. ptr_peer_mgmt_list->peer_id = HTT_INVALID_PEER;
  487. qdf_mem_zero(ptr_peer_mgmt_list->mac_addr,
  488. QDF_MAC_ADDR_SIZE);
  489. status = true;
  490. break;
  491. }
  492. }
  493. if (!status)
  494. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  495. "unable to delete peer[%d] mac[%pM] filter list",
  496. peer_id, mac_addr);
  497. return status;
  498. }
  499. /*
  500. * dp_peer_tx_cap_print_mgmt_filter: pradd peer filter mgmt pkt based on peer
  501. * and mac address
  502. * @pdev: DP PDEV handle
  503. * @peer_id: DP PEER ID
  504. * @mac_addr: pointer to mac address
  505. *
  506. * return: true on added and false on not failed
  507. */
  508. void dp_peer_tx_cap_print_mgmt_filter(struct dp_pdev *pdev,
  509. uint16_t peer_id, uint8_t *mac_addr)
  510. {
  511. struct dp_pdev_tx_capture *tx_capture;
  512. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  513. uint8_t i = 0;
  514. tx_capture = &pdev->tx_capture;
  515. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  516. "peer filter list:");
  517. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  518. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  519. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  520. "peer_id[%d] mac_addr[%pM] avail[%d]",
  521. ptr_peer_mgmt_list->peer_id,
  522. ptr_peer_mgmt_list->mac_addr,
  523. ptr_peer_mgmt_list->avail);
  524. }
  525. }
  526. /*
  527. * dp_peer_mgmt_pkt_filter: filter mgmt pkt based on peer and mac address
  528. * @pdev: DP PDEV handle
  529. * @nbuf: buffer containing the ppdu_desc
  530. *
  531. * return: status
  532. */
  533. bool is_dp_peer_mgmt_pkt_filter(struct dp_pdev *pdev,
  534. uint32_t peer_id, uint8_t *mac_addr)
  535. {
  536. bool found = false;
  537. found = dp_peer_tx_cap_search(pdev, peer_id, mac_addr);
  538. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_HIGH,
  539. "%s: %d peer_id[%d] mac_addr[%pM] found[%d]!",
  540. __func__, __LINE__, peer_id, mac_addr, found);
  541. return found;
  542. }
  543. /**
  544. * dp_tx_ppdu_stats_attach - Initialize Tx PPDU stats and enhanced capture
  545. * @pdev: DP PDEV
  546. *
  547. * Return: none
  548. */
  549. void dp_tx_ppdu_stats_attach(struct dp_pdev *pdev)
  550. {
  551. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  552. struct dp_pdev_tx_capture *tx_capture;
  553. int i, j;
  554. tx_capture = &pdev->tx_capture;
  555. tx_capture->tx_cap_mode_flag = true;
  556. /* Work queue setup for HTT stats and tx capture handling */
  557. qdf_create_work(0, &pdev->tx_capture.ppdu_stats_work,
  558. dp_tx_ppdu_stats_process,
  559. pdev);
  560. pdev->tx_capture.ppdu_stats_workqueue =
  561. qdf_alloc_unbound_workqueue("ppdu_stats_work_queue");
  562. STAILQ_INIT(&pdev->tx_capture.ppdu_stats_queue);
  563. STAILQ_INIT(&pdev->tx_capture.ppdu_stats_defer_queue);
  564. qdf_spinlock_create(&pdev->tx_capture.ppdu_stats_lock);
  565. pdev->tx_capture.ppdu_stats_queue_depth = 0;
  566. pdev->tx_capture.ppdu_stats_next_sched = 0;
  567. pdev->tx_capture.ppdu_stats_defer_queue_depth = 0;
  568. pdev->tx_capture.ppdu_dropped = 0;
  569. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  570. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  571. qdf_nbuf_queue_init(
  572. &pdev->tx_capture.ctl_mgmt_q[i][j]);
  573. qdf_spinlock_create(
  574. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  575. }
  576. }
  577. qdf_mem_zero(&pdev->tx_capture.dummy_ppdu_desc,
  578. sizeof(struct cdp_tx_completion_ppdu));
  579. pdev->tx_capture.ptr_peer_mgmt_list = (struct dp_peer_mgmt_list *)
  580. qdf_mem_malloc(sizeof(struct dp_peer_mgmt_list) *
  581. MAX_MGMT_PEER_FILTER);
  582. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  583. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  584. ptr_peer_mgmt_list->avail = true;
  585. }
  586. }
  587. /**
  588. * dp_tx_ppdu_stats_detach - Cleanup Tx PPDU stats and enhanced capture
  589. * @pdev: DP PDEV
  590. *
  591. * Return: none
  592. */
  593. void dp_tx_ppdu_stats_detach(struct dp_pdev *pdev)
  594. {
  595. struct ppdu_info *ppdu_info, *tmp_ppdu_info = NULL;
  596. int i, j;
  597. if (!pdev || !pdev->tx_capture.ppdu_stats_workqueue)
  598. return;
  599. qdf_flush_workqueue(0, pdev->tx_capture.ppdu_stats_workqueue);
  600. qdf_destroy_workqueue(0, pdev->tx_capture.ppdu_stats_workqueue);
  601. qdf_spinlock_destroy(&pdev->tx_capture.ppdu_stats_lock);
  602. STAILQ_FOREACH_SAFE(ppdu_info,
  603. &pdev->tx_capture.ppdu_stats_queue,
  604. ppdu_info_queue_elem, tmp_ppdu_info) {
  605. STAILQ_REMOVE(&pdev->tx_capture.ppdu_stats_queue,
  606. ppdu_info, ppdu_info, ppdu_info_queue_elem);
  607. qdf_nbuf_free(ppdu_info->nbuf);
  608. qdf_mem_free(ppdu_info);
  609. }
  610. STAILQ_FOREACH_SAFE(ppdu_info,
  611. &pdev->tx_capture.ppdu_stats_defer_queue,
  612. ppdu_info_queue_elem, tmp_ppdu_info) {
  613. STAILQ_REMOVE(&pdev->tx_capture.ppdu_stats_defer_queue,
  614. ppdu_info, ppdu_info, ppdu_info_queue_elem);
  615. qdf_nbuf_free(ppdu_info->nbuf);
  616. qdf_mem_free(ppdu_info);
  617. }
  618. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  619. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  620. qdf_spin_lock_bh(
  621. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  622. qdf_nbuf_queue_free(
  623. &pdev->tx_capture.ctl_mgmt_q[i][j]);
  624. qdf_spin_unlock_bh(
  625. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  626. qdf_spinlock_destroy(
  627. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  628. }
  629. }
  630. qdf_mem_free(pdev->tx_capture.ptr_peer_mgmt_list);
  631. }
  632. #define MAX_MSDU_THRESHOLD_TSF 100000
  633. #define MAX_MSDU_ENQUEUE_THRESHOLD 10000
  634. /**
  635. * dp_update_msdu_to_list(): Function to queue msdu from wbm
  636. * @pdev: dp_pdev
  637. * @peer: dp_peer
  638. * @ts: hal tx completion status
  639. * @netbuf: msdu
  640. *
  641. * return: status
  642. */
  643. QDF_STATUS
  644. dp_update_msdu_to_list(struct dp_soc *soc,
  645. struct dp_pdev *pdev,
  646. struct dp_peer *peer,
  647. struct hal_tx_completion_status *ts,
  648. qdf_nbuf_t netbuf)
  649. {
  650. struct dp_tx_tid *tx_tid;
  651. struct msdu_completion_info *msdu_comp_info;
  652. struct msdu_completion_info *ptr_msdu_info = NULL;
  653. qdf_nbuf_t nbuf;
  654. qdf_nbuf_t head_msdu;
  655. uint32_t tsf_delta;
  656. uint32_t qlen;
  657. if (!peer) {
  658. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  659. "%s: %d peer NULL !", __func__, __LINE__);
  660. return QDF_STATUS_E_FAILURE;
  661. }
  662. if ((ts->tid > DP_MAX_TIDS) ||
  663. (peer->bss_peer && ts->tid == DP_NON_QOS_TID)) {
  664. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  665. "%s: %d peer_id %d, tid %d > NON_QOS_TID!",
  666. __func__, __LINE__, ts->peer_id, ts->tid);
  667. return QDF_STATUS_E_FAILURE;
  668. }
  669. tx_tid = &peer->tx_capture.tx_tid[ts->tid];
  670. if (!tx_tid) {
  671. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  672. "%s: %d tid[%d] NULL !", __func__, __LINE__, ts->tid);
  673. return QDF_STATUS_E_FAILURE;
  674. }
  675. qdf_nbuf_unmap(soc->osdev, netbuf, QDF_DMA_TO_DEVICE);
  676. if (!qdf_nbuf_push_head(netbuf, sizeof(struct msdu_completion_info))) {
  677. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  678. FL("No headroom"));
  679. return QDF_STATUS_E_NOMEM;
  680. }
  681. msdu_comp_info = (struct msdu_completion_info *)qdf_nbuf_data(netbuf);
  682. /* copy msdu_completion_info to control buffer */
  683. msdu_comp_info->ppdu_id = ts->ppdu_id;
  684. msdu_comp_info->peer_id = ts->peer_id;
  685. msdu_comp_info->tid = ts->tid;
  686. msdu_comp_info->first_msdu = ts->first_msdu;
  687. msdu_comp_info->last_msdu = ts->last_msdu;
  688. msdu_comp_info->msdu_part_of_amsdu = ts->msdu_part_of_amsdu;
  689. msdu_comp_info->transmit_cnt = ts->transmit_cnt;
  690. msdu_comp_info->tsf = ts->tsf;
  691. msdu_comp_info->status = ts->status;
  692. /* update max ppdu_id */
  693. tx_tid->max_ppdu_id = ts->ppdu_id;
  694. pdev->tx_capture.last_msdu_id = ts->ppdu_id;
  695. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  696. "msdu_completion: ppdu_id[%d] peer_id[%d] tid[%d] rel_src[%d] status[%d] tsf[%u] A[%d] CNT[%d]",
  697. ts->ppdu_id, ts->peer_id, ts->tid, ts->release_src,
  698. ts->status, ts->tsf, ts->msdu_part_of_amsdu,
  699. ts->transmit_cnt);
  700. /* lock here */
  701. qdf_spin_lock_bh(&tx_tid->tid_lock);
  702. while ((head_msdu = qdf_nbuf_queue_first(&tx_tid->msdu_comp_q))) {
  703. ptr_msdu_info =
  704. (struct msdu_completion_info *)qdf_nbuf_data(head_msdu);
  705. if (ts->tsf > ptr_msdu_info->tsf)
  706. tsf_delta = ts->tsf - ptr_msdu_info->tsf;
  707. else
  708. tsf_delta = LOWER_32_MASK - ptr_msdu_info->tsf + ts->tsf;
  709. if (tsf_delta < MAX_MSDU_THRESHOLD_TSF)
  710. break;
  711. /* free head */
  712. nbuf = qdf_nbuf_queue_remove(&tx_tid->msdu_comp_q);
  713. qdf_nbuf_free(nbuf);
  714. }
  715. /* get queue length */
  716. qlen = qdf_nbuf_queue_len(&tx_tid->msdu_comp_q);
  717. if (qlen > MAX_MSDU_ENQUEUE_THRESHOLD) {
  718. /* free head */
  719. nbuf = qdf_nbuf_queue_remove(&tx_tid->msdu_comp_q);
  720. qdf_nbuf_free(nbuf);
  721. }
  722. /* add nbuf to tail queue per peer tid */
  723. qdf_nbuf_queue_add(&tx_tid->msdu_comp_q, netbuf);
  724. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  725. return QDF_STATUS_SUCCESS;
  726. }
  727. /**
  728. * dp_tx_add_to_comp_queue() - add completion msdu to queue
  729. * @soc: DP Soc handle
  730. * @tx_desc: software Tx descriptor
  731. * @ts : Tx completion status from HAL/HTT descriptor
  732. * @peer: DP peer
  733. *
  734. * Return: none
  735. */
  736. QDF_STATUS dp_tx_add_to_comp_queue(struct dp_soc *soc,
  737. struct dp_tx_desc_s *desc,
  738. struct hal_tx_completion_status *ts,
  739. struct dp_peer *peer)
  740. {
  741. int ret = QDF_STATUS_E_FAILURE;
  742. struct dp_pdev *pdev = desc->pdev;
  743. if (peer &&
  744. dp_peer_or_pdev_tx_cap_enabled(pdev, peer, peer->mac_addr.raw) &&
  745. ((ts->status == HAL_TX_TQM_RR_FRAME_ACKED) ||
  746. (ts->status == HAL_TX_TQM_RR_REM_CMD_TX) ||
  747. ((ts->status == HAL_TX_TQM_RR_REM_CMD_AGED) && ts->transmit_cnt))) {
  748. /* skip enqueuing OFDMA frames */
  749. if (ts->ofdma)
  750. return ret;
  751. if (qdf_unlikely(desc->pkt_offset != 0) &&
  752. (qdf_nbuf_pull_head(
  753. desc->nbuf, desc->pkt_offset) == NULL)) {
  754. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  755. QDF_TRACE_LEVEL_ERROR,
  756. "netbuf %pK offset %d",
  757. desc->nbuf, desc->pkt_offset);
  758. return ret;
  759. }
  760. ret = dp_update_msdu_to_list(soc, pdev, peer, ts, desc->nbuf);
  761. }
  762. return ret;
  763. }
  764. /**
  765. * dp_process_ppdu_stats_update_failed_bitmap(): update failed bitmap
  766. * @pdev: dp_pdev
  767. * @data: tx completion ppdu desc
  768. * @ppdu_id: ppdu id
  769. * @size: size of bitmap
  770. *
  771. * return: status
  772. */
  773. void dp_process_ppdu_stats_update_failed_bitmap(struct dp_pdev *pdev,
  774. void *data,
  775. uint32_t ppdu_id,
  776. uint32_t size)
  777. {
  778. struct cdp_tx_completion_ppdu_user *user;
  779. uint32_t mpdu_tried;
  780. uint32_t ba_seq_no;
  781. uint32_t start_seq;
  782. uint32_t num_mpdu;
  783. uint32_t diff;
  784. uint32_t carry = 0;
  785. uint32_t bitmask = 0;
  786. uint32_t i;
  787. uint32_t k;
  788. uint32_t ba_bitmap = 0;
  789. int last_set_bit;
  790. user = (struct cdp_tx_completion_ppdu_user *)data;
  791. /* get number of mpdu from ppdu_desc */
  792. mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;
  793. ba_seq_no = user->ba_seq_no;
  794. start_seq = user->start_seq;
  795. num_mpdu = user->num_mpdu;
  796. /* assumption: number of mpdu will be less than 32 */
  797. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  798. "ppdu_id[%d] ba_seq_no[%d] start_seq_no[%d] mpdu_tried[%d]",
  799. ppdu_id, ba_seq_no, start_seq, mpdu_tried);
  800. for (i = 0; i < size; i++) {
  801. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  802. "ppdu_id[%d] ba_bitmap[%x] enqueue_bitmap[%x]",
  803. ppdu_id, user->ba_bitmap[i], user->enq_bitmap[i]);
  804. }
  805. /* Handle sequence no. wraparound */
  806. if (start_seq <= ba_seq_no) {
  807. diff = ba_seq_no - start_seq;
  808. /* Sequence delta of more than 2048 is considered wraparound
  809. * and we extend start_seq to be more than ba_seq just to
  810. * adjust failed_bitmap
  811. */
  812. if (qdf_unlikely(diff > (IEEE80211_SEQ_MAX / 2))) {
  813. diff = (start_seq - ba_seq_no) &
  814. (IEEE80211_SEQ_MAX - 1);
  815. start_seq = ba_seq_no + diff;
  816. }
  817. } else {
  818. diff = start_seq - ba_seq_no;
  819. /* Sequence delta of more than 2048 is considered wraparound
  820. * and we extend ba_seq to be more than start_seq just to
  821. * adjust failed_bitmap
  822. */
  823. if (qdf_unlikely(diff > (IEEE80211_SEQ_MAX / 2))) {
  824. diff = (ba_seq_no - start_seq) &
  825. (IEEE80211_SEQ_MAX - 1);
  826. ba_seq_no = start_seq + diff;
  827. }
  828. }
  829. /* Adjust failed_bitmap to start from same seq_no as enq_bitmap */
  830. last_set_bit = 0;
  831. if (start_seq <= ba_seq_no) {
  832. bitmask = (1 << diff) - 1;
  833. for (i = 0; i < size; i++) {
  834. ba_bitmap = user->ba_bitmap[i];
  835. user->failed_bitmap[i] = (ba_bitmap << diff);
  836. user->failed_bitmap[i] |= (bitmask & carry);
  837. carry = ((ba_bitmap & (bitmask << (32 - diff))) >>
  838. (32 - diff));
  839. user->failed_bitmap[i] = user->enq_bitmap[i] &
  840. user->failed_bitmap[i];
  841. if (user->enq_bitmap[i]) {
  842. last_set_bit = i * 32 +
  843. qdf_fls(user->enq_bitmap[i]) - 1;
  844. }
  845. }
  846. } else {
  847. /* array index */
  848. k = diff >> 5;
  849. diff = diff & 0x1F;
  850. bitmask = (1 << diff) - 1;
  851. for (i = 0; i < size; i++, k++) {
  852. ba_bitmap = user->ba_bitmap[k];
  853. user->failed_bitmap[i] = ba_bitmap >> diff;
  854. /* get next ba_bitmap */
  855. ba_bitmap = user->ba_bitmap[k + 1];
  856. carry = (ba_bitmap & bitmask);
  857. user->failed_bitmap[i] |=
  858. ((carry & bitmask) << (32 - diff));
  859. user->failed_bitmap[i] = user->enq_bitmap[i] &
  860. user->failed_bitmap[i];
  861. if (user->enq_bitmap[i]) {
  862. last_set_bit = i * 32 +
  863. qdf_fls(user->enq_bitmap[i]) - 1;
  864. }
  865. }
  866. }
  867. user->last_enq_seq = user->start_seq + last_set_bit;
  868. user->ba_size = user->last_enq_seq - user->start_seq + 1;
  869. }
  870. /*
  871. * dp_soc_set_txrx_ring_map_single()
  872. * @dp_soc: DP handler for soc
  873. *
  874. * Return: Void
  875. */
  876. static void dp_soc_set_txrx_ring_map_single(struct dp_soc *soc)
  877. {
  878. uint32_t i;
  879. for (i = 0; i < WLAN_CFG_INT_NUM_CONTEXTS; i++) {
  880. soc->tx_ring_map[i] =
  881. dp_cpu_ring_map[DP_SINGLE_TX_RING_MAP][i];
  882. }
  883. }
  884. /*
  885. * dp_iterate_free_peer_msdu_q()- API to free msdu queue
  886. * @pdev_handle: DP_PDEV handle
  887. *
  888. * Return: void
  889. */
  890. static void dp_iterate_free_peer_msdu_q(void *pdev_hdl)
  891. {
  892. struct dp_pdev *pdev = (struct dp_pdev *)pdev_hdl;
  893. struct dp_soc *soc = pdev->soc;
  894. struct dp_vdev *vdev = NULL;
  895. struct dp_peer *peer = NULL;
  896. qdf_spin_lock_bh(&soc->peer_ref_mutex);
  897. qdf_spin_lock_bh(&pdev->vdev_list_lock);
  898. DP_PDEV_ITERATE_VDEV_LIST(pdev, vdev) {
  899. DP_VDEV_ITERATE_PEER_LIST(vdev, peer) {
  900. int tid;
  901. struct dp_tx_tid *tx_tid;
  902. /* set peer tx cap enabled to 0, when feature disable */
  903. peer->tx_cap_enabled = 0;
  904. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  905. qdf_nbuf_t ppdu_nbuf = NULL;
  906. struct cdp_tx_completion_ppdu *ppdu_desc =
  907. NULL;
  908. int i;
  909. tx_tid = &peer->tx_capture.tx_tid[tid];
  910. /* spinlock hold */
  911. qdf_spin_lock_bh(&tx_tid->tid_lock);
  912. qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
  913. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  914. while ((ppdu_nbuf = qdf_nbuf_queue_remove(
  915. &tx_tid->pending_ppdu_q))) {
  916. ppdu_desc =
  917. (struct cdp_tx_completion_ppdu *)
  918. qdf_nbuf_data(ppdu_nbuf);
  919. if (!ppdu_desc->mpdus) {
  920. qdf_nbuf_free(ppdu_nbuf);
  921. continue;
  922. }
  923. for (i = 0; i <
  924. ppdu_desc->user[0].ba_size; i++) {
  925. if (!ppdu_desc->mpdus[i])
  926. continue;
  927. qdf_nbuf_free(
  928. ppdu_desc->mpdus[i]);
  929. ppdu_desc->mpdus[i] = NULL;
  930. }
  931. qdf_mem_free(ppdu_desc->mpdus);
  932. ppdu_desc->mpdus = NULL;
  933. qdf_nbuf_free(ppdu_nbuf);
  934. }
  935. }
  936. }
  937. }
  938. qdf_spin_unlock_bh(&pdev->vdev_list_lock);
  939. qdf_spin_unlock_bh(&soc->peer_ref_mutex);
  940. }
  941. /*
  942. * dp_enh_tx_capture_disable()- API to disable enhanced tx capture
  943. * @pdev_handle: DP_PDEV handle
  944. *
  945. * Return: void
  946. */
  947. void
  948. dp_enh_tx_capture_disable(struct dp_pdev *pdev)
  949. {
  950. int i, j;
  951. dp_soc_set_txrx_ring_map(pdev->soc);
  952. dp_h2t_cfg_stats_msg_send(pdev,
  953. DP_PPDU_STATS_CFG_ENH_STATS,
  954. pdev->pdev_id);
  955. dp_iterate_free_peer_msdu_q(pdev);
  956. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  957. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  958. qdf_nbuf_queue_t *retries_q;
  959. qdf_spin_lock_bh(
  960. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  961. qdf_nbuf_queue_free(
  962. &pdev->tx_capture.ctl_mgmt_q[i][j]);
  963. qdf_spin_unlock_bh(
  964. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  965. retries_q = &pdev->tx_capture.retries_ctl_mgmt_q[i][j];
  966. if (!qdf_nbuf_is_queue_empty(retries_q))
  967. qdf_nbuf_queue_free(retries_q);
  968. }
  969. }
  970. dp_peer_tx_cap_del_all_filter(pdev);
  971. pdev->tx_capture.tx_cap_mode_flag = true;
  972. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  973. "Mode change request done cur mode - %d\n",
  974. pdev->tx_capture_enabled);
  975. }
  976. /*
  977. * dp_config_enh_tx_capture()- API to enable/disable enhanced tx capture
  978. * @pdev_handle: DP_PDEV handle
  979. * @val: user provided value
  980. *
  981. * Return: QDF_STATUS
  982. */
  983. QDF_STATUS
  984. dp_config_enh_tx_capture(struct dp_pdev *pdev, uint8_t val)
  985. {
  986. qdf_spin_lock(&pdev->tx_capture.config_lock);
  987. if (pdev->tx_capture.tx_cap_mode_flag) {
  988. pdev->tx_capture.tx_cap_mode_flag = false;
  989. pdev->tx_capture_enabled = val;
  990. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  991. "Mode change requested - %d\n",
  992. pdev->tx_capture_enabled);
  993. } else if (!pdev->tx_capture.tx_cap_mode_flag &&
  994. !val && !!pdev->tx_capture_enabled) {
  995. /* here the val is always 0 which is disable */
  996. pdev->tx_capture_enabled = val;
  997. pdev->tx_capture.tx_cap_mode_flag = false;
  998. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  999. "Mode change requested - %d\n",
  1000. pdev->tx_capture_enabled);
  1001. } else {
  1002. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  1003. "Mode change request pending prev mode - %d\n",
  1004. pdev->tx_capture_enabled);
  1005. qdf_spin_unlock(&pdev->tx_capture.config_lock);
  1006. return QDF_STATUS_E_BUSY;
  1007. }
  1008. if (pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS ||
  1009. pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) {
  1010. dp_soc_set_txrx_ring_map_single(pdev->soc);
  1011. if (!pdev->pktlog_ppdu_stats)
  1012. dp_h2t_cfg_stats_msg_send(pdev,
  1013. DP_PPDU_STATS_CFG_SNIFFER,
  1014. pdev->pdev_id);
  1015. pdev->tx_capture.tx_cap_mode_flag = true;
  1016. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  1017. "Mode change request done cur mode - %d\n",
  1018. pdev->tx_capture_enabled);
  1019. }
  1020. qdf_spin_unlock(&pdev->tx_capture.config_lock);
  1021. return QDF_STATUS_SUCCESS;
  1022. }
  1023. /**
  1024. * get_number_of_1s(): Function to get number of 1s
  1025. * @value: value to find
  1026. *
  1027. * return: number of 1s
  1028. */
  1029. static
  1030. inline uint32_t get_number_of_1s(uint32_t value)
  1031. {
  1032. uint32_t shift[] = {1, 2, 4, 8, 16};
  1033. uint32_t magic_number[] = { 0x55555555, 0x33333333, 0x0F0F0F0F,
  1034. 0x00FF00FF, 0x0000FFFF};
  1035. uint8_t k = 0;
  1036. for (; k <= 4; k++) {
  1037. value = (value & magic_number[k]) +
  1038. ((value >> shift[k]) & magic_number[k]);
  1039. }
  1040. return value;
  1041. }
  1042. /**
  1043. * dp_tx_print_bitmap(): Function to print bitmap
  1044. * @pdev: dp_pdev
  1045. * @ppdu_desc: ppdu completion descriptor
  1046. * @user_inder: user index
  1047. * @ppdu_id: ppdu id
  1048. *
  1049. * return: status
  1050. */
  1051. static
  1052. QDF_STATUS dp_tx_print_bitmap(struct dp_pdev *pdev,
  1053. struct cdp_tx_completion_ppdu *ppdu_desc,
  1054. uint32_t user_index,
  1055. uint32_t ppdu_id)
  1056. {
  1057. struct cdp_tx_completion_ppdu_user *user;
  1058. uint8_t i;
  1059. uint32_t mpdu_tried;
  1060. uint32_t ba_seq_no;
  1061. uint32_t start_seq;
  1062. uint32_t num_mpdu;
  1063. uint32_t fail_num_mpdu = 0;
  1064. user = &ppdu_desc->user[user_index];
  1065. /* get number of mpdu from ppdu_desc */
  1066. mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;
  1067. ba_seq_no = user->ba_seq_no;
  1068. start_seq = user->start_seq;
  1069. num_mpdu = user->mpdu_success;
  1070. if (user->tid > DP_MAX_TIDS) {
  1071. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  1072. "%s: ppdu[%d] peer_id[%d] TID[%d] > NON_QOS_TID!",
  1073. __func__, ppdu_id, user->peer_id, user->tid);
  1074. return QDF_STATUS_E_FAILURE;
  1075. }
  1076. if (mpdu_tried != num_mpdu) {
  1077. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  1078. "%s: ppdu[%d] peer[%d] tid[%d] ba[%d] start[%d] mpdu_tri[%d] num_mpdu[%d] is_mcast[%d]",
  1079. __func__, ppdu_id, user->peer_id, user->tid,
  1080. ba_seq_no, start_seq, mpdu_tried,
  1081. num_mpdu, user->is_mcast);
  1082. for (i = 0; i < CDP_BA_256_BIT_MAP_SIZE_DWORDS; i++) {
  1083. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1084. QDF_TRACE_LEVEL_INFO,
  1085. "ppdu_id[%d] ba_bitmap[0x%x] enqueue_bitmap[0x%x] failed_bitmap[0x%x]",
  1086. ppdu_id, user->ba_bitmap[i],
  1087. user->enq_bitmap[i],
  1088. user->failed_bitmap[i]);
  1089. fail_num_mpdu +=
  1090. get_number_of_1s(user->failed_bitmap[i]);
  1091. }
  1092. }
  1093. if (fail_num_mpdu == num_mpdu && num_mpdu)
  1094. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  1095. "%s: %d ppdu_id[%d] num_mpdu[%d, %d]",
  1096. __func__, __LINE__, ppdu_id, num_mpdu, fail_num_mpdu);
  1097. return QDF_STATUS_SUCCESS;
  1098. }
  1099. static uint32_t dp_tx_update_80211_hdr(struct dp_pdev *pdev,
  1100. struct dp_peer *peer,
  1101. void *data,
  1102. qdf_nbuf_t nbuf,
  1103. uint16_t ether_type,
  1104. uint8_t *src_addr)
  1105. {
  1106. struct cdp_tx_completion_ppdu *ppdu_desc;
  1107. struct ieee80211_frame *ptr_wh;
  1108. struct ieee80211_qoscntl *ptr_qoscntl;
  1109. uint32_t mpdu_buf_len;
  1110. uint8_t *ptr_hdr;
  1111. uint16_t eth_type = qdf_htons(ether_type);
  1112. ppdu_desc = (struct cdp_tx_completion_ppdu *)data;
  1113. ptr_wh = &peer->tx_capture.tx_wifi_hdr;
  1114. ptr_qoscntl = &peer->tx_capture.tx_qoscntl;
  1115. /*
  1116. * update framectrl only for first ppdu_id
  1117. * rest of mpdu will have same frame ctrl
  1118. * mac address and duration
  1119. */
  1120. if (ppdu_desc->ppdu_id != peer->tx_capture.tx_wifi_ppdu_id) {
  1121. ptr_wh->i_fc[1] = (ppdu_desc->frame_ctrl & 0xFF00) >> 8;
  1122. ptr_wh->i_fc[0] = (ppdu_desc->frame_ctrl & 0xFF);
  1123. ptr_wh->i_dur[1] = (ppdu_desc->tx_duration & 0xFF00) >> 8;
  1124. ptr_wh->i_dur[0] = (ppdu_desc->tx_duration & 0xFF);
  1125. ptr_qoscntl->i_qos[1] = (ppdu_desc->user[0].qos_ctrl &
  1126. 0xFF00) >> 8;
  1127. ptr_qoscntl->i_qos[0] = (ppdu_desc->user[0].qos_ctrl & 0xFF);
  1128. /* Update Addr 3 (SA) with SA derived from ether packet */
  1129. qdf_mem_copy(ptr_wh->i_addr3, src_addr, QDF_MAC_ADDR_SIZE);
  1130. peer->tx_capture.tx_wifi_ppdu_id = ppdu_desc->ppdu_id;
  1131. }
  1132. mpdu_buf_len = sizeof(struct ieee80211_frame) + LLC_SNAP_HDR_LEN;
  1133. if (qdf_likely(ppdu_desc->user[0].tid != DP_NON_QOS_TID))
  1134. mpdu_buf_len += sizeof(struct ieee80211_qoscntl);
  1135. nbuf->protocol = qdf_htons(ETH_P_802_2);
  1136. /* update ieee80211_frame header */
  1137. if (!qdf_nbuf_push_head(nbuf, mpdu_buf_len)) {
  1138. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  1139. FL("No headroom"));
  1140. return QDF_STATUS_E_NOMEM;
  1141. }
  1142. ptr_hdr = (void *)qdf_nbuf_data(nbuf);
  1143. qdf_mem_copy(ptr_hdr, ptr_wh, sizeof(struct ieee80211_frame));
  1144. ptr_hdr = ptr_hdr + (sizeof(struct ieee80211_frame));
  1145. /* update qoscntl header */
  1146. if (qdf_likely(ppdu_desc->user[0].tid != DP_NON_QOS_TID)) {
  1147. qdf_mem_copy(ptr_hdr, ptr_qoscntl,
  1148. sizeof(struct ieee80211_qoscntl));
  1149. ptr_hdr = ptr_hdr + sizeof(struct ieee80211_qoscntl);
  1150. }
  1151. /* update LLC */
  1152. *ptr_hdr = LLC_SNAP_LSAP;
  1153. *(ptr_hdr + 1) = LLC_SNAP_LSAP;
  1154. *(ptr_hdr + 2) = LLC_UI;
  1155. *(ptr_hdr + 3) = 0x00;
  1156. *(ptr_hdr + 4) = 0x00;
  1157. *(ptr_hdr + 5) = 0x00;
  1158. *(ptr_hdr + 6) = (eth_type & 0xFF00) >> 8;
  1159. *(ptr_hdr + 7) = (eth_type & 0xFF);
  1160. qdf_nbuf_trim_tail(nbuf, qdf_nbuf_len(nbuf) - mpdu_buf_len);
  1161. return 0;
  1162. }
  1163. /**
  1164. * dp_tx_mon_restitch_mpdu(): Function to restitch msdu to mpdu
  1165. * @pdev: dp_pdev
  1166. * @peer: dp_peer
  1167. * @head_msdu: head msdu queue
  1168. *
  1169. * return: status
  1170. */
  1171. static uint32_t
  1172. dp_tx_mon_restitch_mpdu(struct dp_pdev *pdev, struct dp_peer *peer,
  1173. struct cdp_tx_completion_ppdu *ppdu_desc,
  1174. qdf_nbuf_queue_t *head_msdu,
  1175. qdf_nbuf_queue_t *mpdu_q)
  1176. {
  1177. qdf_nbuf_t curr_nbuf = NULL;
  1178. qdf_nbuf_t first_nbuf = NULL;
  1179. qdf_nbuf_t prev_nbuf = NULL;
  1180. qdf_nbuf_t mpdu_nbuf = NULL;
  1181. struct msdu_completion_info *ptr_msdu_info = NULL;
  1182. uint8_t first_msdu = 0;
  1183. uint8_t last_msdu = 0;
  1184. uint32_t frag_list_sum_len = 0;
  1185. uint8_t first_msdu_not_seen = 1;
  1186. uint16_t ether_type = 0;
  1187. qdf_ether_header_t *eh = NULL;
  1188. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  1189. while (curr_nbuf) {
  1190. ptr_msdu_info =
  1191. (struct msdu_completion_info *)qdf_nbuf_data(curr_nbuf);
  1192. first_msdu = ptr_msdu_info->first_msdu;
  1193. last_msdu = ptr_msdu_info->last_msdu;
  1194. eh = (qdf_ether_header_t *)(curr_nbuf->data +
  1195. sizeof(struct msdu_completion_info));
  1196. ether_type = eh->ether_type;
  1197. /* pull msdu_completion_info added in pre header */
  1198. qdf_nbuf_pull_head(curr_nbuf,
  1199. sizeof(struct msdu_completion_info));
  1200. if (first_msdu && first_msdu_not_seen) {
  1201. first_nbuf = curr_nbuf;
  1202. frag_list_sum_len = 0;
  1203. first_msdu_not_seen = 0;
  1204. /* pull ethernet header from first MSDU alone */
  1205. qdf_nbuf_pull_head(curr_nbuf,
  1206. sizeof(qdf_ether_header_t));
  1207. /* update first buffer to previous buffer */
  1208. prev_nbuf = curr_nbuf;
  1209. } else if (first_msdu && !first_msdu_not_seen) {
  1210. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1211. QDF_TRACE_LEVEL_FATAL,
  1212. "!!!!! NO LAST MSDU\n");
  1213. /*
  1214. * no last msdu in a mpdu
  1215. * handle this case
  1216. */
  1217. qdf_nbuf_free(curr_nbuf);
  1218. /*
  1219. * No last msdu found because WBM comes out
  1220. * of order, free the pkt
  1221. */
  1222. goto free_ppdu_desc_mpdu_q;
  1223. } else if (!first_msdu && first_msdu_not_seen) {
  1224. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1225. QDF_TRACE_LEVEL_FATAL,
  1226. "!!!!! NO FIRST MSDU\n");
  1227. /*
  1228. * no first msdu in a mpdu
  1229. * handle this case
  1230. */
  1231. qdf_nbuf_free(curr_nbuf);
  1232. /*
  1233. * no first msdu found beacuse WBM comes out
  1234. * of order, free the pkt
  1235. */
  1236. goto free_ppdu_desc_mpdu_q;
  1237. } else {
  1238. /* update current buffer to previous buffer next */
  1239. prev_nbuf->next = curr_nbuf;
  1240. /* move the previous buffer to next buffer */
  1241. prev_nbuf = prev_nbuf->next;
  1242. }
  1243. frag_list_sum_len += qdf_nbuf_len(curr_nbuf);
  1244. if (last_msdu) {
  1245. mpdu_nbuf = qdf_nbuf_alloc(pdev->soc->osdev,
  1246. MAX_MONITOR_HEADER,
  1247. MAX_MONITOR_HEADER,
  1248. 4, FALSE);
  1249. if (!mpdu_nbuf) {
  1250. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1251. QDF_TRACE_LEVEL_FATAL,
  1252. "MPDU head allocation failed !!!");
  1253. goto free_ppdu_desc_mpdu_q;
  1254. }
  1255. dp_tx_update_80211_hdr(pdev, peer,
  1256. ppdu_desc, mpdu_nbuf,
  1257. ether_type, eh->ether_shost);
  1258. /*
  1259. * first nbuf will hold list of msdu
  1260. * stored in prev_nbuf
  1261. */
  1262. qdf_nbuf_append_ext_list(mpdu_nbuf,
  1263. first_nbuf,
  1264. frag_list_sum_len);
  1265. /* add mpdu to mpdu queue */
  1266. qdf_nbuf_queue_add(mpdu_q, mpdu_nbuf);
  1267. first_nbuf = NULL;
  1268. mpdu_nbuf = NULL;
  1269. /* next msdu will start with first msdu */
  1270. first_msdu_not_seen = 1;
  1271. goto check_for_next_msdu;
  1272. }
  1273. /* get next msdu from the head_msdu */
  1274. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  1275. if (!curr_nbuf) {
  1276. /* msdu missed in list */
  1277. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1278. QDF_TRACE_LEVEL_FATAL,
  1279. "!!!! WAITING for msdu but list empty !!!!");
  1280. /* for incomplete list, free up the queue */
  1281. goto free_ppdu_desc_mpdu_q;
  1282. }
  1283. continue;
  1284. check_for_next_msdu:
  1285. if (qdf_nbuf_is_queue_empty(head_msdu))
  1286. return 0;
  1287. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  1288. }
  1289. return 0;
  1290. free_ppdu_desc_mpdu_q:
  1291. /* free already chained msdu pkt */
  1292. while (first_nbuf) {
  1293. curr_nbuf = first_nbuf;
  1294. first_nbuf = first_nbuf->next;
  1295. qdf_nbuf_free(curr_nbuf);
  1296. }
  1297. /* free allocated mpdu hdr */
  1298. if (mpdu_nbuf)
  1299. qdf_nbuf_free(mpdu_nbuf);
  1300. /* free queued remaining msdu pkt per ppdu */
  1301. qdf_nbuf_queue_free(head_msdu);
  1302. /* free queued mpdu per ppdu */
  1303. qdf_nbuf_queue_free(mpdu_q);
  1304. return 0;
  1305. }
  1306. /**
  1307. * dp_tx_msdu_dequeue(): Function to dequeue msdu from peer based tid
  1308. * @peer: dp_peer
  1309. * @ppdu_id: ppdu_id
  1310. * @tid: tid
  1311. * @num_msdu: number of msdu
  1312. * @head: head queue
  1313. * @start_tsf: start tsf from ppdu_desc
  1314. * @end_tsf: end tsf from ppdu_desc
  1315. *
  1316. * return: status
  1317. */
  1318. static
  1319. uint32_t dp_tx_msdu_dequeue(struct dp_peer *peer, uint32_t ppdu_id,
  1320. uint16_t tid, uint32_t num_msdu,
  1321. qdf_nbuf_queue_t *head,
  1322. qdf_nbuf_queue_t *head_xretries,
  1323. uint32_t start_tsf, uint32_t end_tsf)
  1324. {
  1325. struct dp_tx_tid *tx_tid = NULL;
  1326. uint32_t msdu_ppdu_id;
  1327. qdf_nbuf_t curr_msdu = NULL;
  1328. qdf_nbuf_t prev_msdu = NULL;
  1329. struct msdu_completion_info *ptr_msdu_info = NULL;
  1330. uint32_t wbm_tsf;
  1331. uint32_t matched = 0;
  1332. if (qdf_unlikely(!peer))
  1333. return 0;
  1334. /* Non-QOS frames are being indicated with TID 0
  1335. * in WBM completion path, an hence we should
  1336. * TID 0 to reap MSDUs from completion path
  1337. */
  1338. if (qdf_unlikely(tid == DP_NON_QOS_TID))
  1339. tid = 0;
  1340. tx_tid = &peer->tx_capture.tx_tid[tid];
  1341. if (qdf_unlikely(!tx_tid))
  1342. return 0;
  1343. /* lock here */
  1344. qdf_spin_lock_bh(&tx_tid->tid_lock);
  1345. if (qdf_nbuf_is_queue_empty(&tx_tid->msdu_comp_q)) {
  1346. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  1347. return 0;
  1348. }
  1349. curr_msdu = qdf_nbuf_queue_first(&tx_tid->msdu_comp_q);
  1350. while (curr_msdu) {
  1351. if (qdf_nbuf_queue_len(head) == num_msdu) {
  1352. matched = 1;
  1353. break;
  1354. }
  1355. ptr_msdu_info =
  1356. (struct msdu_completion_info *)qdf_nbuf_data(curr_msdu);
  1357. msdu_ppdu_id = ptr_msdu_info->ppdu_id;
  1358. wbm_tsf = ptr_msdu_info->tsf;
  1359. if ((ptr_msdu_info->status == HAL_TX_TQM_RR_REM_CMD_TX) ||
  1360. (ptr_msdu_info->status == HAL_TX_TQM_RR_REM_CMD_AGED)) {
  1361. /* Frames removed due to excessive retries */
  1362. qdf_nbuf_queue_remove(&tx_tid->msdu_comp_q);
  1363. qdf_nbuf_queue_add(head_xretries, curr_msdu);
  1364. curr_msdu = qdf_nbuf_queue_first(
  1365. &tx_tid->msdu_comp_q);
  1366. prev_msdu = NULL;
  1367. continue;
  1368. }
  1369. if (wbm_tsf > end_tsf) {
  1370. /* PPDU being matched is older than MSDU at head of
  1371. * completion queue. Return matched=1 to skip PPDU
  1372. */
  1373. matched = 1;
  1374. break;
  1375. }
  1376. if (wbm_tsf && (wbm_tsf < start_tsf)) {
  1377. /* remove the aged packet */
  1378. qdf_nbuf_queue_remove(&tx_tid->msdu_comp_q);
  1379. qdf_nbuf_free(curr_msdu);
  1380. curr_msdu = qdf_nbuf_queue_first(
  1381. &tx_tid->msdu_comp_q);
  1382. prev_msdu = NULL;
  1383. continue;
  1384. }
  1385. if (msdu_ppdu_id == ppdu_id) {
  1386. if (qdf_likely(!prev_msdu)) {
  1387. /* remove head */
  1388. qdf_nbuf_queue_remove(&tx_tid->msdu_comp_q);
  1389. /* add msdu to head queue */
  1390. qdf_nbuf_queue_add(head, curr_msdu);
  1391. /* get next msdu from msdu_comp_q */
  1392. curr_msdu = qdf_nbuf_queue_first(
  1393. &tx_tid->msdu_comp_q);
  1394. continue;
  1395. } else {
  1396. /* update prev_msdu next to current msdu next */
  1397. prev_msdu->next = curr_msdu->next;
  1398. /* set current msdu next as NULL */
  1399. curr_msdu->next = NULL;
  1400. /* decrement length */
  1401. ((qdf_nbuf_queue_t *)(
  1402. &tx_tid->msdu_comp_q))->qlen--;
  1403. /* add msdu to head queue */
  1404. qdf_nbuf_queue_add(head, curr_msdu);
  1405. /* set previous msdu to current msdu */
  1406. curr_msdu = prev_msdu->next;
  1407. continue;
  1408. }
  1409. }
  1410. prev_msdu = curr_msdu;
  1411. curr_msdu = prev_msdu->next;
  1412. }
  1413. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  1414. return matched;
  1415. }
  1416. /**
  1417. * get_mpdu_clone_from_next_ppdu(): Function to clone missing mpdu from
  1418. * next ppdu
  1419. * @nbuf_ppdu_desc_list: nbuf list
  1420. * @ppdu_desc_cnt: ppdu_desc_cnt
  1421. * @missed_seq_no:
  1422. * @ppdu_id: ppdu_id
  1423. * @mpdu_info: cdp_tx_indication_mpdu_info
  1424. *
  1425. * return: void
  1426. */
  1427. static
  1428. qdf_nbuf_t get_mpdu_clone_from_next_ppdu(qdf_nbuf_t nbuf_ppdu_desc_list[],
  1429. uint32_t ppdu_desc_cnt,
  1430. uint16_t missed_seq_no,
  1431. uint16_t peer_id, uint32_t ppdu_id)
  1432. {
  1433. uint32_t i = 0;
  1434. uint32_t found = 0;
  1435. uint32_t seq_no = 0;
  1436. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  1437. qdf_nbuf_t mpdu = NULL;
  1438. for (i = 1; i < ppdu_desc_cnt; i++) {
  1439. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1440. qdf_nbuf_data(nbuf_ppdu_desc_list[i]);
  1441. /* check if seq number is between the range */
  1442. if ((peer_id == ppdu_desc->user[0].peer_id) &&
  1443. ((missed_seq_no >= ppdu_desc->user[0].start_seq) &&
  1444. (missed_seq_no <= ppdu_desc->user[0].last_enq_seq))) {
  1445. seq_no = ppdu_desc->user[0].start_seq;
  1446. if (SEQ_BIT(ppdu_desc->user[0].failed_bitmap,
  1447. (missed_seq_no - seq_no))) {
  1448. found = 1;
  1449. break;
  1450. }
  1451. }
  1452. }
  1453. if (found == 0) {
  1454. /* mpdu not found in sched cmd id */
  1455. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  1456. "%s: missed seq_no[%d] ppdu_id[%d] [%d] not found!!!",
  1457. __func__, missed_seq_no, ppdu_id, ppdu_desc_cnt);
  1458. return NULL;
  1459. }
  1460. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  1461. "%s: seq_no[%d] missed ppdu_id[%d] m[%d] found in ppdu_id[%d]!!",
  1462. __func__,
  1463. missed_seq_no, ppdu_id,
  1464. (missed_seq_no - seq_no), ppdu_desc->ppdu_id);
  1465. mpdu = qdf_nbuf_queue_first(&ppdu_desc->mpdu_q);
  1466. if (!mpdu) {
  1467. /* bitmap shows it found sequence number, but
  1468. * MPDU not found in PPDU
  1469. */
  1470. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  1471. "%s: missed seq_no[%d] ppdu_id[%d] [%d] found but queue empty!!!",
  1472. __func__, missed_seq_no, ppdu_id, ppdu_desc_cnt);
  1473. return NULL;
  1474. }
  1475. for (i = 0; i < (missed_seq_no - seq_no); i++) {
  1476. mpdu = mpdu->next;
  1477. if (!mpdu) {
  1478. /*
  1479. * bitmap shows it found sequence number,
  1480. * but queue empty, do we need to allocate
  1481. * skb and send instead of NULL ?
  1482. * add counter here:
  1483. */
  1484. return NULL;
  1485. }
  1486. }
  1487. return qdf_nbuf_copy_expand_fraglist(mpdu, MAX_MONITOR_HEADER, 0);
  1488. }
  1489. /**
  1490. * dp_tx_update_user_mpdu_info(): Function to update mpdu info
  1491. * from ppdu_desc
  1492. * @ppdu_id: ppdu_id
  1493. * @mpdu_info: cdp_tx_indication_mpdu_info
  1494. * @user: cdp_tx_completion_ppdu_user
  1495. *
  1496. * return: void
  1497. */
  1498. static void
  1499. dp_tx_update_user_mpdu_info(uint32_t ppdu_id,
  1500. struct cdp_tx_indication_mpdu_info *mpdu_info,
  1501. struct cdp_tx_completion_ppdu_user *user)
  1502. {
  1503. mpdu_info->ppdu_id = ppdu_id;
  1504. mpdu_info->frame_ctrl = user->frame_ctrl;
  1505. mpdu_info->qos_ctrl = user->qos_ctrl;
  1506. mpdu_info->tid = user->tid;
  1507. mpdu_info->ltf_size = user->ltf_size;
  1508. mpdu_info->he_re = user->he_re;
  1509. mpdu_info->txbf = user->txbf;
  1510. mpdu_info->bw = user->bw;
  1511. mpdu_info->nss = user->nss;
  1512. mpdu_info->mcs = user->mcs;
  1513. mpdu_info->preamble = user->preamble;
  1514. mpdu_info->gi = user->gi;
  1515. mpdu_info->ack_rssi = user->ack_rssi[0];
  1516. mpdu_info->tx_rate = user->tx_rate;
  1517. mpdu_info->ldpc = user->ldpc;
  1518. mpdu_info->ppdu_cookie = user->ppdu_cookie;
  1519. mpdu_info->long_retries = user->long_retries;
  1520. mpdu_info->short_retries = user->short_retries;
  1521. mpdu_info->completion_status = user->completion_status;
  1522. qdf_mem_copy(mpdu_info->mac_address, user->mac_addr, 6);
  1523. mpdu_info->ba_start_seq = user->ba_seq_no;
  1524. qdf_mem_copy(mpdu_info->ba_bitmap, user->ba_bitmap,
  1525. CDP_BA_256_BIT_MAP_SIZE_DWORDS * sizeof(uint32_t));
  1526. }
  1527. static inline
  1528. void dp_tx_update_sequence_number(qdf_nbuf_t nbuf, uint32_t seq_no)
  1529. {
  1530. struct ieee80211_frame *ptr_wh = NULL;
  1531. uint16_t wh_seq = 0;
  1532. if (!nbuf)
  1533. return;
  1534. /* update sequence number in frame header */
  1535. ptr_wh = (struct ieee80211_frame *)qdf_nbuf_data(nbuf);
  1536. wh_seq = (seq_no & 0xFFF) << 4;
  1537. qdf_mem_copy(ptr_wh->i_seq, &wh_seq, sizeof(uint16_t));
  1538. }
  1539. static inline
  1540. void dp_update_frame_ctrl_from_frame_type(void *desc)
  1541. {
  1542. struct cdp_tx_completion_ppdu *ppdu_desc = desc;
  1543. /* frame control is not set properly, sometimes it is zero */
  1544. switch (ppdu_desc->htt_frame_type) {
  1545. case HTT_STATS_FTYPE_SGEN_NDPA:
  1546. case HTT_STATS_FTYPE_SGEN_NDP:
  1547. case HTT_STATS_FTYPE_SGEN_AX_NDPA:
  1548. case HTT_STATS_FTYPE_SGEN_AX_NDP:
  1549. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_NDPA |
  1550. IEEE80211_FC0_TYPE_CTL);
  1551. break;
  1552. case HTT_STATS_FTYPE_SGEN_BRP:
  1553. case HTT_STATS_FTYPE_SGEN_MU_BRP:
  1554. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_BRPOLL |
  1555. IEEE80211_FC0_TYPE_CTL);
  1556. break;
  1557. case HTT_STATS_FTYPE_SGEN_RTS:
  1558. case HTT_STATS_FTYPE_SGEN_MU_RTS:
  1559. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_RTS |
  1560. IEEE80211_FC0_TYPE_CTL);
  1561. break;
  1562. case HTT_STATS_FTYPE_SGEN_CTS:
  1563. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_CTS |
  1564. IEEE80211_FC0_TYPE_CTL);
  1565. break;
  1566. case HTT_STATS_FTYPE_SGEN_CFEND:
  1567. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_CF_END |
  1568. IEEE80211_FC0_TYPE_CTL);
  1569. break;
  1570. case HTT_STATS_FTYPE_SGEN_MU_TRIG:
  1571. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_TRIGGER |
  1572. IEEE80211_FC0_TYPE_CTL);
  1573. break;
  1574. case HTT_STATS_FTYPE_SGEN_BAR:
  1575. case HTT_STATS_FTYPE_SGEN_MU_BAR:
  1576. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_BAR |
  1577. IEEE80211_FC0_TYPE_CTL);
  1578. break;
  1579. }
  1580. }
  1581. /**
  1582. * dp_send_dummy_mpdu_info_to_stack(): send dummy payload to stack
  1583. * to upper layer if complete
  1584. * @pdev: DP pdev handle
  1585. * @desc: cdp tx completion ppdu desc
  1586. *
  1587. * return: status
  1588. */
  1589. static inline
  1590. QDF_STATUS dp_send_dummy_mpdu_info_to_stack(struct dp_pdev *pdev,
  1591. void *desc)
  1592. {
  1593. struct dp_peer *peer;
  1594. struct dp_vdev *vdev = NULL;
  1595. struct cdp_tx_completion_ppdu *ppdu_desc = desc;
  1596. struct cdp_tx_completion_ppdu_user *user = &ppdu_desc->user[0];
  1597. struct ieee80211_ctlframe_addr2 *wh_min;
  1598. uint16_t frame_ctrl_le, duration_le;
  1599. struct cdp_tx_indication_info tx_capture_info;
  1600. struct cdp_tx_indication_mpdu_info *mpdu_info;
  1601. uint8_t type, subtype;
  1602. qdf_mem_set(&tx_capture_info,
  1603. sizeof(struct cdp_tx_indication_info),
  1604. 0);
  1605. tx_capture_info.mpdu_nbuf =
  1606. qdf_nbuf_alloc(pdev->soc->osdev,
  1607. MAX_MONITOR_HEADER + MAX_DUMMY_FRM_BODY,
  1608. MAX_MONITOR_HEADER,
  1609. 4, FALSE);
  1610. if (!tx_capture_info.mpdu_nbuf)
  1611. return QDF_STATUS_E_ABORTED;
  1612. mpdu_info = &tx_capture_info.mpdu_info;
  1613. mpdu_info->resp_type = ppdu_desc->resp_type;
  1614. mpdu_info->mprot_type = ppdu_desc->mprot_type;
  1615. mpdu_info->rts_success = ppdu_desc->rts_success;
  1616. mpdu_info->rts_failure = ppdu_desc->rts_failure;
  1617. /* update cdp_tx_indication_mpdu_info */
  1618. dp_tx_update_user_mpdu_info(ppdu_desc->bar_ppdu_id,
  1619. &tx_capture_info.mpdu_info,
  1620. &ppdu_desc->user[0]);
  1621. tx_capture_info.ppdu_desc = ppdu_desc;
  1622. mpdu_info->ppdu_id = ppdu_desc->ppdu_id;
  1623. mpdu_info->channel_num = pdev->operating_channel.num;
  1624. mpdu_info->channel = ppdu_desc->channel;
  1625. mpdu_info->frame_type = ppdu_desc->frame_type;
  1626. mpdu_info->ppdu_start_timestamp = ppdu_desc->ppdu_start_timestamp;
  1627. mpdu_info->ppdu_end_timestamp = ppdu_desc->ppdu_end_timestamp;
  1628. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  1629. mpdu_info->seq_no = user->start_seq;
  1630. qdf_mem_copy(mpdu_info->mac_address, user->mac_addr, QDF_MAC_ADDR_SIZE);
  1631. mpdu_info->ba_start_seq = user->ba_seq_no;
  1632. qdf_mem_copy(mpdu_info->ba_bitmap, user->ba_bitmap,
  1633. CDP_BA_256_BIT_MAP_SIZE_DWORDS * sizeof(uint32_t));
  1634. mpdu_info->frame_ctrl = ppdu_desc->frame_ctrl;
  1635. type = (ppdu_desc->frame_ctrl & IEEE80211_FC0_TYPE_MASK);
  1636. subtype = (ppdu_desc->frame_ctrl & IEEE80211_FC0_SUBTYPE_MASK);
  1637. if (type == IEEE80211_FC0_TYPE_CTL &&
  1638. subtype == IEEE80211_FC0_SUBTYPE_BAR) {
  1639. mpdu_info->frame_ctrl = (IEEE80211_FC0_SUBTYPE_BAR |
  1640. IEEE80211_FC0_TYPE_CTL);
  1641. mpdu_info->ppdu_id = ppdu_desc->bar_ppdu_id;
  1642. mpdu_info->ppdu_start_timestamp =
  1643. ppdu_desc->bar_ppdu_start_timestamp;
  1644. mpdu_info->ppdu_end_timestamp =
  1645. ppdu_desc->bar_ppdu_end_timestamp;
  1646. mpdu_info->tx_duration = ppdu_desc->bar_tx_duration;
  1647. }
  1648. wh_min = (struct ieee80211_ctlframe_addr2 *)
  1649. qdf_nbuf_data(
  1650. tx_capture_info.mpdu_nbuf);
  1651. qdf_mem_zero(wh_min, MAX_DUMMY_FRM_BODY);
  1652. frame_ctrl_le =
  1653. qdf_cpu_to_le16(mpdu_info->frame_ctrl);
  1654. duration_le =
  1655. qdf_cpu_to_le16(mpdu_info->tx_duration);
  1656. wh_min->i_fc[1] = (frame_ctrl_le & 0xFF00) >> 8;
  1657. wh_min->i_fc[0] = (frame_ctrl_le & 0xFF);
  1658. wh_min->i_aidordur[1] = (duration_le & 0xFF00) >> 8;
  1659. wh_min->i_aidordur[0] = (duration_le & 0xFF);
  1660. qdf_mem_copy(wh_min->i_addr1,
  1661. mpdu_info->mac_address,
  1662. QDF_MAC_ADDR_SIZE);
  1663. if (subtype == IEEE80211_FC0_SUBTYPE_ACK)
  1664. qdf_nbuf_set_pktlen(tx_capture_info.mpdu_nbuf,
  1665. sizeof(struct ieee80211_frame_min_one));
  1666. else {
  1667. peer = dp_tx_cap_peer_find_by_id(pdev->soc, user->peer_id);
  1668. if (peer) {
  1669. vdev = peer->vdev;
  1670. dp_tx_cap_peer_unref_del(peer);
  1671. } else {
  1672. vdev =
  1673. dp_get_vdev_from_soc_vdev_id_wifi3(pdev->soc,
  1674. ppdu_desc->vdev_id);
  1675. }
  1676. if (vdev)
  1677. qdf_mem_copy(wh_min->i_addr2,
  1678. vdev->mac_addr.raw,
  1679. QDF_MAC_ADDR_SIZE);
  1680. qdf_nbuf_set_pktlen(tx_capture_info.mpdu_nbuf, sizeof(*wh_min));
  1681. }
  1682. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1683. QDF_TRACE_LEVEL_DEBUG,
  1684. "HTT_FTYPE[%d] frm(0x%08x): fc %x %x, dur 0x%x%x\n",
  1685. ppdu_desc->htt_frame_type, mpdu_info->ppdu_id,
  1686. wh_min->i_fc[1], wh_min->i_fc[0],
  1687. wh_min->i_aidordur[1], wh_min->i_aidordur[0]);
  1688. /*
  1689. * send MPDU to osif layer
  1690. */
  1691. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  1692. &tx_capture_info, HTT_INVALID_PEER,
  1693. WDI_NO_VAL, pdev->pdev_id);
  1694. if (tx_capture_info.mpdu_nbuf)
  1695. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  1696. return QDF_STATUS_SUCCESS;
  1697. }
  1698. /**
  1699. * dp_send_dummy_rts_cts_frame(): send dummy rts and cts frame out
  1700. * to upper layer if complete
  1701. * @pdev: DP pdev handle
  1702. * @cur_ppdu_desc: cdp tx completion ppdu desc
  1703. *
  1704. * return: void
  1705. */
  1706. static
  1707. void dp_send_dummy_rts_cts_frame(struct dp_pdev *pdev,
  1708. struct cdp_tx_completion_ppdu *cur_ppdu_desc)
  1709. {
  1710. struct cdp_tx_completion_ppdu *ppdu_desc;
  1711. struct dp_pdev_tx_capture *ptr_tx_cap;
  1712. struct dp_peer *peer;
  1713. uint8_t rts_send;
  1714. struct dp_vdev *vdev = NULL;
  1715. rts_send = 0;
  1716. ptr_tx_cap = &pdev->tx_capture;
  1717. ppdu_desc = &ptr_tx_cap->dummy_ppdu_desc;
  1718. ppdu_desc->channel = cur_ppdu_desc->channel;
  1719. ppdu_desc->num_mpdu = 1;
  1720. ppdu_desc->num_msdu = 1;
  1721. ppdu_desc->user[0].ppdu_type = HTT_PPDU_STATS_PPDU_TYPE_SU;
  1722. ppdu_desc->bar_num_users = 0;
  1723. ppdu_desc->num_users = 1;
  1724. if (cur_ppdu_desc->mprot_type == SEND_WIFIRTS_LEGACY_E ||
  1725. cur_ppdu_desc->mprot_type == SEND_WIFIRTS_11AC_DYNAMIC_BW_E ||
  1726. cur_ppdu_desc->mprot_type == SEND_WIFIRTS_11AC_STATIC_BW_E) {
  1727. rts_send = 1;
  1728. /*
  1729. * send dummy RTS frame followed by CTS
  1730. * update frame_ctrl and htt_frame_type
  1731. */
  1732. ppdu_desc->htt_frame_type = HTT_STATS_FTYPE_SGEN_RTS;
  1733. ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
  1734. ppdu_desc->ppdu_start_timestamp =
  1735. cur_ppdu_desc->ppdu_start_timestamp;
  1736. ppdu_desc->ppdu_end_timestamp =
  1737. cur_ppdu_desc->ppdu_end_timestamp;
  1738. ppdu_desc->tx_duration = cur_ppdu_desc->tx_duration;
  1739. ppdu_desc->user[0].peer_id = cur_ppdu_desc->user[0].peer_id;
  1740. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_RTS |
  1741. IEEE80211_FC0_TYPE_CTL);
  1742. qdf_mem_copy(&ppdu_desc->user[0].mac_addr,
  1743. &cur_ppdu_desc->user[0].mac_addr,
  1744. QDF_MAC_ADDR_SIZE);
  1745. dp_send_dummy_mpdu_info_to_stack(pdev, ppdu_desc);
  1746. }
  1747. if ((rts_send && cur_ppdu_desc->rts_success) ||
  1748. cur_ppdu_desc->mprot_type == SEND_WIFICTS2SELF_E) {
  1749. uint16_t peer_id;
  1750. peer_id = cur_ppdu_desc->user[0].peer_id;
  1751. /* send dummy CTS frame */
  1752. ppdu_desc->htt_frame_type = HTT_STATS_FTYPE_SGEN_CTS;
  1753. ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
  1754. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_CTS |
  1755. IEEE80211_FC0_TYPE_CTL);
  1756. ppdu_desc->ppdu_start_timestamp =
  1757. cur_ppdu_desc->ppdu_start_timestamp;
  1758. ppdu_desc->ppdu_end_timestamp =
  1759. cur_ppdu_desc->ppdu_end_timestamp;
  1760. ppdu_desc->tx_duration = cur_ppdu_desc->tx_duration -
  1761. (RTS_INTERVAL + SIFS_INTERVAL);
  1762. ppdu_desc->user[0].peer_id = peer_id;
  1763. peer = dp_tx_cap_peer_find_by_id(pdev->soc, peer_id);
  1764. if (peer) {
  1765. vdev = peer->vdev;
  1766. dp_tx_cap_peer_unref_del(peer);
  1767. } else {
  1768. uint8_t vdev_id;
  1769. vdev_id = ppdu_desc->vdev_id;
  1770. vdev = dp_get_vdev_from_soc_vdev_id_wifi3(pdev->soc,
  1771. vdev_id);
  1772. }
  1773. if (vdev)
  1774. qdf_mem_copy(&ppdu_desc->user[0].mac_addr,
  1775. vdev->mac_addr.raw, QDF_MAC_ADDR_SIZE);
  1776. dp_send_dummy_mpdu_info_to_stack(pdev, ppdu_desc);
  1777. }
  1778. }
  1779. static void dp_gen_ack_rx_frame(struct dp_pdev *pdev,
  1780. struct cdp_tx_indication_info *tx_capture_info)
  1781. {
  1782. struct cdp_tx_completion_ppdu *ppdu_desc;
  1783. struct dp_peer *peer;
  1784. struct dp_pdev_tx_capture *ptr_tx_cap;
  1785. ptr_tx_cap = &pdev->tx_capture;
  1786. ppdu_desc = &ptr_tx_cap->dummy_ppdu_desc;
  1787. ppdu_desc->channel = tx_capture_info->ppdu_desc->channel;
  1788. ppdu_desc->num_mpdu = 1;
  1789. ppdu_desc->num_msdu = 1;
  1790. ppdu_desc->user[0].ppdu_type = HTT_PPDU_STATS_PPDU_TYPE_SU;
  1791. ppdu_desc->bar_num_users = 0;
  1792. ppdu_desc->num_users = 1;
  1793. ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
  1794. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_ACK |
  1795. IEEE80211_FC0_TYPE_CTL);
  1796. ppdu_desc->ppdu_start_timestamp =
  1797. tx_capture_info->ppdu_desc->ppdu_start_timestamp;
  1798. ppdu_desc->ppdu_end_timestamp =
  1799. tx_capture_info->ppdu_desc->ppdu_end_timestamp;
  1800. ppdu_desc->user[0].peer_id =
  1801. tx_capture_info->ppdu_desc->user[0].peer_id;
  1802. peer = dp_peer_find_by_id(pdev->soc,
  1803. tx_capture_info->ppdu_desc->user[0].peer_id);
  1804. if (peer) {
  1805. struct dp_vdev *vdev = NULL;
  1806. vdev = peer->vdev;
  1807. if (vdev)
  1808. qdf_mem_copy(&ppdu_desc->user[0].mac_addr,
  1809. vdev->mac_addr.raw,
  1810. QDF_MAC_ADDR_SIZE);
  1811. dp_peer_unref_del_find_by_id(peer);
  1812. }
  1813. dp_send_dummy_mpdu_info_to_stack(pdev, ppdu_desc);
  1814. }
  1815. /**
  1816. * dp_send_data_to_stack(): Function to deliver mpdu info to stack
  1817. * to upper layer
  1818. * @pdev: DP pdev handle
  1819. * @nbuf_ppdu_desc_list: ppdu_desc_list per sched cmd id
  1820. * @ppdu_desc_cnt: number of ppdu_desc_cnt
  1821. *
  1822. * return: status
  1823. */
  1824. static
  1825. void dp_send_data_to_stack(struct dp_pdev *pdev,
  1826. struct cdp_tx_completion_ppdu *ppdu_desc)
  1827. {
  1828. struct cdp_tx_indication_info tx_capture_info;
  1829. struct cdp_tx_indication_mpdu_info *mpdu_info;
  1830. int i;
  1831. uint32_t seq_no, start_seq;
  1832. uint32_t ppdu_id = ppdu_desc->ppdu_id;
  1833. qdf_mem_set(&tx_capture_info,
  1834. sizeof(struct cdp_tx_indication_info),
  1835. 0);
  1836. mpdu_info = &tx_capture_info.mpdu_info;
  1837. mpdu_info->channel = ppdu_desc->channel;
  1838. mpdu_info->frame_type = ppdu_desc->frame_type;
  1839. mpdu_info->ppdu_start_timestamp =
  1840. ppdu_desc->ppdu_start_timestamp;
  1841. mpdu_info->ppdu_end_timestamp =
  1842. ppdu_desc->ppdu_end_timestamp;
  1843. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  1844. mpdu_info->num_msdu = ppdu_desc->num_msdu;
  1845. mpdu_info->resp_type = ppdu_desc->resp_type;
  1846. mpdu_info->mprot_type = ppdu_desc->mprot_type;
  1847. mpdu_info->rts_success = ppdu_desc->rts_success;
  1848. mpdu_info->rts_failure = ppdu_desc->rts_failure;
  1849. /* update cdp_tx_indication_mpdu_info */
  1850. dp_tx_update_user_mpdu_info(ppdu_id,
  1851. &tx_capture_info.mpdu_info,
  1852. &ppdu_desc->user[0]);
  1853. tx_capture_info.ppdu_desc = ppdu_desc;
  1854. tx_capture_info.mpdu_info.channel_num = pdev->operating_channel.num;
  1855. if (ppdu_desc->mprot_type)
  1856. dp_send_dummy_rts_cts_frame(pdev, ppdu_desc);
  1857. start_seq = ppdu_desc->user[0].start_seq;
  1858. for (i = 0; i < ppdu_desc->user[0].ba_size; i++) {
  1859. if (qdf_likely(ppdu_desc->user[0].tid !=
  1860. DP_NON_QOS_TID) &&
  1861. !(SEQ_BIT(ppdu_desc->user[0].enq_bitmap, i))) {
  1862. continue;
  1863. }
  1864. seq_no = start_seq + i;
  1865. if (!ppdu_desc->mpdus[i])
  1866. continue;
  1867. tx_capture_info.mpdu_nbuf = ppdu_desc->mpdus[i];
  1868. ppdu_desc->mpdus[i] = NULL;
  1869. mpdu_info->seq_no = seq_no;
  1870. dp_tx_update_sequence_number(tx_capture_info.mpdu_nbuf, seq_no);
  1871. /*
  1872. * send MPDU to osif layer
  1873. * do we need to update mpdu_info before tranmit
  1874. * get current mpdu_nbuf
  1875. */
  1876. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  1877. &tx_capture_info,
  1878. HTT_INVALID_PEER,
  1879. WDI_NO_VAL, pdev->pdev_id);
  1880. if (tx_capture_info.mpdu_nbuf)
  1881. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  1882. }
  1883. if (ppdu_desc->resp_type == HTT_PPDU_STATS_ACK_EXPECTED_E &&
  1884. ppdu_desc->user[0].completion_status ==
  1885. HTT_PPDU_STATS_USER_STATUS_OK)
  1886. dp_gen_ack_rx_frame(pdev, &tx_capture_info);
  1887. }
  1888. static qdf_nbuf_t dp_tx_mon_get_next_mpdu(
  1889. struct cdp_tx_completion_ppdu *xretry_ppdu,
  1890. qdf_nbuf_t mpdu_nbuf)
  1891. {
  1892. qdf_nbuf_t next_nbuf = NULL;
  1893. qdf_nbuf_queue_t temp_xretries;
  1894. if (mpdu_nbuf != qdf_nbuf_queue_first(&xretry_ppdu->mpdu_q)) {
  1895. next_nbuf = qdf_nbuf_queue_next(mpdu_nbuf);
  1896. /* Initialize temp list */
  1897. qdf_nbuf_queue_init(&temp_xretries);
  1898. /* Move entries into temp list till the mpdu_nbuf is found */
  1899. while ((qdf_nbuf_queue_first(&xretry_ppdu->mpdu_q)) &&
  1900. (mpdu_nbuf !=
  1901. qdf_nbuf_queue_first(&xretry_ppdu->mpdu_q))) {
  1902. qdf_nbuf_queue_add(&temp_xretries,
  1903. qdf_nbuf_queue_remove(&xretry_ppdu->mpdu_q));
  1904. }
  1905. if ((qdf_nbuf_queue_first(&xretry_ppdu->mpdu_q)) &&
  1906. (mpdu_nbuf == qdf_nbuf_queue_first(&xretry_ppdu->mpdu_q))) {
  1907. /* Remove mpdu_nbuf from queue */
  1908. qdf_nbuf_queue_remove(&xretry_ppdu->mpdu_q);
  1909. /* Add remaining nbufs into temp queue */
  1910. qdf_nbuf_queue_append(&temp_xretries,
  1911. &xretry_ppdu->mpdu_q);
  1912. /* Reinit xretry_ppdu->mpdu_q */
  1913. qdf_nbuf_queue_init(&xretry_ppdu->mpdu_q);
  1914. /* append all the entries into original queue */
  1915. qdf_nbuf_queue_append(&xretry_ppdu->mpdu_q,
  1916. &temp_xretries);
  1917. } else {
  1918. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1919. QDF_TRACE_LEVEL_FATAL,
  1920. "%s: This is buggy scenario, did not find nbuf in queue ",
  1921. __func__);
  1922. }
  1923. } else {
  1924. qdf_nbuf_queue_remove(&xretry_ppdu->mpdu_q);
  1925. next_nbuf = qdf_nbuf_queue_first(&xretry_ppdu->mpdu_q);
  1926. }
  1927. return next_nbuf;
  1928. }
  1929. static void
  1930. dp_tx_mon_proc_xretries(struct dp_pdev *pdev, struct dp_peer *peer,
  1931. uint16_t tid)
  1932. {
  1933. struct dp_tx_tid *tx_tid = &peer->tx_capture.tx_tid[tid];
  1934. struct cdp_tx_completion_ppdu *ppdu_desc;
  1935. struct cdp_tx_completion_ppdu *xretry_ppdu;
  1936. qdf_nbuf_t ppdu_nbuf;
  1937. qdf_nbuf_t mpdu_nbuf;
  1938. uint32_t mpdu_tried = 0;
  1939. int i;
  1940. uint32_t seq_no;
  1941. xretry_ppdu = &tx_tid->xretry_ppdu;
  1942. if (qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q)) {
  1943. qdf_nbuf_queue_free(&xretry_ppdu->mpdu_q);
  1944. return;
  1945. }
  1946. if (qdf_nbuf_is_queue_empty(&xretry_ppdu->mpdu_q))
  1947. return;
  1948. ppdu_nbuf = qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q);
  1949. while (ppdu_nbuf) {
  1950. struct msdu_completion_info *ptr_msdu_info = NULL;
  1951. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  1952. qdf_nbuf_data(ppdu_nbuf);
  1953. if (ppdu_desc->pending_retries) {
  1954. uint32_t start_seq = ppdu_desc->user[0].start_seq;
  1955. mpdu_tried = ppdu_desc->user[0].mpdu_tried_ucast +
  1956. ppdu_desc->user[0].mpdu_tried_mcast;
  1957. mpdu_nbuf = qdf_nbuf_queue_first(&xretry_ppdu->mpdu_q);
  1958. for (i = 0; (i < ppdu_desc->user[0].ba_size) &&
  1959. (mpdu_tried > 0) && (mpdu_nbuf); i++) {
  1960. if (!(SEQ_BIT(ppdu_desc->user[0].enq_bitmap,
  1961. i)))
  1962. continue;
  1963. mpdu_tried--;
  1964. /* missed seq number */
  1965. seq_no = start_seq + i;
  1966. if (SEQ_BIT(ppdu_desc->user[0].failed_bitmap, i))
  1967. continue;
  1968. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1969. QDF_TRACE_LEVEL_INFO,
  1970. "%s: fill seqno %d from xretries",
  1971. __func__, seq_no);
  1972. ptr_msdu_info = (struct msdu_completion_info *)
  1973. (qdf_nbuf_data(qdf_nbuf_get_ext_list(
  1974. mpdu_nbuf)) -
  1975. (sizeof(struct msdu_completion_info) +
  1976. sizeof(qdf_ether_header_t)));
  1977. ptr_msdu_info->transmit_cnt--;
  1978. SEQ_SEG(ppdu_desc->user[0].failed_bitmap, i) |=
  1979. SEQ_SEG_MSK(ppdu_desc->user[0].failed_bitmap[0],
  1980. i);
  1981. ppdu_desc->pending_retries--;
  1982. if (ptr_msdu_info->transmit_cnt == 0) {
  1983. ppdu_desc->mpdus[seq_no - start_seq] =
  1984. mpdu_nbuf;
  1985. /*
  1986. * This API removes mpdu_nbuf from q and
  1987. * returns next mpdu from the queue
  1988. */
  1989. mpdu_nbuf = dp_tx_mon_get_next_mpdu(
  1990. xretry_ppdu, mpdu_nbuf);
  1991. } else {
  1992. ppdu_desc->mpdus[seq_no - start_seq] =
  1993. qdf_nbuf_copy_expand_fraglist(
  1994. mpdu_nbuf,
  1995. MAX_MONITOR_HEADER, 0);
  1996. mpdu_nbuf =
  1997. qdf_nbuf_queue_next(mpdu_nbuf);
  1998. }
  1999. }
  2000. }
  2001. if ((ppdu_desc->pending_retries == 0) && (ppdu_nbuf ==
  2002. qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q))) {
  2003. qdf_nbuf_queue_remove(&tx_tid->pending_ppdu_q);
  2004. /* Deliver PPDU */
  2005. dp_send_data_to_stack(pdev, ppdu_desc);
  2006. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  2007. qdf_mem_free(ppdu_desc->mpdus);
  2008. ppdu_desc->mpdus = NULL;
  2009. qdf_nbuf_free(ppdu_nbuf);
  2010. ppdu_nbuf = qdf_nbuf_queue_first(
  2011. &tx_tid->pending_ppdu_q);
  2012. } else {
  2013. ppdu_nbuf = qdf_nbuf_queue_next(ppdu_nbuf);
  2014. }
  2015. }
  2016. qdf_nbuf_queue_free(&xretry_ppdu->mpdu_q);
  2017. }
  2018. #define MAX_PENDING_PPDUS 32
  2019. static void
  2020. dp_tx_mon_proc_pending_ppdus(struct dp_pdev *pdev, struct dp_tx_tid *tx_tid,
  2021. qdf_nbuf_t nbuf_ppdu_desc_list[], uint32_t
  2022. ppdu_desc_cnt, qdf_nbuf_queue_t *head_ppdu,
  2023. uint32_t peer_id)
  2024. {
  2025. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  2026. struct cdp_tx_completion_ppdu *cur_ppdu_desc = NULL;
  2027. qdf_nbuf_t pend_ppdu;
  2028. uint32_t ppdu_cnt;
  2029. uint32_t failed_seq;
  2030. uint32_t cur_index, cur_start_seq, cur_last_seq;
  2031. int i, k;
  2032. bool last_pend_ppdu = false;
  2033. qdf_nbuf_t tmp_nbuf;
  2034. pend_ppdu = qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q);
  2035. if (!pend_ppdu) {
  2036. for (ppdu_cnt = 0; ppdu_cnt < ppdu_desc_cnt; ppdu_cnt++) {
  2037. if (!nbuf_ppdu_desc_list[ppdu_cnt])
  2038. continue;
  2039. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2040. qdf_nbuf_data(
  2041. nbuf_ppdu_desc_list[ppdu_cnt]);
  2042. if (!ppdu_desc || (peer_id !=
  2043. ppdu_desc->user[0].peer_id) || (tx_tid->tid !=
  2044. ppdu_desc->user[0].tid))
  2045. continue;
  2046. if ((ppdu_desc->pending_retries == 0) &&
  2047. qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q) &&
  2048. qdf_nbuf_is_queue_empty(head_ppdu)) {
  2049. dp_send_data_to_stack(pdev, ppdu_desc);
  2050. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  2051. qdf_mem_free(ppdu_desc->mpdus);
  2052. ppdu_desc->mpdus = NULL;
  2053. tmp_nbuf = nbuf_ppdu_desc_list[ppdu_cnt];
  2054. nbuf_ppdu_desc_list[ppdu_cnt] = NULL;
  2055. qdf_nbuf_free(tmp_nbuf);
  2056. } else {
  2057. qdf_nbuf_queue_add(head_ppdu,
  2058. nbuf_ppdu_desc_list[ppdu_cnt]);
  2059. nbuf_ppdu_desc_list[ppdu_cnt] = NULL;
  2060. }
  2061. }
  2062. return;
  2063. }
  2064. while (pend_ppdu) {
  2065. qdf_nbuf_t mpdu_nbuf;
  2066. /* Find missing mpdus from current schedule list */
  2067. ppdu_cnt = 0;
  2068. while (!nbuf_ppdu_desc_list[ppdu_cnt]) {
  2069. ppdu_cnt++;
  2070. if (ppdu_cnt < ppdu_desc_cnt)
  2071. continue;
  2072. break;
  2073. }
  2074. if (ppdu_cnt == ppdu_desc_cnt)
  2075. break;
  2076. ppdu_desc = (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(
  2077. pend_ppdu);
  2078. cur_ppdu_desc = (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(
  2079. nbuf_ppdu_desc_list[ppdu_cnt]);
  2080. if (pend_ppdu == qdf_nbuf_queue_last(
  2081. &tx_tid->pending_ppdu_q)) {
  2082. last_pend_ppdu = true;
  2083. qdf_nbuf_queue_add(head_ppdu,
  2084. nbuf_ppdu_desc_list[ppdu_cnt]);
  2085. nbuf_ppdu_desc_list[ppdu_cnt] = NULL;
  2086. }
  2087. cur_index = 0;
  2088. cur_start_seq = cur_ppdu_desc->user[0].start_seq;
  2089. cur_last_seq = cur_ppdu_desc->user[0].last_enq_seq;
  2090. if (qdf_unlikely(ppdu_desc->user[0].ba_size >
  2091. CDP_BA_256_BIT_MAP_SIZE_DWORDS *
  2092. SEQ_SEG_SZ_BITS(ppdu_desc->user[0].failed_bitmap))) {
  2093. qdf_assert_always(0);
  2094. return;
  2095. }
  2096. for (i = 0; (i < ppdu_desc->user[0].ba_size) && cur_ppdu_desc;
  2097. i++) {
  2098. if (!(i & (SEQ_SEG_SZ_BITS(
  2099. ppdu_desc->user[0].failed_bitmap) - 1))) {
  2100. k =
  2101. SEQ_SEG_INDEX(ppdu_desc->user[0].failed_bitmap,
  2102. i);
  2103. failed_seq =
  2104. ppdu_desc->user[0].failed_bitmap[k] ^
  2105. ppdu_desc->user[0].enq_bitmap[k];
  2106. }
  2107. /* Skip to next bitmap segment if there are no
  2108. * more holes in current segment
  2109. */
  2110. if (!failed_seq) {
  2111. i = ((k + 1) *
  2112. SEQ_SEG_SZ_BITS(ppdu_desc->user[0].failed_bitmap))
  2113. - 1;
  2114. continue;
  2115. }
  2116. if (!(SEQ_SEG_BIT(failed_seq, i)))
  2117. continue;
  2118. failed_seq ^= SEQ_SEG_MSK(failed_seq, i);
  2119. mpdu_nbuf = cur_ppdu_desc->mpdus[cur_index];
  2120. if (mpdu_nbuf) {
  2121. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2122. QDF_TRACE_LEVEL_INFO,
  2123. "%s: fill seqno %d (%d) from swretries",
  2124. __func__,
  2125. ppdu_desc->user[0].start_seq + i,
  2126. ppdu_desc->ppdu_id);
  2127. ppdu_desc->mpdus[i] =
  2128. qdf_nbuf_copy_expand_fraglist(
  2129. mpdu_nbuf, MAX_MONITOR_HEADER, 0);
  2130. ppdu_desc->user[0].failed_bitmap[k] |=
  2131. SEQ_SEG_MSK(ppdu_desc->user[0].failed_bitmap[k],
  2132. i);
  2133. ppdu_desc->pending_retries--;
  2134. }
  2135. cur_index++;
  2136. if (cur_index >= cur_ppdu_desc->user[0].ba_size) {
  2137. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2138. QDF_TRACE_LEVEL_INFO,
  2139. "%s: ba_size[%d] cur_index[%d]\n",
  2140. __func__,
  2141. cur_ppdu_desc->user[0].ba_size,
  2142. cur_index);
  2143. break;
  2144. }
  2145. /* Skip through empty slots in current PPDU */
  2146. while (!(SEQ_BIT(cur_ppdu_desc->user[0].enq_bitmap,
  2147. cur_index))) {
  2148. struct cdp_tx_completion_ppdu *next_ppdu = NULL;
  2149. cur_index++;
  2150. if (cur_index <= (cur_last_seq -
  2151. cur_start_seq))
  2152. continue;
  2153. cur_ppdu_desc = NULL;
  2154. /* Check if subsequent PPDUs in this schedule
  2155. * has higher sequence numbers enqueued
  2156. */
  2157. while (ppdu_cnt < (ppdu_desc_cnt - 1)) {
  2158. ppdu_cnt++;
  2159. if (!nbuf_ppdu_desc_list[ppdu_cnt])
  2160. continue;
  2161. next_ppdu =
  2162. (struct cdp_tx_completion_ppdu *)
  2163. qdf_nbuf_data(
  2164. nbuf_ppdu_desc_list[
  2165. ppdu_cnt]);
  2166. if (!next_ppdu || (peer_id !=
  2167. next_ppdu->user[0].peer_id))
  2168. continue;
  2169. if (last_pend_ppdu) {
  2170. qdf_nbuf_queue_add(head_ppdu,
  2171. nbuf_ppdu_desc_list[ppdu_cnt]);
  2172. nbuf_ppdu_desc_list[ppdu_cnt] =
  2173. NULL;
  2174. }
  2175. if (next_ppdu->user[0].last_enq_seq >
  2176. cur_last_seq) {
  2177. cur_ppdu_desc = next_ppdu;
  2178. break;
  2179. }
  2180. }
  2181. if (!cur_ppdu_desc)
  2182. break;
  2183. /* Start from seq. no following cur_last_seq
  2184. * since everything before is already populated
  2185. * from previous PPDU
  2186. */
  2187. cur_start_seq =
  2188. cur_ppdu_desc->user[0].start_seq;
  2189. cur_index = (cur_last_seq >= cur_start_seq) ?
  2190. cur_last_seq - cur_start_seq + 1 : 0;
  2191. cur_last_seq =
  2192. cur_ppdu_desc->user[0].last_enq_seq;
  2193. }
  2194. }
  2195. if ((pend_ppdu ==
  2196. qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q)) &&
  2197. (ppdu_desc->pending_retries == 0)) {
  2198. qdf_nbuf_queue_remove(&tx_tid->pending_ppdu_q);
  2199. dp_send_data_to_stack(pdev, ppdu_desc);
  2200. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  2201. qdf_mem_free(ppdu_desc->mpdus);
  2202. ppdu_desc->mpdus = NULL;
  2203. qdf_nbuf_free(pend_ppdu);
  2204. pend_ppdu = qdf_nbuf_queue_first(
  2205. &tx_tid->pending_ppdu_q);
  2206. } else {
  2207. pend_ppdu = qdf_nbuf_queue_next(pend_ppdu);
  2208. }
  2209. }
  2210. }
  2211. static uint32_t
  2212. dp_send_mgmt_ctrl_to_stack(struct dp_pdev *pdev,
  2213. qdf_nbuf_t nbuf_ppdu_desc,
  2214. struct cdp_tx_indication_info *ptr_tx_cap_info,
  2215. qdf_nbuf_t mgmt_ctl_nbuf,
  2216. bool is_payload)
  2217. {
  2218. struct cdp_tx_completion_ppdu *ppdu_desc;
  2219. struct cdp_tx_indication_mpdu_info *mpdu_info;
  2220. struct ieee80211_frame *wh;
  2221. uint16_t duration_le, seq_le;
  2222. struct ieee80211_frame_min_one *wh_min;
  2223. uint16_t frame_ctrl_le;
  2224. uint8_t type, subtype;
  2225. mpdu_info = &ptr_tx_cap_info->mpdu_info;
  2226. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2227. qdf_nbuf_data(nbuf_ppdu_desc);
  2228. if (ppdu_desc->mprot_type)
  2229. dp_send_dummy_rts_cts_frame(pdev, ppdu_desc);
  2230. type = (ppdu_desc->frame_ctrl &
  2231. IEEE80211_FC0_TYPE_MASK) >>
  2232. IEEE80211_FC0_TYPE_SHIFT;
  2233. subtype = (ppdu_desc->frame_ctrl &
  2234. IEEE80211_FC0_SUBTYPE_MASK) >>
  2235. IEEE80211_FC0_SUBTYPE_SHIFT;
  2236. if (is_payload) {
  2237. wh = (struct ieee80211_frame *)qdf_nbuf_data(mgmt_ctl_nbuf);
  2238. if (subtype != IEEE80211_FC0_SUBTYPE_BEACON) {
  2239. duration_le = qdf_cpu_to_le16(ppdu_desc->tx_duration);
  2240. wh->i_dur[1] = (duration_le & 0xFF00) >> 8;
  2241. wh->i_dur[0] = duration_le & 0xFF;
  2242. seq_le = qdf_cpu_to_le16(ppdu_desc->user[0].start_seq <<
  2243. IEEE80211_SEQ_SEQ_SHIFT);
  2244. wh->i_seq[1] = (seq_le & 0xFF00) >> 8;
  2245. wh->i_seq[0] = seq_le & 0xFF;
  2246. }
  2247. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2248. QDF_TRACE_LEVEL_DEBUG,
  2249. "ctrl/mgmt frm(0x%08x): fc 0x%x 0x%x\n",
  2250. ptr_tx_cap_info->mpdu_info.ppdu_id,
  2251. wh->i_fc[1], wh->i_fc[0]);
  2252. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2253. QDF_TRACE_LEVEL_DEBUG,
  2254. "desc->ppdu_id 0x%08x\n", ppdu_desc->ppdu_id);
  2255. /* append ext list */
  2256. qdf_nbuf_append_ext_list(ptr_tx_cap_info->mpdu_nbuf,
  2257. mgmt_ctl_nbuf,
  2258. qdf_nbuf_len(mgmt_ctl_nbuf));
  2259. } else {
  2260. wh_min = (struct ieee80211_frame_min_one *)
  2261. qdf_nbuf_data(ptr_tx_cap_info->mpdu_nbuf);
  2262. qdf_mem_zero(wh_min, MAX_DUMMY_FRM_BODY);
  2263. frame_ctrl_le = qdf_cpu_to_le16(ppdu_desc->frame_ctrl);
  2264. duration_le = qdf_cpu_to_le16(ppdu_desc->tx_duration);
  2265. wh_min->i_fc[1] = (frame_ctrl_le & 0xFF00) >> 8;
  2266. wh_min->i_fc[0] = (frame_ctrl_le & 0xFF);
  2267. wh_min->i_dur[1] = (duration_le & 0xFF00) >> 8;
  2268. wh_min->i_dur[0] = (duration_le & 0xFF);
  2269. qdf_mem_copy(wh_min->i_addr1, mpdu_info->mac_address,
  2270. QDF_MAC_ADDR_SIZE);
  2271. qdf_nbuf_set_pktlen(ptr_tx_cap_info->mpdu_nbuf,
  2272. sizeof(*wh_min));
  2273. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2274. QDF_TRACE_LEVEL_DEBUG,
  2275. "frm(0x%08x): fc %x %x, dur 0x%x%x\n",
  2276. ptr_tx_cap_info->mpdu_info.ppdu_id,
  2277. wh_min->i_fc[1], wh_min->i_fc[0],
  2278. wh_min->i_dur[1], wh_min->i_dur[0]);
  2279. }
  2280. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  2281. ptr_tx_cap_info, HTT_INVALID_PEER,
  2282. WDI_NO_VAL, pdev->pdev_id);
  2283. if (ptr_tx_cap_info->mpdu_nbuf)
  2284. qdf_nbuf_free(ptr_tx_cap_info->mpdu_nbuf);
  2285. return 0;
  2286. }
  2287. static uint32_t
  2288. dp_update_tx_cap_info(struct dp_pdev *pdev,
  2289. qdf_nbuf_t nbuf_ppdu_desc,
  2290. void *tx_info, bool is_payload)
  2291. {
  2292. struct cdp_tx_completion_ppdu *ppdu_desc;
  2293. struct cdp_tx_indication_info *tx_capture_info =
  2294. (struct cdp_tx_indication_info *)tx_info;
  2295. struct cdp_tx_indication_mpdu_info *mpdu_info;
  2296. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2297. qdf_nbuf_data(nbuf_ppdu_desc);
  2298. qdf_mem_set(tx_capture_info, sizeof(struct cdp_tx_indication_info), 0);
  2299. mpdu_info = &tx_capture_info->mpdu_info;
  2300. mpdu_info->channel = ppdu_desc->channel;
  2301. mpdu_info->frame_type = ppdu_desc->frame_type;
  2302. mpdu_info->ppdu_start_timestamp = ppdu_desc->ppdu_start_timestamp;
  2303. mpdu_info->ppdu_end_timestamp = ppdu_desc->ppdu_end_timestamp;
  2304. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  2305. mpdu_info->seq_no = ppdu_desc->user[0].start_seq;
  2306. mpdu_info->num_msdu = ppdu_desc->num_msdu;
  2307. /* update cdp_tx_indication_mpdu_info */
  2308. dp_tx_update_user_mpdu_info(ppdu_desc->ppdu_id,
  2309. &tx_capture_info->mpdu_info,
  2310. &ppdu_desc->user[0]);
  2311. tx_capture_info->ppdu_desc = ppdu_desc;
  2312. tx_capture_info->mpdu_info.channel_num = pdev->operating_channel.num;
  2313. tx_capture_info->mpdu_info.ppdu_id = ppdu_desc->ppdu_id;
  2314. if (is_payload)
  2315. tx_capture_info->mpdu_nbuf = qdf_nbuf_alloc(pdev->soc->osdev,
  2316. MAX_MONITOR_HEADER,
  2317. MAX_MONITOR_HEADER,
  2318. 4, FALSE);
  2319. else
  2320. tx_capture_info->mpdu_nbuf = qdf_nbuf_alloc(pdev->soc->osdev,
  2321. MAX_MONITOR_HEADER +
  2322. MAX_DUMMY_FRM_BODY,
  2323. MAX_MONITOR_HEADER,
  2324. 4, FALSE);
  2325. return 0;
  2326. }
  2327. static uint32_t
  2328. dp_check_mgmt_ctrl_ppdu(struct dp_pdev *pdev,
  2329. qdf_nbuf_t nbuf_ppdu_desc)
  2330. {
  2331. struct cdp_tx_indication_info tx_capture_info;
  2332. qdf_nbuf_t mgmt_ctl_nbuf;
  2333. uint8_t type, subtype;
  2334. uint8_t fc_type, fc_subtype;
  2335. bool is_sgen_pkt;
  2336. struct cdp_tx_mgmt_comp_info *ptr_comp_info;
  2337. qdf_nbuf_queue_t *retries_q;
  2338. struct cdp_tx_completion_ppdu *ppdu_desc;
  2339. uint32_t ppdu_id;
  2340. size_t head_size;
  2341. uint32_t status = 1;
  2342. uint32_t tsf_delta;
  2343. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2344. qdf_nbuf_data(nbuf_ppdu_desc);
  2345. /*
  2346. * only for host generated frame we do have
  2347. * timestamp and retries count.
  2348. */
  2349. head_size = sizeof(struct cdp_tx_mgmt_comp_info);
  2350. fc_type = (ppdu_desc->frame_ctrl &
  2351. IEEE80211_FC0_TYPE_MASK);
  2352. fc_subtype = (ppdu_desc->frame_ctrl &
  2353. IEEE80211_FC0_SUBTYPE_MASK);
  2354. type = (ppdu_desc->frame_ctrl &
  2355. IEEE80211_FC0_TYPE_MASK) >>
  2356. IEEE80211_FC0_TYPE_SHIFT;
  2357. subtype = (ppdu_desc->frame_ctrl &
  2358. IEEE80211_FC0_SUBTYPE_MASK) >>
  2359. IEEE80211_FC0_SUBTYPE_SHIFT;
  2360. if (ppdu_desc->htt_frame_type == HTT_STATS_FTYPE_SGEN_NDP) {
  2361. dp_update_frame_ctrl_from_frame_type(ppdu_desc);
  2362. type = 0;
  2363. subtype = 0;
  2364. }
  2365. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, NULL,
  2366. ppdu_desc->user[0].mac_addr)) {
  2367. qdf_nbuf_free(nbuf_ppdu_desc);
  2368. status = 0;
  2369. goto free_ppdu_desc;
  2370. }
  2371. switch (ppdu_desc->htt_frame_type) {
  2372. case HTT_STATS_FTYPE_TIDQ_DATA_SU:
  2373. case HTT_STATS_FTYPE_TIDQ_DATA_MU:
  2374. if ((fc_type == IEEE80211_FC0_TYPE_MGT) &&
  2375. (fc_subtype == IEEE80211_FC0_SUBTYPE_BEACON))
  2376. is_sgen_pkt = true;
  2377. else
  2378. is_sgen_pkt = false;
  2379. break;
  2380. default:
  2381. is_sgen_pkt = true;
  2382. break;
  2383. }
  2384. retries_q = &pdev->tx_capture.retries_ctl_mgmt_q[type][subtype];
  2385. get_mgmt_pkt_from_queue:
  2386. qdf_spin_lock_bh(
  2387. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  2388. mgmt_ctl_nbuf = qdf_nbuf_queue_remove(
  2389. &pdev->tx_capture.ctl_mgmt_q[type][subtype]);
  2390. qdf_spin_unlock_bh(&pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  2391. if (mgmt_ctl_nbuf) {
  2392. qdf_nbuf_t tmp_mgmt_ctl_nbuf;
  2393. uint32_t start_tsf;
  2394. ptr_comp_info = (struct cdp_tx_mgmt_comp_info *)
  2395. qdf_nbuf_data(mgmt_ctl_nbuf);
  2396. is_sgen_pkt = ptr_comp_info->is_sgen_pkt;
  2397. ppdu_id = ptr_comp_info->ppdu_id;
  2398. if (!is_sgen_pkt && ptr_comp_info->tx_tsf <
  2399. ppdu_desc->ppdu_start_timestamp) {
  2400. /*
  2401. * free the older mgmt buffer from
  2402. * the queue and get new mgmt buffer
  2403. */
  2404. qdf_nbuf_free(mgmt_ctl_nbuf);
  2405. goto get_mgmt_pkt_from_queue;
  2406. }
  2407. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2408. QDF_TRACE_LEVEL_INFO_HIGH,
  2409. "ppdu_id [%d 0x%x] type_subtype[%d %d] is_sgen[%d] h_sz[%d]",
  2410. ppdu_id, ppdu_id, type, subtype,
  2411. is_sgen_pkt, head_size);
  2412. QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_TX_CAPTURE,
  2413. QDF_TRACE_LEVEL_INFO_HIGH,
  2414. qdf_nbuf_data(mgmt_ctl_nbuf), 32);
  2415. /*
  2416. * for sgen frame we won't have, retries count
  2417. * and 64 bits tsf in the head.
  2418. */
  2419. if (ppdu_id != ppdu_desc->ppdu_id) {
  2420. if (is_sgen_pkt) {
  2421. start_tsf = (ppdu_desc->ppdu_start_timestamp &
  2422. LOWER_32_MASK);
  2423. if (start_tsf > ptr_comp_info->tx_tsf)
  2424. tsf_delta = start_tsf - ptr_comp_info->tx_tsf;
  2425. else
  2426. tsf_delta = LOWER_32_MASK - ptr_comp_info->tx_tsf + start_tsf;
  2427. if (tsf_delta > MAX_MGMT_ENQ_DELAY) {
  2428. /*
  2429. * free the older mgmt buffer from
  2430. * the queue and get new mgmt buffer
  2431. */
  2432. qdf_nbuf_free(mgmt_ctl_nbuf);
  2433. goto get_mgmt_pkt_from_queue;
  2434. }
  2435. }
  2436. /*
  2437. * only for the packets send over the air are handled
  2438. * packets drop by firmware is not handled in this
  2439. * feature
  2440. */
  2441. if (ppdu_desc->user[0].completion_status ==
  2442. HTT_PPDU_STATS_USER_STATUS_FILTERED) {
  2443. qdf_nbuf_free(nbuf_ppdu_desc);
  2444. status = 0;
  2445. goto insert_mgmt_buf_to_queue;
  2446. }
  2447. /*
  2448. * add the ppdu_desc into retry queue
  2449. */
  2450. qdf_nbuf_queue_add(retries_q, nbuf_ppdu_desc);
  2451. status = 0;
  2452. insert_mgmt_buf_to_queue:
  2453. /*
  2454. * insert the mgmt_ctl buffer back to
  2455. * the queue
  2456. */
  2457. qdf_spin_lock_bh(
  2458. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  2459. qdf_nbuf_queue_insert_head(
  2460. &pdev->tx_capture.ctl_mgmt_q[type][subtype],
  2461. mgmt_ctl_nbuf);
  2462. qdf_spin_unlock_bh(
  2463. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  2464. } else {
  2465. qdf_nbuf_t nbuf_retry_ppdu;
  2466. struct cdp_tx_completion_ppdu *tmp_ppdu_desc;
  2467. uint16_t frame_ctrl_le;
  2468. struct ieee80211_frame *wh;
  2469. /*
  2470. * only for the packets send over the air are handled
  2471. * packets drop by firmware is not handled in this
  2472. * feature
  2473. */
  2474. if (ppdu_desc->user[0].completion_status ==
  2475. HTT_PPDU_STATS_USER_STATUS_FILTERED) {
  2476. qdf_nbuf_free(nbuf_ppdu_desc);
  2477. qdf_nbuf_free(mgmt_ctl_nbuf);
  2478. status = 0;
  2479. goto free_ppdu_desc;
  2480. }
  2481. while (!!qdf_nbuf_queue_len(retries_q)) {
  2482. /*
  2483. * send retried packet stored
  2484. * in queue
  2485. */
  2486. nbuf_retry_ppdu =
  2487. qdf_nbuf_queue_remove(retries_q);
  2488. tmp_ppdu_desc =
  2489. (struct cdp_tx_completion_ppdu *)
  2490. qdf_nbuf_data(nbuf_retry_ppdu);
  2491. tmp_mgmt_ctl_nbuf =
  2492. qdf_nbuf_copy_expand(mgmt_ctl_nbuf,
  2493. 0, 0);
  2494. dp_update_tx_cap_info(pdev, nbuf_retry_ppdu,
  2495. &tx_capture_info, true);
  2496. if (!tx_capture_info.mpdu_nbuf) {
  2497. qdf_nbuf_free(nbuf_retry_ppdu);
  2498. qdf_nbuf_free(tmp_mgmt_ctl_nbuf);
  2499. continue;
  2500. }
  2501. /* pull head based on sgen pkt or mgmt pkt */
  2502. qdf_nbuf_pull_head(tmp_mgmt_ctl_nbuf,
  2503. head_size);
  2504. /*
  2505. * frame control from ppdu_desc has
  2506. * retry flag set
  2507. */
  2508. frame_ctrl_le =
  2509. qdf_cpu_to_le16(tmp_ppdu_desc->frame_ctrl);
  2510. wh = (struct ieee80211_frame *)
  2511. (qdf_nbuf_data(tmp_mgmt_ctl_nbuf));
  2512. wh->i_fc[1] = (frame_ctrl_le & 0xFF00) >> 8;
  2513. wh->i_fc[0] = (frame_ctrl_le & 0xFF);
  2514. tx_capture_info.ppdu_desc = tmp_ppdu_desc;
  2515. /*
  2516. * send MPDU to osif layer
  2517. */
  2518. dp_send_mgmt_ctrl_to_stack(pdev,
  2519. nbuf_retry_ppdu,
  2520. &tx_capture_info,
  2521. tmp_mgmt_ctl_nbuf,
  2522. true);
  2523. /* free retried queue nbuf ppdu_desc */
  2524. qdf_nbuf_free(nbuf_retry_ppdu);
  2525. }
  2526. dp_update_tx_cap_info(pdev, nbuf_ppdu_desc,
  2527. &tx_capture_info, true);
  2528. if (!tx_capture_info.mpdu_nbuf) {
  2529. qdf_nbuf_free(mgmt_ctl_nbuf);
  2530. goto free_ppdu_desc;
  2531. }
  2532. tx_capture_info.mpdu_info.ppdu_id =
  2533. *(uint32_t *)qdf_nbuf_data(mgmt_ctl_nbuf);
  2534. /* pull head based on sgen pkt or mgmt pkt */
  2535. qdf_nbuf_pull_head(mgmt_ctl_nbuf, head_size);
  2536. /* frame control from ppdu_desc has retry flag set */
  2537. frame_ctrl_le = qdf_cpu_to_le16(ppdu_desc->frame_ctrl);
  2538. wh = (struct ieee80211_frame *)
  2539. (qdf_nbuf_data(mgmt_ctl_nbuf));
  2540. wh->i_fc[1] = (frame_ctrl_le & 0xFF00) >> 8;
  2541. wh->i_fc[0] = (frame_ctrl_le & 0xFF);
  2542. tx_capture_info.ppdu_desc = ppdu_desc;
  2543. /*
  2544. * send MPDU to osif layer
  2545. */
  2546. dp_send_mgmt_ctrl_to_stack(pdev, nbuf_ppdu_desc,
  2547. &tx_capture_info,
  2548. mgmt_ctl_nbuf, true);
  2549. }
  2550. } else if (!is_sgen_pkt) {
  2551. /*
  2552. * only for the packets send over the air are handled
  2553. * packets drop by firmware is not handled in this
  2554. * feature
  2555. */
  2556. if (ppdu_desc->user[0].completion_status ==
  2557. HTT_PPDU_STATS_USER_STATUS_FILTERED) {
  2558. qdf_nbuf_free(nbuf_ppdu_desc);
  2559. status = 0;
  2560. goto free_ppdu_desc;
  2561. }
  2562. /*
  2563. * add the ppdu_desc into retry queue
  2564. */
  2565. qdf_nbuf_queue_add(retries_q, nbuf_ppdu_desc);
  2566. status = 0;
  2567. } else if ((ppdu_desc->frame_ctrl &
  2568. IEEE80211_FC0_TYPE_MASK) ==
  2569. IEEE80211_FC0_TYPE_CTL) {
  2570. /*
  2571. * only for the packets send over the air are handled
  2572. * packets drop by firmware is not handled in this
  2573. * feature
  2574. */
  2575. if (ppdu_desc->user[0].completion_status ==
  2576. HTT_PPDU_STATS_USER_STATUS_FILTERED) {
  2577. qdf_nbuf_free(nbuf_ppdu_desc);
  2578. status = 0;
  2579. goto free_ppdu_desc;
  2580. }
  2581. dp_update_tx_cap_info(pdev, nbuf_ppdu_desc,
  2582. &tx_capture_info, false);
  2583. if (!tx_capture_info.mpdu_nbuf)
  2584. goto free_ppdu_desc;
  2585. /*
  2586. * send MPDU to osif layer
  2587. */
  2588. dp_send_mgmt_ctrl_to_stack(pdev, nbuf_ppdu_desc,
  2589. &tx_capture_info, NULL, false);
  2590. }
  2591. free_ppdu_desc:
  2592. return status;
  2593. }
  2594. /**
  2595. * dp_peer_tx_cap_tid_queue_flush_tlv(): Function to dequeue peer queue
  2596. * @pdev: DP pdev handle
  2597. * @peer; DP peer handle
  2598. * @ppdu_desc: ppdu_desc
  2599. *
  2600. * return: void
  2601. */
  2602. static void
  2603. dp_peer_tx_cap_tid_queue_flush_tlv(struct dp_pdev *pdev,
  2604. struct dp_peer *peer,
  2605. struct cdp_tx_completion_ppdu *ppdu_desc)
  2606. {
  2607. int tid;
  2608. struct dp_tx_tid *tx_tid;
  2609. qdf_nbuf_queue_t head_xretries;
  2610. qdf_nbuf_queue_t head_msdu;
  2611. uint32_t qlen = 0;
  2612. uint32_t qlen_curr = 0;
  2613. tid = ppdu_desc->user[0].tid;
  2614. tx_tid = &peer->tx_capture.tx_tid[tid];
  2615. qdf_nbuf_queue_init(&head_msdu);
  2616. qdf_nbuf_queue_init(&head_xretries);
  2617. qlen = qdf_nbuf_queue_len(&tx_tid->msdu_comp_q);
  2618. dp_tx_msdu_dequeue(peer, INVALID_PPDU_ID,
  2619. tid, ppdu_desc->num_msdu,
  2620. &head_msdu,
  2621. &head_xretries,
  2622. 0, MAX_END_TSF);
  2623. if (!qdf_nbuf_is_queue_empty(&head_xretries)) {
  2624. struct cdp_tx_completion_ppdu *xretry_ppdu =
  2625. &tx_tid->xretry_ppdu;
  2626. xretry_ppdu->ppdu_id = peer->tx_capture.tx_wifi_ppdu_id;
  2627. /* Restitch MPDUs from xretry MSDUs */
  2628. dp_tx_mon_restitch_mpdu(pdev, peer,
  2629. xretry_ppdu,
  2630. &head_xretries,
  2631. &xretry_ppdu->mpdu_q);
  2632. }
  2633. qdf_nbuf_queue_free(&head_msdu);
  2634. qdf_nbuf_queue_free(&head_xretries);
  2635. qlen_curr = qdf_nbuf_queue_len(&tx_tid->msdu_comp_q);
  2636. dp_tx_mon_proc_xretries(pdev, peer, tid);
  2637. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2638. QDF_TRACE_LEVEL_INFO_MED,
  2639. "peer_id [%d 0x%x] tid[%d] qlen[%d -> %d]",
  2640. ppdu_desc->user[0].peer_id, peer, tid, qlen, qlen_curr);
  2641. }
  2642. /**
  2643. * dp_tx_ppdu_stats_flush(): Function to flush pending retried ppdu desc
  2644. * @pdev: DP pdev handle
  2645. * @nbuf: ppdu_desc
  2646. *
  2647. * return: void
  2648. */
  2649. static void
  2650. dp_tx_ppdu_stats_flush(struct dp_pdev *pdev,
  2651. struct cdp_tx_completion_ppdu *ppdu_desc)
  2652. {
  2653. struct dp_peer *peer;
  2654. peer = dp_tx_cap_peer_find_by_id(pdev->soc,
  2655. ppdu_desc->user[0].peer_id);
  2656. if (!peer)
  2657. return;
  2658. dp_peer_tx_cap_tid_queue_flush_tlv(pdev, peer, ppdu_desc);
  2659. dp_tx_cap_peer_unref_del(peer);
  2660. return;
  2661. }
  2662. static void dp_ppdu_queue_free(struct cdp_tx_completion_ppdu *ppdu_desc)
  2663. {
  2664. int i;
  2665. qdf_nbuf_t mpdu_nbuf = NULL;
  2666. for (i = 0; i < ppdu_desc->user[0].ba_size; i++) {
  2667. mpdu_nbuf = ppdu_desc->mpdus[i];
  2668. if (mpdu_nbuf)
  2669. qdf_nbuf_free(mpdu_nbuf);
  2670. }
  2671. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  2672. qdf_mem_free(ppdu_desc->mpdus);
  2673. ppdu_desc->mpdus = NULL;
  2674. return;
  2675. }
  2676. /**
  2677. * dp_check_ppdu_and_deliver(): Check PPDUs for any holes and deliver
  2678. * to upper layer if complete
  2679. * @pdev: DP pdev handle
  2680. * @nbuf_ppdu_desc_list: ppdu_desc_list per sched cmd id
  2681. * @ppdu_desc_cnt: number of ppdu_desc_cnt
  2682. *
  2683. * return: status
  2684. */
  2685. static void
  2686. dp_check_ppdu_and_deliver(struct dp_pdev *pdev,
  2687. qdf_nbuf_t nbuf_ppdu_desc_list[],
  2688. uint32_t ppdu_desc_cnt)
  2689. {
  2690. uint32_t ppdu_id;
  2691. uint32_t desc_cnt;
  2692. qdf_nbuf_t tmp_nbuf;
  2693. struct dp_tx_tid *tx_tid = NULL;
  2694. int i;
  2695. for (desc_cnt = 0; desc_cnt < ppdu_desc_cnt; desc_cnt++) {
  2696. struct cdp_tx_completion_ppdu *ppdu_desc;
  2697. uint32_t num_mpdu;
  2698. uint16_t start_seq, seq_no = 0;
  2699. int i;
  2700. qdf_nbuf_t mpdu_nbuf;
  2701. struct dp_peer *peer;
  2702. uint8_t type;
  2703. uint32_t mpdus_tried;
  2704. if (!nbuf_ppdu_desc_list[desc_cnt])
  2705. continue;
  2706. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2707. qdf_nbuf_data(nbuf_ppdu_desc_list[desc_cnt]);
  2708. ppdu_id = ppdu_desc->ppdu_id;
  2709. type = (ppdu_desc->frame_ctrl & IEEE80211_FC0_TYPE_MASK) >>
  2710. IEEE80211_FC0_TYPE_SHIFT;
  2711. if (ppdu_desc->is_flush) {
  2712. dp_tx_ppdu_stats_flush(pdev, ppdu_desc);
  2713. tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
  2714. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  2715. qdf_nbuf_free(tmp_nbuf);
  2716. continue;
  2717. }
  2718. if ((ppdu_desc->frame_type == CDP_PPDU_FTYPE_CTRL) ||
  2719. (ppdu_desc->htt_frame_type ==
  2720. HTT_STATS_FTYPE_SGEN_QOS_NULL) ||
  2721. (type != FRAME_CTRL_TYPE_DATA)) {
  2722. qdf_nbuf_t nbuf_ppdu = nbuf_ppdu_desc_list[desc_cnt];
  2723. if (dp_check_mgmt_ctrl_ppdu(pdev, nbuf_ppdu)) {
  2724. tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
  2725. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  2726. qdf_nbuf_free(tmp_nbuf);
  2727. continue;
  2728. }
  2729. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  2730. continue;
  2731. }
  2732. peer = dp_tx_cap_peer_find_by_id(pdev->soc,
  2733. ppdu_desc->user[0].peer_id);
  2734. if (!peer) {
  2735. tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
  2736. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  2737. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  2738. qdf_nbuf_free(tmp_nbuf);
  2739. continue;
  2740. }
  2741. tx_tid = &peer->tx_capture.tx_tid[ppdu_desc->user[0].tid];
  2742. ppdu_id = ppdu_desc->ppdu_id;
  2743. /* find mpdu tried is same as success mpdu */
  2744. num_mpdu = ppdu_desc->user[0].mpdu_success;
  2745. /* ba_size is updated in BA bitmap TLVs, which are not received
  2746. * in case of non-QoS TID.
  2747. */
  2748. if (qdf_unlikely(ppdu_desc->user[0].tid == DP_NON_QOS_TID)) {
  2749. ppdu_desc->user[0].ba_size = 1;
  2750. ppdu_desc->user[0].last_enq_seq =
  2751. ppdu_desc->user[0].start_seq;
  2752. }
  2753. if (ppdu_desc->user[0].ba_size == 0)
  2754. ppdu_desc->user[0].ba_size = 1;
  2755. /* find list of missing sequence */
  2756. ppdu_desc->mpdus = qdf_mem_malloc(sizeof(qdf_nbuf_t) *
  2757. ppdu_desc->user[0].ba_size);
  2758. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR)
  2759. dp_send_dummy_mpdu_info_to_stack(pdev,
  2760. ppdu_desc);
  2761. if (qdf_unlikely(!ppdu_desc->mpdus)) {
  2762. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2763. QDF_TRACE_LEVEL_FATAL,
  2764. "%s: ppdu_desc->mpdus allocation failed",
  2765. __func__);
  2766. tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
  2767. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  2768. qdf_nbuf_queue_free(&ppdu_desc->mpdu_q);
  2769. qdf_nbuf_free(tmp_nbuf);
  2770. dp_tx_cap_peer_unref_del(peer);
  2771. continue;
  2772. }
  2773. if (qdf_unlikely(ppdu_desc->user[0].ba_size >
  2774. CDP_BA_256_BIT_MAP_SIZE_DWORDS *
  2775. SEQ_SEG_SZ_BITS(ppdu_desc->user[0].failed_bitmap))) {
  2776. dp_tx_cap_peer_unref_del(peer);
  2777. qdf_assert_always(0);
  2778. return;
  2779. }
  2780. /* Fill seq holes within current schedule list */
  2781. start_seq = ppdu_desc->user[0].start_seq;
  2782. mpdus_tried = ppdu_desc->user[0].mpdu_tried_mcast +
  2783. ppdu_desc->user[0].mpdu_tried_ucast;
  2784. for (i = 0; (i < ppdu_desc->user[0].ba_size) && mpdus_tried;
  2785. i++) {
  2786. if (qdf_likely(ppdu_desc->user[0].tid !=
  2787. DP_NON_QOS_TID) &&
  2788. !(SEQ_BIT(ppdu_desc->user[0].enq_bitmap, i)))
  2789. continue;
  2790. mpdus_tried--;
  2791. /* missed seq number */
  2792. seq_no = start_seq + i;
  2793. /* Fill failed MPDUs in AMPDU if they're available in
  2794. * subsequent PPDUs in current burst schedule. This
  2795. * is not applicable for non-QoS TIDs (no AMPDUs)
  2796. */
  2797. if (qdf_likely(ppdu_desc->user[0].tid !=
  2798. DP_NON_QOS_TID) &&
  2799. !(SEQ_BIT(ppdu_desc->user[0].failed_bitmap, i))) {
  2800. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2801. QDF_TRACE_LEVEL_DEBUG,
  2802. "%s:find seq %d in next ppdu %d",
  2803. __func__, seq_no,
  2804. ppdu_desc_cnt);
  2805. mpdu_nbuf = get_mpdu_clone_from_next_ppdu(
  2806. nbuf_ppdu_desc_list +
  2807. desc_cnt,
  2808. ppdu_desc_cnt -
  2809. desc_cnt, seq_no,
  2810. ppdu_desc->user[0].peer_id,
  2811. ppdu_id);
  2812. /* check mpdu_nbuf NULL */
  2813. if (!mpdu_nbuf) {
  2814. ppdu_desc->pending_retries++;
  2815. continue;
  2816. }
  2817. ppdu_desc->mpdus[seq_no - start_seq] =
  2818. mpdu_nbuf;
  2819. SEQ_SEG(ppdu_desc->user[0].failed_bitmap, i) |=
  2820. SEQ_SEG_MSK(ppdu_desc->user[0].failed_bitmap[0],
  2821. i);
  2822. } else {
  2823. /* any error case we need to handle */
  2824. mpdu_nbuf = qdf_nbuf_queue_remove(
  2825. &ppdu_desc->mpdu_q);
  2826. /* check mpdu_nbuf NULL */
  2827. if (!mpdu_nbuf)
  2828. continue;
  2829. ppdu_desc->mpdus[seq_no - start_seq] =
  2830. mpdu_nbuf;
  2831. }
  2832. }
  2833. /* It is possible that enq_bitmap received has more bits than
  2834. * actual mpdus tried if HW was unable to send all MPDUs, and
  2835. * last_enq_seq and ba_size should be adjusted in that case
  2836. */
  2837. if (i < ppdu_desc->user[0].ba_size) {
  2838. ppdu_desc->user[0].last_enq_seq = seq_no;
  2839. ppdu_desc->user[0].ba_size = seq_no - start_seq + 1;
  2840. }
  2841. dp_tx_cap_peer_unref_del(peer);
  2842. if ((ppdu_desc->pending_retries == 0) &&
  2843. qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q)) {
  2844. dp_send_data_to_stack(pdev, ppdu_desc);
  2845. dp_ppdu_queue_free(ppdu_desc);
  2846. tmp_nbuf = nbuf_ppdu_desc_list[desc_cnt];
  2847. nbuf_ppdu_desc_list[desc_cnt] = NULL;
  2848. qdf_nbuf_free(tmp_nbuf);
  2849. }
  2850. }
  2851. for (i = 0; i < ppdu_desc_cnt; i++) {
  2852. uint32_t pending_ppdus;
  2853. struct cdp_tx_completion_ppdu *cur_ppdu_desc;
  2854. struct dp_peer *peer;
  2855. qdf_nbuf_queue_t head_ppdu;
  2856. uint16_t peer_id;
  2857. if (!nbuf_ppdu_desc_list[i])
  2858. continue;
  2859. cur_ppdu_desc = (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(
  2860. nbuf_ppdu_desc_list[i]);
  2861. if (!cur_ppdu_desc)
  2862. continue;
  2863. peer_id = cur_ppdu_desc->user[0].peer_id;
  2864. peer = dp_tx_cap_peer_find_by_id(pdev->soc, peer_id);
  2865. if (!peer) {
  2866. tmp_nbuf = nbuf_ppdu_desc_list[i];
  2867. nbuf_ppdu_desc_list[i] = NULL;
  2868. dp_ppdu_queue_free(cur_ppdu_desc);
  2869. qdf_nbuf_free(tmp_nbuf);
  2870. continue;
  2871. }
  2872. tx_tid = &peer->tx_capture.tx_tid[cur_ppdu_desc->user[0].tid];
  2873. qdf_nbuf_queue_init(&head_ppdu);
  2874. dp_tx_mon_proc_pending_ppdus(pdev, tx_tid,
  2875. nbuf_ppdu_desc_list + i,
  2876. ppdu_desc_cnt - i, &head_ppdu,
  2877. peer_id);
  2878. if (qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q)) {
  2879. while ((tmp_nbuf = qdf_nbuf_queue_first(&head_ppdu))) {
  2880. cur_ppdu_desc =
  2881. (struct cdp_tx_completion_ppdu *)
  2882. qdf_nbuf_data(tmp_nbuf);
  2883. if (cur_ppdu_desc->pending_retries)
  2884. break;
  2885. dp_send_data_to_stack(pdev, cur_ppdu_desc);
  2886. dp_ppdu_queue_free(cur_ppdu_desc);
  2887. qdf_nbuf_queue_remove(&head_ppdu);
  2888. qdf_nbuf_free(tmp_nbuf);
  2889. }
  2890. }
  2891. qdf_nbuf_queue_append(&tx_tid->pending_ppdu_q, &head_ppdu);
  2892. dp_tx_mon_proc_xretries(pdev, peer, tx_tid->tid);
  2893. dp_tx_cap_peer_unref_del(peer);
  2894. pending_ppdus = qdf_nbuf_queue_len(&tx_tid->pending_ppdu_q);
  2895. if (pending_ppdus > MAX_PENDING_PPDUS) {
  2896. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2897. QDF_TRACE_LEVEL_FATAL,
  2898. "pending ppdus (%d, %d) : %d\n",
  2899. cur_ppdu_desc->user[0].peer_id,
  2900. tx_tid->tid, pending_ppdus);
  2901. }
  2902. }
  2903. }
  2904. /**
  2905. * dp_tx_ppdu_stats_process - Deferred PPDU stats handler
  2906. * @context: Opaque work context (PDEV)
  2907. *
  2908. * Return: none
  2909. */
  2910. void dp_tx_ppdu_stats_process(void *context)
  2911. {
  2912. uint32_t curr_sched_cmdid;
  2913. uint32_t last_ppdu_id;
  2914. uint32_t ppdu_cnt;
  2915. uint32_t ppdu_desc_cnt = 0;
  2916. struct dp_pdev *pdev = (struct dp_pdev *)context;
  2917. struct ppdu_info *ppdu_info, *tmp_ppdu_info = NULL;
  2918. uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
  2919. struct ppdu_info *sched_ppdu_info = NULL;
  2920. STAILQ_HEAD(, ppdu_info) sched_ppdu_queue;
  2921. struct ppdu_info *sched_ppdu_list_last_ptr;
  2922. qdf_nbuf_t *nbuf_ppdu_desc_list;
  2923. qdf_nbuf_t tmp_nbuf;
  2924. struct dp_pdev_tx_capture *ptr_tx_cap = &pdev->tx_capture;
  2925. qdf_nbuf_queue_t head_xretries;
  2926. STAILQ_INIT(&sched_ppdu_queue);
  2927. /* Move the PPDU entries to defer list */
  2928. qdf_spin_lock_bh(&ptr_tx_cap->ppdu_stats_lock);
  2929. STAILQ_CONCAT(&ptr_tx_cap->ppdu_stats_defer_queue,
  2930. &ptr_tx_cap->ppdu_stats_queue);
  2931. ptr_tx_cap->ppdu_stats_defer_queue_depth +=
  2932. ptr_tx_cap->ppdu_stats_queue_depth;
  2933. ptr_tx_cap->ppdu_stats_queue_depth = 0;
  2934. qdf_spin_unlock_bh(&ptr_tx_cap->ppdu_stats_lock);
  2935. while (!STAILQ_EMPTY(&ptr_tx_cap->ppdu_stats_defer_queue)) {
  2936. ppdu_info =
  2937. STAILQ_FIRST(&ptr_tx_cap->ppdu_stats_defer_queue);
  2938. curr_sched_cmdid = ppdu_info->sched_cmdid;
  2939. ppdu_cnt = 0;
  2940. STAILQ_FOREACH_SAFE(ppdu_info,
  2941. &ptr_tx_cap->ppdu_stats_defer_queue,
  2942. ppdu_info_queue_elem, tmp_ppdu_info) {
  2943. if (curr_sched_cmdid != ppdu_info->sched_cmdid)
  2944. break;
  2945. sched_ppdu_list_last_ptr = ppdu_info;
  2946. ppdu_cnt++;
  2947. }
  2948. if (ppdu_info && (curr_sched_cmdid == ppdu_info->sched_cmdid) &&
  2949. ptr_tx_cap->ppdu_stats_next_sched < now_ms)
  2950. break;
  2951. last_ppdu_id = sched_ppdu_list_last_ptr->ppdu_id;
  2952. STAILQ_FIRST(&sched_ppdu_queue) =
  2953. STAILQ_FIRST(&ptr_tx_cap->ppdu_stats_defer_queue);
  2954. STAILQ_REMOVE_HEAD_UNTIL(&ptr_tx_cap->ppdu_stats_defer_queue,
  2955. sched_ppdu_list_last_ptr,
  2956. ppdu_info_queue_elem);
  2957. STAILQ_NEXT(sched_ppdu_list_last_ptr,
  2958. ppdu_info_queue_elem) = NULL;
  2959. ptr_tx_cap->ppdu_stats_defer_queue_depth -= ppdu_cnt;
  2960. nbuf_ppdu_desc_list =
  2961. (qdf_nbuf_t *) qdf_mem_malloc(sizeof(qdf_nbuf_t) *
  2962. ppdu_cnt);
  2963. /*
  2964. * if there is no memory allocated we need to free sched ppdu
  2965. * list, no ppdu stats will be updated.
  2966. */
  2967. if (!nbuf_ppdu_desc_list) {
  2968. STAILQ_FOREACH_SAFE(sched_ppdu_info,
  2969. &sched_ppdu_queue,
  2970. ppdu_info_queue_elem,
  2971. tmp_ppdu_info) {
  2972. ppdu_info = sched_ppdu_info;
  2973. tmp_nbuf = ppdu_info->nbuf;
  2974. qdf_mem_free(ppdu_info);
  2975. qdf_nbuf_free(tmp_nbuf);
  2976. }
  2977. continue;
  2978. }
  2979. qdf_spin_lock(&ptr_tx_cap->config_lock);
  2980. ppdu_desc_cnt = 0;
  2981. STAILQ_FOREACH_SAFE(sched_ppdu_info,
  2982. &sched_ppdu_queue,
  2983. ppdu_info_queue_elem, tmp_ppdu_info) {
  2984. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  2985. struct dp_peer *peer = NULL;
  2986. qdf_nbuf_t nbuf;
  2987. uint32_t retries = 0;
  2988. uint32_t ret = 0;
  2989. qdf_nbuf_queue_t head_msdu;
  2990. uint32_t start_tsf = 0;
  2991. uint32_t end_tsf = 0;
  2992. uint16_t tid = 0;
  2993. uint32_t num_msdu = 0;
  2994. uint32_t qlen = 0;
  2995. uint16_t peer_id;
  2996. uint8_t type, subtype;
  2997. qdf_nbuf_queue_init(&head_msdu);
  2998. qdf_nbuf_queue_init(&head_xretries);
  2999. ppdu_info = sched_ppdu_info;
  3000. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3001. qdf_nbuf_data(ppdu_info->nbuf);
  3002. pdev->tx_ppdu_proc++;
  3003. dp_ppdu_desc_user_stats_update(pdev, ppdu_info);
  3004. /*
  3005. * While processing/corelating Tx buffers, we should
  3006. * hold the entire PPDU list for the give sched_cmdid
  3007. * instead of freeing below.
  3008. */
  3009. nbuf = ppdu_info->nbuf;
  3010. qdf_mem_free(ppdu_info);
  3011. qdf_assert_always(nbuf);
  3012. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3013. qdf_nbuf_data(nbuf);
  3014. type = (ppdu_desc->frame_ctrl &
  3015. IEEE80211_FC0_TYPE_MASK);
  3016. subtype = (ppdu_desc->frame_ctrl &
  3017. IEEE80211_FC0_SUBTYPE_MASK);
  3018. if ((type == IEEE80211_FC0_TYPE_DATA) &&
  3019. (subtype == IEEE80211_FC0_SUBTYPE_QOS_NULL) &&
  3020. (ppdu_desc->htt_frame_type ==
  3021. HTT_STATS_FTYPE_TIDQ_DATA_SU)) {
  3022. ppdu_desc->htt_frame_type =
  3023. HTT_STATS_FTYPE_SGEN_QOS_NULL;
  3024. }
  3025. /* send WDI event */
  3026. if (pdev->tx_capture_enabled ==
  3027. CDP_TX_ENH_CAPTURE_DISABLED) {
  3028. if (!pdev->tx_capture.tx_cap_mode_flag)
  3029. dp_enh_tx_capture_disable(pdev);
  3030. /**
  3031. * Deliver PPDU stats only for valid (acked)
  3032. * data frames if sniffer mode is not enabled.
  3033. * If sniffer mode is enabled,
  3034. * PPDU stats for all frames including
  3035. * mgmt/control frames should be delivered
  3036. * to upper layer
  3037. */
  3038. if (pdev->tx_sniffer_enable ||
  3039. pdev->mcopy_mode) {
  3040. dp_wdi_event_handler(
  3041. WDI_EVENT_TX_PPDU_DESC,
  3042. pdev->soc,
  3043. nbuf,
  3044. HTT_INVALID_PEER,
  3045. WDI_NO_VAL,
  3046. pdev->pdev_id);
  3047. } else {
  3048. if (ppdu_desc->num_mpdu != 0 &&
  3049. ppdu_desc->num_users != 0 &&
  3050. (ppdu_desc->frame_ctrl &
  3051. HTT_FRAMECTRL_DATATYPE)) {
  3052. dp_wdi_event_handler(
  3053. WDI_EVENT_TX_PPDU_DESC,
  3054. pdev->soc,
  3055. nbuf,
  3056. HTT_INVALID_PEER,
  3057. WDI_NO_VAL,
  3058. pdev->pdev_id);
  3059. } else {
  3060. qdf_nbuf_free(nbuf);
  3061. }
  3062. }
  3063. continue;
  3064. }
  3065. /* Drop all type of MU frame */
  3066. if ((ppdu_desc->htt_frame_type ==
  3067. HTT_STATS_FTYPE_TIDQ_DATA_MU) ||
  3068. ((ppdu_desc->htt_frame_type >=
  3069. HTT_STATS_FTYPE_SGEN_MU_BAR) &&
  3070. (ppdu_desc->htt_frame_type <=
  3071. HTT_STATS_FTYPE_SGEN_MU_BSR))) {
  3072. qdf_nbuf_free(nbuf);
  3073. continue;
  3074. }
  3075. if (((ppdu_desc->frame_type == CDP_PPDU_FTYPE_DATA) &&
  3076. (ppdu_desc->htt_frame_type !=
  3077. HTT_STATS_FTYPE_SGEN_QOS_NULL)) ||
  3078. (ppdu_desc->num_mpdu &&
  3079. ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR)) {
  3080. peer_id = ppdu_desc->user[0].peer_id;
  3081. peer = dp_tx_cap_peer_find_by_id(pdev->soc,
  3082. peer_id);
  3083. /**
  3084. * peer can be NULL
  3085. */
  3086. if (!peer) {
  3087. qdf_nbuf_free(nbuf);
  3088. continue;
  3089. }
  3090. /**
  3091. * check whether it is bss peer,
  3092. * if bss_peer no need to process further
  3093. * check whether tx_capture feature is enabled
  3094. * for this peer or globally for all peers
  3095. */
  3096. if (peer->bss_peer ||
  3097. !dp_peer_or_pdev_tx_cap_enabled(pdev,
  3098. peer, peer->mac_addr.raw)) {
  3099. dp_tx_cap_peer_unref_del(peer);
  3100. qdf_nbuf_free(nbuf);
  3101. continue;
  3102. }
  3103. /* print the bit map */
  3104. dp_tx_print_bitmap(pdev, ppdu_desc,
  3105. 0, ppdu_desc->ppdu_id);
  3106. if (ppdu_desc->user[0].tid > DP_MAX_TIDS) {
  3107. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3108. QDF_TRACE_LEVEL_ERROR,
  3109. "%s: ppdu[%d] peer_id[%d] TID[%d] > NON_QOS_TID!",
  3110. __func__,
  3111. ppdu_desc->ppdu_id,
  3112. ppdu_desc->user[0].peer_id,
  3113. ppdu_desc->user[0].tid);
  3114. dp_tx_cap_peer_unref_del(peer);
  3115. qdf_nbuf_free(nbuf);
  3116. continue;
  3117. }
  3118. tid = ppdu_desc->user[0].tid;
  3119. dequeue_msdu_again:
  3120. num_msdu = ppdu_desc->user[0].num_msdu;
  3121. start_tsf = ppdu_desc->ppdu_start_timestamp;
  3122. end_tsf = ppdu_desc->ppdu_end_timestamp;
  3123. /*
  3124. * retrieve msdu buffer based on ppdu_id & tid
  3125. * based msdu queue and store it in local queue
  3126. * sometimes, wbm comes later than per ppdu
  3127. * stats. Assumption: all packets are SU,
  3128. * and packets comes in order
  3129. */
  3130. ret = dp_tx_msdu_dequeue(peer,
  3131. ppdu_desc->ppdu_id,
  3132. ppdu_desc->user[0].tid,
  3133. num_msdu,
  3134. &head_msdu,
  3135. &head_xretries,
  3136. start_tsf, end_tsf);
  3137. if (!ret && (++retries < 2)) {
  3138. /* wait for wbm to complete */
  3139. qdf_mdelay(2);
  3140. goto dequeue_msdu_again;
  3141. }
  3142. if (!qdf_nbuf_is_queue_empty(&head_xretries)) {
  3143. struct dp_tx_tid *tx_tid =
  3144. &peer->tx_capture.tx_tid[tid];
  3145. struct cdp_tx_completion_ppdu
  3146. *xretry_ppdu =
  3147. &tx_tid->xretry_ppdu;
  3148. xretry_ppdu->ppdu_id =
  3149. peer->tx_capture.tx_wifi_ppdu_id;
  3150. /* Restitch MPDUs from xretry MSDUs */
  3151. dp_tx_mon_restitch_mpdu(pdev, peer,
  3152. xretry_ppdu,
  3153. &head_xretries,
  3154. &xretry_ppdu->mpdu_q);
  3155. }
  3156. if (!qdf_nbuf_is_queue_empty(&head_msdu)) {
  3157. /*
  3158. * now head_msdu hold - msdu list for
  3159. * that particular ppdu_id, restitch
  3160. * mpdu from msdu and create a mpdu
  3161. * queue
  3162. */
  3163. dp_tx_mon_restitch_mpdu(pdev, peer,
  3164. ppdu_desc,
  3165. &head_msdu,
  3166. &ppdu_desc->mpdu_q);
  3167. /*
  3168. * sanity: free local head msdu queue
  3169. * do we need this ?
  3170. */
  3171. qdf_nbuf_queue_free(&head_msdu);
  3172. qlen =
  3173. qdf_nbuf_queue_len(&ppdu_desc->mpdu_q);
  3174. if (!qlen) {
  3175. qdf_nbuf_free(nbuf);
  3176. dp_tx_cap_peer_unref_del(peer);
  3177. continue;
  3178. }
  3179. } else {
  3180. qdf_nbuf_free(nbuf);
  3181. dp_tx_cap_peer_unref_del(peer);
  3182. continue;
  3183. }
  3184. nbuf_ppdu_desc_list[ppdu_desc_cnt++] = nbuf;
  3185. /* print ppdu_desc info for debugging purpose */
  3186. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3187. QDF_TRACE_LEVEL_INFO,
  3188. "%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]",
  3189. __func__, ppdu_desc->ppdu_id,
  3190. ppdu_desc->user[0].peer_id,
  3191. ppdu_desc->user[0].tid,
  3192. ppdu_desc->num_mpdu,
  3193. ppdu_desc->user[0].mpdu_success,
  3194. ppdu_desc->num_msdu, retries,
  3195. qlen,
  3196. ppdu_desc->ppdu_start_timestamp,
  3197. ppdu_desc->tx_duration,
  3198. ppdu_desc->user[0].start_seq,
  3199. ppdu_cnt,
  3200. ppdu_desc_cnt);
  3201. dp_tx_cap_peer_unref_del(peer);
  3202. } else {
  3203. /*
  3204. * other packet frame also added to
  3205. * descriptor list
  3206. */
  3207. nbuf_ppdu_desc_list[ppdu_desc_cnt++] = nbuf;
  3208. }
  3209. }
  3210. /*
  3211. * At this point we have mpdu queued per ppdu_desc
  3212. * based on packet capture flags send mpdu info to upper stack
  3213. */
  3214. if (ppdu_desc_cnt) {
  3215. dp_check_ppdu_and_deliver(pdev, nbuf_ppdu_desc_list,
  3216. ppdu_desc_cnt);
  3217. }
  3218. qdf_spin_unlock(&ptr_tx_cap->config_lock);
  3219. qdf_mem_free(nbuf_ppdu_desc_list);
  3220. qdf_spin_lock(&pdev->tx_capture.config_lock);
  3221. if (!pdev->tx_capture.tx_cap_mode_flag)
  3222. dp_enh_tx_capture_disable(pdev);
  3223. qdf_spin_unlock(&pdev->tx_capture.config_lock);
  3224. }
  3225. }
  3226. /**
  3227. * dp_ppdu_desc_deliver(): Function to deliver Tx PPDU status descriptor
  3228. * to upper layer
  3229. * @pdev: DP pdev handle
  3230. * @ppdu_info: per PPDU TLV descriptor
  3231. *
  3232. * return: void
  3233. */
  3234. void dp_ppdu_desc_deliver(struct dp_pdev *pdev,
  3235. struct ppdu_info *ppdu_info)
  3236. {
  3237. uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
  3238. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  3239. TAILQ_REMOVE(&pdev->ppdu_info_list, ppdu_info, ppdu_info_list_elem);
  3240. pdev->list_depth--;
  3241. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3242. qdf_nbuf_data(ppdu_info->nbuf);
  3243. qdf_spin_lock_bh(&pdev->tx_capture.ppdu_stats_lock);
  3244. if (qdf_unlikely(!pdev->tx_capture_enabled &&
  3245. (pdev->tx_capture.ppdu_stats_queue_depth +
  3246. pdev->tx_capture.ppdu_stats_defer_queue_depth) >
  3247. DP_TX_PPDU_PROC_MAX_DEPTH)) {
  3248. qdf_nbuf_free(ppdu_info->nbuf);
  3249. qdf_mem_free(ppdu_info);
  3250. pdev->tx_capture.ppdu_dropped++;
  3251. } else {
  3252. STAILQ_INSERT_TAIL(&pdev->tx_capture.ppdu_stats_queue,
  3253. ppdu_info, ppdu_info_queue_elem);
  3254. pdev->tx_capture.ppdu_stats_queue_depth++;
  3255. }
  3256. qdf_spin_unlock_bh(&pdev->tx_capture.ppdu_stats_lock);
  3257. if ((pdev->tx_capture.ppdu_stats_queue_depth >
  3258. DP_TX_PPDU_PROC_THRESHOLD) ||
  3259. (pdev->tx_capture.ppdu_stats_next_sched <= now_ms)) {
  3260. qdf_queue_work(0, pdev->tx_capture.ppdu_stats_workqueue,
  3261. &pdev->tx_capture.ppdu_stats_work);
  3262. pdev->tx_capture.ppdu_stats_next_sched =
  3263. now_ms + DP_TX_PPDU_PROC_TIMEOUT;
  3264. }
  3265. }
  3266. static void set_mpdu_info(
  3267. struct cdp_tx_indication_info *tx_capture_info,
  3268. struct mon_rx_status *rx_status,
  3269. struct mon_rx_user_status *rx_user_status)
  3270. {
  3271. struct cdp_tx_indication_mpdu_info *mpdu_info;
  3272. qdf_mem_set(tx_capture_info,
  3273. sizeof(struct cdp_tx_indication_info), 0);
  3274. mpdu_info = &tx_capture_info->mpdu_info;
  3275. mpdu_info->ppdu_start_timestamp = rx_status->tsft + 16;
  3276. mpdu_info->channel_num = rx_status->chan_num;
  3277. mpdu_info->channel = rx_status->chan_freq;
  3278. mpdu_info->bw = 0;
  3279. if (rx_status->preamble_type == HAL_RX_PKT_TYPE_11B) {
  3280. mpdu_info->preamble = DOT11_B;
  3281. mpdu_info->mcs = CDP_LEGACY_MCS3;
  3282. } else if (rx_status->preamble_type == HAL_RX_PKT_TYPE_11A) {
  3283. mpdu_info->preamble = DOT11_A;
  3284. mpdu_info->mcs = CDP_LEGACY_MCS3;
  3285. } else {
  3286. mpdu_info->preamble = DOT11_A;
  3287. mpdu_info->mcs = CDP_LEGACY_MCS1;
  3288. }
  3289. }
  3290. static void dp_gen_ack_frame(struct hal_rx_ppdu_info *ppdu_info,
  3291. struct dp_peer *peer,
  3292. qdf_nbuf_t mpdu_nbuf)
  3293. {
  3294. struct ieee80211_frame_min_one *wh_addr1;
  3295. wh_addr1 = (struct ieee80211_frame_min_one *)
  3296. qdf_nbuf_data(mpdu_nbuf);
  3297. wh_addr1->i_fc[0] = 0;
  3298. wh_addr1->i_fc[1] = 0;
  3299. wh_addr1->i_fc[0] = IEEE80211_FC0_VERSION_0 |
  3300. IEEE80211_FC0_TYPE_CTL |
  3301. IEEE80211_FC0_SUBTYPE_ACK;
  3302. if (peer) {
  3303. qdf_mem_copy(wh_addr1->i_addr1,
  3304. &peer->mac_addr.raw[0],
  3305. QDF_MAC_ADDR_SIZE);
  3306. } else {
  3307. qdf_mem_copy(wh_addr1->i_addr1,
  3308. &ppdu_info->nac_info.mac_addr2[0],
  3309. QDF_MAC_ADDR_SIZE);
  3310. }
  3311. *(u_int16_t *)(&wh_addr1->i_dur) = qdf_cpu_to_le16(0x0000);
  3312. qdf_nbuf_set_pktlen(mpdu_nbuf, sizeof(*wh_addr1));
  3313. }
  3314. static void dp_gen_block_ack_frame(
  3315. struct hal_rx_ppdu_info *ppdu_info,
  3316. struct mon_rx_user_status *rx_user_status,
  3317. struct mon_rx_user_info *rx_user_info,
  3318. struct dp_peer *peer,
  3319. qdf_nbuf_t mpdu_nbuf)
  3320. {
  3321. struct dp_vdev *vdev = NULL;
  3322. uint32_t tid;
  3323. struct dp_tx_tid *tx_tid;
  3324. struct ieee80211_ctlframe_addr2 *wh_addr2;
  3325. uint8_t *frm;
  3326. tid = rx_user_status->tid;
  3327. tx_tid = &peer->tx_capture.tx_tid[tid];
  3328. if (ppdu_info->sw_frame_group_id != HAL_MPDU_SW_FRAME_GROUP_CTRL_BAR) {
  3329. tx_tid->first_data_seq_ctrl =
  3330. rx_user_status->first_data_seq_ctrl;
  3331. tx_tid->mpdu_cnt = rx_user_status->mpdu_cnt_fcs_ok +
  3332. rx_user_status->mpdu_cnt_fcs_err;
  3333. if (tx_tid->mpdu_cnt > DP_MAX_MPDU_64)
  3334. qdf_mem_copy(tx_tid->mpdu_fcs_ok_bitmap,
  3335. rx_user_status->mpdu_fcs_ok_bitmap,
  3336. HAL_RX_NUM_WORDS_PER_PPDU_BITMAP * sizeof(
  3337. rx_user_status->mpdu_fcs_ok_bitmap[0]));
  3338. else
  3339. qdf_mem_copy(tx_tid->mpdu_fcs_ok_bitmap,
  3340. rx_user_status->mpdu_fcs_ok_bitmap,
  3341. DP_NUM_WORDS_PER_PPDU_BITMAP_64 * sizeof(
  3342. rx_user_status->mpdu_fcs_ok_bitmap[0]));
  3343. }
  3344. wh_addr2 = (struct ieee80211_ctlframe_addr2 *)
  3345. qdf_nbuf_data(mpdu_nbuf);
  3346. qdf_mem_zero(wh_addr2, DP_BA_ACK_FRAME_SIZE);
  3347. wh_addr2->i_fc[0] = 0;
  3348. wh_addr2->i_fc[1] = 0;
  3349. wh_addr2->i_fc[0] = IEEE80211_FC0_VERSION_0 |
  3350. IEEE80211_FC0_TYPE_CTL |
  3351. IEEE80211_FC0_BLOCK_ACK;
  3352. *(u_int16_t *)(&wh_addr2->i_aidordur) = qdf_cpu_to_le16(0x0000);
  3353. vdev = peer->vdev;
  3354. if (vdev)
  3355. qdf_mem_copy(wh_addr2->i_addr2, vdev->mac_addr.raw,
  3356. QDF_MAC_ADDR_SIZE);
  3357. qdf_mem_copy(wh_addr2->i_addr1, &peer->mac_addr.raw[0],
  3358. QDF_MAC_ADDR_SIZE);
  3359. frm = (uint8_t *)&wh_addr2[1];
  3360. *((uint16_t *)frm) =
  3361. qdf_cpu_to_le16((rx_user_status->tid <<
  3362. DP_IEEE80211_BAR_CTL_TID_S) |
  3363. DP_IEEE80211_BAR_CTL_COMBA);
  3364. frm += 2;
  3365. *((uint16_t *)frm) =
  3366. tx_tid->first_data_seq_ctrl;
  3367. frm += 2;
  3368. if (tx_tid->mpdu_cnt > DP_MAX_MPDU_64) {
  3369. qdf_mem_copy(frm,
  3370. tx_tid->mpdu_fcs_ok_bitmap,
  3371. HAL_RX_NUM_WORDS_PER_PPDU_BITMAP *
  3372. sizeof(rx_user_status->mpdu_fcs_ok_bitmap[0]));
  3373. frm += DP_NUM_BYTES_PER_PPDU_BITMAP;
  3374. } else {
  3375. qdf_mem_copy(frm,
  3376. tx_tid->mpdu_fcs_ok_bitmap,
  3377. DP_NUM_WORDS_PER_PPDU_BITMAP_64 *
  3378. sizeof(rx_user_status->mpdu_fcs_ok_bitmap[0]));
  3379. frm += DP_NUM_BYTES_PER_PPDU_BITMAP_64;
  3380. }
  3381. qdf_nbuf_set_pktlen(mpdu_nbuf,
  3382. (frm - (uint8_t *)qdf_nbuf_data(mpdu_nbuf)));
  3383. }
  3384. static void dp_gen_cts_frame(struct hal_rx_ppdu_info *ppdu_info,
  3385. struct dp_peer *peer,
  3386. qdf_nbuf_t mpdu_nbuf)
  3387. {
  3388. struct ieee80211_frame_min_one *wh_addr1;
  3389. uint16_t duration;
  3390. wh_addr1 = (struct ieee80211_frame_min_one *)
  3391. qdf_nbuf_data(mpdu_nbuf);
  3392. wh_addr1->i_fc[0] = 0;
  3393. wh_addr1->i_fc[1] = 0;
  3394. wh_addr1->i_fc[0] = IEEE80211_FC0_VERSION_0 |
  3395. IEEE80211_FC0_TYPE_CTL |
  3396. IEEE80211_FC0_SUBTYPE_CTS;
  3397. qdf_mem_copy(wh_addr1->i_addr1, &peer->mac_addr.raw[0],
  3398. QDF_MAC_ADDR_SIZE);
  3399. duration = (ppdu_info->rx_status.duration > SIFS_INTERVAL) ?
  3400. ppdu_info->rx_status.duration - SIFS_INTERVAL : 0;
  3401. wh_addr1->i_dur[0] = duration & 0xff;
  3402. wh_addr1->i_dur[1] = (duration >> 8) & 0xff;
  3403. qdf_nbuf_set_pktlen(mpdu_nbuf, sizeof(*wh_addr1));
  3404. }
  3405. /**
  3406. * dp_send_cts_frame_to_stack(): Function to deliver HW generated CTS frame
  3407. * in reponse to RTS
  3408. * @soc: core txrx main context
  3409. * @pdev: DP pdev object
  3410. * @ppdu_info: HAL RX PPDU info retrieved from status ring TLV
  3411. *
  3412. * return: status
  3413. */
  3414. QDF_STATUS dp_send_cts_frame_to_stack(struct dp_soc *soc,
  3415. struct dp_pdev *pdev,
  3416. struct hal_rx_ppdu_info *ppdu_info)
  3417. {
  3418. struct cdp_tx_indication_info tx_capture_info;
  3419. struct mon_rx_user_status *rx_user_status =
  3420. &ppdu_info->rx_user_status[0];
  3421. struct dp_ast_entry *ast_entry;
  3422. uint32_t peer_id;
  3423. struct dp_peer *peer;
  3424. if (rx_user_status->ast_index >=
  3425. wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
  3426. return QDF_STATUS_E_FAILURE;
  3427. }
  3428. qdf_spin_lock_bh(&soc->ast_lock);
  3429. ast_entry = soc->ast_table[rx_user_status->ast_index];
  3430. if (!ast_entry) {
  3431. qdf_spin_unlock_bh(&soc->ast_lock);
  3432. return QDF_STATUS_E_FAILURE;
  3433. }
  3434. peer = ast_entry->peer;
  3435. if (!peer || peer->peer_ids[0] == HTT_INVALID_PEER) {
  3436. qdf_spin_unlock_bh(&soc->ast_lock);
  3437. return QDF_STATUS_E_FAILURE;
  3438. }
  3439. peer_id = peer->peer_ids[0];
  3440. qdf_spin_unlock_bh(&soc->ast_lock);
  3441. peer = dp_peer_find_by_id(soc, peer_id);
  3442. if (!peer)
  3443. return QDF_STATUS_E_FAILURE;
  3444. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, NULL, peer->mac_addr.raw)) {
  3445. dp_peer_unref_del_find_by_id(peer);
  3446. return QDF_STATUS_E_FAILURE;
  3447. }
  3448. set_mpdu_info(&tx_capture_info,
  3449. &ppdu_info->rx_status, rx_user_status);
  3450. tx_capture_info.mpdu_info.mcs = rx_user_status->mcs;
  3451. /* ppdu_desc is not required for legacy frames */
  3452. tx_capture_info.ppdu_desc = NULL;
  3453. tx_capture_info.mpdu_nbuf =
  3454. qdf_nbuf_alloc(pdev->soc->osdev,
  3455. MAX_MONITOR_HEADER +
  3456. DP_CTS_FRAME_SIZE,
  3457. MAX_MONITOR_HEADER,
  3458. 4, FALSE);
  3459. if (!tx_capture_info.mpdu_nbuf) {
  3460. dp_peer_unref_del_find_by_id(peer);
  3461. return QDF_STATUS_E_NOMEM;
  3462. }
  3463. dp_gen_cts_frame(ppdu_info, peer,
  3464. tx_capture_info.mpdu_nbuf);
  3465. dp_peer_unref_del_find_by_id(peer);
  3466. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  3467. &tx_capture_info, HTT_INVALID_PEER,
  3468. WDI_NO_VAL, pdev->pdev_id);
  3469. if (tx_capture_info.mpdu_nbuf)
  3470. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  3471. return QDF_STATUS_SUCCESS;
  3472. }
  3473. /**
  3474. * dp_send_usr_ack_frm_to_stack(): Function to generate BA or ACK frame and
  3475. * send to upper layer
  3476. * @soc: core txrx main context
  3477. * @pdev: DP pdev object
  3478. * @ppdu_info: HAL RX PPDU info retrieved from status ring TLV
  3479. * @rx_status: variable for rx status
  3480. * @rx_user_status: variable for rx user status
  3481. * @rx_user_info: variable for rx user info
  3482. *
  3483. * return: no
  3484. */
  3485. void dp_send_usr_ack_frm_to_stack(struct dp_soc *soc,
  3486. struct dp_pdev *pdev,
  3487. struct hal_rx_ppdu_info *ppdu_info,
  3488. struct mon_rx_status *rx_status,
  3489. struct mon_rx_user_status *rx_user_status,
  3490. struct mon_rx_user_info *rx_user_info)
  3491. {
  3492. struct cdp_tx_indication_info tx_capture_info;
  3493. struct dp_peer *peer;
  3494. struct dp_ast_entry *ast_entry;
  3495. uint32_t peer_id;
  3496. uint32_t ast_index;
  3497. uint8_t *ptr_mac_addr;
  3498. if (rx_user_info->qos_control_info_valid &&
  3499. ((rx_user_info->qos_control &
  3500. IEEE80211_QOS_ACKPOLICY) >> IEEE80211_QOS_ACKPOLICY_S)
  3501. == IEEE80211_BAR_CTL_NOACK)
  3502. return;
  3503. ast_index = rx_user_status->ast_index;
  3504. if (ast_index >=
  3505. wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
  3506. if (ppdu_info->sw_frame_group_id ==
  3507. HAL_MPDU_SW_FRAME_GROUP_CTRL_BAR)
  3508. return;
  3509. ptr_mac_addr = &ppdu_info->nac_info.mac_addr2[0];
  3510. if (!dp_peer_or_pdev_tx_cap_enabled(pdev,
  3511. NULL, ptr_mac_addr))
  3512. return;
  3513. set_mpdu_info(&tx_capture_info,
  3514. rx_status, rx_user_status);
  3515. tx_capture_info.mpdu_nbuf =
  3516. qdf_nbuf_alloc(pdev->soc->osdev,
  3517. MAX_MONITOR_HEADER +
  3518. DP_BA_ACK_FRAME_SIZE,
  3519. MAX_MONITOR_HEADER,
  3520. 4, FALSE);
  3521. if (!tx_capture_info.mpdu_nbuf)
  3522. return;
  3523. dp_gen_ack_frame(ppdu_info, NULL,
  3524. tx_capture_info.mpdu_nbuf);
  3525. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  3526. &tx_capture_info, HTT_INVALID_PEER,
  3527. WDI_NO_VAL, pdev->pdev_id);
  3528. return;
  3529. }
  3530. qdf_spin_lock_bh(&soc->ast_lock);
  3531. ast_entry = soc->ast_table[ast_index];
  3532. if (!ast_entry) {
  3533. qdf_spin_unlock_bh(&soc->ast_lock);
  3534. return;
  3535. }
  3536. peer = ast_entry->peer;
  3537. if (!peer || peer->peer_ids[0] == HTT_INVALID_PEER) {
  3538. qdf_spin_unlock_bh(&soc->ast_lock);
  3539. return;
  3540. }
  3541. peer_id = peer->peer_ids[0];
  3542. qdf_spin_unlock_bh(&soc->ast_lock);
  3543. peer = dp_peer_find_by_id(soc, peer_id);
  3544. if (!peer)
  3545. return;
  3546. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, peer,
  3547. peer->mac_addr.raw)) {
  3548. dp_peer_unref_del_find_by_id(peer);
  3549. return;
  3550. }
  3551. set_mpdu_info(&tx_capture_info,
  3552. rx_status, rx_user_status);
  3553. tx_capture_info.mpdu_nbuf =
  3554. qdf_nbuf_alloc(pdev->soc->osdev,
  3555. MAX_MONITOR_HEADER +
  3556. DP_BA_ACK_FRAME_SIZE,
  3557. MAX_MONITOR_HEADER,
  3558. 4, FALSE);
  3559. if (!tx_capture_info.mpdu_nbuf) {
  3560. dp_peer_unref_del_find_by_id(peer);
  3561. return;
  3562. }
  3563. if (peer->rx_tid[rx_user_status->tid].ba_status == DP_RX_BA_ACTIVE ||
  3564. ppdu_info->sw_frame_group_id == HAL_MPDU_SW_FRAME_GROUP_CTRL_BAR) {
  3565. dp_gen_block_ack_frame(ppdu_info,
  3566. rx_user_status,
  3567. rx_user_info,
  3568. peer,
  3569. tx_capture_info.mpdu_nbuf);
  3570. tx_capture_info.mpdu_info.tid = rx_user_status->tid;
  3571. } else {
  3572. dp_gen_ack_frame(ppdu_info, peer,
  3573. tx_capture_info.mpdu_nbuf);
  3574. }
  3575. dp_peer_unref_del_find_by_id(peer);
  3576. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  3577. &tx_capture_info, HTT_INVALID_PEER,
  3578. WDI_NO_VAL, pdev->pdev_id);
  3579. }
  3580. /**
  3581. * dp_send_ack_frame_to_stack(): Function to generate BA or ACK frame and
  3582. * send to upper layer on received unicast frame
  3583. * @soc: core txrx main context
  3584. * @pdev: DP pdev object
  3585. * @ppdu_info: HAL RX PPDU info retrieved from status ring TLV
  3586. *
  3587. * return: status
  3588. */
  3589. QDF_STATUS dp_send_ack_frame_to_stack(struct dp_soc *soc,
  3590. struct dp_pdev *pdev,
  3591. struct hal_rx_ppdu_info *ppdu_info)
  3592. {
  3593. struct mon_rx_status *rx_status;
  3594. struct mon_rx_user_status *rx_user_status;
  3595. struct mon_rx_user_info *rx_user_info;
  3596. uint32_t i;
  3597. rx_status = &ppdu_info->rx_status;
  3598. if (!rx_status->rxpcu_filter_pass)
  3599. return QDF_STATUS_SUCCESS;
  3600. if (ppdu_info->sw_frame_group_id ==
  3601. HAL_MPDU_SW_FRAME_GROUP_MGMT_BEACON ||
  3602. ppdu_info->sw_frame_group_id ==
  3603. HAL_MPDU_SW_FRAME_GROUP_CTRL_NDPA)
  3604. return QDF_STATUS_SUCCESS;
  3605. if (ppdu_info->sw_frame_group_id == HAL_MPDU_SW_FRAME_GROUP_MGMT_PROBE_REQ &&
  3606. (ppdu_info->rx_info.mac_addr1[0] & 1)) {
  3607. return QDF_STATUS_SUCCESS;
  3608. }
  3609. if (ppdu_info->sw_frame_group_id ==
  3610. HAL_MPDU_SW_FRAME_GROUP_CTRL_RTS)
  3611. return dp_send_cts_frame_to_stack(soc, pdev, ppdu_info);
  3612. if (ppdu_info->sw_frame_group_id == HAL_MPDU_SW_FRAME_GROUP_CTRL_BAR)
  3613. return QDF_STATUS_SUCCESS;
  3614. for (i = 0; i < ppdu_info->com_info.num_users; i++) {
  3615. if (i > OFDMA_NUM_USERS)
  3616. return QDF_STATUS_E_FAULT;
  3617. rx_user_status = &ppdu_info->rx_user_status[i];
  3618. rx_user_info = &ppdu_info->rx_user_info[i];
  3619. dp_send_usr_ack_frm_to_stack(soc, pdev, ppdu_info, rx_status,
  3620. rx_user_status, rx_user_info);
  3621. }
  3622. return QDF_STATUS_SUCCESS;
  3623. }
  3624. /**
  3625. * dp_bar_send_ack_frm_to_stack(): send BA or ACK frame
  3626. * to upper layers on received BAR packet for tx capture feature
  3627. *
  3628. * @soc: soc handle
  3629. * @pdev: pdev handle
  3630. * @nbuf: received packet
  3631. *
  3632. * Return: QDF_STATUS_SUCCESS on success
  3633. * others on error
  3634. */
  3635. QDF_STATUS
  3636. dp_bar_send_ack_frm_to_stack(struct dp_soc *soc,
  3637. struct dp_pdev *pdev,
  3638. qdf_nbuf_t nbuf)
  3639. {
  3640. struct ieee80211_ctlframe_addr2 *wh;
  3641. uint8_t *frm;
  3642. struct hal_rx_ppdu_info *ppdu_info;
  3643. struct mon_rx_status *rx_status;
  3644. struct mon_rx_user_status *rx_user_status;
  3645. struct mon_rx_user_info *rx_user_info;
  3646. uint16_t bar_ctl;
  3647. uint32_t user_id;
  3648. uint8_t tid;
  3649. if (!nbuf)
  3650. return QDF_STATUS_E_INVAL;
  3651. wh = (struct ieee80211_ctlframe_addr2 *)qdf_nbuf_data(nbuf);
  3652. if (wh->i_fc[0] != (IEEE80211_FC0_VERSION_0 |
  3653. IEEE80211_FC0_TYPE_CTL | IEEE80211_FC0_SUBTYPE_BAR)) {
  3654. return QDF_STATUS_SUCCESS;
  3655. }
  3656. frm = (uint8_t *)&wh[1];
  3657. bar_ctl = qdf_le16_to_cpu(*(uint16_t *)frm);
  3658. if (bar_ctl & DP_IEEE80211_BAR_CTL_POLICY_M)
  3659. return QDF_STATUS_SUCCESS;
  3660. tid = (bar_ctl >> DP_IEEE80211_BAR_CTL_TID_S) &
  3661. DP_IEEE80211_BAR_CTL_TID_M;
  3662. ppdu_info = &pdev->ppdu_info;
  3663. user_id = ppdu_info->rx_info.user_id;
  3664. rx_status = &ppdu_info->rx_status;
  3665. rx_user_status = &ppdu_info->rx_user_status[user_id];
  3666. rx_user_info = &ppdu_info->rx_user_info[user_id];
  3667. rx_user_status->tid = tid;
  3668. dp_send_usr_ack_frm_to_stack(soc, pdev, ppdu_info, rx_status,
  3669. rx_user_status, rx_user_info);
  3670. return QDF_STATUS_SUCCESS;
  3671. }
  3672. /**
  3673. * dp_gen_noack_frame: generate noack Action frame by using parameters
  3674. * from received NDPA frame
  3675. * @ppdu_info: pointer to ppdu_info
  3676. * @peer: pointer to peer structure
  3677. * @mpdu_nbuf: buffer for the generated noack frame
  3678. * @mon_mpdu: mpdu from monitor destination path
  3679. *
  3680. * Return: QDF_STATUS
  3681. */
  3682. static void dp_gen_noack_frame(struct hal_rx_ppdu_info *ppdu_info,
  3683. struct dp_peer *peer, qdf_nbuf_t mpdu_nbuf,
  3684. qdf_nbuf_t mon_mpdu)
  3685. {
  3686. struct ieee80211_frame *wh;
  3687. uint16_t duration;
  3688. struct dp_vdev *vdev = NULL;
  3689. char *ndpa_buf = qdf_nbuf_data(mon_mpdu);
  3690. uint8_t token = 0;
  3691. uint8_t *frm;
  3692. wh = (struct ieee80211_frame *)qdf_nbuf_data(mpdu_nbuf);
  3693. qdf_mem_zero(((char *)wh), DP_ACKNOACK_FRAME_SIZE);
  3694. wh->i_fc[0] = IEEE80211_FC0_VERSION_0 |
  3695. IEEE80211_FC0_TYPE_MGT |
  3696. IEEE80211_FCO_SUBTYPE_ACTION_NO_ACK;
  3697. qdf_mem_copy(wh->i_addr1, &peer->mac_addr.raw[0], QDF_MAC_ADDR_SIZE);
  3698. vdev = peer->vdev;
  3699. if (vdev) {
  3700. qdf_mem_copy(wh->i_addr2,
  3701. vdev->mac_addr.raw,
  3702. QDF_MAC_ADDR_SIZE);
  3703. qdf_mem_copy(wh->i_addr3,
  3704. vdev->mac_addr.raw,
  3705. QDF_MAC_ADDR_SIZE);
  3706. }
  3707. duration = (ppdu_info->rx_status.duration > SIFS_INTERVAL) ?
  3708. ppdu_info->rx_status.duration - SIFS_INTERVAL : 0;
  3709. wh->i_dur[0] = duration & 0xff;
  3710. wh->i_dur[1] = (duration >> 8) & 0xff;
  3711. frm = (uint8_t *)&wh[1];
  3712. /*
  3713. * Update category field
  3714. */
  3715. *frm = DP_IEEE80211_CATEGORY_VHT;
  3716. /*
  3717. * Update sounding token obtained from NDPA,
  3718. * shift to get upper six bits
  3719. */
  3720. frm += DP_NOACK_SOUNDING_TOKEN_POS;
  3721. token = ndpa_buf[DP_NDPA_TOKEN_POS] >> DP_NOACK_STOKEN_POS_SHIFT;
  3722. *frm = (token) << DP_NOACK_STOKEN_POS_SHIFT;
  3723. qdf_nbuf_set_pktlen(mpdu_nbuf, DP_ACKNOACK_FRAME_SIZE);
  3724. }
  3725. /**
  3726. * dp_send_noack_frame_to_stack: Sends noack Action frame to upper stack
  3727. * in response to received NDPA frame.
  3728. * @soc: SoC handle
  3729. * @pdev: PDEV pointer
  3730. * @mon_mpdu: mpdu from monitor destination path
  3731. *
  3732. * Return: QDF_STATUS
  3733. */
  3734. QDF_STATUS dp_send_noack_frame_to_stack(struct dp_soc *soc,
  3735. struct dp_pdev *pdev,
  3736. qdf_nbuf_t mon_mpdu)
  3737. {
  3738. struct hal_rx_ppdu_info *ppdu_info = &pdev->ppdu_info;
  3739. struct mon_rx_user_status *rx_user_status =
  3740. &ppdu_info->rx_user_status[0];
  3741. struct dp_ast_entry *ast_entry;
  3742. uint32_t peer_id;
  3743. struct dp_peer *peer;
  3744. struct cdp_tx_indication_info tx_capture_info;
  3745. if (rx_user_status->ast_index >=
  3746. wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
  3747. return QDF_STATUS_E_FAILURE;
  3748. }
  3749. qdf_spin_lock_bh(&soc->ast_lock);
  3750. ast_entry = soc->ast_table[rx_user_status->ast_index];
  3751. if (!ast_entry) {
  3752. qdf_spin_unlock_bh(&soc->ast_lock);
  3753. return QDF_STATUS_E_FAILURE;
  3754. }
  3755. peer = ast_entry->peer;
  3756. if (!peer || peer->peer_ids[0] == HTT_INVALID_PEER) {
  3757. qdf_spin_unlock_bh(&soc->ast_lock);
  3758. return QDF_STATUS_E_FAILURE;
  3759. }
  3760. peer_id = peer->peer_ids[0];
  3761. qdf_spin_unlock_bh(&soc->ast_lock);
  3762. peer = dp_peer_find_by_id(soc, peer_id);
  3763. if (!peer) {
  3764. return QDF_STATUS_E_FAILURE;
  3765. }
  3766. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, peer, peer->mac_addr.raw)) {
  3767. dp_peer_unref_del_find_by_id(peer);
  3768. return QDF_STATUS_E_FAILURE;
  3769. }
  3770. set_mpdu_info(&tx_capture_info,
  3771. &ppdu_info->rx_status, rx_user_status);
  3772. tx_capture_info.mpdu_info.mcs = rx_user_status->mcs;
  3773. /*
  3774. *ppdu_desc is not required for legacy frames
  3775. */
  3776. tx_capture_info.ppdu_desc = NULL;
  3777. tx_capture_info.mpdu_nbuf =
  3778. qdf_nbuf_alloc(pdev->soc->osdev,
  3779. MAX_MONITOR_HEADER +
  3780. DP_ACKNOACK_FRAME_SIZE,
  3781. MAX_MONITOR_HEADER,
  3782. 4, FALSE);
  3783. if (!tx_capture_info.mpdu_nbuf) {
  3784. dp_peer_unref_del_find_by_id(peer);
  3785. return QDF_STATUS_E_NOMEM;
  3786. }
  3787. dp_gen_noack_frame(ppdu_info, peer,
  3788. tx_capture_info.mpdu_nbuf, mon_mpdu);
  3789. dp_peer_unref_del_find_by_id(peer);
  3790. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  3791. &tx_capture_info, HTT_INVALID_PEER,
  3792. WDI_NO_VAL, pdev->pdev_id);
  3793. if (tx_capture_info.mpdu_nbuf)
  3794. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  3795. return QDF_STATUS_SUCCESS;
  3796. }
  3797. /**
  3798. * dp_handle_tx_capture_from_dest: Handle any TX capture frames from
  3799. * monitor destination path.
  3800. * @soc: SoC handle
  3801. * @pdev: PDEV pointer
  3802. * @mon_mpdu: mpdu from monitor destination path
  3803. *
  3804. * Return: QDF_STATUS
  3805. */
  3806. QDF_STATUS dp_handle_tx_capture_from_dest(struct dp_soc *soc,
  3807. struct dp_pdev *pdev,
  3808. qdf_nbuf_t mon_mpdu)
  3809. {
  3810. struct hal_rx_ppdu_info *ppdu_info = &pdev->ppdu_info;
  3811. /*
  3812. * The below switch case can be extended to
  3813. * add more frame types as needed
  3814. */
  3815. switch (ppdu_info->sw_frame_group_id) {
  3816. case HAL_MPDU_SW_FRAME_GROUP_CTRL_NDPA:
  3817. return dp_send_noack_frame_to_stack(soc, pdev, mon_mpdu);
  3818. case HAL_MPDU_SW_FRAME_GROUP_CTRL_BAR:
  3819. return dp_bar_send_ack_frm_to_stack(soc, pdev, mon_mpdu);
  3820. default:
  3821. break;
  3822. }
  3823. return QDF_STATUS_SUCCESS;
  3824. }
  3825. /**
  3826. * dp_peer_set_tx_capture_enabled: Set tx_cap_enabled bit in peer
  3827. * @pdev: DP PDEV handle
  3828. * @peer: Peer handle
  3829. * @value: Enable/disable setting for tx_cap_enabled
  3830. * @peer_mac: peer mac address
  3831. *
  3832. * Return: QDF_STATUS
  3833. */
  3834. QDF_STATUS
  3835. dp_peer_set_tx_capture_enabled(struct dp_pdev *pdev,
  3836. struct dp_peer *peer, uint8_t value,
  3837. uint8_t *peer_mac)
  3838. {
  3839. uint32_t peer_id = HTT_INVALID_PEER;
  3840. QDF_STATUS status = QDF_STATUS_E_FAILURE;
  3841. if (value) {
  3842. if (dp_peer_tx_cap_add_filter(pdev, peer_id, peer_mac)) {
  3843. if (peer)
  3844. peer->tx_cap_enabled = value;
  3845. status = QDF_STATUS_SUCCESS;
  3846. }
  3847. } else {
  3848. if (dp_peer_tx_cap_del_filter(pdev, peer_id, peer_mac)) {
  3849. if (peer)
  3850. peer->tx_cap_enabled = value;
  3851. status = QDF_STATUS_SUCCESS;
  3852. }
  3853. }
  3854. return status;
  3855. }
  3856. /*
  3857. * dp_peer_tx_capture_filter_check: check filter is enable for the filter
  3858. * and update tx_cap_enabled flag
  3859. * @pdev: DP PDEV handle
  3860. * @peer: DP PEER handle
  3861. *
  3862. * return: void
  3863. */
  3864. void dp_peer_tx_capture_filter_check(struct dp_pdev *pdev,
  3865. struct dp_peer *peer)
  3866. {
  3867. if (!peer)
  3868. return;
  3869. if (dp_peer_tx_cap_search(pdev, peer->peer_ids[0],
  3870. peer->mac_addr.raw)) {
  3871. peer->tx_cap_enabled = 1;
  3872. }
  3873. return;
  3874. }
  3875. #endif