dp_tx_capture.c 121 KB

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