dp_mon.c 158 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732
  1. /*
  2. * Copyright (c) 2016-2021, The Linux Foundation. All rights reserved.
  3. * Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved.
  4. *
  5. * Permission to use, copy, modify, and/or distribute this software for any
  6. * purpose with or without fee is hereby granted, provided that the above
  7. * copyright notice and this permission notice appear in all copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  10. * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  11. * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  12. * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  13. * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  14. * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  15. * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  16. */
  17. #include <dp_types.h>
  18. #include "dp_rx.h"
  19. #include "dp_peer.h"
  20. #include <dp_htt.h>
  21. #include <dp_mon_filter.h>
  22. #include <dp_htt.h>
  23. #include <dp_mon.h>
  24. #include <dp_rx_mon.h>
  25. #include <dp_internal.h>
  26. #include "htt_ppdu_stats.h"
  27. #include "dp_cal_client_api.h"
  28. #if defined(DP_CON_MON)
  29. #ifndef REMOVE_PKT_LOG
  30. #include <pktlog_ac_api.h>
  31. #include <pktlog_ac.h>
  32. #endif
  33. #endif
  34. #ifdef FEATURE_PERPKT_INFO
  35. #include "dp_ratetable.h"
  36. #endif
  37. #define DP_INTR_POLL_TIMER_MS 5
  38. #define INVALID_FREE_BUFF 0xffffffff
  39. #ifdef WLAN_RX_PKT_CAPTURE_ENH
  40. #include "dp_rx_mon_feature.h"
  41. #endif /* WLAN_RX_PKT_CAPTURE_ENH */
  42. #ifdef QCA_UNDECODED_METADATA_SUPPORT
  43. #define MAX_STRING_LEN_PER_FIELD 6
  44. #define DP_UNDECODED_ERR_LENGTH (MAX_STRING_LEN_PER_FIELD * CDP_PHYRX_ERR_MAX)
  45. #endif
  46. #ifdef QCA_MCOPY_SUPPORT
  47. static inline void
  48. dp_pdev_disable_mcopy_code(struct dp_pdev *pdev)
  49. {
  50. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  51. mon_pdev->mcopy_mode = M_COPY_DISABLED;
  52. mon_pdev->mvdev = NULL;
  53. }
  54. static inline void
  55. dp_reset_mcopy_mode(struct dp_pdev *pdev)
  56. {
  57. QDF_STATUS status = QDF_STATUS_SUCCESS;
  58. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  59. struct cdp_mon_ops *cdp_ops;
  60. if (mon_pdev->mcopy_mode) {
  61. cdp_ops = dp_mon_cdp_ops_get(pdev->soc);
  62. if (cdp_ops && cdp_ops->config_full_mon_mode)
  63. cdp_ops->soc_config_full_mon_mode((struct cdp_pdev *)pdev,
  64. DP_FULL_MON_ENABLE);
  65. dp_pdev_disable_mcopy_code(pdev);
  66. dp_mon_filter_reset_mcopy_mode(pdev);
  67. status = dp_mon_filter_update(pdev);
  68. if (status != QDF_STATUS_SUCCESS) {
  69. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  70. FL("Failed to reset AM copy mode filters"));
  71. }
  72. mon_pdev->monitor_configured = false;
  73. }
  74. }
  75. static QDF_STATUS
  76. dp_config_mcopy_mode(struct dp_pdev *pdev, int val)
  77. {
  78. QDF_STATUS status = QDF_STATUS_SUCCESS;
  79. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  80. struct dp_mon_ops *mon_ops;
  81. struct cdp_mon_ops *cdp_ops;
  82. if (mon_pdev->mvdev)
  83. return QDF_STATUS_E_RESOURCES;
  84. mon_pdev->mcopy_mode = val;
  85. mon_pdev->tx_sniffer_enable = 0;
  86. mon_pdev->monitor_configured = true;
  87. mon_ops = dp_mon_ops_get(pdev->soc);
  88. if (!wlan_cfg_is_delay_mon_replenish(pdev->soc->wlan_cfg_ctx)) {
  89. if (mon_ops && mon_ops->mon_vdev_set_monitor_mode_rings)
  90. mon_ops->mon_vdev_set_monitor_mode_rings(pdev, true);
  91. }
  92. /*
  93. * Setup the M copy mode filter.
  94. */
  95. cdp_ops = dp_mon_cdp_ops_get(pdev->soc);
  96. if (cdp_ops && cdp_ops->config_full_mon_mode)
  97. cdp_ops->soc_config_full_mon_mode((struct cdp_pdev *)pdev,
  98. DP_FULL_MON_ENABLE);
  99. dp_mon_filter_setup_mcopy_mode(pdev);
  100. status = dp_mon_filter_update(pdev);
  101. if (status != QDF_STATUS_SUCCESS) {
  102. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  103. FL("Failed to set M_copy mode filters"));
  104. dp_mon_filter_reset_mcopy_mode(pdev);
  105. dp_pdev_disable_mcopy_code(pdev);
  106. return status;
  107. }
  108. if (!mon_pdev->pktlog_ppdu_stats)
  109. dp_h2t_cfg_stats_msg_send(pdev,
  110. DP_PPDU_STATS_CFG_SNIFFER,
  111. pdev->pdev_id);
  112. return status;
  113. }
  114. #else
  115. static inline void
  116. dp_reset_mcopy_mode(struct dp_pdev *pdev)
  117. {
  118. }
  119. static inline QDF_STATUS
  120. dp_config_mcopy_mode(struct dp_pdev *pdev, int val)
  121. {
  122. return QDF_STATUS_E_INVAL;
  123. }
  124. #endif /* QCA_MCOPY_SUPPORT */
  125. #ifdef QCA_UNDECODED_METADATA_SUPPORT
  126. static QDF_STATUS
  127. dp_reset_undecoded_metadata_capture(struct dp_pdev *pdev)
  128. {
  129. QDF_STATUS status = QDF_STATUS_SUCCESS;
  130. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  131. if (mon_pdev->undecoded_metadata_capture) {
  132. dp_mon_filter_reset_undecoded_metadata_mode(pdev);
  133. status = dp_mon_filter_update(pdev);
  134. if (status != QDF_STATUS_SUCCESS) {
  135. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  136. FL("Undecoded capture filter reset failed"));
  137. }
  138. }
  139. mon_pdev->undecoded_metadata_capture = 0;
  140. return status;
  141. }
  142. static QDF_STATUS
  143. dp_enable_undecoded_metadata_capture(struct dp_pdev *pdev, int val)
  144. {
  145. QDF_STATUS status = QDF_STATUS_SUCCESS;
  146. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  147. struct dp_mon_ops *mon_ops;
  148. if (!mon_pdev->mvdev) {
  149. qdf_err("monitor_pdev is NULL");
  150. return QDF_STATUS_E_RESOURCES;
  151. }
  152. mon_pdev->undecoded_metadata_capture = val;
  153. mon_pdev->monitor_configured = true;
  154. mon_ops = dp_mon_ops_get(pdev->soc);
  155. /* Setup the undecoded metadata capture mode filter. */
  156. dp_mon_filter_setup_undecoded_metadata_mode(pdev);
  157. status = dp_mon_filter_update(pdev);
  158. if (status != QDF_STATUS_SUCCESS) {
  159. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  160. FL("Failed to set Undecoded capture filters"));
  161. dp_mon_filter_reset_undecoded_metadata_mode(pdev);
  162. return status;
  163. }
  164. return status;
  165. }
  166. #else
  167. static inline QDF_STATUS
  168. dp_reset_undecoded_metadata_capture(struct dp_pdev *pdev)
  169. {
  170. return QDF_STATUS_E_INVAL;
  171. }
  172. static inline QDF_STATUS
  173. dp_enable_undecoded_metadata_capture(struct dp_pdev *pdev, int val)
  174. {
  175. return QDF_STATUS_E_INVAL;
  176. }
  177. #endif /* QCA_UNDECODED_METADATA_SUPPORT */
  178. QDF_STATUS dp_reset_monitor_mode(struct cdp_soc_t *soc_hdl,
  179. uint8_t pdev_id,
  180. uint8_t special_monitor)
  181. {
  182. struct dp_soc *soc = (struct dp_soc *)soc_hdl;
  183. struct dp_pdev *pdev =
  184. dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc,
  185. pdev_id);
  186. QDF_STATUS status = QDF_STATUS_SUCCESS;
  187. struct dp_mon_pdev *mon_pdev;
  188. struct cdp_mon_ops *cdp_ops;
  189. if (!pdev)
  190. return QDF_STATUS_E_FAILURE;
  191. mon_pdev = pdev->monitor_pdev;
  192. qdf_spin_lock_bh(&mon_pdev->mon_lock);
  193. cdp_ops = dp_mon_cdp_ops_get(soc);
  194. if (cdp_ops && cdp_ops->soc_config_full_mon_mode)
  195. cdp_ops->soc_config_full_mon_mode((struct cdp_pdev *)pdev,
  196. DP_FULL_MON_DISABLE);
  197. mon_pdev->mvdev = NULL;
  198. /*
  199. * Lite monitor mode, smart monitor mode and monitor
  200. * mode uses this APIs to filter reset and mode disable
  201. */
  202. if (mon_pdev->mcopy_mode) {
  203. #if defined(QCA_MCOPY_SUPPORT)
  204. dp_pdev_disable_mcopy_code(pdev);
  205. dp_mon_filter_reset_mcopy_mode(pdev);
  206. #endif /* QCA_MCOPY_SUPPORT */
  207. } else if (special_monitor) {
  208. #if defined(ATH_SUPPORT_NAC)
  209. dp_mon_filter_reset_smart_monitor(pdev);
  210. #endif /* ATH_SUPPORT_NAC */
  211. } else if (mon_pdev->undecoded_metadata_capture) {
  212. #ifdef QCA_UNDECODED_METADATA_SUPPORT
  213. dp_reset_undecoded_metadata_capture(pdev);
  214. #endif
  215. } else {
  216. dp_mon_filter_reset_mon_mode(pdev);
  217. }
  218. status = dp_mon_filter_update(pdev);
  219. if (status != QDF_STATUS_SUCCESS) {
  220. dp_rx_mon_dest_err("%pK: Failed to reset monitor filters",
  221. soc);
  222. }
  223. mon_pdev->monitor_configured = false;
  224. qdf_spin_unlock_bh(&mon_pdev->mon_lock);
  225. return QDF_STATUS_SUCCESS;
  226. }
  227. #ifdef QCA_ADVANCE_MON_FILTER_SUPPORT
  228. QDF_STATUS
  229. dp_pdev_set_advance_monitor_filter(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
  230. struct cdp_monitor_filter *filter_val)
  231. {
  232. /* Many monitor VAPs can exists in a system but only one can be up at
  233. * anytime
  234. */
  235. struct dp_soc *soc = (struct dp_soc *)soc_hdl;
  236. struct dp_vdev *vdev;
  237. struct dp_pdev *pdev =
  238. dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc,
  239. pdev_id);
  240. QDF_STATUS status = QDF_STATUS_SUCCESS;
  241. struct dp_mon_pdev *mon_pdev;
  242. if (!pdev || !pdev->monitor_pdev)
  243. return QDF_STATUS_E_FAILURE;
  244. mon_pdev = pdev->monitor_pdev;
  245. vdev = mon_pdev->mvdev;
  246. if (!vdev)
  247. return QDF_STATUS_E_FAILURE;
  248. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_WARN,
  249. "pdev=%pK, pdev_id=%d, soc=%pK vdev=%pK",
  250. pdev, pdev_id, soc, vdev);
  251. /*Check if current pdev's monitor_vdev exists */
  252. if (!mon_pdev->mvdev) {
  253. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  254. "vdev=%pK", vdev);
  255. qdf_assert(vdev);
  256. }
  257. /* update filter mode, type in pdev structure */
  258. mon_pdev->mon_filter_mode = filter_val->mode;
  259. mon_pdev->fp_mgmt_filter = filter_val->fp_mgmt;
  260. mon_pdev->fp_ctrl_filter = filter_val->fp_ctrl;
  261. mon_pdev->fp_data_filter = filter_val->fp_data;
  262. mon_pdev->mo_mgmt_filter = filter_val->mo_mgmt;
  263. mon_pdev->mo_ctrl_filter = filter_val->mo_ctrl;
  264. mon_pdev->mo_data_filter = filter_val->mo_data;
  265. dp_mon_filter_setup_mon_mode(pdev);
  266. status = dp_mon_filter_update(pdev);
  267. if (status != QDF_STATUS_SUCCESS) {
  268. dp_rx_mon_dest_err("%pK: Failed to set filter for adv mon mode",
  269. soc);
  270. dp_mon_filter_reset_mon_mode(pdev);
  271. }
  272. return status;
  273. }
  274. #endif
  275. QDF_STATUS
  276. dp_deliver_tx_mgmt(struct cdp_soc_t *cdp_soc, uint8_t pdev_id, qdf_nbuf_t nbuf)
  277. {
  278. struct dp_pdev *pdev =
  279. dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)cdp_soc,
  280. pdev_id);
  281. if (!pdev)
  282. return QDF_STATUS_E_FAILURE;
  283. dp_deliver_mgmt_frm(pdev, nbuf);
  284. return QDF_STATUS_SUCCESS;
  285. }
  286. #ifdef QCA_SUPPORT_SCAN_SPCL_VAP_STATS
  287. /**
  288. * dp_scan_spcl_vap_stats_attach() - alloc spcl vap stats struct
  289. * @mon_vdev: Datapath mon VDEV handle
  290. *
  291. * Return: 0 on success, not 0 on failure
  292. */
  293. static inline QDF_STATUS
  294. dp_scan_spcl_vap_stats_attach(struct dp_mon_vdev *mon_vdev)
  295. {
  296. mon_vdev->scan_spcl_vap_stats =
  297. qdf_mem_malloc(sizeof(struct cdp_scan_spcl_vap_stats));
  298. if (!mon_vdev->scan_spcl_vap_stats) {
  299. dp_mon_err("scan spcl vap stats attach fail");
  300. return QDF_STATUS_E_NOMEM;
  301. }
  302. return QDF_STATUS_SUCCESS;
  303. }
  304. /**
  305. * dp_scan_spcl_vap_stats_detach() - free spcl vap stats struct
  306. * @mon_vdev: Datapath mon VDEV handle
  307. *
  308. * Return: void
  309. */
  310. static inline void
  311. dp_scan_spcl_vap_stats_detach(struct dp_mon_vdev *mon_vdev)
  312. {
  313. if (mon_vdev->scan_spcl_vap_stats) {
  314. qdf_mem_free(mon_vdev->scan_spcl_vap_stats);
  315. mon_vdev->scan_spcl_vap_stats = NULL;
  316. }
  317. }
  318. /**
  319. * dp_reset_scan_spcl_vap_stats() - reset spcl vap rx stats
  320. * @vdev: Datapath VDEV handle
  321. *
  322. * Return: void
  323. */
  324. static inline void
  325. dp_reset_scan_spcl_vap_stats(struct dp_vdev *vdev)
  326. {
  327. struct dp_mon_vdev *mon_vdev;
  328. struct dp_mon_pdev *mon_pdev;
  329. mon_pdev = vdev->pdev->monitor_pdev;
  330. if (!mon_pdev || !mon_pdev->reset_scan_spcl_vap_stats_enable)
  331. return;
  332. mon_vdev = vdev->monitor_vdev;
  333. if (!mon_vdev || !mon_vdev->scan_spcl_vap_stats)
  334. return;
  335. qdf_mem_zero(mon_vdev->scan_spcl_vap_stats,
  336. sizeof(struct cdp_scan_spcl_vap_stats));
  337. }
  338. /**
  339. * dp_get_scan_spcl_vap_stats() - get spcl vap rx stats
  340. * @soc_hdl: Datapath soc handle
  341. * @vdev_id: vdev id
  342. * @stats: structure to hold spcl vap stats
  343. *
  344. * Return: 0 on success, not 0 on failure
  345. */
  346. static QDF_STATUS
  347. dp_get_scan_spcl_vap_stats(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
  348. struct cdp_scan_spcl_vap_stats *stats)
  349. {
  350. struct dp_mon_vdev *mon_vdev = NULL;
  351. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  352. struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id,
  353. DP_MOD_ID_CDP);
  354. if (!vdev || !stats) {
  355. if (vdev)
  356. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP);
  357. return QDF_STATUS_E_INVAL;
  358. }
  359. mon_vdev = vdev->monitor_vdev;
  360. if (!mon_vdev || !mon_vdev->scan_spcl_vap_stats) {
  361. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP);
  362. return QDF_STATUS_E_INVAL;
  363. }
  364. qdf_mem_copy(stats, mon_vdev->scan_spcl_vap_stats,
  365. sizeof(struct cdp_scan_spcl_vap_stats));
  366. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP);
  367. return QDF_STATUS_SUCCESS;
  368. }
  369. #else
  370. static inline void
  371. dp_reset_scan_spcl_vap_stats(struct dp_vdev *vdev)
  372. {
  373. }
  374. static inline QDF_STATUS
  375. dp_scan_spcl_vap_stats_attach(struct dp_mon_vdev *mon_vdev)
  376. {
  377. return QDF_STATUS_SUCCESS;
  378. }
  379. static inline void
  380. dp_scan_spcl_vap_stats_detach(struct dp_mon_vdev *mon_vdev)
  381. {
  382. }
  383. #endif
  384. /**
  385. * dp_vdev_set_monitor_mode() - Set DP VDEV to monitor mode
  386. * @vdev_handle: Datapath VDEV handle
  387. * @smart_monitor: Flag to denote if its smart monitor mode
  388. *
  389. * Return: 0 on success, not 0 on failure
  390. */
  391. static QDF_STATUS dp_vdev_set_monitor_mode(struct cdp_soc_t *dp_soc,
  392. uint8_t vdev_id,
  393. uint8_t special_monitor)
  394. {
  395. struct dp_soc *soc = (struct dp_soc *)dp_soc;
  396. struct dp_pdev *pdev;
  397. struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id,
  398. DP_MOD_ID_CDP);
  399. QDF_STATUS status = QDF_STATUS_SUCCESS;
  400. struct dp_mon_pdev *mon_pdev;
  401. struct cdp_mon_ops *cdp_ops;
  402. if (!vdev)
  403. return QDF_STATUS_E_FAILURE;
  404. pdev = vdev->pdev;
  405. if (!pdev || !pdev->monitor_pdev)
  406. return QDF_STATUS_E_FAILURE;
  407. mon_pdev = pdev->monitor_pdev;
  408. mon_pdev->mvdev = vdev;
  409. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_WARN,
  410. "pdev=%pK, pdev_id=%d, soc=%pK vdev=%pK\n",
  411. pdev, pdev->pdev_id, pdev->soc, vdev);
  412. /*
  413. * do not configure monitor buf ring and filter for smart and
  414. * lite monitor
  415. * for smart monitor filters are added along with first NAC
  416. * for lite monitor required configuration done through
  417. * dp_set_pdev_param
  418. */
  419. if (special_monitor) {
  420. status = QDF_STATUS_SUCCESS;
  421. goto fail;
  422. }
  423. if (mon_pdev->scan_spcl_vap_configured)
  424. dp_reset_scan_spcl_vap_stats(vdev);
  425. /*Check if current pdev's monitor_vdev exists */
  426. if (mon_pdev->monitor_configured) {
  427. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
  428. "monitor vap already created vdev=%pK\n", vdev);
  429. status = QDF_STATUS_E_RESOURCES;
  430. goto fail;
  431. }
  432. mon_pdev->monitor_configured = true;
  433. cdp_ops = dp_mon_cdp_ops_get(soc);
  434. if (cdp_ops && cdp_ops->soc_config_full_mon_mode)
  435. cdp_ops->soc_config_full_mon_mode((struct cdp_pdev *)pdev,
  436. DP_FULL_MON_ENABLE);
  437. dp_mon_filter_setup_mon_mode(pdev);
  438. status = dp_mon_filter_update(pdev);
  439. if (status != QDF_STATUS_SUCCESS) {
  440. dp_cdp_err("%pK: Failed to reset monitor filters", soc);
  441. dp_mon_filter_reset_mon_mode(pdev);
  442. mon_pdev->monitor_configured = false;
  443. mon_pdev->mvdev = NULL;
  444. }
  445. fail:
  446. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP);
  447. return status;
  448. }
  449. #ifdef QCA_TX_CAPTURE_SUPPORT
  450. static QDF_STATUS
  451. dp_config_tx_capture_mode(struct dp_pdev *pdev)
  452. {
  453. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  454. mon_pdev->tx_sniffer_enable = 1;
  455. mon_pdev->monitor_configured = false;
  456. if (!mon_pdev->pktlog_ppdu_stats)
  457. dp_h2t_cfg_stats_msg_send(pdev,
  458. DP_PPDU_STATS_CFG_SNIFFER,
  459. pdev->pdev_id);
  460. return QDF_STATUS_SUCCESS;
  461. }
  462. #else
  463. #ifdef QCA_MCOPY_SUPPORT
  464. static QDF_STATUS
  465. dp_config_tx_capture_mode(struct dp_pdev *pdev)
  466. {
  467. return QDF_STATUS_E_INVAL;
  468. }
  469. #endif
  470. #endif
  471. #if defined(QCA_MCOPY_SUPPORT) || defined(QCA_TX_CAPTURE_SUPPORT)
  472. QDF_STATUS
  473. dp_config_debug_sniffer(struct dp_pdev *pdev, int val)
  474. {
  475. QDF_STATUS status = QDF_STATUS_SUCCESS;
  476. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  477. /*
  478. * Note: The mirror copy mode cannot co-exist with any other
  479. * monitor modes. Hence disabling the filter for this mode will
  480. * reset the monitor destination ring filters.
  481. */
  482. dp_reset_mcopy_mode(pdev);
  483. switch (val) {
  484. case 0:
  485. mon_pdev->tx_sniffer_enable = 0;
  486. mon_pdev->monitor_configured = false;
  487. /*
  488. * We don't need to reset the Rx monitor status ring or call
  489. * the API dp_ppdu_ring_reset() if all debug sniffer mode is
  490. * disabled. The Rx monitor status ring will be disabled when
  491. * the last mode using the monitor status ring get disabled.
  492. */
  493. if (!mon_pdev->pktlog_ppdu_stats &&
  494. !mon_pdev->enhanced_stats_en &&
  495. !mon_pdev->bpr_enable) {
  496. dp_h2t_cfg_stats_msg_send(pdev, 0, pdev->pdev_id);
  497. } else if (mon_pdev->enhanced_stats_en &&
  498. !mon_pdev->bpr_enable) {
  499. dp_h2t_cfg_stats_msg_send(pdev,
  500. DP_PPDU_STATS_CFG_ENH_STATS,
  501. pdev->pdev_id);
  502. } else if (!mon_pdev->enhanced_stats_en &&
  503. mon_pdev->bpr_enable) {
  504. dp_h2t_cfg_stats_msg_send(pdev,
  505. DP_PPDU_STATS_CFG_BPR_ENH,
  506. pdev->pdev_id);
  507. } else {
  508. dp_h2t_cfg_stats_msg_send(pdev,
  509. DP_PPDU_STATS_CFG_BPR,
  510. pdev->pdev_id);
  511. }
  512. break;
  513. case 1:
  514. status = dp_config_tx_capture_mode(pdev);
  515. break;
  516. case 2:
  517. case 4:
  518. status = dp_config_mcopy_mode(pdev, val);
  519. break;
  520. default:
  521. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  522. "Invalid value, mode not supported");
  523. status = QDF_STATUS_E_INVAL;
  524. break;
  525. }
  526. return status;
  527. }
  528. #endif
  529. #ifdef QCA_UNDECODED_METADATA_SUPPORT
  530. QDF_STATUS
  531. dp_mon_config_undecoded_metadata_capture(struct dp_pdev *pdev, int val)
  532. {
  533. QDF_STATUS status = QDF_STATUS_SUCCESS;
  534. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  535. if (!mon_pdev->mvdev && !mon_pdev->scan_spcl_vap_configured) {
  536. qdf_err("No monitor or Special vap, undecoded capture not supported");
  537. return QDF_STATUS_E_RESOURCES;
  538. }
  539. if (val)
  540. status = dp_enable_undecoded_metadata_capture(pdev, val);
  541. else
  542. status = dp_reset_undecoded_metadata_capture(pdev);
  543. return status;
  544. }
  545. #endif
  546. /**
  547. * dp_monitor_mode_ring_config() - Send the tlv config to fw for monitor buffer
  548. * ring based on target
  549. * @soc: soc handle
  550. * @mac_for_pdev: WIN- pdev_id, MCL- mac id
  551. * @pdev: physical device handle
  552. * @ring_num: mac id
  553. * @htt_tlv_filter: tlv filter
  554. *
  555. * Return: zero on success, non-zero on failure
  556. */
  557. static inline QDF_STATUS
  558. dp_monitor_mode_ring_config(struct dp_soc *soc, uint8_t mac_for_pdev,
  559. struct dp_pdev *pdev, uint8_t ring_num,
  560. struct htt_rx_ring_tlv_filter htt_tlv_filter)
  561. {
  562. QDF_STATUS status;
  563. if (soc->wlan_cfg_ctx->rxdma1_enable)
  564. status = htt_h2t_rx_ring_cfg(soc->htt_handle, mac_for_pdev,
  565. soc->rxdma_mon_buf_ring[ring_num]
  566. .hal_srng,
  567. RXDMA_MONITOR_BUF,
  568. RX_MONITOR_BUFFER_SIZE,
  569. &htt_tlv_filter);
  570. else
  571. status = htt_h2t_rx_ring_cfg(soc->htt_handle, mac_for_pdev,
  572. pdev->rx_mac_buf_ring[ring_num]
  573. .hal_srng,
  574. RXDMA_BUF, RX_DATA_BUFFER_SIZE,
  575. &htt_tlv_filter);
  576. return status;
  577. }
  578. /**
  579. * dp_get_mon_vdev_from_pdev_wifi3() - Get vdev id of monitor mode
  580. * @soc_hdl: datapath soc handle
  581. * @pdev_id: physical device instance id
  582. *
  583. * Return: virtual interface id
  584. */
  585. static uint8_t dp_get_mon_vdev_from_pdev_wifi3(struct cdp_soc_t *soc_hdl,
  586. uint8_t pdev_id)
  587. {
  588. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  589. struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id);
  590. if (qdf_unlikely(!pdev || !pdev->monitor_pdev ||
  591. !pdev->monitor_pdev->mvdev))
  592. return -EINVAL;
  593. return pdev->monitor_pdev->mvdev->vdev_id;
  594. }
  595. #if defined(QCA_TX_CAPTURE_SUPPORT) || defined(QCA_ENHANCED_STATS_SUPPORT)
  596. #ifndef WLAN_TX_PKT_CAPTURE_ENH
  597. void dp_deliver_mgmt_frm(struct dp_pdev *pdev, qdf_nbuf_t nbuf)
  598. {
  599. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  600. if (mon_pdev->tx_sniffer_enable || mon_pdev->mcopy_mode) {
  601. dp_wdi_event_handler(WDI_EVENT_TX_MGMT_CTRL, pdev->soc,
  602. nbuf, HTT_INVALID_PEER,
  603. WDI_NO_VAL, pdev->pdev_id);
  604. } else {
  605. if (!mon_pdev->bpr_enable)
  606. qdf_nbuf_free(nbuf);
  607. }
  608. }
  609. #endif
  610. #endif
  611. QDF_STATUS dp_htt_ppdu_stats_attach(struct dp_pdev *pdev)
  612. {
  613. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  614. mon_pdev->ppdu_tlv_buf = qdf_mem_malloc(HTT_T2H_MAX_MSG_SIZE);
  615. if (!mon_pdev->ppdu_tlv_buf) {
  616. QDF_TRACE_ERROR(QDF_MODULE_ID_DP, "ppdu_tlv_buf alloc fail");
  617. return QDF_STATUS_E_NOMEM;
  618. }
  619. return QDF_STATUS_SUCCESS;
  620. }
  621. void dp_htt_ppdu_stats_detach(struct dp_pdev *pdev)
  622. {
  623. struct ppdu_info *ppdu_info, *ppdu_info_next;
  624. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  625. TAILQ_FOREACH_SAFE(ppdu_info, &mon_pdev->ppdu_info_list,
  626. ppdu_info_list_elem, ppdu_info_next) {
  627. if (!ppdu_info)
  628. break;
  629. TAILQ_REMOVE(&mon_pdev->ppdu_info_list,
  630. ppdu_info, ppdu_info_list_elem);
  631. mon_pdev->list_depth--;
  632. qdf_assert_always(ppdu_info->nbuf);
  633. qdf_nbuf_free(ppdu_info->nbuf);
  634. qdf_mem_free(ppdu_info);
  635. }
  636. TAILQ_FOREACH_SAFE(ppdu_info, &mon_pdev->sched_comp_ppdu_list,
  637. ppdu_info_list_elem, ppdu_info_next) {
  638. if (!ppdu_info)
  639. break;
  640. TAILQ_REMOVE(&mon_pdev->sched_comp_ppdu_list,
  641. ppdu_info, ppdu_info_list_elem);
  642. mon_pdev->sched_comp_list_depth--;
  643. qdf_assert_always(ppdu_info->nbuf);
  644. qdf_nbuf_free(ppdu_info->nbuf);
  645. qdf_mem_free(ppdu_info);
  646. }
  647. if (mon_pdev->ppdu_tlv_buf)
  648. qdf_mem_free(mon_pdev->ppdu_tlv_buf);
  649. }
  650. QDF_STATUS dp_pdev_get_rx_mon_stats(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
  651. struct cdp_pdev_mon_stats *stats)
  652. {
  653. struct dp_soc *soc = (struct dp_soc *)soc_hdl;
  654. struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id);
  655. struct dp_mon_pdev *mon_pdev;
  656. if (!pdev)
  657. return QDF_STATUS_E_FAILURE;
  658. mon_pdev = pdev->monitor_pdev;
  659. if (!mon_pdev)
  660. return QDF_STATUS_E_FAILURE;
  661. qdf_mem_copy(stats, &mon_pdev->rx_mon_stats,
  662. sizeof(struct cdp_pdev_mon_stats));
  663. return QDF_STATUS_SUCCESS;
  664. }
  665. #ifdef QCA_UNDECODED_METADATA_SUPPORT
  666. /**
  667. * dp_pdev_get_undecoded_capture_stats() - Get undecoded metadata captured
  668. * monitor pdev stats
  669. * @mon_pdev: Monitor PDEV handle
  670. * @rx_mon_stats: Monitor pdev status/destination ring stats
  671. *
  672. * Return: None
  673. */
  674. static inline void
  675. dp_pdev_get_undecoded_capture_stats(struct dp_mon_pdev *mon_pdev,
  676. struct cdp_pdev_mon_stats *rx_mon_stats)
  677. {
  678. char undecoded_error[DP_UNDECODED_ERR_LENGTH];
  679. uint8_t index = 0, i;
  680. DP_PRINT_STATS("Rx Undecoded Frame count:%d",
  681. rx_mon_stats->rx_undecoded_count);
  682. index = 0;
  683. for (i = 0; i < (CDP_PHYRX_ERR_MAX); i++) {
  684. index += qdf_snprint(&undecoded_error[index],
  685. DP_UNDECODED_ERR_LENGTH - index,
  686. " %d", rx_mon_stats->rx_undecoded_error[i]);
  687. }
  688. DP_PRINT_STATS("Undecoded Error (0-63):%s", undecoded_error);
  689. }
  690. #else
  691. static inline void
  692. dp_pdev_get_undecoded_capture_stats(struct dp_mon_pdev *mon_pdev,
  693. struct cdp_pdev_mon_stats *rx_mon_stats)
  694. {
  695. }
  696. #endif
  697. void
  698. dp_print_pdev_rx_mon_stats(struct dp_pdev *pdev)
  699. {
  700. struct cdp_pdev_mon_stats *rx_mon_stats;
  701. uint32_t *stat_ring_ppdu_ids;
  702. uint32_t *dest_ring_ppdu_ids;
  703. int i, idx;
  704. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  705. rx_mon_stats = &mon_pdev->rx_mon_stats;
  706. DP_PRINT_STATS("PDEV Rx Monitor Stats:\n");
  707. DP_PRINT_STATS("status_ppdu_compl_cnt = %d",
  708. rx_mon_stats->status_ppdu_compl);
  709. DP_PRINT_STATS("status_ppdu_start_cnt = %d",
  710. rx_mon_stats->status_ppdu_start);
  711. DP_PRINT_STATS("status_ppdu_end_cnt = %d",
  712. rx_mon_stats->status_ppdu_end);
  713. DP_PRINT_STATS("status_ppdu_start_mis_cnt = %d",
  714. rx_mon_stats->status_ppdu_start_mis);
  715. DP_PRINT_STATS("status_ppdu_end_mis_cnt = %d",
  716. rx_mon_stats->status_ppdu_end_mis);
  717. DP_PRINT_STATS("status_ppdu_done_cnt = %d",
  718. rx_mon_stats->status_ppdu_done);
  719. DP_PRINT_STATS("dest_ppdu_done_cnt = %d",
  720. rx_mon_stats->dest_ppdu_done);
  721. DP_PRINT_STATS("dest_mpdu_done_cnt = %d",
  722. rx_mon_stats->dest_mpdu_done);
  723. DP_PRINT_STATS("tlv_tag_status_err_cnt = %u",
  724. rx_mon_stats->tlv_tag_status_err);
  725. DP_PRINT_STATS("mon status DMA not done WAR count= %u",
  726. rx_mon_stats->status_buf_done_war);
  727. DP_PRINT_STATS("dest_mpdu_drop_cnt = %d",
  728. rx_mon_stats->dest_mpdu_drop);
  729. DP_PRINT_STATS("dup_mon_linkdesc_cnt = %d",
  730. rx_mon_stats->dup_mon_linkdesc_cnt);
  731. DP_PRINT_STATS("dup_mon_buf_cnt = %d",
  732. rx_mon_stats->dup_mon_buf_cnt);
  733. DP_PRINT_STATS("mon_rx_buf_reaped = %u",
  734. rx_mon_stats->mon_rx_bufs_reaped_dest);
  735. DP_PRINT_STATS("mon_rx_buf_replenished = %u",
  736. rx_mon_stats->mon_rx_bufs_replenished_dest);
  737. DP_PRINT_STATS("ppdu_id_mismatch = %u",
  738. rx_mon_stats->ppdu_id_mismatch);
  739. DP_PRINT_STATS("mpdu_ppdu_id_match_cnt = %d",
  740. rx_mon_stats->ppdu_id_match);
  741. DP_PRINT_STATS("ppdus dropped frm status ring = %d",
  742. rx_mon_stats->status_ppdu_drop);
  743. DP_PRINT_STATS("ppdus dropped frm dest ring = %d",
  744. rx_mon_stats->dest_ppdu_drop);
  745. stat_ring_ppdu_ids =
  746. (uint32_t *)qdf_mem_malloc(sizeof(uint32_t) * MAX_PPDU_ID_HIST);
  747. dest_ring_ppdu_ids =
  748. (uint32_t *)qdf_mem_malloc(sizeof(uint32_t) * MAX_PPDU_ID_HIST);
  749. if (!stat_ring_ppdu_ids || !dest_ring_ppdu_ids)
  750. DP_PRINT_STATS("Unable to allocate ppdu id hist mem\n");
  751. qdf_spin_lock_bh(&mon_pdev->mon_lock);
  752. idx = rx_mon_stats->ppdu_id_hist_idx;
  753. qdf_mem_copy(stat_ring_ppdu_ids,
  754. rx_mon_stats->stat_ring_ppdu_id_hist,
  755. sizeof(uint32_t) * MAX_PPDU_ID_HIST);
  756. qdf_mem_copy(dest_ring_ppdu_ids,
  757. rx_mon_stats->dest_ring_ppdu_id_hist,
  758. sizeof(uint32_t) * MAX_PPDU_ID_HIST);
  759. qdf_spin_unlock_bh(&mon_pdev->mon_lock);
  760. DP_PRINT_STATS("PPDU Id history:");
  761. DP_PRINT_STATS("stat_ring_ppdu_ids\t dest_ring_ppdu_ids");
  762. for (i = 0; i < MAX_PPDU_ID_HIST; i++) {
  763. idx = (idx + 1) & (MAX_PPDU_ID_HIST - 1);
  764. DP_PRINT_STATS("%*u\t%*u", 16,
  765. rx_mon_stats->stat_ring_ppdu_id_hist[idx], 16,
  766. rx_mon_stats->dest_ring_ppdu_id_hist[idx]);
  767. }
  768. qdf_mem_free(stat_ring_ppdu_ids);
  769. qdf_mem_free(dest_ring_ppdu_ids);
  770. DP_PRINT_STATS("mon_rx_dest_stuck = %d",
  771. rx_mon_stats->mon_rx_dest_stuck);
  772. dp_pdev_get_undecoded_capture_stats(mon_pdev, rx_mon_stats);
  773. }
  774. #ifdef QCA_SUPPORT_BPR
  775. QDF_STATUS
  776. dp_set_bpr_enable(struct dp_pdev *pdev, int val)
  777. {
  778. struct dp_mon_ops *mon_ops;
  779. mon_ops = dp_mon_ops_get(pdev->soc);
  780. if (mon_ops && mon_ops->mon_set_bpr_enable)
  781. return mon_ops->mon_set_bpr_enable(pdev, val);
  782. return QDF_STATUS_E_FAILURE;
  783. }
  784. #endif
  785. #ifdef WDI_EVENT_ENABLE
  786. #ifdef BE_PKTLOG_SUPPORT
  787. static bool
  788. dp_set_hybrid_pktlog_enable(struct dp_pdev *pdev,
  789. struct dp_mon_pdev *mon_pdev,
  790. struct dp_mon_soc *mon_soc)
  791. {
  792. if (mon_pdev->mvdev) {
  793. /* Nothing needs to be done if monitor mode is
  794. * enabled
  795. */
  796. mon_pdev->pktlog_hybrid_mode = true;
  797. return false;
  798. }
  799. if (!mon_pdev->pktlog_hybrid_mode) {
  800. mon_pdev->pktlog_hybrid_mode = true;
  801. dp_mon_filter_setup_pktlog_hybrid(pdev);
  802. if (dp_mon_filter_update(pdev) !=
  803. QDF_STATUS_SUCCESS) {
  804. dp_cdp_err("Set hybrid filters failed");
  805. dp_mon_filter_reset_pktlog_hybrid(pdev);
  806. mon_pdev->rx_pktlog_mode =
  807. DP_RX_PKTLOG_DISABLED;
  808. return false;
  809. }
  810. if (mon_soc->reap_timer_init &&
  811. !dp_mon_is_enable_reap_timer_non_pkt(pdev))
  812. qdf_timer_mod(&mon_soc->mon_reap_timer,
  813. DP_INTR_POLL_TIMER_MS);
  814. }
  815. return true;
  816. }
  817. static void
  818. dp_set_hybrid_pktlog_disable(struct dp_mon_pdev *mon_pdev)
  819. {
  820. mon_pdev->pktlog_hybrid_mode = false;
  821. }
  822. #else
  823. static void
  824. dp_set_hybrid_pktlog_disable(struct dp_mon_pdev *mon_pdev)
  825. {
  826. }
  827. static bool
  828. dp_set_hybrid_pktlog_enable(struct dp_pdev *pdev,
  829. struct dp_mon_pdev *mon_pdev,
  830. struct dp_mon_soc *mon_soc)
  831. {
  832. dp_cdp_err("Hybrid mode is supported only on beryllium");
  833. return true;
  834. }
  835. #endif
  836. int dp_set_pktlog_wifi3(struct dp_pdev *pdev, uint32_t event,
  837. bool enable)
  838. {
  839. struct dp_soc *soc = NULL;
  840. int max_mac_rings = wlan_cfg_get_num_mac_rings
  841. (pdev->wlan_cfg_ctx);
  842. uint8_t mac_id = 0;
  843. struct dp_mon_soc *mon_soc;
  844. struct dp_mon_ops *mon_ops;
  845. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  846. soc = pdev->soc;
  847. mon_soc = soc->monitor_soc;
  848. mon_ops = dp_mon_ops_get(soc);
  849. if (!mon_ops)
  850. return 0;
  851. dp_update_num_mac_rings_for_dbs(soc, &max_mac_rings);
  852. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG,
  853. FL("Max_mac_rings %d "),
  854. max_mac_rings);
  855. if (enable) {
  856. switch (event) {
  857. case WDI_EVENT_RX_DESC:
  858. if (mon_pdev->mvdev) {
  859. /* Nothing needs to be done if monitor mode is
  860. * enabled
  861. */
  862. mon_pdev->rx_pktlog_mode = DP_RX_PKTLOG_FULL;
  863. return 0;
  864. }
  865. if (mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_FULL) {
  866. mon_pdev->rx_pktlog_mode = DP_RX_PKTLOG_FULL;
  867. dp_mon_filter_setup_rx_pkt_log_full(pdev);
  868. if (dp_mon_filter_update(pdev) !=
  869. QDF_STATUS_SUCCESS) {
  870. dp_cdp_err("%pK: Pktlog full filters set failed", soc);
  871. dp_mon_filter_reset_rx_pkt_log_full(pdev);
  872. mon_pdev->rx_pktlog_mode =
  873. DP_RX_PKTLOG_DISABLED;
  874. return 0;
  875. }
  876. if (mon_soc->reap_timer_init &&
  877. (!dp_mon_is_enable_reap_timer_non_pkt(pdev)))
  878. qdf_timer_mod(&mon_soc->mon_reap_timer,
  879. DP_INTR_POLL_TIMER_MS);
  880. }
  881. break;
  882. case WDI_EVENT_LITE_RX:
  883. if (mon_pdev->mvdev) {
  884. /* Nothing needs to be done if monitor mode is
  885. * enabled
  886. */
  887. mon_pdev->rx_pktlog_mode = DP_RX_PKTLOG_LITE;
  888. return 0;
  889. }
  890. if (mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_LITE) {
  891. mon_pdev->rx_pktlog_mode = DP_RX_PKTLOG_LITE;
  892. /*
  893. * Set the packet log lite mode filter.
  894. */
  895. dp_mon_filter_setup_rx_pkt_log_lite(pdev);
  896. if (dp_mon_filter_update(pdev) !=
  897. QDF_STATUS_SUCCESS) {
  898. dp_cdp_err("%pK: Pktlog lite filters set failed", soc);
  899. dp_mon_filter_reset_rx_pkt_log_lite(pdev);
  900. mon_pdev->rx_pktlog_mode =
  901. DP_RX_PKTLOG_DISABLED;
  902. return 0;
  903. }
  904. if (mon_soc->reap_timer_init &&
  905. (!dp_mon_is_enable_reap_timer_non_pkt(pdev)))
  906. qdf_timer_mod(&mon_soc->mon_reap_timer,
  907. DP_INTR_POLL_TIMER_MS);
  908. }
  909. break;
  910. case WDI_EVENT_LITE_T2H:
  911. for (mac_id = 0; mac_id < max_mac_rings; mac_id++) {
  912. int mac_for_pdev = dp_get_mac_id_for_pdev(
  913. mac_id, pdev->pdev_id);
  914. mon_pdev->pktlog_ppdu_stats = true;
  915. dp_h2t_cfg_stats_msg_send(pdev,
  916. DP_PPDU_TXLITE_STATS_BITMASK_CFG,
  917. mac_for_pdev);
  918. }
  919. break;
  920. case WDI_EVENT_RX_CBF:
  921. if (mon_pdev->mvdev) {
  922. /* Nothing needs to be done if monitor mode is
  923. * enabled
  924. */
  925. dp_mon_info("Mon mode, CBF setting filters");
  926. mon_pdev->rx_pktlog_cbf = true;
  927. return 0;
  928. }
  929. if (!mon_pdev->rx_pktlog_cbf) {
  930. mon_pdev->rx_pktlog_cbf = true;
  931. mon_pdev->monitor_configured = true;
  932. if (mon_ops->mon_vdev_set_monitor_mode_buf_rings)
  933. mon_ops->mon_vdev_set_monitor_mode_buf_rings(pdev);
  934. /*
  935. * Set the packet log lite mode filter.
  936. */
  937. qdf_info("Non mon mode: Enable destination ring");
  938. dp_mon_filter_setup_rx_pkt_log_cbf(pdev);
  939. if (dp_mon_filter_update(pdev) !=
  940. QDF_STATUS_SUCCESS) {
  941. dp_mon_err("Pktlog set CBF filters failed");
  942. dp_mon_filter_reset_rx_pktlog_cbf(pdev);
  943. mon_pdev->rx_pktlog_mode =
  944. DP_RX_PKTLOG_DISABLED;
  945. mon_pdev->monitor_configured = false;
  946. return 0;
  947. }
  948. if (mon_soc->reap_timer_init &&
  949. !dp_mon_is_enable_reap_timer_non_pkt(pdev))
  950. qdf_timer_mod(&mon_soc->mon_reap_timer,
  951. DP_INTR_POLL_TIMER_MS);
  952. }
  953. break;
  954. case WDI_EVENT_HYBRID_TX:
  955. if (!dp_set_hybrid_pktlog_enable(pdev,
  956. mon_pdev, mon_soc))
  957. return 0;
  958. break;
  959. default:
  960. /* Nothing needs to be done for other pktlog types */
  961. break;
  962. }
  963. } else {
  964. switch (event) {
  965. case WDI_EVENT_RX_DESC:
  966. case WDI_EVENT_LITE_RX:
  967. if (mon_pdev->mvdev) {
  968. /* Nothing needs to be done if monitor mode is
  969. * enabled
  970. */
  971. mon_pdev->rx_pktlog_mode =
  972. DP_RX_PKTLOG_DISABLED;
  973. return 0;
  974. }
  975. if (mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED) {
  976. mon_pdev->rx_pktlog_mode =
  977. DP_RX_PKTLOG_DISABLED;
  978. dp_mon_filter_reset_rx_pkt_log_full(pdev);
  979. if (dp_mon_filter_update(pdev) !=
  980. QDF_STATUS_SUCCESS) {
  981. dp_cdp_err("%pK: Pktlog filters reset failed", soc);
  982. return 0;
  983. }
  984. dp_mon_filter_reset_rx_pkt_log_lite(pdev);
  985. if (dp_mon_filter_update(pdev) !=
  986. QDF_STATUS_SUCCESS) {
  987. dp_cdp_err("%pK: Pktlog filters reset failed", soc);
  988. return 0;
  989. }
  990. if (mon_soc->reap_timer_init &&
  991. (!dp_mon_is_enable_reap_timer_non_pkt(pdev)))
  992. qdf_timer_stop(&mon_soc->mon_reap_timer);
  993. }
  994. break;
  995. case WDI_EVENT_LITE_T2H:
  996. /*
  997. * To disable HTT_H2T_MSG_TYPE_PPDU_STATS_CFG in FW
  998. * passing value 0. Once these macros will define in htt
  999. * header file will use proper macros
  1000. */
  1001. for (mac_id = 0; mac_id < max_mac_rings; mac_id++) {
  1002. int mac_for_pdev =
  1003. dp_get_mac_id_for_pdev(mac_id,
  1004. pdev->pdev_id);
  1005. mon_pdev->pktlog_ppdu_stats = false;
  1006. if (!mon_pdev->enhanced_stats_en &&
  1007. !mon_pdev->tx_sniffer_enable &&
  1008. !mon_pdev->mcopy_mode) {
  1009. dp_h2t_cfg_stats_msg_send(pdev, 0,
  1010. mac_for_pdev);
  1011. } else if (mon_pdev->tx_sniffer_enable ||
  1012. mon_pdev->mcopy_mode) {
  1013. dp_h2t_cfg_stats_msg_send(pdev,
  1014. DP_PPDU_STATS_CFG_SNIFFER,
  1015. mac_for_pdev);
  1016. } else if (mon_pdev->enhanced_stats_en) {
  1017. dp_h2t_cfg_stats_msg_send(pdev,
  1018. DP_PPDU_STATS_CFG_ENH_STATS,
  1019. mac_for_pdev);
  1020. }
  1021. }
  1022. break;
  1023. case WDI_EVENT_RX_CBF:
  1024. mon_pdev->rx_pktlog_cbf = false;
  1025. break;
  1026. case WDI_EVENT_HYBRID_TX:
  1027. dp_set_hybrid_pktlog_disable(mon_pdev);
  1028. break;
  1029. default:
  1030. /* Nothing needs to be done for other pktlog types */
  1031. break;
  1032. }
  1033. }
  1034. return 0;
  1035. }
  1036. #endif
  1037. /* MCL specific functions */
  1038. #if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
  1039. void dp_pktlogmod_exit(struct dp_pdev *pdev)
  1040. {
  1041. struct dp_soc *soc = pdev->soc;
  1042. struct hif_opaque_softc *scn = soc->hif_handle;
  1043. struct dp_mon_soc *mon_soc = soc->monitor_soc;
  1044. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  1045. if (!scn) {
  1046. dp_mon_err("Invalid hif(scn) handle");
  1047. return;
  1048. }
  1049. /* stop mon_reap_timer if it has been started */
  1050. if (mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED &&
  1051. mon_soc->reap_timer_init &&
  1052. (!dp_mon_is_enable_reap_timer_non_pkt(pdev)))
  1053. qdf_timer_sync_cancel(&mon_soc->mon_reap_timer);
  1054. pktlogmod_exit(scn);
  1055. mon_pdev->pkt_log_init = false;
  1056. }
  1057. #endif /*DP_CON_MON*/
  1058. #if defined(WDI_EVENT_ENABLE) && defined(QCA_ENHANCED_STATS_SUPPORT)
  1059. QDF_STATUS dp_peer_stats_notify(struct dp_pdev *dp_pdev, struct dp_peer *peer)
  1060. {
  1061. struct cdp_interface_peer_stats peer_stats_intf;
  1062. struct dp_mon_peer_stats *mon_peer_stats = NULL;
  1063. struct dp_peer *tgt_peer = NULL;
  1064. struct dp_txrx_peer *txrx_peer = NULL;
  1065. if (!peer || !peer->vdev || !peer->monitor_peer)
  1066. return QDF_STATUS_E_FAULT;
  1067. tgt_peer = dp_get_tgt_peer_from_peer(peer);
  1068. if (!tgt_peer)
  1069. return QDF_STATUS_E_FAULT;
  1070. txrx_peer = tgt_peer->txrx_peer;
  1071. if (!txrx_peer)
  1072. return QDF_STATUS_E_FAULT;
  1073. mon_peer_stats = &peer->monitor_peer->stats;
  1074. qdf_mem_zero(&peer_stats_intf, sizeof(peer_stats_intf));
  1075. if (mon_peer_stats->rx.last_snr != mon_peer_stats->rx.snr)
  1076. peer_stats_intf.rssi_changed = true;
  1077. if ((mon_peer_stats->rx.snr && peer_stats_intf.rssi_changed) ||
  1078. (mon_peer_stats->tx.tx_rate &&
  1079. mon_peer_stats->tx.tx_rate != mon_peer_stats->tx.last_tx_rate)) {
  1080. qdf_mem_copy(peer_stats_intf.peer_mac, peer->mac_addr.raw,
  1081. QDF_MAC_ADDR_SIZE);
  1082. peer_stats_intf.vdev_id = peer->vdev->vdev_id;
  1083. peer_stats_intf.last_peer_tx_rate =
  1084. mon_peer_stats->tx.last_tx_rate;
  1085. peer_stats_intf.peer_tx_rate = mon_peer_stats->tx.tx_rate;
  1086. peer_stats_intf.peer_rssi = mon_peer_stats->rx.snr;
  1087. peer_stats_intf.ack_rssi = mon_peer_stats->tx.last_ack_rssi;
  1088. peer_stats_intf.rx_packet_count = txrx_peer->to_stack.num;
  1089. peer_stats_intf.rx_byte_count = txrx_peer->to_stack.bytes;
  1090. peer_stats_intf.tx_packet_count =
  1091. txrx_peer->stats.per_pkt_stats.tx.ucast.num;
  1092. peer_stats_intf.tx_byte_count =
  1093. txrx_peer->stats.per_pkt_stats.tx.tx_success.bytes;
  1094. peer_stats_intf.per = tgt_peer->stats.tx.last_per;
  1095. peer_stats_intf.free_buff = INVALID_FREE_BUFF;
  1096. dp_wdi_event_handler(WDI_EVENT_PEER_STATS, dp_pdev->soc,
  1097. (void *)&peer_stats_intf, 0,
  1098. WDI_NO_VAL, dp_pdev->pdev_id);
  1099. }
  1100. return QDF_STATUS_SUCCESS;
  1101. }
  1102. #endif
  1103. #ifdef FEATURE_NAC_RSSI
  1104. /**
  1105. * dp_rx_nac_filter(): Function to perform filtering of non-associated
  1106. * clients
  1107. * @pdev: DP pdev handle
  1108. * @rx_pkt_hdr: Rx packet Header
  1109. *
  1110. * return: dp_vdev*
  1111. */
  1112. static
  1113. struct dp_vdev *dp_rx_nac_filter(struct dp_pdev *pdev,
  1114. uint8_t *rx_pkt_hdr)
  1115. {
  1116. struct ieee80211_frame *wh;
  1117. struct dp_neighbour_peer *peer = NULL;
  1118. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  1119. wh = (struct ieee80211_frame *)rx_pkt_hdr;
  1120. if ((wh->i_fc[1] & IEEE80211_FC1_DIR_MASK) != IEEE80211_FC1_DIR_TODS)
  1121. return NULL;
  1122. qdf_spin_lock_bh(&mon_pdev->neighbour_peer_mutex);
  1123. TAILQ_FOREACH(peer, &mon_pdev->neighbour_peers_list,
  1124. neighbour_peer_list_elem) {
  1125. if (qdf_mem_cmp(&peer->neighbour_peers_macaddr.raw[0],
  1126. wh->i_addr2, QDF_MAC_ADDR_SIZE) == 0) {
  1127. dp_rx_debug("%pK: NAC configuration matched for mac-%2x:%2x:%2x:%2x:%2x:%2x",
  1128. pdev->soc,
  1129. peer->neighbour_peers_macaddr.raw[0],
  1130. peer->neighbour_peers_macaddr.raw[1],
  1131. peer->neighbour_peers_macaddr.raw[2],
  1132. peer->neighbour_peers_macaddr.raw[3],
  1133. peer->neighbour_peers_macaddr.raw[4],
  1134. peer->neighbour_peers_macaddr.raw[5]);
  1135. qdf_spin_unlock_bh(&mon_pdev->neighbour_peer_mutex);
  1136. return mon_pdev->mvdev;
  1137. }
  1138. }
  1139. qdf_spin_unlock_bh(&mon_pdev->neighbour_peer_mutex);
  1140. return NULL;
  1141. }
  1142. QDF_STATUS dp_filter_neighbour_peer(struct dp_pdev *pdev,
  1143. uint8_t *rx_pkt_hdr)
  1144. {
  1145. struct dp_vdev *vdev = NULL;
  1146. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  1147. if (mon_pdev->filter_neighbour_peers) {
  1148. /* Next Hop scenario not yet handle */
  1149. vdev = dp_rx_nac_filter(pdev, rx_pkt_hdr);
  1150. if (vdev) {
  1151. dp_rx_mon_deliver(pdev->soc, pdev->pdev_id,
  1152. pdev->invalid_peer_head_msdu,
  1153. pdev->invalid_peer_tail_msdu);
  1154. pdev->invalid_peer_head_msdu = NULL;
  1155. pdev->invalid_peer_tail_msdu = NULL;
  1156. return QDF_STATUS_SUCCESS;
  1157. }
  1158. }
  1159. return QDF_STATUS_E_FAILURE;
  1160. }
  1161. #endif
  1162. #if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
  1163. /*
  1164. * dp_update_filter_neighbour_peers() - set neighbour peers(nac clients)
  1165. * address for smart mesh filtering
  1166. * @txrx_soc: cdp soc handle
  1167. * @vdev_id: id of virtual device object
  1168. * @cmd: Add/Del command
  1169. * @macaddr: nac client mac address
  1170. *
  1171. * Return: success/failure
  1172. */
  1173. static int dp_update_filter_neighbour_peers(struct cdp_soc_t *soc_hdl,
  1174. uint8_t vdev_id,
  1175. uint32_t cmd, uint8_t *macaddr)
  1176. {
  1177. struct dp_soc *soc = (struct dp_soc *)soc_hdl;
  1178. struct dp_pdev *pdev;
  1179. struct dp_neighbour_peer *peer = NULL;
  1180. struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id,
  1181. DP_MOD_ID_CDP);
  1182. struct dp_mon_pdev *mon_pdev;
  1183. if (!vdev || !macaddr)
  1184. goto fail0;
  1185. pdev = vdev->pdev;
  1186. if (!pdev)
  1187. goto fail0;
  1188. mon_pdev = pdev->monitor_pdev;
  1189. /* Store address of NAC (neighbour peer) which will be checked
  1190. * against TA of received packets.
  1191. */
  1192. if (cmd == DP_NAC_PARAM_ADD) {
  1193. peer = (struct dp_neighbour_peer *)qdf_mem_malloc(
  1194. sizeof(*peer));
  1195. if (!peer) {
  1196. dp_cdp_err("%pK: DP neighbour peer node memory allocation failed"
  1197. , soc);
  1198. goto fail0;
  1199. }
  1200. qdf_mem_copy(&peer->neighbour_peers_macaddr.raw[0],
  1201. macaddr, QDF_MAC_ADDR_SIZE);
  1202. peer->vdev = vdev;
  1203. qdf_spin_lock_bh(&mon_pdev->neighbour_peer_mutex);
  1204. /* add this neighbour peer into the list */
  1205. TAILQ_INSERT_TAIL(&mon_pdev->neighbour_peers_list, peer,
  1206. neighbour_peer_list_elem);
  1207. qdf_spin_unlock_bh(&mon_pdev->neighbour_peer_mutex);
  1208. /* first neighbour */
  1209. if (!mon_pdev->neighbour_peers_added) {
  1210. QDF_STATUS status = QDF_STATUS_SUCCESS;
  1211. mon_pdev->neighbour_peers_added = true;
  1212. dp_mon_filter_setup_smart_monitor(pdev);
  1213. status = dp_mon_filter_update(pdev);
  1214. if (status != QDF_STATUS_SUCCESS) {
  1215. dp_cdp_err("%pK: smart mon filter setup failed",
  1216. soc);
  1217. dp_mon_filter_reset_smart_monitor(pdev);
  1218. mon_pdev->neighbour_peers_added = false;
  1219. }
  1220. }
  1221. } else if (cmd == DP_NAC_PARAM_DEL) {
  1222. qdf_spin_lock_bh(&mon_pdev->neighbour_peer_mutex);
  1223. TAILQ_FOREACH(peer, &mon_pdev->neighbour_peers_list,
  1224. neighbour_peer_list_elem) {
  1225. if (!qdf_mem_cmp(&peer->neighbour_peers_macaddr.raw[0],
  1226. macaddr, QDF_MAC_ADDR_SIZE)) {
  1227. /* delete this peer from the list */
  1228. TAILQ_REMOVE(&mon_pdev->neighbour_peers_list,
  1229. peer, neighbour_peer_list_elem);
  1230. qdf_mem_free(peer);
  1231. break;
  1232. }
  1233. }
  1234. /* last neighbour deleted */
  1235. if (TAILQ_EMPTY(&mon_pdev->neighbour_peers_list)) {
  1236. QDF_STATUS status = QDF_STATUS_SUCCESS;
  1237. dp_mon_filter_reset_smart_monitor(pdev);
  1238. status = dp_mon_filter_update(pdev);
  1239. if (status != QDF_STATUS_SUCCESS) {
  1240. dp_cdp_err("%pK: smart mon filter clear failed",
  1241. soc);
  1242. }
  1243. mon_pdev->neighbour_peers_added = false;
  1244. }
  1245. qdf_spin_unlock_bh(&mon_pdev->neighbour_peer_mutex);
  1246. }
  1247. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP);
  1248. return 1;
  1249. fail0:
  1250. if (vdev)
  1251. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP);
  1252. return 0;
  1253. }
  1254. #endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */
  1255. #ifdef ATH_SUPPORT_NAC_RSSI
  1256. /**
  1257. * dp_vdev_get_neighbour_rssi(): Store RSSI for configured NAC
  1258. * @soc_hdl: DP soc handle
  1259. * @vdev_id: id of DP vdev handle
  1260. * @mac_addr: neighbour mac
  1261. * @rssi: rssi value
  1262. *
  1263. * Return: 0 for success. nonzero for failure.
  1264. */
  1265. static QDF_STATUS dp_vdev_get_neighbour_rssi(struct cdp_soc_t *soc_hdl,
  1266. uint8_t vdev_id,
  1267. char *mac_addr,
  1268. uint8_t *rssi)
  1269. {
  1270. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  1271. struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id,
  1272. DP_MOD_ID_CDP);
  1273. struct dp_pdev *pdev;
  1274. struct dp_neighbour_peer *peer = NULL;
  1275. QDF_STATUS status = QDF_STATUS_E_FAILURE;
  1276. struct dp_mon_pdev *mon_pdev;
  1277. if (!vdev)
  1278. return status;
  1279. pdev = vdev->pdev;
  1280. mon_pdev = pdev->monitor_pdev;
  1281. *rssi = 0;
  1282. qdf_spin_lock_bh(&mon_pdev->neighbour_peer_mutex);
  1283. TAILQ_FOREACH(peer, &mon_pdev->neighbour_peers_list,
  1284. neighbour_peer_list_elem) {
  1285. if (qdf_mem_cmp(&peer->neighbour_peers_macaddr.raw[0],
  1286. mac_addr, QDF_MAC_ADDR_SIZE) == 0) {
  1287. *rssi = peer->rssi;
  1288. status = QDF_STATUS_SUCCESS;
  1289. break;
  1290. }
  1291. }
  1292. qdf_spin_unlock_bh(&mon_pdev->neighbour_peer_mutex);
  1293. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP);
  1294. return status;
  1295. }
  1296. static QDF_STATUS
  1297. dp_config_for_nac_rssi(struct cdp_soc_t *cdp_soc,
  1298. uint8_t vdev_id,
  1299. enum cdp_nac_param_cmd cmd, char *bssid,
  1300. char *client_macaddr,
  1301. uint8_t chan_num)
  1302. {
  1303. struct dp_soc *soc = (struct dp_soc *)cdp_soc;
  1304. struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id,
  1305. DP_MOD_ID_CDP);
  1306. struct dp_pdev *pdev;
  1307. struct dp_mon_pdev *mon_pdev;
  1308. if (!vdev)
  1309. return QDF_STATUS_E_FAILURE;
  1310. pdev = (struct dp_pdev *)vdev->pdev;
  1311. mon_pdev = pdev->monitor_pdev;
  1312. mon_pdev->nac_rssi_filtering = 1;
  1313. /* Store address of NAC (neighbour peer) which will be checked
  1314. * against TA of received packets.
  1315. */
  1316. if (cmd == CDP_NAC_PARAM_ADD) {
  1317. dp_update_filter_neighbour_peers(cdp_soc, vdev->vdev_id,
  1318. DP_NAC_PARAM_ADD,
  1319. (uint8_t *)client_macaddr);
  1320. } else if (cmd == CDP_NAC_PARAM_DEL) {
  1321. dp_update_filter_neighbour_peers(cdp_soc, vdev->vdev_id,
  1322. DP_NAC_PARAM_DEL,
  1323. (uint8_t *)client_macaddr);
  1324. }
  1325. if (soc->cdp_soc.ol_ops->config_bssid_in_fw_for_nac_rssi)
  1326. soc->cdp_soc.ol_ops->config_bssid_in_fw_for_nac_rssi
  1327. (soc->ctrl_psoc, pdev->pdev_id,
  1328. vdev->vdev_id, cmd, bssid, client_macaddr);
  1329. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_CDP);
  1330. return QDF_STATUS_SUCCESS;
  1331. }
  1332. #endif
  1333. #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE)
  1334. /*
  1335. * dp_cfr_filter() - Configure HOST RX monitor status ring for CFR
  1336. * @soc_hdl: Datapath soc handle
  1337. * @pdev_id: id of data path pdev handle
  1338. * @enable: Enable/Disable CFR
  1339. * @filter_val: Flag to select Filter for monitor mode
  1340. */
  1341. static void dp_cfr_filter(struct cdp_soc_t *soc_hdl,
  1342. uint8_t pdev_id,
  1343. bool enable,
  1344. struct cdp_monitor_filter *filter_val)
  1345. {
  1346. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  1347. struct dp_pdev *pdev = NULL;
  1348. struct htt_rx_ring_tlv_filter htt_tlv_filter = {0};
  1349. int max_mac_rings;
  1350. uint8_t mac_id = 0;
  1351. struct dp_mon_pdev *mon_pdev;
  1352. pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id);
  1353. if (!pdev) {
  1354. dp_mon_err("pdev is NULL");
  1355. return;
  1356. }
  1357. mon_pdev = pdev->monitor_pdev;
  1358. if (mon_pdev->mvdev) {
  1359. dp_mon_info("No action is needed since mon mode is enabled\n");
  1360. return;
  1361. }
  1362. soc = pdev->soc;
  1363. pdev->cfr_rcc_mode = false;
  1364. max_mac_rings = wlan_cfg_get_num_mac_rings(pdev->wlan_cfg_ctx);
  1365. dp_update_num_mac_rings_for_dbs(soc, &max_mac_rings);
  1366. dp_mon_debug("Max_mac_rings %d", max_mac_rings);
  1367. dp_mon_info("enable : %d, mode: 0x%x", enable, filter_val->mode);
  1368. if (enable) {
  1369. pdev->cfr_rcc_mode = true;
  1370. htt_tlv_filter.ppdu_start = 1;
  1371. htt_tlv_filter.ppdu_end = 1;
  1372. htt_tlv_filter.ppdu_end_user_stats = 1;
  1373. htt_tlv_filter.ppdu_end_user_stats_ext = 1;
  1374. htt_tlv_filter.ppdu_end_status_done = 1;
  1375. htt_tlv_filter.mpdu_start = 1;
  1376. htt_tlv_filter.offset_valid = false;
  1377. htt_tlv_filter.enable_fp =
  1378. (filter_val->mode & MON_FILTER_PASS) ? 1 : 0;
  1379. htt_tlv_filter.enable_md = 0;
  1380. htt_tlv_filter.enable_mo =
  1381. (filter_val->mode & MON_FILTER_OTHER) ? 1 : 0;
  1382. htt_tlv_filter.fp_mgmt_filter = filter_val->fp_mgmt;
  1383. htt_tlv_filter.fp_ctrl_filter = filter_val->fp_ctrl;
  1384. htt_tlv_filter.fp_data_filter = filter_val->fp_data;
  1385. htt_tlv_filter.mo_mgmt_filter = filter_val->mo_mgmt;
  1386. htt_tlv_filter.mo_ctrl_filter = filter_val->mo_ctrl;
  1387. htt_tlv_filter.mo_data_filter = filter_val->mo_data;
  1388. }
  1389. for (mac_id = 0;
  1390. mac_id < soc->wlan_cfg_ctx->num_rxdma_status_rings_per_pdev;
  1391. mac_id++) {
  1392. int mac_for_pdev =
  1393. dp_get_mac_id_for_pdev(mac_id,
  1394. pdev->pdev_id);
  1395. htt_h2t_rx_ring_cfg(soc->htt_handle,
  1396. mac_for_pdev,
  1397. soc->rxdma_mon_status_ring[mac_id]
  1398. .hal_srng,
  1399. RXDMA_MONITOR_STATUS,
  1400. RX_MON_STATUS_BUF_SIZE,
  1401. &htt_tlv_filter);
  1402. }
  1403. }
  1404. #endif
  1405. void
  1406. dp_enable_mon_reap_timer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
  1407. bool enable)
  1408. {
  1409. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  1410. struct dp_pdev *pdev = NULL;
  1411. struct dp_mon_soc *mon_soc = soc->monitor_soc;
  1412. struct dp_mon_pdev *mon_pdev;
  1413. pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id);
  1414. if (!pdev) {
  1415. dp_mon_err("pdev is NULL");
  1416. return;
  1417. }
  1418. mon_pdev = pdev->monitor_pdev;
  1419. mon_pdev->enable_reap_timer_non_pkt = enable;
  1420. if (mon_pdev->rx_pktlog_mode != DP_RX_PKTLOG_DISABLED) {
  1421. dp_mon_debug("pktlog enabled %d", mon_pdev->rx_pktlog_mode);
  1422. return;
  1423. }
  1424. if (!mon_soc->reap_timer_init) {
  1425. dp_mon_err("reap timer not init");
  1426. return;
  1427. }
  1428. if (enable)
  1429. qdf_timer_mod(&mon_soc->mon_reap_timer,
  1430. DP_INTR_POLL_TIMER_MS);
  1431. else
  1432. qdf_timer_sync_cancel(&mon_soc->mon_reap_timer);
  1433. }
  1434. #if defined(DP_CON_MON)
  1435. #ifndef REMOVE_PKT_LOG
  1436. /**
  1437. * dp_pkt_log_init() - API to initialize packet log
  1438. * @soc_hdl: Datapath soc handle
  1439. * @pdev_id: id of data path pdev handle
  1440. * @scn: HIF context
  1441. *
  1442. * Return: none
  1443. */
  1444. void dp_pkt_log_init(struct cdp_soc_t *soc_hdl, uint8_t pdev_id, void *scn)
  1445. {
  1446. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  1447. struct dp_pdev *handle =
  1448. dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id);
  1449. struct dp_mon_pdev *mon_pdev;
  1450. if (!handle) {
  1451. dp_mon_err("pdev handle is NULL");
  1452. return;
  1453. }
  1454. mon_pdev = handle->monitor_pdev;
  1455. if (mon_pdev->pkt_log_init) {
  1456. dp_mon_err("%pK: Packet log not initialized", soc);
  1457. return;
  1458. }
  1459. pktlog_sethandle(&mon_pdev->pl_dev, scn);
  1460. pktlog_set_pdev_id(mon_pdev->pl_dev, pdev_id);
  1461. pktlog_set_callback_regtype(PKTLOG_DEFAULT_CALLBACK_REGISTRATION);
  1462. if (pktlogmod_init(scn)) {
  1463. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1464. "%s: pktlogmod_init failed", __func__);
  1465. mon_pdev->pkt_log_init = false;
  1466. } else {
  1467. mon_pdev->pkt_log_init = true;
  1468. }
  1469. }
  1470. /**
  1471. * dp_pkt_log_con_service() - connect packet log service
  1472. * @soc_hdl: Datapath soc handle
  1473. * @pdev_id: id of data path pdev handle
  1474. * @scn: device context
  1475. *
  1476. * Return: none
  1477. */
  1478. static void dp_pkt_log_con_service(struct cdp_soc_t *soc_hdl,
  1479. uint8_t pdev_id, void *scn)
  1480. {
  1481. dp_pkt_log_init(soc_hdl, pdev_id, scn);
  1482. pktlog_htc_attach();
  1483. }
  1484. /**
  1485. * dp_pkt_log_exit() - Wrapper API to cleanup pktlog info
  1486. * @soc_hdl: Datapath soc handle
  1487. * @pdev_id: id of data path pdev handle
  1488. *
  1489. * Return: none
  1490. */
  1491. static void dp_pkt_log_exit(struct cdp_soc_t *soc_hdl, uint8_t pdev_id)
  1492. {
  1493. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  1494. struct dp_pdev *pdev =
  1495. dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id);
  1496. if (!pdev) {
  1497. dp_err("pdev handle is NULL");
  1498. return;
  1499. }
  1500. dp_pktlogmod_exit(pdev);
  1501. }
  1502. #else
  1503. static void dp_pkt_log_con_service(struct cdp_soc_t *soc_hdl,
  1504. uint8_t pdev_id, void *scn)
  1505. {
  1506. }
  1507. static void dp_pkt_log_exit(struct cdp_soc_t *soc_hdl, uint8_t pdev_id)
  1508. {
  1509. }
  1510. #endif
  1511. #endif
  1512. void dp_neighbour_peers_detach(struct dp_pdev *pdev)
  1513. {
  1514. struct dp_neighbour_peer *peer = NULL;
  1515. struct dp_neighbour_peer *temp_peer = NULL;
  1516. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  1517. TAILQ_FOREACH_SAFE(peer, &mon_pdev->neighbour_peers_list,
  1518. neighbour_peer_list_elem, temp_peer) {
  1519. /* delete this peer from the list */
  1520. TAILQ_REMOVE(&mon_pdev->neighbour_peers_list,
  1521. peer, neighbour_peer_list_elem);
  1522. qdf_mem_free(peer);
  1523. }
  1524. qdf_spinlock_destroy(&mon_pdev->neighbour_peer_mutex);
  1525. }
  1526. #ifdef QCA_ENHANCED_STATS_SUPPORT
  1527. /*
  1528. * dp_mon_tx_enable_enhanced_stats() - Enable enhanced Tx stats
  1529. * @pdev: Datapath pdev handle
  1530. *
  1531. * Return: void
  1532. */
  1533. static void dp_mon_tx_enable_enhanced_stats(struct dp_pdev *pdev)
  1534. {
  1535. struct dp_soc *soc = pdev->soc;
  1536. struct dp_mon_ops *mon_ops = NULL;
  1537. mon_ops = dp_mon_ops_get(soc);
  1538. if (mon_ops && mon_ops->mon_tx_enable_enhanced_stats)
  1539. mon_ops->mon_tx_enable_enhanced_stats(pdev);
  1540. }
  1541. /*
  1542. * dp_enable_enhanced_stats()- API to enable enhanced statistcs
  1543. * @soc_handle: DP_SOC handle
  1544. * @pdev_id: id of DP_PDEV handle
  1545. *
  1546. * Return: QDF_STATUS
  1547. */
  1548. static QDF_STATUS
  1549. dp_enable_enhanced_stats(struct cdp_soc_t *soc, uint8_t pdev_id)
  1550. {
  1551. struct dp_pdev *pdev = NULL;
  1552. QDF_STATUS status = QDF_STATUS_SUCCESS;
  1553. struct dp_mon_pdev *mon_pdev;
  1554. pdev = dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc,
  1555. pdev_id);
  1556. if (!pdev)
  1557. return QDF_STATUS_E_FAILURE;
  1558. mon_pdev = pdev->monitor_pdev;
  1559. if (!mon_pdev)
  1560. return QDF_STATUS_E_FAILURE;
  1561. if (mon_pdev->enhanced_stats_en == 0)
  1562. dp_cal_client_timer_start(mon_pdev->cal_client_ctx);
  1563. mon_pdev->enhanced_stats_en = 1;
  1564. pdev->enhanced_stats_en = true;
  1565. dp_mon_filter_setup_enhanced_stats(pdev);
  1566. status = dp_mon_filter_update(pdev);
  1567. if (status != QDF_STATUS_SUCCESS) {
  1568. dp_cdp_err("%pK: Failed to set enhanced mode filters", soc);
  1569. dp_mon_filter_reset_enhanced_stats(pdev);
  1570. dp_cal_client_timer_stop(mon_pdev->cal_client_ctx);
  1571. mon_pdev->enhanced_stats_en = 0;
  1572. pdev->enhanced_stats_en = false;
  1573. return QDF_STATUS_E_FAILURE;
  1574. }
  1575. dp_mon_tx_enable_enhanced_stats(pdev);
  1576. return QDF_STATUS_SUCCESS;
  1577. }
  1578. /*
  1579. * dp_mon_tx_disable_enhanced_stats() - Disable enhanced Tx stats
  1580. * @pdev: Datapath pdev handle
  1581. *
  1582. * Return: void
  1583. */
  1584. static void dp_mon_tx_disable_enhanced_stats(struct dp_pdev *pdev)
  1585. {
  1586. struct dp_soc *soc = pdev->soc;
  1587. struct dp_mon_ops *mon_ops = NULL;
  1588. mon_ops = dp_mon_ops_get(soc);
  1589. if (mon_ops && mon_ops->mon_tx_disable_enhanced_stats)
  1590. mon_ops->mon_tx_disable_enhanced_stats(pdev);
  1591. }
  1592. /*
  1593. * dp_disable_enhanced_stats()- API to disable enhanced statistcs
  1594. *
  1595. * @param soc - the soc handle
  1596. * @param pdev_id - pdev_id of pdev
  1597. * @return - QDF_STATUS
  1598. */
  1599. static QDF_STATUS
  1600. dp_disable_enhanced_stats(struct cdp_soc_t *soc, uint8_t pdev_id)
  1601. {
  1602. struct dp_pdev *pdev =
  1603. dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc,
  1604. pdev_id);
  1605. struct dp_mon_pdev *mon_pdev;
  1606. if (!pdev || !pdev->monitor_pdev)
  1607. return QDF_STATUS_E_FAILURE;
  1608. mon_pdev = pdev->monitor_pdev;
  1609. if (mon_pdev->enhanced_stats_en == 1)
  1610. dp_cal_client_timer_stop(mon_pdev->cal_client_ctx);
  1611. mon_pdev->enhanced_stats_en = 0;
  1612. pdev->enhanced_stats_en = false;
  1613. dp_mon_tx_disable_enhanced_stats(pdev);
  1614. dp_mon_filter_reset_enhanced_stats(pdev);
  1615. if (dp_mon_filter_update(pdev) != QDF_STATUS_SUCCESS) {
  1616. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1617. FL("Failed to reset enhanced mode filters"));
  1618. }
  1619. return QDF_STATUS_SUCCESS;
  1620. }
  1621. #ifdef WDI_EVENT_ENABLE
  1622. QDF_STATUS dp_peer_qos_stats_notify(struct dp_pdev *dp_pdev,
  1623. struct cdp_rx_stats_ppdu_user *ppdu_user)
  1624. {
  1625. struct cdp_interface_peer_qos_stats qos_stats_intf;
  1626. if (ppdu_user->peer_id == HTT_INVALID_PEER) {
  1627. dp_mon_warn("Invalid peer id");
  1628. return QDF_STATUS_E_FAILURE;
  1629. }
  1630. qdf_mem_zero(&qos_stats_intf, sizeof(qos_stats_intf));
  1631. qdf_mem_copy(qos_stats_intf.peer_mac, ppdu_user->mac_addr,
  1632. QDF_MAC_ADDR_SIZE);
  1633. qos_stats_intf.frame_control = ppdu_user->frame_control;
  1634. qos_stats_intf.frame_control_info_valid =
  1635. ppdu_user->frame_control_info_valid;
  1636. qos_stats_intf.qos_control = ppdu_user->qos_control;
  1637. qos_stats_intf.qos_control_info_valid =
  1638. ppdu_user->qos_control_info_valid;
  1639. qos_stats_intf.vdev_id = ppdu_user->vdev_id;
  1640. dp_wdi_event_handler(WDI_EVENT_PEER_QOS_STATS, dp_pdev->soc,
  1641. (void *)&qos_stats_intf, 0,
  1642. WDI_NO_VAL, dp_pdev->pdev_id);
  1643. return QDF_STATUS_SUCCESS;
  1644. }
  1645. #else
  1646. static inline QDF_STATUS
  1647. dp_peer_qos_stats_notify(struct dp_pdev *dp_pdev,
  1648. struct cdp_rx_stats_ppdu_user *ppdu_user)
  1649. {
  1650. return QDF_STATUS_SUCCESS;
  1651. }
  1652. #endif
  1653. #endif /* QCA_ENHANCED_STATS_SUPPORT */
  1654. /**
  1655. * dp_enable_peer_based_pktlog() - Set Flag for peer based filtering
  1656. * for pktlog
  1657. * @soc: cdp_soc handle
  1658. * @pdev_id: id of dp pdev handle
  1659. * @mac_addr: Peer mac address
  1660. * @enb_dsb: Enable or disable peer based filtering
  1661. *
  1662. * Return: QDF_STATUS
  1663. */
  1664. static int
  1665. dp_enable_peer_based_pktlog(struct cdp_soc_t *soc, uint8_t pdev_id,
  1666. uint8_t *mac_addr, uint8_t enb_dsb)
  1667. {
  1668. struct dp_peer *peer;
  1669. QDF_STATUS status = QDF_STATUS_E_FAILURE;
  1670. struct dp_pdev *pdev =
  1671. dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc,
  1672. pdev_id);
  1673. struct dp_mon_pdev *mon_pdev;
  1674. if (!pdev)
  1675. return QDF_STATUS_E_FAILURE;
  1676. mon_pdev = pdev->monitor_pdev;
  1677. peer = dp_peer_find_hash_find((struct dp_soc *)soc, mac_addr,
  1678. 0, DP_VDEV_ALL, DP_MOD_ID_CDP);
  1679. if (!peer) {
  1680. dp_mon_err("Invalid Peer");
  1681. return QDF_STATUS_E_FAILURE;
  1682. }
  1683. if (!IS_MLO_DP_MLD_PEER(peer) && peer->monitor_peer) {
  1684. peer->monitor_peer->peer_based_pktlog_filter = enb_dsb;
  1685. mon_pdev->dp_peer_based_pktlog = enb_dsb;
  1686. status = QDF_STATUS_SUCCESS;
  1687. }
  1688. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  1689. return status;
  1690. }
  1691. /**
  1692. * dp_peer_update_pkt_capture_params: Set Rx & Tx Capture flags for a peer
  1693. * @soc: DP_SOC handle
  1694. * @pdev_id: id of DP_PDEV handle
  1695. * @is_rx_pkt_cap_enable: enable/disable Rx packet capture in monitor mode
  1696. * @is_tx_pkt_cap_enable: enable/disable/delete/print
  1697. * Tx packet capture in monitor mode
  1698. * @peer_mac: MAC address for which the above need to be enabled/disabled
  1699. *
  1700. * Return: Success if Rx & Tx capture is enabled for peer, false otherwise
  1701. */
  1702. #if defined(WLAN_TX_PKT_CAPTURE_ENH) || defined(WLAN_RX_PKT_CAPTURE_ENH)
  1703. static QDF_STATUS
  1704. dp_peer_update_pkt_capture_params(ol_txrx_soc_handle soc,
  1705. uint8_t pdev_id,
  1706. bool is_rx_pkt_cap_enable,
  1707. uint8_t is_tx_pkt_cap_enable,
  1708. uint8_t *peer_mac)
  1709. {
  1710. struct dp_peer *peer;
  1711. QDF_STATUS status = QDF_STATUS_E_FAILURE;
  1712. struct dp_pdev *pdev =
  1713. dp_get_pdev_from_soc_pdev_id_wifi3((struct dp_soc *)soc,
  1714. pdev_id);
  1715. if (!pdev)
  1716. return QDF_STATUS_E_FAILURE;
  1717. peer = dp_peer_find_hash_find((struct dp_soc *)soc,
  1718. peer_mac, 0, DP_VDEV_ALL,
  1719. DP_MOD_ID_CDP);
  1720. if (!peer)
  1721. return QDF_STATUS_E_FAILURE;
  1722. /* we need to set tx pkt capture for non associated peer */
  1723. if (!IS_MLO_DP_MLD_PEER(peer)) {
  1724. status = dp_monitor_tx_peer_filter(pdev, peer,
  1725. is_tx_pkt_cap_enable,
  1726. peer_mac);
  1727. status = dp_peer_set_rx_capture_enabled(pdev, peer,
  1728. is_rx_pkt_cap_enable,
  1729. peer_mac);
  1730. }
  1731. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  1732. return status;
  1733. }
  1734. #endif
  1735. #ifdef QCA_MCOPY_SUPPORT
  1736. QDF_STATUS dp_mcopy_check_deliver(struct dp_pdev *pdev,
  1737. uint16_t peer_id,
  1738. uint32_t ppdu_id,
  1739. uint8_t first_msdu)
  1740. {
  1741. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  1742. if (mon_pdev->mcopy_mode) {
  1743. if (mon_pdev->mcopy_mode == M_COPY) {
  1744. if ((mon_pdev->m_copy_id.tx_ppdu_id == ppdu_id) &&
  1745. (mon_pdev->m_copy_id.tx_peer_id == peer_id)) {
  1746. return QDF_STATUS_E_INVAL;
  1747. }
  1748. }
  1749. if (!first_msdu)
  1750. return QDF_STATUS_E_INVAL;
  1751. mon_pdev->m_copy_id.tx_ppdu_id = ppdu_id;
  1752. mon_pdev->m_copy_id.tx_peer_id = peer_id;
  1753. }
  1754. return QDF_STATUS_SUCCESS;
  1755. }
  1756. #endif
  1757. #ifdef WDI_EVENT_ENABLE
  1758. #ifndef REMOVE_PKT_LOG
  1759. static void *dp_get_pldev(struct cdp_soc_t *soc_hdl, uint8_t pdev_id)
  1760. {
  1761. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  1762. struct dp_pdev *pdev = dp_get_pdev_from_soc_pdev_id_wifi3(soc, pdev_id);
  1763. if (!pdev || !pdev->monitor_pdev)
  1764. return NULL;
  1765. return pdev->monitor_pdev->pl_dev;
  1766. }
  1767. #else
  1768. static void *dp_get_pldev(struct cdp_soc_t *soc_hdl, uint8_t pdev_id)
  1769. {
  1770. return NULL;
  1771. }
  1772. #endif
  1773. #endif
  1774. QDF_STATUS dp_rx_populate_cbf_hdr(struct dp_soc *soc,
  1775. uint32_t mac_id,
  1776. uint32_t event,
  1777. qdf_nbuf_t mpdu,
  1778. uint32_t msdu_timestamp)
  1779. {
  1780. uint32_t data_size, hdr_size, ppdu_id, align4byte;
  1781. struct dp_pdev *pdev = dp_get_pdev_for_lmac_id(soc, mac_id);
  1782. uint32_t *msg_word;
  1783. if (!pdev)
  1784. return QDF_STATUS_E_INVAL;
  1785. ppdu_id = pdev->monitor_pdev->ppdu_info.com_info.ppdu_id;
  1786. hdr_size = HTT_T2H_PPDU_STATS_IND_HDR_SIZE
  1787. + qdf_offsetof(htt_ppdu_stats_rx_mgmtctrl_payload_tlv, payload);
  1788. data_size = qdf_nbuf_len(mpdu);
  1789. qdf_nbuf_push_head(mpdu, hdr_size);
  1790. msg_word = (uint32_t *)qdf_nbuf_data(mpdu);
  1791. /*
  1792. * Populate the PPDU Stats Indication header
  1793. */
  1794. HTT_H2T_MSG_TYPE_SET(*msg_word, HTT_T2H_MSG_TYPE_PPDU_STATS_IND);
  1795. HTT_T2H_PPDU_STATS_MAC_ID_SET(*msg_word, mac_id);
  1796. HTT_T2H_PPDU_STATS_PDEV_ID_SET(*msg_word, pdev->pdev_id);
  1797. align4byte = ((data_size +
  1798. qdf_offsetof(htt_ppdu_stats_rx_mgmtctrl_payload_tlv, payload)
  1799. + 3) >> 2) << 2;
  1800. HTT_T2H_PPDU_STATS_PAYLOAD_SIZE_SET(*msg_word, align4byte);
  1801. msg_word++;
  1802. HTT_T2H_PPDU_STATS_PPDU_ID_SET(*msg_word, ppdu_id);
  1803. msg_word++;
  1804. *msg_word = msdu_timestamp;
  1805. msg_word++;
  1806. /* Skip reserved field */
  1807. msg_word++;
  1808. /*
  1809. * Populate MGMT_CTRL Payload TLV first
  1810. */
  1811. HTT_STATS_TLV_TAG_SET(*msg_word,
  1812. HTT_PPDU_STATS_RX_MGMTCTRL_PAYLOAD_TLV);
  1813. align4byte = ((data_size - sizeof(htt_tlv_hdr_t) +
  1814. qdf_offsetof(htt_ppdu_stats_rx_mgmtctrl_payload_tlv, payload)
  1815. + 3) >> 2) << 2;
  1816. HTT_STATS_TLV_LENGTH_SET(*msg_word, align4byte);
  1817. msg_word++;
  1818. HTT_PPDU_STATS_RX_MGMTCTRL_TLV_FRAME_LENGTH_SET(
  1819. *msg_word, data_size);
  1820. msg_word++;
  1821. dp_wdi_event_handler(event, soc, (void *)mpdu,
  1822. HTT_INVALID_PEER, WDI_NO_VAL, pdev->pdev_id);
  1823. qdf_nbuf_pull_head(mpdu, hdr_size);
  1824. return QDF_STATUS_SUCCESS;
  1825. }
  1826. #ifdef ATH_SUPPORT_EXT_STAT
  1827. /*dp_peer_cal_clients_stats_update - update peer stats on cal client timer
  1828. * @soc : Datapath SOC
  1829. * @peer : Datapath peer
  1830. * @arg : argument to iter function
  1831. */
  1832. static void
  1833. dp_peer_cal_clients_stats_update(struct dp_soc *soc,
  1834. struct dp_peer *peer,
  1835. void *arg)
  1836. {
  1837. struct cdp_calibr_stats_intf peer_stats_intf = {0};
  1838. struct dp_peer *tgt_peer = NULL;
  1839. struct dp_txrx_peer *txrx_peer = NULL;
  1840. if (!dp_peer_is_primary_link_peer(peer))
  1841. return;
  1842. tgt_peer = dp_get_tgt_peer_from_peer(peer);
  1843. if (!tgt_peer || !(tgt_peer->txrx_peer))
  1844. return;
  1845. txrx_peer = tgt_peer->txrx_peer;
  1846. peer_stats_intf.to_stack = txrx_peer->to_stack;
  1847. peer_stats_intf.tx_success =
  1848. txrx_peer->stats.per_pkt_stats.tx.tx_success;
  1849. peer_stats_intf.tx_ucast =
  1850. txrx_peer->stats.per_pkt_stats.tx.ucast;
  1851. dp_cal_client_update_peer_stats_wifi3(&peer_stats_intf,
  1852. &tgt_peer->stats);
  1853. }
  1854. /*dp_iterate_update_peer_list - update peer stats on cal client timer
  1855. * @pdev_hdl: pdev handle
  1856. */
  1857. static void dp_iterate_update_peer_list(struct cdp_pdev *pdev_hdl)
  1858. {
  1859. struct dp_pdev *pdev = (struct dp_pdev *)pdev_hdl;
  1860. dp_pdev_iterate_peer(pdev, dp_peer_cal_clients_stats_update, NULL,
  1861. DP_MOD_ID_CDP);
  1862. }
  1863. #else
  1864. static void dp_iterate_update_peer_list(struct cdp_pdev *pdev_hdl)
  1865. {
  1866. }
  1867. #endif
  1868. #ifdef ATH_SUPPORT_NAC
  1869. int dp_set_filter_neigh_peers(struct dp_pdev *pdev,
  1870. bool val)
  1871. {
  1872. /* Enable/Disable smart mesh filtering. This flag will be checked
  1873. * during rx processing to check if packets are from NAC clients.
  1874. */
  1875. pdev->monitor_pdev->filter_neighbour_peers = val;
  1876. return 0;
  1877. }
  1878. #endif /* ATH_SUPPORT_NAC */
  1879. #ifdef WLAN_ATF_ENABLE
  1880. void dp_set_atf_stats_enable(struct dp_pdev *pdev, bool value)
  1881. {
  1882. if (!pdev) {
  1883. dp_cdp_err("Invalid pdev");
  1884. return;
  1885. }
  1886. pdev->monitor_pdev->dp_atf_stats_enable = value;
  1887. }
  1888. #endif
  1889. #ifdef QCA_ENHANCED_STATS_SUPPORT
  1890. /*
  1891. * dp_process_ppdu_stats_tx_mgmtctrl_payload_tlv: Process
  1892. * htt_ppdu_stats_tx_mgmtctrl_payload_tlv
  1893. * @pdev: DP PDEV handle
  1894. * @tag_buf: buffer containing the htt_ppdu_stats_tx_mgmtctrl_payload_tlv
  1895. * @length: tlv_length
  1896. *
  1897. * return:QDF_STATUS_SUCCESS if nbuf has to be freed in caller
  1898. */
  1899. QDF_STATUS
  1900. dp_process_ppdu_stats_tx_mgmtctrl_payload_tlv(struct dp_pdev *pdev,
  1901. qdf_nbuf_t tag_buf,
  1902. uint32_t ppdu_id)
  1903. {
  1904. uint32_t *nbuf_ptr;
  1905. uint8_t trim_size;
  1906. size_t head_size;
  1907. struct cdp_tx_mgmt_comp_info *ptr_mgmt_comp_info;
  1908. uint32_t *msg_word;
  1909. uint32_t tsf_hdr;
  1910. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  1911. if ((!mon_pdev->tx_sniffer_enable) && (!mon_pdev->mcopy_mode) &&
  1912. (!mon_pdev->bpr_enable) && (!mon_pdev->tx_capture_enabled))
  1913. return QDF_STATUS_SUCCESS;
  1914. /*
  1915. * get timestamp from htt_t2h_ppdu_stats_ind_hdr_t
  1916. */
  1917. msg_word = (uint32_t *)qdf_nbuf_data(tag_buf);
  1918. msg_word = msg_word + 2;
  1919. tsf_hdr = *msg_word;
  1920. trim_size = ((mon_pdev->mgmtctrl_frm_info.mgmt_buf +
  1921. HTT_MGMT_CTRL_TLV_HDR_RESERVERD_LEN) -
  1922. qdf_nbuf_data(tag_buf));
  1923. if (!qdf_nbuf_pull_head(tag_buf, trim_size))
  1924. return QDF_STATUS_SUCCESS;
  1925. qdf_nbuf_trim_tail(tag_buf, qdf_nbuf_len(tag_buf) -
  1926. mon_pdev->mgmtctrl_frm_info.mgmt_buf_len);
  1927. if (mon_pdev->tx_capture_enabled) {
  1928. head_size = sizeof(struct cdp_tx_mgmt_comp_info);
  1929. if (qdf_unlikely(qdf_nbuf_headroom(tag_buf) < head_size)) {
  1930. qdf_err("Fail to get headroom h_sz %zu h_avail %d\n",
  1931. head_size, qdf_nbuf_headroom(tag_buf));
  1932. qdf_assert_always(0);
  1933. return QDF_STATUS_E_NOMEM;
  1934. }
  1935. ptr_mgmt_comp_info = (struct cdp_tx_mgmt_comp_info *)
  1936. qdf_nbuf_push_head(tag_buf, head_size);
  1937. qdf_assert_always(ptr_mgmt_comp_info);
  1938. ptr_mgmt_comp_info->ppdu_id = ppdu_id;
  1939. ptr_mgmt_comp_info->is_sgen_pkt = true;
  1940. ptr_mgmt_comp_info->tx_tsf = tsf_hdr;
  1941. } else {
  1942. head_size = sizeof(ppdu_id);
  1943. nbuf_ptr = (uint32_t *)qdf_nbuf_push_head(tag_buf, head_size);
  1944. *nbuf_ptr = ppdu_id;
  1945. }
  1946. if (mon_pdev->bpr_enable) {
  1947. dp_wdi_event_handler(WDI_EVENT_TX_BEACON, pdev->soc,
  1948. tag_buf, HTT_INVALID_PEER,
  1949. WDI_NO_VAL, pdev->pdev_id);
  1950. }
  1951. dp_deliver_mgmt_frm(pdev, tag_buf);
  1952. return QDF_STATUS_E_ALREADY;
  1953. }
  1954. /*
  1955. * dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap() - Get ppdu stats tlv
  1956. * bitmap for sniffer mode
  1957. * @bitmap: received bitmap
  1958. *
  1959. * Return: expected bitmap value, returns zero if doesn't match with
  1960. * either 64-bit Tx window or 256-bit window tlv bitmap
  1961. */
  1962. int
  1963. dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap(uint32_t bitmap)
  1964. {
  1965. if (bitmap == (HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_64))
  1966. return HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_64;
  1967. else if (bitmap == (HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_256))
  1968. return HTT_PPDU_SNIFFER_AMPDU_TLV_BITMAP_256;
  1969. return 0;
  1970. }
  1971. /*
  1972. * dp_peer_copy_delay_stats() - copy ppdu stats to peer delayed stats.
  1973. * @peer: Datapath peer handle
  1974. * @ppdu: User PPDU Descriptor
  1975. * @cur_ppdu_id: PPDU_ID
  1976. *
  1977. * Return: None
  1978. *
  1979. * on Tx data frame, we may get delayed ba set
  1980. * in htt_ppdu_stats_user_common_tlv. which mean we get Block Ack(BA) after we
  1981. * request Block Ack Request(BAR). Successful msdu is received only after Block
  1982. * Ack. To populate peer stats we need successful msdu(data frame).
  1983. * So we hold the Tx data stats on delayed_ba for stats update.
  1984. */
  1985. static void
  1986. dp_peer_copy_delay_stats(struct dp_peer *peer,
  1987. struct cdp_tx_completion_ppdu_user *ppdu,
  1988. uint32_t cur_ppdu_id)
  1989. {
  1990. struct dp_pdev *pdev;
  1991. struct dp_vdev *vdev;
  1992. struct dp_mon_peer *mon_peer = peer->monitor_peer;
  1993. if (mon_peer->last_delayed_ba) {
  1994. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  1995. "BA not yet recv for prev delayed ppdu[%d] - cur ppdu[%d]",
  1996. mon_peer->last_delayed_ba_ppduid, cur_ppdu_id);
  1997. vdev = peer->vdev;
  1998. if (vdev) {
  1999. pdev = vdev->pdev;
  2000. pdev->stats.cdp_delayed_ba_not_recev++;
  2001. }
  2002. }
  2003. mon_peer->delayed_ba_ppdu_stats.ltf_size = ppdu->ltf_size;
  2004. mon_peer->delayed_ba_ppdu_stats.stbc = ppdu->stbc;
  2005. mon_peer->delayed_ba_ppdu_stats.he_re = ppdu->he_re;
  2006. mon_peer->delayed_ba_ppdu_stats.txbf = ppdu->txbf;
  2007. mon_peer->delayed_ba_ppdu_stats.bw = ppdu->bw;
  2008. mon_peer->delayed_ba_ppdu_stats.nss = ppdu->nss;
  2009. mon_peer->delayed_ba_ppdu_stats.gi = ppdu->gi;
  2010. mon_peer->delayed_ba_ppdu_stats.dcm = ppdu->dcm;
  2011. mon_peer->delayed_ba_ppdu_stats.ldpc = ppdu->ldpc;
  2012. mon_peer->delayed_ba_ppdu_stats.dcm = ppdu->dcm;
  2013. mon_peer->delayed_ba_ppdu_stats.mpdu_tried_ucast =
  2014. ppdu->mpdu_tried_ucast;
  2015. mon_peer->delayed_ba_ppdu_stats.mpdu_tried_mcast =
  2016. ppdu->mpdu_tried_mcast;
  2017. mon_peer->delayed_ba_ppdu_stats.frame_ctrl = ppdu->frame_ctrl;
  2018. mon_peer->delayed_ba_ppdu_stats.qos_ctrl = ppdu->qos_ctrl;
  2019. mon_peer->delayed_ba_ppdu_stats.dcm = ppdu->dcm;
  2020. mon_peer->delayed_ba_ppdu_stats.ru_start = ppdu->ru_start;
  2021. mon_peer->delayed_ba_ppdu_stats.ru_tones = ppdu->ru_tones;
  2022. mon_peer->delayed_ba_ppdu_stats.is_mcast = ppdu->is_mcast;
  2023. mon_peer->delayed_ba_ppdu_stats.user_pos = ppdu->user_pos;
  2024. mon_peer->delayed_ba_ppdu_stats.mu_group_id = ppdu->mu_group_id;
  2025. mon_peer->last_delayed_ba = true;
  2026. ppdu->debug_copied = true;
  2027. }
  2028. /*
  2029. * dp_peer_copy_stats_to_bar() - copy delayed stats to ppdu stats.
  2030. * @peer: Datapath peer handle
  2031. * @ppdu: PPDU Descriptor
  2032. *
  2033. * Return: None
  2034. *
  2035. * For Tx BAR, PPDU stats TLV include Block Ack info. PPDU info
  2036. * from Tx BAR frame not required to populate peer stats.
  2037. * But we need successful MPDU and MSDU to update previous
  2038. * transmitted Tx data frame. Overwrite ppdu stats with the previous
  2039. * stored ppdu stats.
  2040. */
  2041. static void
  2042. dp_peer_copy_stats_to_bar(struct dp_peer *peer,
  2043. struct cdp_tx_completion_ppdu_user *ppdu)
  2044. {
  2045. struct dp_mon_peer *mon_peer = peer->monitor_peer;
  2046. ppdu->ltf_size = mon_peer->delayed_ba_ppdu_stats.ltf_size;
  2047. ppdu->stbc = mon_peer->delayed_ba_ppdu_stats.stbc;
  2048. ppdu->he_re = mon_peer->delayed_ba_ppdu_stats.he_re;
  2049. ppdu->txbf = mon_peer->delayed_ba_ppdu_stats.txbf;
  2050. ppdu->bw = mon_peer->delayed_ba_ppdu_stats.bw;
  2051. ppdu->nss = mon_peer->delayed_ba_ppdu_stats.nss;
  2052. ppdu->gi = mon_peer->delayed_ba_ppdu_stats.gi;
  2053. ppdu->dcm = mon_peer->delayed_ba_ppdu_stats.dcm;
  2054. ppdu->ldpc = mon_peer->delayed_ba_ppdu_stats.ldpc;
  2055. ppdu->dcm = mon_peer->delayed_ba_ppdu_stats.dcm;
  2056. ppdu->mpdu_tried_ucast =
  2057. mon_peer->delayed_ba_ppdu_stats.mpdu_tried_ucast;
  2058. ppdu->mpdu_tried_mcast =
  2059. mon_peer->delayed_ba_ppdu_stats.mpdu_tried_mcast;
  2060. ppdu->frame_ctrl = mon_peer->delayed_ba_ppdu_stats.frame_ctrl;
  2061. ppdu->qos_ctrl = mon_peer->delayed_ba_ppdu_stats.qos_ctrl;
  2062. ppdu->dcm = mon_peer->delayed_ba_ppdu_stats.dcm;
  2063. ppdu->ru_start = mon_peer->delayed_ba_ppdu_stats.ru_start;
  2064. ppdu->ru_tones = mon_peer->delayed_ba_ppdu_stats.ru_tones;
  2065. ppdu->is_mcast = mon_peer->delayed_ba_ppdu_stats.is_mcast;
  2066. ppdu->user_pos = mon_peer->delayed_ba_ppdu_stats.user_pos;
  2067. ppdu->mu_group_id = mon_peer->delayed_ba_ppdu_stats.mu_group_id;
  2068. mon_peer->last_delayed_ba = false;
  2069. ppdu->debug_copied = true;
  2070. }
  2071. /*
  2072. * dp_tx_rate_stats_update() - Update rate per-peer statistics
  2073. * @peer: Datapath peer handle
  2074. * @ppdu: PPDU Descriptor
  2075. *
  2076. * Return: None
  2077. */
  2078. static void
  2079. dp_tx_rate_stats_update(struct dp_peer *peer,
  2080. struct cdp_tx_completion_ppdu_user *ppdu)
  2081. {
  2082. uint32_t ratekbps = 0;
  2083. uint64_t ppdu_tx_rate = 0;
  2084. uint32_t rix;
  2085. uint16_t ratecode = 0;
  2086. struct dp_mon_peer *mon_peer = NULL;
  2087. if (!peer || !ppdu)
  2088. return;
  2089. if (ppdu->completion_status != HTT_PPDU_STATS_USER_STATUS_OK)
  2090. return;
  2091. mon_peer = peer->monitor_peer;
  2092. if (!mon_peer)
  2093. return;
  2094. ratekbps = dp_getrateindex(ppdu->gi,
  2095. ppdu->mcs,
  2096. ppdu->nss,
  2097. ppdu->preamble,
  2098. ppdu->bw,
  2099. ppdu->punc_mode,
  2100. &rix,
  2101. &ratecode);
  2102. if (!ratekbps)
  2103. return;
  2104. /* Calculate goodput in non-training period
  2105. * In training period, don't do anything as
  2106. * pending pkt is send as goodput.
  2107. */
  2108. if ((!peer->bss_peer) && (!ppdu->sa_is_training)) {
  2109. ppdu->sa_goodput = ((ratekbps / CDP_NUM_KB_IN_MB) *
  2110. (CDP_PERCENT_MACRO - ppdu->current_rate_per));
  2111. }
  2112. ppdu->rix = rix;
  2113. ppdu->tx_ratekbps = ratekbps;
  2114. ppdu->tx_ratecode = ratecode;
  2115. DP_STATS_UPD(mon_peer, tx.tx_rate, ratekbps);
  2116. mon_peer->stats.tx.avg_tx_rate =
  2117. dp_ath_rate_lpf(mon_peer->stats.tx.avg_tx_rate, ratekbps);
  2118. ppdu_tx_rate = dp_ath_rate_out(mon_peer->stats.tx.avg_tx_rate);
  2119. DP_STATS_UPD(mon_peer, tx.rnd_avg_tx_rate, ppdu_tx_rate);
  2120. mon_peer->stats.tx.bw_info = ppdu->bw;
  2121. mon_peer->stats.tx.gi_info = ppdu->gi;
  2122. mon_peer->stats.tx.nss_info = ppdu->nss;
  2123. mon_peer->stats.tx.mcs_info = ppdu->mcs;
  2124. mon_peer->stats.tx.preamble_info = ppdu->preamble;
  2125. if (peer->vdev) {
  2126. /*
  2127. * In STA mode:
  2128. * We get ucast stats as BSS peer stats.
  2129. *
  2130. * In AP mode:
  2131. * We get mcast stats as BSS peer stats.
  2132. * We get ucast stats as assoc peer stats.
  2133. */
  2134. if (peer->vdev->opmode == wlan_op_mode_ap && peer->bss_peer) {
  2135. peer->vdev->stats.tx.mcast_last_tx_rate = ratekbps;
  2136. peer->vdev->stats.tx.mcast_last_tx_rate_mcs = ppdu->mcs;
  2137. } else {
  2138. peer->vdev->stats.tx.last_tx_rate = ratekbps;
  2139. peer->vdev->stats.tx.last_tx_rate_mcs = ppdu->mcs;
  2140. }
  2141. }
  2142. }
  2143. #if defined(FEATURE_PERPKT_INFO) && defined(WDI_EVENT_ENABLE)
  2144. void dp_send_stats_event(struct dp_pdev *pdev, struct dp_peer *peer,
  2145. uint16_t peer_id)
  2146. {
  2147. struct cdp_interface_peer_stats peer_stats_intf;
  2148. struct dp_mon_peer *mon_peer = peer->monitor_peer;
  2149. struct dp_txrx_peer *txrx_peer = NULL;
  2150. if (!mon_peer)
  2151. return;
  2152. qdf_mem_zero(&peer_stats_intf,
  2153. sizeof(struct cdp_interface_peer_stats));
  2154. mon_peer->stats.rx.rx_snr_measured_time = qdf_system_ticks();
  2155. peer_stats_intf.rx_avg_snr = mon_peer->stats.rx.avg_snr;
  2156. txrx_peer = dp_get_txrx_peer(peer);
  2157. if (txrx_peer) {
  2158. peer_stats_intf.rx_byte_count = txrx_peer->to_stack.bytes;
  2159. peer_stats_intf.tx_byte_count =
  2160. txrx_peer->stats.per_pkt_stats.tx.tx_success.bytes;
  2161. }
  2162. dp_wdi_event_handler(WDI_EVENT_UPDATE_DP_STATS, pdev->soc,
  2163. &peer_stats_intf, peer_id,
  2164. UPDATE_PEER_STATS, pdev->pdev_id);
  2165. }
  2166. #endif
  2167. /*
  2168. * dp_get_ru_index_frm_ru_tones() - get ru index
  2169. * @ru_tones: ru tones
  2170. *
  2171. * Return: ru index
  2172. */
  2173. #ifdef WLAN_FEATURE_11BE
  2174. static inline enum cdp_ru_index dp_get_ru_index_frm_ru_tones(uint16_t ru_tones)
  2175. {
  2176. enum cdp_ru_index ru_index;
  2177. switch (ru_tones) {
  2178. case RU_26:
  2179. ru_index = RU_26_INDEX;
  2180. break;
  2181. case RU_52:
  2182. ru_index = RU_52_INDEX;
  2183. break;
  2184. case RU_52_26:
  2185. ru_index = RU_52_26_INDEX;
  2186. break;
  2187. case RU_106:
  2188. ru_index = RU_106_INDEX;
  2189. break;
  2190. case RU_106_26:
  2191. ru_index = RU_106_26_INDEX;
  2192. break;
  2193. case RU_242:
  2194. ru_index = RU_242_INDEX;
  2195. break;
  2196. case RU_484:
  2197. ru_index = RU_484_INDEX;
  2198. break;
  2199. case RU_484_242:
  2200. ru_index = RU_484_242_INDEX;
  2201. break;
  2202. case RU_996:
  2203. ru_index = RU_996_INDEX;
  2204. break;
  2205. case RU_996_484:
  2206. ru_index = RU_996_484_INDEX;
  2207. break;
  2208. case RU_996_484_242:
  2209. ru_index = RU_996_484_242_INDEX;
  2210. break;
  2211. case RU_2X996:
  2212. ru_index = RU_2X996_INDEX;
  2213. break;
  2214. case RU_2X996_484:
  2215. ru_index = RU_2X996_484_INDEX;
  2216. break;
  2217. case RU_3X996:
  2218. ru_index = RU_3X996_INDEX;
  2219. break;
  2220. case RU_3X996_484:
  2221. ru_index = RU_2X996_484_INDEX;
  2222. break;
  2223. case RU_4X996:
  2224. ru_index = RU_4X996_INDEX;
  2225. break;
  2226. default:
  2227. ru_index = RU_INDEX_MAX;
  2228. break;
  2229. }
  2230. return ru_index;
  2231. }
  2232. #else
  2233. static inline enum cdp_ru_index dp_get_ru_index_frm_ru_tones(uint16_t ru_tones)
  2234. {
  2235. enum cdp_ru_index ru_index;
  2236. switch (ru_tones) {
  2237. case RU_26:
  2238. ru_index = RU_26_INDEX;
  2239. break;
  2240. case RU_52:
  2241. ru_index = RU_52_INDEX;
  2242. break;
  2243. case RU_106:
  2244. ru_index = RU_106_INDEX;
  2245. break;
  2246. case RU_242:
  2247. ru_index = RU_242_INDEX;
  2248. break;
  2249. case RU_484:
  2250. ru_index = RU_484_INDEX;
  2251. break;
  2252. case RU_996:
  2253. ru_index = RU_996_INDEX;
  2254. break;
  2255. default:
  2256. ru_index = RU_INDEX_MAX;
  2257. break;
  2258. }
  2259. return ru_index;
  2260. }
  2261. #endif
  2262. /*
  2263. * dp_tx_stats_update() - Update per-peer statistics
  2264. * @pdev: Datapath pdev handle
  2265. * @peer: Datapath peer handle
  2266. * @ppdu: PPDU Descriptor
  2267. * @ack_rssi: RSSI of last ack received
  2268. *
  2269. * Return: None
  2270. */
  2271. static void
  2272. dp_tx_stats_update(struct dp_pdev *pdev, struct dp_peer *peer,
  2273. struct cdp_tx_completion_ppdu_user *ppdu,
  2274. uint32_t ack_rssi)
  2275. {
  2276. uint8_t preamble, mcs;
  2277. uint16_t num_msdu;
  2278. uint16_t num_mpdu;
  2279. uint16_t mpdu_tried;
  2280. uint16_t mpdu_failed;
  2281. struct dp_mon_ops *mon_ops;
  2282. enum cdp_ru_index ru_index;
  2283. struct dp_mon_peer *mon_peer = NULL;
  2284. uint32_t ratekbps = 0;
  2285. preamble = ppdu->preamble;
  2286. mcs = ppdu->mcs;
  2287. num_msdu = ppdu->num_msdu;
  2288. num_mpdu = ppdu->mpdu_success;
  2289. mpdu_tried = ppdu->mpdu_tried_ucast + ppdu->mpdu_tried_mcast;
  2290. mpdu_failed = mpdu_tried - num_mpdu;
  2291. /* If the peer statistics are already processed as part of
  2292. * per-MSDU completion handler, do not process these again in per-PPDU
  2293. * indications
  2294. */
  2295. if (pdev->soc->process_tx_status)
  2296. return;
  2297. mon_peer = peer->monitor_peer;
  2298. if (!mon_peer)
  2299. return;
  2300. if (ppdu->completion_status != HTT_PPDU_STATS_USER_STATUS_OK) {
  2301. /*
  2302. * All failed mpdu will be retried, so incrementing
  2303. * retries mpdu based on mpdu failed. Even for
  2304. * ack failure i.e for long retries we get
  2305. * mpdu failed equal mpdu tried.
  2306. */
  2307. DP_STATS_INC(mon_peer, tx.retries, mpdu_failed);
  2308. return;
  2309. }
  2310. if (ppdu->is_ppdu_cookie_valid)
  2311. DP_STATS_INC(mon_peer, tx.num_ppdu_cookie_valid, 1);
  2312. if (ppdu->mu_group_id <= MAX_MU_GROUP_ID &&
  2313. ppdu->ppdu_type != HTT_PPDU_STATS_PPDU_TYPE_SU) {
  2314. if (unlikely(!(ppdu->mu_group_id & (MAX_MU_GROUP_ID - 1))))
  2315. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  2316. "mu_group_id out of bound!!\n");
  2317. else
  2318. DP_STATS_UPD(mon_peer, tx.mu_group_id[ppdu->mu_group_id],
  2319. (ppdu->user_pos + 1));
  2320. }
  2321. if (ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_OFDMA ||
  2322. ppdu->ppdu_type == HTT_PPDU_STATS_PPDU_TYPE_MU_MIMO_OFDMA) {
  2323. DP_STATS_UPD(mon_peer, tx.ru_tones, ppdu->ru_tones);
  2324. DP_STATS_UPD(mon_peer, tx.ru_start, ppdu->ru_start);
  2325. ru_index = dp_get_ru_index_frm_ru_tones(ppdu->ru_tones);
  2326. if (ru_index != RU_INDEX_MAX) {
  2327. DP_STATS_INC(mon_peer, tx.ru_loc[ru_index].num_msdu,
  2328. num_msdu);
  2329. DP_STATS_INC(mon_peer, tx.ru_loc[ru_index].num_mpdu,
  2330. num_mpdu);
  2331. DP_STATS_INC(mon_peer, tx.ru_loc[ru_index].mpdu_tried,
  2332. mpdu_tried);
  2333. }
  2334. }
  2335. /*
  2336. * All failed mpdu will be retried, so incrementing
  2337. * retries mpdu based on mpdu failed. Even for
  2338. * ack failure i.e for long retries we get
  2339. * mpdu failed equal mpdu tried.
  2340. */
  2341. DP_STATS_INC(mon_peer, tx.retries, mpdu_failed);
  2342. DP_STATS_INC(mon_peer, tx.transmit_type[ppdu->ppdu_type].num_msdu,
  2343. num_msdu);
  2344. DP_STATS_INC(mon_peer, tx.transmit_type[ppdu->ppdu_type].num_mpdu,
  2345. num_mpdu);
  2346. DP_STATS_INC(mon_peer, tx.transmit_type[ppdu->ppdu_type].mpdu_tried,
  2347. mpdu_tried);
  2348. DP_STATS_INC(mon_peer, tx.sgi_count[ppdu->gi], num_msdu);
  2349. DP_STATS_INC(mon_peer, tx.bw[ppdu->bw], num_msdu);
  2350. DP_STATS_INC(mon_peer, tx.nss[ppdu->nss], num_msdu);
  2351. if (ppdu->tid < CDP_DATA_TID_MAX)
  2352. DP_STATS_INC(mon_peer, tx.wme_ac_type[TID_TO_WME_AC(ppdu->tid)],
  2353. num_msdu);
  2354. DP_STATS_INCC(mon_peer, tx.stbc, num_msdu, ppdu->stbc);
  2355. DP_STATS_INCC(mon_peer, tx.ldpc, num_msdu, ppdu->ldpc);
  2356. if (!(ppdu->is_mcast) && ppdu->ack_rssi_valid)
  2357. DP_STATS_UPD(mon_peer, tx.last_ack_rssi, ack_rssi);
  2358. DP_STATS_INCC(mon_peer,
  2359. tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
  2360. ((mcs >= MAX_MCS_11A) && (preamble == DOT11_A)));
  2361. DP_STATS_INCC(mon_peer,
  2362. tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
  2363. ((mcs < MAX_MCS_11A) && (preamble == DOT11_A)));
  2364. DP_STATS_INCC(mon_peer,
  2365. tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
  2366. ((mcs >= MAX_MCS_11B) && (preamble == DOT11_B)));
  2367. DP_STATS_INCC(mon_peer,
  2368. tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
  2369. ((mcs < (MAX_MCS_11B)) && (preamble == DOT11_B)));
  2370. DP_STATS_INCC(mon_peer,
  2371. tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
  2372. ((mcs >= MAX_MCS_11A) && (preamble == DOT11_N)));
  2373. DP_STATS_INCC(mon_peer,
  2374. tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
  2375. ((mcs < MAX_MCS_11A) && (preamble == DOT11_N)));
  2376. DP_STATS_INCC(mon_peer,
  2377. tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
  2378. ((mcs >= MAX_MCS_11AC) && (preamble == DOT11_AC)));
  2379. DP_STATS_INCC(mon_peer,
  2380. tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
  2381. ((mcs < MAX_MCS_11AC) && (preamble == DOT11_AC)));
  2382. DP_STATS_INCC(mon_peer,
  2383. tx.pkt_type[preamble].mcs_count[MAX_MCS - 1], num_msdu,
  2384. ((mcs >= MAX_MCS_11AX) && (preamble == DOT11_AX)));
  2385. DP_STATS_INCC(mon_peer,
  2386. tx.pkt_type[preamble].mcs_count[mcs], num_msdu,
  2387. ((mcs < MAX_MCS_11AX) && (preamble == DOT11_AX)));
  2388. DP_STATS_INCC(mon_peer, tx.ampdu_cnt, num_mpdu, ppdu->is_ampdu);
  2389. DP_STATS_INCC(mon_peer, tx.non_ampdu_cnt, num_mpdu, !(ppdu->is_ampdu));
  2390. DP_STATS_INCC(mon_peer, tx.pream_punct_cnt, 1, ppdu->pream_punct);
  2391. DP_STATS_INC(mon_peer, tx.tx_ppdus, 1);
  2392. DP_STATS_INC(mon_peer, tx.tx_mpdus_success, num_mpdu);
  2393. DP_STATS_INC(mon_peer, tx.tx_mpdus_tried, mpdu_tried);
  2394. mon_ops = dp_mon_ops_get(pdev->soc);
  2395. if (mon_ops && mon_ops->mon_tx_stats_update)
  2396. mon_ops->mon_tx_stats_update(mon_peer, ppdu);
  2397. dp_tx_rate_stats_update(peer, ppdu);
  2398. dp_peer_stats_notify(pdev, peer);
  2399. ratekbps = mon_peer->stats.tx.tx_rate;
  2400. DP_STATS_UPD(mon_peer, tx.last_tx_rate, ratekbps);
  2401. dp_send_stats_event(pdev, peer, ppdu->peer_id);
  2402. }
  2403. /*
  2404. * dp_get_ppdu_info_user_index: Find and allocate a per-user descriptor for a PPDU,
  2405. * if a new peer id arrives in a PPDU
  2406. * pdev: DP pdev handle
  2407. * @peer_id : peer unique identifier
  2408. * @ppdu_info: per ppdu tlv structure
  2409. *
  2410. * return:user index to be populated
  2411. */
  2412. static uint8_t dp_get_ppdu_info_user_index(struct dp_pdev *pdev,
  2413. uint16_t peer_id,
  2414. struct ppdu_info *ppdu_info)
  2415. {
  2416. uint8_t user_index = 0;
  2417. struct cdp_tx_completion_ppdu *ppdu_desc;
  2418. struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
  2419. ppdu_desc =
  2420. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  2421. while ((user_index + 1) <= ppdu_info->last_user) {
  2422. ppdu_user_desc = &ppdu_desc->user[user_index];
  2423. if (ppdu_user_desc->peer_id != peer_id) {
  2424. user_index++;
  2425. continue;
  2426. } else {
  2427. /* Max users possible is 8 so user array index should
  2428. * not exceed 7
  2429. */
  2430. qdf_assert_always(user_index <= (ppdu_desc->max_users - 1));
  2431. return user_index;
  2432. }
  2433. }
  2434. ppdu_info->last_user++;
  2435. /* Max users possible is 8 so last user should not exceed 8 */
  2436. qdf_assert_always(ppdu_info->last_user <= ppdu_desc->max_users);
  2437. return ppdu_info->last_user - 1;
  2438. }
  2439. /*
  2440. * dp_process_ppdu_stats_common_tlv: Process htt_ppdu_stats_common_tlv
  2441. * pdev: DP pdev handle
  2442. * @tag_buf: buffer containing the tlv htt_ppdu_stats_common_tlv
  2443. * @ppdu_info: per ppdu tlv structure
  2444. *
  2445. * return:void
  2446. */
  2447. static void
  2448. dp_process_ppdu_stats_common_tlv(struct dp_pdev *pdev,
  2449. uint32_t *tag_buf,
  2450. struct ppdu_info *ppdu_info)
  2451. {
  2452. uint16_t frame_type;
  2453. uint16_t frame_ctrl;
  2454. uint16_t freq;
  2455. struct dp_soc *soc = NULL;
  2456. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  2457. uint64_t ppdu_start_timestamp;
  2458. uint32_t *start_tag_buf;
  2459. start_tag_buf = tag_buf;
  2460. ppdu_desc =
  2461. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  2462. ppdu_desc->ppdu_id = ppdu_info->ppdu_id;
  2463. tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(RING_ID_SCH_CMD_ID);
  2464. ppdu_info->sched_cmdid =
  2465. HTT_PPDU_STATS_COMMON_TLV_SCH_CMDID_GET(*tag_buf);
  2466. ppdu_desc->num_users =
  2467. HTT_PPDU_STATS_COMMON_TLV_NUM_USERS_GET(*tag_buf);
  2468. qdf_assert_always(ppdu_desc->num_users <= ppdu_desc->max_users);
  2469. tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(QTYPE_FRM_TYPE);
  2470. frame_type = HTT_PPDU_STATS_COMMON_TLV_FRM_TYPE_GET(*tag_buf);
  2471. ppdu_desc->htt_frame_type = frame_type;
  2472. frame_ctrl = ppdu_desc->frame_ctrl;
  2473. ppdu_desc->bar_ppdu_id = ppdu_info->ppdu_id;
  2474. switch (frame_type) {
  2475. case HTT_STATS_FTYPE_TIDQ_DATA_SU:
  2476. case HTT_STATS_FTYPE_TIDQ_DATA_MU:
  2477. case HTT_STATS_FTYPE_SGEN_QOS_NULL:
  2478. /*
  2479. * for management packet, frame type come as DATA_SU
  2480. * need to check frame_ctrl before setting frame_type
  2481. */
  2482. if (HTT_GET_FRAME_CTRL_TYPE(frame_ctrl) <= FRAME_CTRL_TYPE_CTRL)
  2483. ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
  2484. else
  2485. ppdu_desc->frame_type = CDP_PPDU_FTYPE_DATA;
  2486. break;
  2487. case HTT_STATS_FTYPE_SGEN_MU_BAR:
  2488. case HTT_STATS_FTYPE_SGEN_BAR:
  2489. ppdu_desc->frame_type = CDP_PPDU_FTYPE_BAR;
  2490. break;
  2491. default:
  2492. ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
  2493. break;
  2494. }
  2495. tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(FES_DUR_US);
  2496. ppdu_desc->tx_duration = *tag_buf;
  2497. tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(START_TSTMP_L32_US);
  2498. ppdu_desc->ppdu_start_timestamp = *tag_buf;
  2499. tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(CHAN_MHZ_PHY_MODE);
  2500. freq = HTT_PPDU_STATS_COMMON_TLV_CHAN_MHZ_GET(*tag_buf);
  2501. if (freq != ppdu_desc->channel) {
  2502. soc = pdev->soc;
  2503. ppdu_desc->channel = freq;
  2504. pdev->operating_channel.freq = freq;
  2505. if (soc && soc->cdp_soc.ol_ops->freq_to_channel)
  2506. pdev->operating_channel.num =
  2507. soc->cdp_soc.ol_ops->freq_to_channel(soc->ctrl_psoc,
  2508. pdev->pdev_id,
  2509. freq);
  2510. if (soc && soc->cdp_soc.ol_ops->freq_to_band)
  2511. pdev->operating_channel.band =
  2512. soc->cdp_soc.ol_ops->freq_to_band(soc->ctrl_psoc,
  2513. pdev->pdev_id,
  2514. freq);
  2515. }
  2516. ppdu_desc->phy_mode = HTT_PPDU_STATS_COMMON_TLV_PHY_MODE_GET(*tag_buf);
  2517. tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(RESV_NUM_UL_BEAM);
  2518. ppdu_desc->phy_ppdu_tx_time_us =
  2519. HTT_PPDU_STATS_COMMON_TLV_PHY_PPDU_TX_TIME_US_GET(*tag_buf);
  2520. ppdu_desc->beam_change =
  2521. HTT_PPDU_STATS_COMMON_TLV_BEAM_CHANGE_GET(*tag_buf);
  2522. ppdu_desc->doppler =
  2523. HTT_PPDU_STATS_COMMON_TLV_DOPPLER_INDICATION_GET(*tag_buf);
  2524. ppdu_desc->spatial_reuse =
  2525. HTT_PPDU_STATS_COMMON_TLV_SPATIAL_REUSE_GET(*tag_buf);
  2526. dp_tx_capture_htt_frame_counter(pdev, frame_type);
  2527. tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(START_TSTMP_U32_US);
  2528. ppdu_start_timestamp = *tag_buf;
  2529. ppdu_desc->ppdu_start_timestamp |= ((ppdu_start_timestamp <<
  2530. HTT_SHIFT_UPPER_TIMESTAMP) &
  2531. HTT_MASK_UPPER_TIMESTAMP);
  2532. ppdu_desc->ppdu_end_timestamp = ppdu_desc->ppdu_start_timestamp +
  2533. ppdu_desc->tx_duration;
  2534. /* Ack time stamp is same as end time stamp*/
  2535. ppdu_desc->ack_timestamp = ppdu_desc->ppdu_end_timestamp;
  2536. ppdu_desc->ppdu_end_timestamp = ppdu_desc->ppdu_start_timestamp +
  2537. ppdu_desc->tx_duration;
  2538. ppdu_desc->bar_ppdu_start_timestamp = ppdu_desc->ppdu_start_timestamp;
  2539. ppdu_desc->bar_ppdu_end_timestamp = ppdu_desc->ppdu_end_timestamp;
  2540. ppdu_desc->bar_tx_duration = ppdu_desc->tx_duration;
  2541. /* Ack time stamp is same as end time stamp*/
  2542. ppdu_desc->ack_timestamp = ppdu_desc->ppdu_end_timestamp;
  2543. tag_buf = start_tag_buf + HTT_GET_STATS_CMN_INDEX(BSSCOLOR_OBSS_PSR);
  2544. ppdu_desc->bss_color =
  2545. HTT_PPDU_STATS_COMMON_TLV_BSS_COLOR_ID_GET(*tag_buf);
  2546. }
  2547. /*
  2548. * dp_process_ppdu_stats_user_common_tlv: Process ppdu_stats_user_common
  2549. * @tag_buf: buffer containing the tlv htt_ppdu_stats_user_common_tlv
  2550. * @ppdu_info: per ppdu tlv structure
  2551. *
  2552. * return:void
  2553. */
  2554. static void dp_process_ppdu_stats_user_common_tlv(
  2555. struct dp_pdev *pdev, uint32_t *tag_buf,
  2556. struct ppdu_info *ppdu_info)
  2557. {
  2558. uint16_t peer_id;
  2559. struct cdp_tx_completion_ppdu *ppdu_desc;
  2560. struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
  2561. uint8_t curr_user_index = 0;
  2562. struct dp_peer *peer;
  2563. struct dp_vdev *vdev;
  2564. uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
  2565. ppdu_desc =
  2566. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  2567. tag_buf++;
  2568. peer_id = HTT_PPDU_STATS_USER_RATE_TLV_SW_PEER_ID_GET(*tag_buf);
  2569. curr_user_index =
  2570. dp_get_ppdu_info_user_index(pdev,
  2571. peer_id, ppdu_info);
  2572. ppdu_user_desc = &ppdu_desc->user[curr_user_index];
  2573. ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
  2574. ppdu_desc->vdev_id =
  2575. HTT_PPDU_STATS_USER_COMMON_TLV_VAP_ID_GET(*tag_buf);
  2576. ppdu_user_desc->peer_id = peer_id;
  2577. tag_buf++;
  2578. if (HTT_PPDU_STATS_USER_COMMON_TLV_DELAYED_BA_GET(*tag_buf)) {
  2579. ppdu_user_desc->delayed_ba = 1;
  2580. ppdu_desc->delayed_ba = 1;
  2581. }
  2582. if (HTT_PPDU_STATS_USER_COMMON_TLV_MCAST_GET(*tag_buf)) {
  2583. ppdu_user_desc->is_mcast = true;
  2584. ppdu_user_desc->mpdu_tried_mcast =
  2585. HTT_PPDU_STATS_USER_COMMON_TLV_MPDUS_TRIED_GET(*tag_buf);
  2586. ppdu_user_desc->num_mpdu = ppdu_user_desc->mpdu_tried_mcast;
  2587. } else {
  2588. ppdu_user_desc->mpdu_tried_ucast =
  2589. HTT_PPDU_STATS_USER_COMMON_TLV_MPDUS_TRIED_GET(*tag_buf);
  2590. }
  2591. ppdu_user_desc->is_seq_num_valid =
  2592. HTT_PPDU_STATS_USER_COMMON_TLV_IS_SQNUM_VALID_IN_BUFFER_GET(*tag_buf);
  2593. tag_buf++;
  2594. ppdu_user_desc->qos_ctrl =
  2595. HTT_PPDU_STATS_USER_COMMON_TLV_QOS_CTRL_GET(*tag_buf);
  2596. ppdu_user_desc->frame_ctrl =
  2597. HTT_PPDU_STATS_USER_COMMON_TLV_FRAME_CTRL_GET(*tag_buf);
  2598. ppdu_desc->frame_ctrl = ppdu_user_desc->frame_ctrl;
  2599. if (ppdu_user_desc->delayed_ba)
  2600. ppdu_user_desc->mpdu_success = 0;
  2601. tag_buf += 3;
  2602. if (HTT_PPDU_STATS_IS_OPAQUE_VALID_GET(*tag_buf)) {
  2603. ppdu_user_desc->ppdu_cookie =
  2604. HTT_PPDU_STATS_HOST_OPAQUE_COOKIE_GET(*tag_buf);
  2605. ppdu_user_desc->is_ppdu_cookie_valid = 1;
  2606. }
  2607. /* returning earlier causes other feilds unpopulated */
  2608. if (peer_id == DP_SCAN_PEER_ID) {
  2609. vdev = dp_vdev_get_ref_by_id(pdev->soc, ppdu_desc->vdev_id,
  2610. DP_MOD_ID_TX_PPDU_STATS);
  2611. if (!vdev)
  2612. return;
  2613. qdf_mem_copy(ppdu_user_desc->mac_addr, vdev->mac_addr.raw,
  2614. QDF_MAC_ADDR_SIZE);
  2615. dp_vdev_unref_delete(pdev->soc, vdev, DP_MOD_ID_TX_PPDU_STATS);
  2616. } else {
  2617. peer = dp_peer_get_ref_by_id(pdev->soc, peer_id,
  2618. DP_MOD_ID_TX_PPDU_STATS);
  2619. if (!peer) {
  2620. /*
  2621. * fw sends peer_id which is about to removed but
  2622. * it was already removed in host.
  2623. * eg: for disassoc, fw send ppdu stats
  2624. * with peer id equal to previously associated
  2625. * peer's peer_id but it was removed
  2626. */
  2627. vdev = dp_vdev_get_ref_by_id(pdev->soc,
  2628. ppdu_desc->vdev_id,
  2629. DP_MOD_ID_TX_PPDU_STATS);
  2630. if (!vdev)
  2631. return;
  2632. qdf_mem_copy(ppdu_user_desc->mac_addr,
  2633. vdev->mac_addr.raw, QDF_MAC_ADDR_SIZE);
  2634. dp_vdev_unref_delete(pdev->soc, vdev,
  2635. DP_MOD_ID_TX_PPDU_STATS);
  2636. return;
  2637. }
  2638. qdf_mem_copy(ppdu_user_desc->mac_addr,
  2639. peer->mac_addr.raw, QDF_MAC_ADDR_SIZE);
  2640. dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
  2641. }
  2642. }
  2643. /**
  2644. * dp_process_ppdu_stats_user_rate_tlv() - Process htt_ppdu_stats_user_rate_tlv
  2645. * @pdev: DP pdev handle
  2646. * @tag_buf: T2H message buffer carrying the user rate TLV
  2647. * @ppdu_info: per ppdu tlv structure
  2648. *
  2649. * return:void
  2650. */
  2651. static void
  2652. dp_process_ppdu_stats_user_rate_tlv(struct dp_pdev *pdev,
  2653. uint32_t *tag_buf,
  2654. struct ppdu_info *ppdu_info)
  2655. {
  2656. uint16_t peer_id;
  2657. struct cdp_tx_completion_ppdu *ppdu_desc;
  2658. struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
  2659. uint8_t curr_user_index = 0;
  2660. struct dp_vdev *vdev;
  2661. uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
  2662. uint8_t bw;
  2663. ppdu_desc =
  2664. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  2665. tag_buf++;
  2666. peer_id = HTT_PPDU_STATS_USER_RATE_TLV_SW_PEER_ID_GET(*tag_buf);
  2667. curr_user_index =
  2668. dp_get_ppdu_info_user_index(pdev,
  2669. peer_id, ppdu_info);
  2670. ppdu_user_desc = &ppdu_desc->user[curr_user_index];
  2671. ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
  2672. if (peer_id == DP_SCAN_PEER_ID) {
  2673. vdev = dp_vdev_get_ref_by_id(pdev->soc, ppdu_desc->vdev_id,
  2674. DP_MOD_ID_TX_PPDU_STATS);
  2675. if (!vdev)
  2676. return;
  2677. dp_vdev_unref_delete(pdev->soc, vdev,
  2678. DP_MOD_ID_TX_PPDU_STATS);
  2679. }
  2680. ppdu_user_desc->peer_id = peer_id;
  2681. ppdu_user_desc->tid =
  2682. HTT_PPDU_STATS_USER_RATE_TLV_TID_NUM_GET(*tag_buf);
  2683. tag_buf += 1;
  2684. ppdu_user_desc->user_pos =
  2685. HTT_PPDU_STATS_USER_RATE_TLV_USER_POS_GET(*tag_buf);
  2686. ppdu_user_desc->mu_group_id =
  2687. HTT_PPDU_STATS_USER_RATE_TLV_MU_GROUPID_GET(*tag_buf);
  2688. tag_buf += 1;
  2689. ppdu_user_desc->ru_start =
  2690. HTT_PPDU_STATS_USER_RATE_TLV_RU_START_GET(*tag_buf);
  2691. ppdu_user_desc->ru_tones =
  2692. (HTT_PPDU_STATS_USER_RATE_TLV_RU_END_GET(*tag_buf) -
  2693. HTT_PPDU_STATS_USER_RATE_TLV_RU_START_GET(*tag_buf)) + 1;
  2694. ppdu_desc->usr_ru_tones_sum += ppdu_user_desc->ru_tones;
  2695. tag_buf += 2;
  2696. ppdu_user_desc->ppdu_type =
  2697. HTT_PPDU_STATS_USER_RATE_TLV_PPDU_TYPE_GET(*tag_buf);
  2698. tag_buf++;
  2699. ppdu_user_desc->tx_rate = *tag_buf;
  2700. ppdu_user_desc->ltf_size =
  2701. HTT_PPDU_STATS_USER_RATE_TLV_LTF_SIZE_GET(*tag_buf);
  2702. ppdu_user_desc->stbc =
  2703. HTT_PPDU_STATS_USER_RATE_TLV_STBC_GET(*tag_buf);
  2704. ppdu_user_desc->he_re =
  2705. HTT_PPDU_STATS_USER_RATE_TLV_HE_RE_GET(*tag_buf);
  2706. ppdu_user_desc->txbf =
  2707. HTT_PPDU_STATS_USER_RATE_TLV_TXBF_GET(*tag_buf);
  2708. bw = HTT_PPDU_STATS_USER_RATE_TLV_BW_GET(*tag_buf);
  2709. /* Align bw value as per host data structures */
  2710. if (bw == HTT_PPDU_STATS_BANDWIDTH_320MHZ)
  2711. ppdu_user_desc->bw = bw - 3;
  2712. else
  2713. ppdu_user_desc->bw = bw - 2;
  2714. ppdu_user_desc->nss = HTT_PPDU_STATS_USER_RATE_TLV_NSS_GET(*tag_buf);
  2715. ppdu_desc->usr_nss_sum += ppdu_user_desc->nss;
  2716. ppdu_user_desc->mcs = HTT_PPDU_STATS_USER_RATE_TLV_MCS_GET(*tag_buf);
  2717. ppdu_user_desc->preamble =
  2718. HTT_PPDU_STATS_USER_RATE_TLV_PREAMBLE_GET(*tag_buf);
  2719. ppdu_user_desc->gi = HTT_PPDU_STATS_USER_RATE_TLV_GI_GET(*tag_buf);
  2720. ppdu_user_desc->dcm = HTT_PPDU_STATS_USER_RATE_TLV_DCM_GET(*tag_buf);
  2721. ppdu_user_desc->ldpc = HTT_PPDU_STATS_USER_RATE_TLV_LDPC_GET(*tag_buf);
  2722. }
  2723. /*
  2724. * dp_process_ppdu_stats_enq_mpdu_bitmap_64_tlv: Process
  2725. * htt_ppdu_stats_enq_mpdu_bitmap_64_tlv
  2726. * pdev: DP PDEV handle
  2727. * @tag_buf: buffer containing the tlv htt_ppdu_stats_enq_mpdu_bitmap_64_tlv
  2728. * @ppdu_info: per ppdu tlv structure
  2729. *
  2730. * return:void
  2731. */
  2732. static void dp_process_ppdu_stats_enq_mpdu_bitmap_64_tlv(
  2733. struct dp_pdev *pdev, uint32_t *tag_buf,
  2734. struct ppdu_info *ppdu_info)
  2735. {
  2736. htt_ppdu_stats_enq_mpdu_bitmap_64_tlv *dp_stats_buf =
  2737. (htt_ppdu_stats_enq_mpdu_bitmap_64_tlv *)tag_buf;
  2738. struct cdp_tx_completion_ppdu *ppdu_desc;
  2739. struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
  2740. uint8_t curr_user_index = 0;
  2741. uint16_t peer_id;
  2742. uint32_t size = CDP_BA_64_BIT_MAP_SIZE_DWORDS;
  2743. uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
  2744. ppdu_desc =
  2745. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  2746. tag_buf++;
  2747. peer_id =
  2748. HTT_PPDU_STATS_ENQ_MPDU_BITMAP_TLV_SW_PEER_ID_GET(*tag_buf);
  2749. curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
  2750. ppdu_user_desc = &ppdu_desc->user[curr_user_index];
  2751. ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
  2752. ppdu_user_desc->peer_id = peer_id;
  2753. ppdu_user_desc->start_seq = dp_stats_buf->start_seq;
  2754. qdf_mem_copy(&ppdu_user_desc->enq_bitmap, &dp_stats_buf->enq_bitmap,
  2755. sizeof(uint32_t) * CDP_BA_64_BIT_MAP_SIZE_DWORDS);
  2756. dp_process_ppdu_stats_update_failed_bitmap(pdev,
  2757. (void *)ppdu_user_desc,
  2758. ppdu_info->ppdu_id,
  2759. size);
  2760. }
  2761. /*
  2762. * dp_process_ppdu_stats_enq_mpdu_bitmap_256_tlv: Process
  2763. * htt_ppdu_stats_enq_mpdu_bitmap_256_tlv
  2764. * soc: DP SOC handle
  2765. * @tag_buf: buffer containing the tlv htt_ppdu_stats_enq_mpdu_bitmap_256_tlv
  2766. * @ppdu_info: per ppdu tlv structure
  2767. *
  2768. * return:void
  2769. */
  2770. static void dp_process_ppdu_stats_enq_mpdu_bitmap_256_tlv(
  2771. struct dp_pdev *pdev, uint32_t *tag_buf,
  2772. struct ppdu_info *ppdu_info)
  2773. {
  2774. htt_ppdu_stats_enq_mpdu_bitmap_256_tlv *dp_stats_buf =
  2775. (htt_ppdu_stats_enq_mpdu_bitmap_256_tlv *)tag_buf;
  2776. struct cdp_tx_completion_ppdu *ppdu_desc;
  2777. struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
  2778. uint8_t curr_user_index = 0;
  2779. uint16_t peer_id;
  2780. uint32_t size = CDP_BA_256_BIT_MAP_SIZE_DWORDS;
  2781. uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
  2782. ppdu_desc =
  2783. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  2784. tag_buf++;
  2785. peer_id =
  2786. HTT_PPDU_STATS_ENQ_MPDU_BITMAP_TLV_SW_PEER_ID_GET(*tag_buf);
  2787. curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
  2788. ppdu_user_desc = &ppdu_desc->user[curr_user_index];
  2789. ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
  2790. ppdu_user_desc->peer_id = peer_id;
  2791. ppdu_user_desc->start_seq = dp_stats_buf->start_seq;
  2792. qdf_mem_copy(&ppdu_user_desc->enq_bitmap, &dp_stats_buf->enq_bitmap,
  2793. sizeof(uint32_t) * CDP_BA_256_BIT_MAP_SIZE_DWORDS);
  2794. dp_process_ppdu_stats_update_failed_bitmap(pdev,
  2795. (void *)ppdu_user_desc,
  2796. ppdu_info->ppdu_id,
  2797. size);
  2798. }
  2799. /*
  2800. * dp_process_ppdu_stats_user_cmpltn_common_tlv: Process
  2801. * htt_ppdu_stats_user_cmpltn_common_tlv
  2802. * soc: DP SOC handle
  2803. * @tag_buf: buffer containing the tlv htt_ppdu_stats_user_cmpltn_common_tlv
  2804. * @ppdu_info: per ppdu tlv structure
  2805. *
  2806. * return:void
  2807. */
  2808. static void dp_process_ppdu_stats_user_cmpltn_common_tlv(
  2809. struct dp_pdev *pdev, uint32_t *tag_buf,
  2810. struct ppdu_info *ppdu_info)
  2811. {
  2812. uint16_t peer_id;
  2813. struct cdp_tx_completion_ppdu *ppdu_desc;
  2814. struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
  2815. uint8_t curr_user_index = 0;
  2816. uint8_t bw_iter;
  2817. htt_ppdu_stats_user_cmpltn_common_tlv *dp_stats_buf =
  2818. (htt_ppdu_stats_user_cmpltn_common_tlv *)tag_buf;
  2819. uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
  2820. ppdu_desc =
  2821. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  2822. tag_buf++;
  2823. peer_id =
  2824. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_SW_PEER_ID_GET(*tag_buf);
  2825. curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
  2826. ppdu_user_desc = &ppdu_desc->user[curr_user_index];
  2827. ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
  2828. ppdu_user_desc->peer_id = peer_id;
  2829. ppdu_user_desc->completion_status =
  2830. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_COMPLETION_STATUS_GET(
  2831. *tag_buf);
  2832. ppdu_user_desc->tid =
  2833. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_TID_NUM_GET(*tag_buf);
  2834. tag_buf++;
  2835. if (qdf_likely(ppdu_user_desc->completion_status ==
  2836. HTT_PPDU_STATS_USER_STATUS_OK)) {
  2837. ppdu_desc->ack_rssi = dp_stats_buf->ack_rssi;
  2838. ppdu_user_desc->usr_ack_rssi = dp_stats_buf->ack_rssi;
  2839. ppdu_user_desc->ack_rssi_valid = 1;
  2840. } else {
  2841. ppdu_user_desc->ack_rssi_valid = 0;
  2842. }
  2843. tag_buf++;
  2844. ppdu_user_desc->mpdu_success =
  2845. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_MPDU_SUCCESS_GET(*tag_buf);
  2846. ppdu_user_desc->mpdu_failed =
  2847. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_MPDU_TRIED_GET(*tag_buf) -
  2848. ppdu_user_desc->mpdu_success;
  2849. tag_buf++;
  2850. ppdu_user_desc->long_retries =
  2851. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_LONG_RETRY_GET(*tag_buf);
  2852. ppdu_user_desc->short_retries =
  2853. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_SHORT_RETRY_GET(*tag_buf);
  2854. ppdu_user_desc->retry_mpdus =
  2855. ppdu_user_desc->long_retries + ppdu_user_desc->short_retries;
  2856. ppdu_user_desc->is_ampdu =
  2857. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_IS_AMPDU_GET(*tag_buf);
  2858. ppdu_info->is_ampdu = ppdu_user_desc->is_ampdu;
  2859. ppdu_desc->resp_type =
  2860. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_RESP_TYPE_GET(*tag_buf);
  2861. ppdu_desc->mprot_type =
  2862. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_MPROT_TYPE_GET(*tag_buf);
  2863. ppdu_desc->rts_success =
  2864. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_RTS_SUCCESS_GET(*tag_buf);
  2865. ppdu_desc->rts_failure =
  2866. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_RTS_FAILURE_GET(*tag_buf);
  2867. ppdu_user_desc->pream_punct =
  2868. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_PREAM_PUNC_TX_GET(*tag_buf);
  2869. ppdu_info->compltn_common_tlv++;
  2870. /*
  2871. * MU BAR may send request to n users but we may received ack only from
  2872. * m users. To have count of number of users respond back, we have a
  2873. * separate counter bar_num_users per PPDU that get increment for every
  2874. * htt_ppdu_stats_user_cmpltn_common_tlv
  2875. */
  2876. ppdu_desc->bar_num_users++;
  2877. tag_buf++;
  2878. for (bw_iter = 0; bw_iter < CDP_RSSI_CHAIN_LEN; bw_iter++) {
  2879. ppdu_user_desc->rssi_chain[bw_iter] =
  2880. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_CHAIN_RSSI_GET(*tag_buf);
  2881. tag_buf++;
  2882. }
  2883. ppdu_user_desc->sa_tx_antenna =
  2884. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_TX_ANTENNA_MASK_GET(*tag_buf);
  2885. tag_buf++;
  2886. ppdu_user_desc->sa_is_training =
  2887. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_IS_TRAINING_GET(*tag_buf);
  2888. if (ppdu_user_desc->sa_is_training) {
  2889. ppdu_user_desc->sa_goodput =
  2890. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_PENDING_TRAINING_PKTS_GET(*tag_buf);
  2891. }
  2892. tag_buf++;
  2893. for (bw_iter = 0; bw_iter < CDP_NUM_SA_BW; bw_iter++) {
  2894. ppdu_user_desc->sa_max_rates[bw_iter] =
  2895. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_MAX_RATES_GET(tag_buf[bw_iter]);
  2896. }
  2897. tag_buf += CDP_NUM_SA_BW;
  2898. ppdu_user_desc->current_rate_per =
  2899. HTT_PPDU_STATS_USER_CMPLTN_COMMON_TLV_CURRENT_RATE_PER_GET(*tag_buf);
  2900. }
  2901. /*
  2902. * dp_process_ppdu_stats_user_compltn_ba_bitmap_64_tlv: Process
  2903. * htt_ppdu_stats_user_compltn_ba_bitmap_64_tlv
  2904. * pdev: DP PDEV handle
  2905. * @tag_buf: buffer containing the htt_ppdu_stats_user_compltn_ba_bitmap_64_tlv
  2906. * @ppdu_info: per ppdu tlv structure
  2907. *
  2908. * return:void
  2909. */
  2910. static void dp_process_ppdu_stats_user_compltn_ba_bitmap_64_tlv(
  2911. struct dp_pdev *pdev, uint32_t *tag_buf,
  2912. struct ppdu_info *ppdu_info)
  2913. {
  2914. htt_ppdu_stats_user_compltn_ba_bitmap_64_tlv *dp_stats_buf =
  2915. (htt_ppdu_stats_user_compltn_ba_bitmap_64_tlv *)tag_buf;
  2916. struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
  2917. struct cdp_tx_completion_ppdu *ppdu_desc;
  2918. uint8_t curr_user_index = 0;
  2919. uint16_t peer_id;
  2920. uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
  2921. ppdu_desc =
  2922. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  2923. tag_buf++;
  2924. peer_id =
  2925. HTT_PPDU_STATS_USER_CMPLTN_BA_BITMAP_TLV_SW_PEER_ID_GET(*tag_buf);
  2926. curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
  2927. ppdu_user_desc = &ppdu_desc->user[curr_user_index];
  2928. ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
  2929. ppdu_user_desc->peer_id = peer_id;
  2930. ppdu_user_desc->ba_seq_no = dp_stats_buf->ba_seq_no;
  2931. qdf_mem_copy(&ppdu_user_desc->ba_bitmap, &dp_stats_buf->ba_bitmap,
  2932. sizeof(uint32_t) * CDP_BA_64_BIT_MAP_SIZE_DWORDS);
  2933. ppdu_user_desc->ba_size = CDP_BA_64_BIT_MAP_SIZE_DWORDS * 32;
  2934. }
  2935. /*
  2936. * dp_process_ppdu_stats_user_compltn_ba_bitmap_256_tlv: Process
  2937. * htt_ppdu_stats_user_compltn_ba_bitmap_256_tlv
  2938. * pdev: DP PDEV handle
  2939. * @tag_buf: buffer containing the htt_ppdu_stats_user_compltn_ba_bitmap_256_tlv
  2940. * @ppdu_info: per ppdu tlv structure
  2941. *
  2942. * return:void
  2943. */
  2944. static void dp_process_ppdu_stats_user_compltn_ba_bitmap_256_tlv(
  2945. struct dp_pdev *pdev, uint32_t *tag_buf,
  2946. struct ppdu_info *ppdu_info)
  2947. {
  2948. htt_ppdu_stats_user_compltn_ba_bitmap_256_tlv *dp_stats_buf =
  2949. (htt_ppdu_stats_user_compltn_ba_bitmap_256_tlv *)tag_buf;
  2950. struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
  2951. struct cdp_tx_completion_ppdu *ppdu_desc;
  2952. uint8_t curr_user_index = 0;
  2953. uint16_t peer_id;
  2954. uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
  2955. ppdu_desc =
  2956. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  2957. tag_buf++;
  2958. peer_id =
  2959. HTT_PPDU_STATS_USER_CMPLTN_BA_BITMAP_TLV_SW_PEER_ID_GET(*tag_buf);
  2960. curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
  2961. ppdu_user_desc = &ppdu_desc->user[curr_user_index];
  2962. ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
  2963. ppdu_user_desc->peer_id = peer_id;
  2964. ppdu_user_desc->ba_seq_no = dp_stats_buf->ba_seq_no;
  2965. qdf_mem_copy(&ppdu_user_desc->ba_bitmap, &dp_stats_buf->ba_bitmap,
  2966. sizeof(uint32_t) * CDP_BA_256_BIT_MAP_SIZE_DWORDS);
  2967. ppdu_user_desc->ba_size = CDP_BA_256_BIT_MAP_SIZE_DWORDS * 32;
  2968. }
  2969. /*
  2970. * dp_process_ppdu_stats_user_compltn_ack_ba_status_tlv: Process
  2971. * htt_ppdu_stats_user_compltn_ack_ba_status_tlv
  2972. * pdev: DP PDE handle
  2973. * @tag_buf: buffer containing the htt_ppdu_stats_user_compltn_ack_ba_status_tlv
  2974. * @ppdu_info: per ppdu tlv structure
  2975. *
  2976. * return:void
  2977. */
  2978. static void dp_process_ppdu_stats_user_compltn_ack_ba_status_tlv(
  2979. struct dp_pdev *pdev, uint32_t *tag_buf,
  2980. struct ppdu_info *ppdu_info)
  2981. {
  2982. uint16_t peer_id;
  2983. struct cdp_tx_completion_ppdu *ppdu_desc;
  2984. struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
  2985. uint8_t curr_user_index = 0;
  2986. uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
  2987. ppdu_desc =
  2988. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  2989. tag_buf += 2;
  2990. peer_id =
  2991. HTT_PPDU_STATS_USER_CMPLTN_ACK_BA_STATUS_TLV_SW_PEER_ID_GET(*tag_buf);
  2992. curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
  2993. ppdu_user_desc = &ppdu_desc->user[curr_user_index];
  2994. ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
  2995. if (!ppdu_user_desc->ack_ba_tlv) {
  2996. ppdu_user_desc->ack_ba_tlv = 1;
  2997. } else {
  2998. pdev->stats.ack_ba_comes_twice++;
  2999. return;
  3000. }
  3001. ppdu_user_desc->peer_id = peer_id;
  3002. tag_buf++;
  3003. /* not to update ppdu_desc->tid from this TLV */
  3004. ppdu_user_desc->num_mpdu =
  3005. HTT_PPDU_STATS_USER_CMPLTN_ACK_BA_STATUS_TLV_NUM_MPDU_GET(*tag_buf);
  3006. ppdu_user_desc->num_msdu =
  3007. HTT_PPDU_STATS_USER_CMPLTN_ACK_BA_STATUS_TLV_NUM_MSDU_GET(*tag_buf);
  3008. ppdu_user_desc->success_msdus = ppdu_user_desc->num_msdu;
  3009. tag_buf++;
  3010. ppdu_user_desc->start_seq =
  3011. HTT_PPDU_STATS_USER_CMPLTN_ACK_BA_STATUS_TLV_START_SEQ_GET(
  3012. *tag_buf);
  3013. tag_buf++;
  3014. ppdu_user_desc->success_bytes = *tag_buf;
  3015. /* increase ack ba tlv counter on successful mpdu */
  3016. if (ppdu_user_desc->num_mpdu)
  3017. ppdu_info->ack_ba_tlv++;
  3018. if (ppdu_user_desc->ba_size == 0) {
  3019. ppdu_user_desc->ba_seq_no = ppdu_user_desc->start_seq;
  3020. ppdu_user_desc->ba_bitmap[0] = 1;
  3021. ppdu_user_desc->ba_size = 1;
  3022. }
  3023. }
  3024. /*
  3025. * dp_process_ppdu_stats_user_common_array_tlv: Process
  3026. * htt_ppdu_stats_user_common_array_tlv
  3027. * pdev: DP PDEV handle
  3028. * @tag_buf: buffer containing the htt_ppdu_stats_user_compltn_ack_ba_status_tlv
  3029. * @ppdu_info: per ppdu tlv structure
  3030. *
  3031. * return:void
  3032. */
  3033. static void dp_process_ppdu_stats_user_common_array_tlv(
  3034. struct dp_pdev *pdev, uint32_t *tag_buf,
  3035. struct ppdu_info *ppdu_info)
  3036. {
  3037. uint32_t peer_id;
  3038. struct cdp_tx_completion_ppdu *ppdu_desc;
  3039. struct cdp_tx_completion_ppdu_user *ppdu_user_desc;
  3040. uint8_t curr_user_index = 0;
  3041. struct htt_tx_ppdu_stats_info *dp_stats_buf;
  3042. uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
  3043. ppdu_desc =
  3044. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  3045. tag_buf++;
  3046. dp_stats_buf = (struct htt_tx_ppdu_stats_info *)tag_buf;
  3047. tag_buf += 3;
  3048. peer_id =
  3049. HTT_PPDU_STATS_ARRAY_ITEM_TLV_PEERID_GET(*tag_buf);
  3050. if (!dp_peer_find_by_id_valid(pdev->soc, peer_id)) {
  3051. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR,
  3052. "Invalid peer");
  3053. return;
  3054. }
  3055. curr_user_index = dp_get_ppdu_info_user_index(pdev, peer_id, ppdu_info);
  3056. ppdu_user_desc = &ppdu_desc->user[curr_user_index];
  3057. ppdu_user_desc->tlv_bitmap |= (1 << tlv_type);
  3058. ppdu_user_desc->retry_bytes = dp_stats_buf->tx_retry_bytes;
  3059. ppdu_user_desc->failed_bytes = dp_stats_buf->tx_failed_bytes;
  3060. tag_buf++;
  3061. ppdu_user_desc->success_msdus =
  3062. HTT_PPDU_STATS_ARRAY_ITEM_TLV_TX_SUCC_MSDUS_GET(*tag_buf);
  3063. ppdu_user_desc->retry_bytes =
  3064. HTT_PPDU_STATS_ARRAY_ITEM_TLV_TX_RETRY_MSDUS_GET(*tag_buf);
  3065. tag_buf++;
  3066. ppdu_user_desc->failed_msdus =
  3067. HTT_PPDU_STATS_ARRAY_ITEM_TLV_TX_FAILED_MSDUS_GET(*tag_buf);
  3068. }
  3069. /*
  3070. * dp_process_ppdu_stats_flush_tlv: Process
  3071. * htt_ppdu_stats_flush_tlv
  3072. * @pdev: DP PDEV handle
  3073. * @tag_buf: buffer containing the htt_ppdu_stats_flush_tlv
  3074. * @ppdu_info: per ppdu tlv structure
  3075. *
  3076. * return:void
  3077. */
  3078. static void
  3079. dp_process_ppdu_stats_user_compltn_flush_tlv(struct dp_pdev *pdev,
  3080. uint32_t *tag_buf,
  3081. struct ppdu_info *ppdu_info)
  3082. {
  3083. struct cdp_tx_completion_ppdu *ppdu_desc;
  3084. uint32_t peer_id;
  3085. uint8_t tid;
  3086. struct dp_peer *peer;
  3087. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  3088. struct dp_mon_peer *mon_peer = NULL;
  3089. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3090. qdf_nbuf_data(ppdu_info->nbuf);
  3091. ppdu_desc->is_flush = 1;
  3092. tag_buf++;
  3093. ppdu_desc->drop_reason = *tag_buf;
  3094. tag_buf++;
  3095. ppdu_desc->num_msdu = HTT_PPDU_STATS_FLUSH_TLV_NUM_MSDU_GET(*tag_buf);
  3096. ppdu_desc->num_mpdu = HTT_PPDU_STATS_FLUSH_TLV_NUM_MPDU_GET(*tag_buf);
  3097. ppdu_desc->flow_type = HTT_PPDU_STATS_FLUSH_TLV_FLOW_TYPE_GET(*tag_buf);
  3098. tag_buf++;
  3099. peer_id = HTT_PPDU_STATS_FLUSH_TLV_SW_PEER_ID_GET(*tag_buf);
  3100. tid = HTT_PPDU_STATS_FLUSH_TLV_TID_NUM_GET(*tag_buf);
  3101. ppdu_desc->num_users = 1;
  3102. ppdu_desc->user[0].peer_id = peer_id;
  3103. ppdu_desc->user[0].tid = tid;
  3104. ppdu_desc->queue_type =
  3105. HTT_PPDU_STATS_FLUSH_TLV_QUEUE_TYPE_GET(*tag_buf);
  3106. peer = dp_peer_get_ref_by_id(pdev->soc, peer_id,
  3107. DP_MOD_ID_TX_PPDU_STATS);
  3108. if (!peer)
  3109. goto add_ppdu_to_sched_list;
  3110. if (ppdu_desc->drop_reason == HTT_FLUSH_EXCESS_RETRIES) {
  3111. mon_peer = peer->monitor_peer;
  3112. DP_STATS_INC(mon_peer,
  3113. tx.excess_retries_per_ac[TID_TO_WME_AC(tid)],
  3114. ppdu_desc->num_msdu);
  3115. }
  3116. dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
  3117. add_ppdu_to_sched_list:
  3118. ppdu_info->done = 1;
  3119. TAILQ_REMOVE(&mon_pdev->ppdu_info_list, ppdu_info, ppdu_info_list_elem);
  3120. mon_pdev->list_depth--;
  3121. TAILQ_INSERT_TAIL(&mon_pdev->sched_comp_ppdu_list, ppdu_info,
  3122. ppdu_info_list_elem);
  3123. mon_pdev->sched_comp_list_depth++;
  3124. }
  3125. /**
  3126. * dp_process_ppdu_stats_sch_cmd_status_tlv: Process schedule command status tlv
  3127. * Here we are not going to process the buffer.
  3128. * @pdev: DP PDEV handle
  3129. * @ppdu_info: per ppdu tlv structure
  3130. *
  3131. * return:void
  3132. */
  3133. static void
  3134. dp_process_ppdu_stats_sch_cmd_status_tlv(struct dp_pdev *pdev,
  3135. struct ppdu_info *ppdu_info)
  3136. {
  3137. struct cdp_tx_completion_ppdu *ppdu_desc;
  3138. struct dp_peer *peer;
  3139. uint8_t num_users;
  3140. uint8_t i;
  3141. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  3142. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3143. qdf_nbuf_data(ppdu_info->nbuf);
  3144. num_users = ppdu_desc->bar_num_users;
  3145. for (i = 0; i < num_users; i++) {
  3146. if (ppdu_desc->user[i].user_pos == 0) {
  3147. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR) {
  3148. /* update phy mode for bar frame */
  3149. ppdu_desc->phy_mode =
  3150. ppdu_desc->user[i].preamble;
  3151. ppdu_desc->user[0].mcs = ppdu_desc->user[i].mcs;
  3152. break;
  3153. }
  3154. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_CTRL) {
  3155. ppdu_desc->frame_ctrl =
  3156. ppdu_desc->user[i].frame_ctrl;
  3157. break;
  3158. }
  3159. }
  3160. }
  3161. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_DATA &&
  3162. ppdu_desc->delayed_ba) {
  3163. qdf_assert_always(ppdu_desc->num_users <= ppdu_desc->max_users);
  3164. for (i = 0; i < ppdu_desc->num_users; i++) {
  3165. struct cdp_delayed_tx_completion_ppdu_user *delay_ppdu;
  3166. uint64_t start_tsf;
  3167. uint64_t end_tsf;
  3168. uint32_t ppdu_id;
  3169. struct dp_mon_peer *mon_peer;
  3170. ppdu_id = ppdu_desc->ppdu_id;
  3171. peer = dp_peer_get_ref_by_id
  3172. (pdev->soc, ppdu_desc->user[i].peer_id,
  3173. DP_MOD_ID_TX_PPDU_STATS);
  3174. /**
  3175. * This check is to make sure peer is not deleted
  3176. * after processing the TLVs.
  3177. */
  3178. if (!peer)
  3179. continue;
  3180. mon_peer = peer->monitor_peer;
  3181. delay_ppdu = &mon_peer->delayed_ba_ppdu_stats;
  3182. start_tsf = ppdu_desc->ppdu_start_timestamp;
  3183. end_tsf = ppdu_desc->ppdu_end_timestamp;
  3184. /**
  3185. * save delayed ba user info
  3186. */
  3187. if (ppdu_desc->user[i].delayed_ba) {
  3188. dp_peer_copy_delay_stats(peer,
  3189. &ppdu_desc->user[i],
  3190. ppdu_id);
  3191. mon_peer->last_delayed_ba_ppduid = ppdu_id;
  3192. delay_ppdu->ppdu_start_timestamp = start_tsf;
  3193. delay_ppdu->ppdu_end_timestamp = end_tsf;
  3194. }
  3195. ppdu_desc->user[i].peer_last_delayed_ba =
  3196. mon_peer->last_delayed_ba;
  3197. dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
  3198. if (ppdu_desc->user[i].delayed_ba &&
  3199. !ppdu_desc->user[i].debug_copied) {
  3200. QDF_TRACE(QDF_MODULE_ID_TXRX,
  3201. QDF_TRACE_LEVEL_INFO_MED,
  3202. "%s: %d ppdu_id[%d] bar_ppdu_id[%d] num_users[%d] usr[%d] htt_frame_type[%d]\n",
  3203. __func__, __LINE__,
  3204. ppdu_desc->ppdu_id,
  3205. ppdu_desc->bar_ppdu_id,
  3206. ppdu_desc->num_users,
  3207. i,
  3208. ppdu_desc->htt_frame_type);
  3209. }
  3210. }
  3211. }
  3212. /*
  3213. * when frame type is BAR and STATS_COMMON_TLV is set
  3214. * copy the store peer delayed info to BAR status
  3215. */
  3216. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR) {
  3217. for (i = 0; i < ppdu_desc->bar_num_users; i++) {
  3218. struct cdp_delayed_tx_completion_ppdu_user *delay_ppdu;
  3219. uint64_t start_tsf;
  3220. uint64_t end_tsf;
  3221. struct dp_mon_peer *mon_peer;
  3222. peer = dp_peer_get_ref_by_id
  3223. (pdev->soc,
  3224. ppdu_desc->user[i].peer_id,
  3225. DP_MOD_ID_TX_PPDU_STATS);
  3226. /**
  3227. * This check is to make sure peer is not deleted
  3228. * after processing the TLVs.
  3229. */
  3230. if (!peer)
  3231. continue;
  3232. mon_peer = peer->monitor_peer;
  3233. if (ppdu_desc->user[i].completion_status !=
  3234. HTT_PPDU_STATS_USER_STATUS_OK) {
  3235. dp_peer_unref_delete(peer,
  3236. DP_MOD_ID_TX_PPDU_STATS);
  3237. continue;
  3238. }
  3239. delay_ppdu = &mon_peer->delayed_ba_ppdu_stats;
  3240. start_tsf = delay_ppdu->ppdu_start_timestamp;
  3241. end_tsf = delay_ppdu->ppdu_end_timestamp;
  3242. if (mon_peer->last_delayed_ba) {
  3243. dp_peer_copy_stats_to_bar(peer,
  3244. &ppdu_desc->user[i]);
  3245. ppdu_desc->ppdu_id =
  3246. mon_peer->last_delayed_ba_ppduid;
  3247. ppdu_desc->ppdu_start_timestamp = start_tsf;
  3248. ppdu_desc->ppdu_end_timestamp = end_tsf;
  3249. }
  3250. ppdu_desc->user[i].peer_last_delayed_ba =
  3251. mon_peer->last_delayed_ba;
  3252. dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
  3253. }
  3254. }
  3255. TAILQ_REMOVE(&mon_pdev->ppdu_info_list, ppdu_info, ppdu_info_list_elem);
  3256. mon_pdev->list_depth--;
  3257. TAILQ_INSERT_TAIL(&mon_pdev->sched_comp_ppdu_list, ppdu_info,
  3258. ppdu_info_list_elem);
  3259. mon_pdev->sched_comp_list_depth++;
  3260. }
  3261. /**
  3262. * dp_validate_fix_ppdu_tlv(): Function to validate the length of PPDU
  3263. *
  3264. * If the TLV length sent as part of PPDU TLV is less that expected size i.e
  3265. * size of corresponding data structure, pad the remaining bytes with zeros
  3266. * and continue processing the TLVs
  3267. *
  3268. * @pdev: DP pdev handle
  3269. * @tag_buf: TLV buffer
  3270. * @tlv_expected_size: Expected size of Tag
  3271. * @tlv_len: TLV length received from FW
  3272. *
  3273. * Return: Pointer to updated TLV
  3274. */
  3275. static inline uint32_t *dp_validate_fix_ppdu_tlv(struct dp_pdev *pdev,
  3276. uint32_t *tag_buf,
  3277. uint16_t tlv_expected_size,
  3278. uint16_t tlv_len)
  3279. {
  3280. uint32_t *tlv_desc = tag_buf;
  3281. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  3282. qdf_assert_always(tlv_len != 0);
  3283. if (tlv_len < tlv_expected_size) {
  3284. qdf_mem_zero(mon_pdev->ppdu_tlv_buf, tlv_expected_size);
  3285. qdf_mem_copy(mon_pdev->ppdu_tlv_buf, tag_buf, tlv_len);
  3286. tlv_desc = mon_pdev->ppdu_tlv_buf;
  3287. }
  3288. return tlv_desc;
  3289. }
  3290. /**
  3291. * dp_process_ppdu_tag(): Function to process the PPDU TLVs
  3292. * @pdev: DP pdev handle
  3293. * @tag_buf: TLV buffer
  3294. * @tlv_len: length of tlv
  3295. * @ppdu_info: per ppdu tlv structure
  3296. *
  3297. * return: void
  3298. */
  3299. static void dp_process_ppdu_tag(struct dp_pdev *pdev,
  3300. uint32_t *tag_buf,
  3301. uint32_t tlv_len,
  3302. struct ppdu_info *ppdu_info)
  3303. {
  3304. uint32_t tlv_type = HTT_STATS_TLV_TAG_GET(*tag_buf);
  3305. uint16_t tlv_expected_size;
  3306. uint32_t *tlv_desc;
  3307. switch (tlv_type) {
  3308. case HTT_PPDU_STATS_COMMON_TLV:
  3309. tlv_expected_size = sizeof(htt_ppdu_stats_common_tlv);
  3310. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3311. tlv_expected_size, tlv_len);
  3312. dp_process_ppdu_stats_common_tlv(pdev, tlv_desc, ppdu_info);
  3313. break;
  3314. case HTT_PPDU_STATS_USR_COMMON_TLV:
  3315. tlv_expected_size = sizeof(htt_ppdu_stats_user_common_tlv);
  3316. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3317. tlv_expected_size, tlv_len);
  3318. dp_process_ppdu_stats_user_common_tlv(pdev, tlv_desc,
  3319. ppdu_info);
  3320. break;
  3321. case HTT_PPDU_STATS_USR_RATE_TLV:
  3322. tlv_expected_size = sizeof(htt_ppdu_stats_user_rate_tlv);
  3323. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3324. tlv_expected_size, tlv_len);
  3325. dp_process_ppdu_stats_user_rate_tlv(pdev, tlv_desc,
  3326. ppdu_info);
  3327. break;
  3328. case HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_64_TLV:
  3329. tlv_expected_size =
  3330. sizeof(htt_ppdu_stats_enq_mpdu_bitmap_64_tlv);
  3331. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3332. tlv_expected_size, tlv_len);
  3333. dp_process_ppdu_stats_enq_mpdu_bitmap_64_tlv(
  3334. pdev, tlv_desc, ppdu_info);
  3335. break;
  3336. case HTT_PPDU_STATS_USR_MPDU_ENQ_BITMAP_256_TLV:
  3337. tlv_expected_size =
  3338. sizeof(htt_ppdu_stats_enq_mpdu_bitmap_256_tlv);
  3339. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3340. tlv_expected_size, tlv_len);
  3341. dp_process_ppdu_stats_enq_mpdu_bitmap_256_tlv(
  3342. pdev, tlv_desc, ppdu_info);
  3343. break;
  3344. case HTT_PPDU_STATS_USR_COMPLTN_COMMON_TLV:
  3345. tlv_expected_size =
  3346. sizeof(htt_ppdu_stats_user_cmpltn_common_tlv);
  3347. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3348. tlv_expected_size, tlv_len);
  3349. dp_process_ppdu_stats_user_cmpltn_common_tlv(
  3350. pdev, tlv_desc, ppdu_info);
  3351. break;
  3352. case HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_64_TLV:
  3353. tlv_expected_size =
  3354. sizeof(htt_ppdu_stats_user_compltn_ba_bitmap_64_tlv);
  3355. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3356. tlv_expected_size, tlv_len);
  3357. dp_process_ppdu_stats_user_compltn_ba_bitmap_64_tlv(
  3358. pdev, tlv_desc, ppdu_info);
  3359. break;
  3360. case HTT_PPDU_STATS_USR_COMPLTN_BA_BITMAP_256_TLV:
  3361. tlv_expected_size =
  3362. sizeof(htt_ppdu_stats_user_compltn_ba_bitmap_256_tlv);
  3363. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3364. tlv_expected_size, tlv_len);
  3365. dp_process_ppdu_stats_user_compltn_ba_bitmap_256_tlv(
  3366. pdev, tlv_desc, ppdu_info);
  3367. break;
  3368. case HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV:
  3369. tlv_expected_size =
  3370. sizeof(htt_ppdu_stats_user_compltn_ack_ba_status_tlv);
  3371. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3372. tlv_expected_size, tlv_len);
  3373. dp_process_ppdu_stats_user_compltn_ack_ba_status_tlv(
  3374. pdev, tlv_desc, ppdu_info);
  3375. break;
  3376. case HTT_PPDU_STATS_USR_COMMON_ARRAY_TLV:
  3377. tlv_expected_size =
  3378. sizeof(htt_ppdu_stats_usr_common_array_tlv_v);
  3379. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3380. tlv_expected_size, tlv_len);
  3381. dp_process_ppdu_stats_user_common_array_tlv(
  3382. pdev, tlv_desc, ppdu_info);
  3383. break;
  3384. case HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV:
  3385. tlv_expected_size = sizeof(htt_ppdu_stats_flush_tlv);
  3386. tlv_desc = dp_validate_fix_ppdu_tlv(pdev, tag_buf,
  3387. tlv_expected_size, tlv_len);
  3388. dp_process_ppdu_stats_user_compltn_flush_tlv(pdev, tlv_desc,
  3389. ppdu_info);
  3390. break;
  3391. case HTT_PPDU_STATS_SCH_CMD_STATUS_TLV:
  3392. dp_process_ppdu_stats_sch_cmd_status_tlv(pdev, ppdu_info);
  3393. break;
  3394. default:
  3395. break;
  3396. }
  3397. }
  3398. #ifdef WLAN_ATF_ENABLE
  3399. static void
  3400. dp_ppdu_desc_user_phy_tx_time_update(struct dp_pdev *pdev,
  3401. struct cdp_tx_completion_ppdu *ppdu_desc,
  3402. struct cdp_tx_completion_ppdu_user *user)
  3403. {
  3404. uint32_t nss_ru_width_sum = 0;
  3405. struct dp_mon_pdev *mon_pdev = NULL;
  3406. if (!pdev || !ppdu_desc || !user)
  3407. return;
  3408. mon_pdev = pdev->monitor_pdev;
  3409. if (!mon_pdev || !mon_pdev->dp_atf_stats_enable)
  3410. return;
  3411. if (ppdu_desc->frame_type != CDP_PPDU_FTYPE_DATA)
  3412. return;
  3413. nss_ru_width_sum = ppdu_desc->usr_nss_sum * ppdu_desc->usr_ru_tones_sum;
  3414. if (!nss_ru_width_sum)
  3415. nss_ru_width_sum = 1;
  3416. /**
  3417. * For SU-MIMO PPDU phy Tx time is same for the single user.
  3418. * For MU-MIMO phy Tx time is calculated per user as below
  3419. * user phy tx time =
  3420. * Entire PPDU duration * MU Ratio * OFDMA Ratio
  3421. * MU Ratio = usr_nss / Sum_of_nss_of_all_users
  3422. * OFDMA_ratio = usr_ru_width / Sum_of_ru_width_of_all_users
  3423. * usr_ru_widt = ru_end – ru_start + 1
  3424. */
  3425. if (ppdu_desc->htt_frame_type == HTT_STATS_FTYPE_TIDQ_DATA_SU) {
  3426. user->phy_tx_time_us = ppdu_desc->phy_ppdu_tx_time_us;
  3427. } else {
  3428. user->phy_tx_time_us = (ppdu_desc->phy_ppdu_tx_time_us *
  3429. user->nss * user->ru_tones) / nss_ru_width_sum;
  3430. }
  3431. }
  3432. #else
  3433. static void
  3434. dp_ppdu_desc_user_phy_tx_time_update(struct dp_pdev *pdev,
  3435. struct cdp_tx_completion_ppdu *ppdu_desc,
  3436. struct cdp_tx_completion_ppdu_user *user)
  3437. {
  3438. }
  3439. #endif
  3440. /**
  3441. * dp_ppdu_desc_user_stats_update(): Function to update TX user stats
  3442. * @pdev: DP pdev handle
  3443. * @ppdu_info: per PPDU TLV descriptor
  3444. *
  3445. * return: void
  3446. */
  3447. void
  3448. dp_ppdu_desc_user_stats_update(struct dp_pdev *pdev,
  3449. struct ppdu_info *ppdu_info)
  3450. {
  3451. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  3452. struct dp_peer *peer = NULL;
  3453. uint32_t tlv_bitmap_expected;
  3454. uint32_t tlv_bitmap_default;
  3455. uint16_t i;
  3456. uint32_t num_users;
  3457. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  3458. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3459. qdf_nbuf_data(ppdu_info->nbuf);
  3460. if (ppdu_desc->frame_type != CDP_PPDU_FTYPE_BAR)
  3461. ppdu_desc->ppdu_id = ppdu_info->ppdu_id;
  3462. tlv_bitmap_expected = HTT_PPDU_DEFAULT_TLV_BITMAP;
  3463. if (mon_pdev->tx_sniffer_enable || mon_pdev->mcopy_mode ||
  3464. mon_pdev->tx_capture_enabled) {
  3465. if (ppdu_info->is_ampdu)
  3466. tlv_bitmap_expected =
  3467. dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap(
  3468. ppdu_info->tlv_bitmap);
  3469. }
  3470. tlv_bitmap_default = tlv_bitmap_expected;
  3471. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR) {
  3472. num_users = ppdu_desc->bar_num_users;
  3473. ppdu_desc->num_users = ppdu_desc->bar_num_users;
  3474. } else {
  3475. num_users = ppdu_desc->num_users;
  3476. }
  3477. qdf_assert_always(ppdu_desc->num_users <= ppdu_desc->max_users);
  3478. for (i = 0; i < num_users; i++) {
  3479. ppdu_desc->num_mpdu += ppdu_desc->user[i].num_mpdu;
  3480. ppdu_desc->num_msdu += ppdu_desc->user[i].num_msdu;
  3481. peer = dp_peer_get_ref_by_id(pdev->soc,
  3482. ppdu_desc->user[i].peer_id,
  3483. DP_MOD_ID_TX_PPDU_STATS);
  3484. /**
  3485. * This check is to make sure peer is not deleted
  3486. * after processing the TLVs.
  3487. */
  3488. if (!peer)
  3489. continue;
  3490. ppdu_desc->user[i].is_bss_peer = peer->bss_peer;
  3491. /*
  3492. * different frame like DATA, BAR or CTRL has different
  3493. * tlv bitmap expected. Apart from ACK_BA_STATUS TLV, we
  3494. * receive other tlv in-order/sequential from fw.
  3495. * Since ACK_BA_STATUS TLV come from Hardware it is
  3496. * asynchronous So we need to depend on some tlv to confirm
  3497. * all tlv is received for a ppdu.
  3498. * So we depend on both SCHED_CMD_STATUS_TLV and
  3499. * ACK_BA_STATUS_TLV. for failure packet we won't get
  3500. * ACK_BA_STATUS_TLV.
  3501. */
  3502. if (!(ppdu_info->tlv_bitmap &
  3503. (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV)) ||
  3504. (!(ppdu_info->tlv_bitmap &
  3505. (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV)) &&
  3506. (ppdu_desc->user[i].completion_status ==
  3507. HTT_PPDU_STATS_USER_STATUS_OK))) {
  3508. dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
  3509. continue;
  3510. }
  3511. /**
  3512. * Update tx stats for data frames having Qos as well as
  3513. * non-Qos data tid
  3514. */
  3515. if ((ppdu_desc->user[i].tid < CDP_DATA_TID_MAX ||
  3516. (ppdu_desc->user[i].tid == CDP_DATA_NON_QOS_TID) ||
  3517. (ppdu_desc->htt_frame_type ==
  3518. HTT_STATS_FTYPE_SGEN_QOS_NULL) ||
  3519. ((ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR) &&
  3520. (ppdu_desc->num_mpdu > 1))) &&
  3521. (ppdu_desc->frame_type != CDP_PPDU_FTYPE_CTRL)) {
  3522. dp_tx_stats_update(pdev, peer,
  3523. &ppdu_desc->user[i],
  3524. ppdu_desc->ack_rssi);
  3525. }
  3526. dp_ppdu_desc_user_phy_tx_time_update(pdev, ppdu_desc,
  3527. &ppdu_desc->user[i]);
  3528. dp_peer_unref_delete(peer, DP_MOD_ID_TX_PPDU_STATS);
  3529. tlv_bitmap_expected = tlv_bitmap_default;
  3530. }
  3531. }
  3532. #if !defined(WLAN_TX_PKT_CAPTURE_ENH) || defined(QCA_MONITOR_2_0_SUPPORT)
  3533. /*
  3534. * dp_tx_ppdu_desc_notify() - Notify to upper layer about PPDU via WDI
  3535. *
  3536. * @pdev: Datapath pdev handle
  3537. * @nbuf: Buffer to be delivered to upper layer
  3538. *
  3539. * Return: void
  3540. */
  3541. static void dp_tx_ppdu_desc_notify(struct dp_pdev *pdev, qdf_nbuf_t nbuf)
  3542. {
  3543. struct dp_soc *soc = pdev->soc;
  3544. struct dp_mon_ops *mon_ops = NULL;
  3545. mon_ops = dp_mon_ops_get(soc);
  3546. if (mon_ops && mon_ops->mon_ppdu_desc_notify)
  3547. mon_ops->mon_ppdu_desc_notify(pdev, nbuf);
  3548. else
  3549. qdf_nbuf_free(nbuf);
  3550. }
  3551. void dp_ppdu_desc_deliver(struct dp_pdev *pdev,
  3552. struct ppdu_info *ppdu_info)
  3553. {
  3554. struct ppdu_info *s_ppdu_info = NULL;
  3555. struct ppdu_info *ppdu_info_next = NULL;
  3556. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  3557. qdf_nbuf_t nbuf;
  3558. uint32_t time_delta = 0;
  3559. bool starved = 0;
  3560. bool matched = 0;
  3561. bool recv_ack_ba_done = 0;
  3562. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  3563. if (ppdu_info->tlv_bitmap &
  3564. (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) &&
  3565. ppdu_info->done)
  3566. recv_ack_ba_done = 1;
  3567. mon_pdev->last_sched_cmdid = ppdu_info->sched_cmdid;
  3568. s_ppdu_info = TAILQ_FIRST(&mon_pdev->sched_comp_ppdu_list);
  3569. TAILQ_FOREACH_SAFE(s_ppdu_info, &mon_pdev->sched_comp_ppdu_list,
  3570. ppdu_info_list_elem, ppdu_info_next) {
  3571. if (s_ppdu_info->tsf_l32 > ppdu_info->tsf_l32)
  3572. time_delta = (MAX_TSF_32 - s_ppdu_info->tsf_l32) +
  3573. ppdu_info->tsf_l32;
  3574. else
  3575. time_delta = ppdu_info->tsf_l32 - s_ppdu_info->tsf_l32;
  3576. if (!s_ppdu_info->done && !recv_ack_ba_done) {
  3577. if (time_delta < MAX_SCHED_STARVE) {
  3578. dp_mon_info("pdev[%d] ppdu_id[%d] sched_cmdid[%d] TLV_B[0x%x] TSF[%u] D[%d]",
  3579. pdev->pdev_id,
  3580. s_ppdu_info->ppdu_id,
  3581. s_ppdu_info->sched_cmdid,
  3582. s_ppdu_info->tlv_bitmap,
  3583. s_ppdu_info->tsf_l32,
  3584. s_ppdu_info->done);
  3585. break;
  3586. }
  3587. starved = 1;
  3588. }
  3589. mon_pdev->delivered_sched_cmdid = s_ppdu_info->sched_cmdid;
  3590. TAILQ_REMOVE(&mon_pdev->sched_comp_ppdu_list, s_ppdu_info,
  3591. ppdu_info_list_elem);
  3592. mon_pdev->sched_comp_list_depth--;
  3593. nbuf = s_ppdu_info->nbuf;
  3594. qdf_assert_always(nbuf);
  3595. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3596. qdf_nbuf_data(nbuf);
  3597. ppdu_desc->tlv_bitmap = s_ppdu_info->tlv_bitmap;
  3598. if (starved) {
  3599. dp_mon_info("ppdu starved fc[0x%x] h_ftype[%d] tlv_bitmap[0x%x] cs[%d]\n",
  3600. ppdu_desc->frame_ctrl,
  3601. ppdu_desc->htt_frame_type,
  3602. ppdu_desc->tlv_bitmap,
  3603. ppdu_desc->user[0].completion_status);
  3604. starved = 0;
  3605. }
  3606. if (ppdu_info->ppdu_id == s_ppdu_info->ppdu_id &&
  3607. ppdu_info->sched_cmdid == s_ppdu_info->sched_cmdid)
  3608. matched = 1;
  3609. dp_ppdu_desc_user_stats_update(pdev, s_ppdu_info);
  3610. qdf_mem_free(s_ppdu_info);
  3611. dp_tx_ppdu_desc_notify(pdev, nbuf);
  3612. if (matched)
  3613. break;
  3614. }
  3615. }
  3616. #endif
  3617. /*
  3618. * dp_tx_ppdu_desc_deliver() - Deliver PPDU desc to upper layer
  3619. *
  3620. * @pdev: Datapath pdev handle
  3621. * @ppdu_info: per PPDU TLV descriptor
  3622. *
  3623. * Return: void
  3624. */
  3625. static void dp_tx_ppdu_desc_deliver(struct dp_pdev *pdev,
  3626. struct ppdu_info *ppdu_info)
  3627. {
  3628. struct dp_soc *soc = pdev->soc;
  3629. struct dp_mon_ops *mon_ops = NULL;
  3630. mon_ops = dp_mon_ops_get(soc);
  3631. if (mon_ops && mon_ops->mon_ppdu_desc_deliver) {
  3632. mon_ops->mon_ppdu_desc_deliver(pdev, ppdu_info);
  3633. } else {
  3634. qdf_nbuf_free(ppdu_info->nbuf);
  3635. ppdu_info->nbuf = NULL;
  3636. qdf_mem_free(ppdu_info);
  3637. }
  3638. }
  3639. /**
  3640. * dp_get_ppdu_desc(): Function to allocate new PPDU status
  3641. * desc for new ppdu id
  3642. * @pdev: DP pdev handle
  3643. * @ppdu_id: PPDU unique identifier
  3644. * @tlv_type: TLV type received
  3645. * @tsf_l32: timestamp received along with ppdu stats indication header
  3646. * @max_users: Maximum user for that particular ppdu
  3647. *
  3648. * return: ppdu_info per ppdu tlv structure
  3649. */
  3650. static
  3651. struct ppdu_info *dp_get_ppdu_desc(struct dp_pdev *pdev, uint32_t ppdu_id,
  3652. uint8_t tlv_type, uint32_t tsf_l32,
  3653. uint8_t max_users)
  3654. {
  3655. struct ppdu_info *ppdu_info = NULL;
  3656. struct ppdu_info *s_ppdu_info = NULL;
  3657. struct ppdu_info *ppdu_info_next = NULL;
  3658. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  3659. uint32_t size = 0;
  3660. struct cdp_tx_completion_ppdu *tmp_ppdu_desc = NULL;
  3661. struct cdp_tx_completion_ppdu_user *tmp_user;
  3662. uint32_t time_delta;
  3663. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  3664. /*
  3665. * Find ppdu_id node exists or not
  3666. */
  3667. TAILQ_FOREACH_SAFE(ppdu_info, &mon_pdev->ppdu_info_list,
  3668. ppdu_info_list_elem, ppdu_info_next) {
  3669. if (ppdu_info && (ppdu_info->ppdu_id == ppdu_id)) {
  3670. if (ppdu_info->tsf_l32 > tsf_l32)
  3671. time_delta = (MAX_TSF_32 -
  3672. ppdu_info->tsf_l32) + tsf_l32;
  3673. else
  3674. time_delta = tsf_l32 - ppdu_info->tsf_l32;
  3675. if (time_delta > WRAP_DROP_TSF_DELTA) {
  3676. TAILQ_REMOVE(&mon_pdev->ppdu_info_list,
  3677. ppdu_info, ppdu_info_list_elem);
  3678. mon_pdev->list_depth--;
  3679. pdev->stats.ppdu_wrap_drop++;
  3680. tmp_ppdu_desc =
  3681. (struct cdp_tx_completion_ppdu *)
  3682. qdf_nbuf_data(ppdu_info->nbuf);
  3683. tmp_user = &tmp_ppdu_desc->user[0];
  3684. dp_htt_tx_stats_info("S_PID [%d] S_TSF[%u] TLV_BITMAP[0x%x] [CMPLTN - %d ACK_BA - %d] CS[%d] - R_PID[%d] R_TSF[%u] R_TLV_TAG[0x%x]\n",
  3685. ppdu_info->ppdu_id,
  3686. ppdu_info->tsf_l32,
  3687. ppdu_info->tlv_bitmap,
  3688. tmp_user->completion_status,
  3689. ppdu_info->compltn_common_tlv,
  3690. ppdu_info->ack_ba_tlv,
  3691. ppdu_id, tsf_l32,
  3692. tlv_type);
  3693. qdf_nbuf_free(ppdu_info->nbuf);
  3694. ppdu_info->nbuf = NULL;
  3695. qdf_mem_free(ppdu_info);
  3696. } else {
  3697. break;
  3698. }
  3699. }
  3700. }
  3701. /*
  3702. * check if it is ack ba tlv and if it is not there in ppdu info
  3703. * list then check it in sched completion ppdu list
  3704. */
  3705. if (!ppdu_info &&
  3706. tlv_type == HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) {
  3707. TAILQ_FOREACH(s_ppdu_info,
  3708. &mon_pdev->sched_comp_ppdu_list,
  3709. ppdu_info_list_elem) {
  3710. if (s_ppdu_info && (s_ppdu_info->ppdu_id == ppdu_id)) {
  3711. if (s_ppdu_info->tsf_l32 > tsf_l32)
  3712. time_delta = (MAX_TSF_32 -
  3713. s_ppdu_info->tsf_l32) +
  3714. tsf_l32;
  3715. else
  3716. time_delta = tsf_l32 -
  3717. s_ppdu_info->tsf_l32;
  3718. if (time_delta < WRAP_DROP_TSF_DELTA) {
  3719. ppdu_info = s_ppdu_info;
  3720. break;
  3721. }
  3722. } else {
  3723. /*
  3724. * ACK BA STATUS TLV comes sequential order
  3725. * if we received ack ba status tlv for second
  3726. * ppdu and first ppdu is still waiting for
  3727. * ACK BA STATUS TLV. Based on fw comment
  3728. * we won't receive it tlv later. So we can
  3729. * set ppdu info done.
  3730. */
  3731. if (s_ppdu_info)
  3732. s_ppdu_info->done = 1;
  3733. }
  3734. }
  3735. }
  3736. if (ppdu_info) {
  3737. if (ppdu_info->tlv_bitmap & (1 << tlv_type)) {
  3738. /**
  3739. * if we get tlv_type that is already been processed
  3740. * for ppdu, that means we got a new ppdu with same
  3741. * ppdu id. Hence Flush the older ppdu
  3742. * for MUMIMO and OFDMA, In a PPDU we have
  3743. * multiple user with same tlv types. tlv bitmap is
  3744. * used to check whether SU or MU_MIMO/OFDMA
  3745. */
  3746. if (!(ppdu_info->tlv_bitmap &
  3747. (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV)))
  3748. return ppdu_info;
  3749. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3750. qdf_nbuf_data(ppdu_info->nbuf);
  3751. /**
  3752. * apart from ACK BA STATUS TLV rest all comes in order
  3753. * so if tlv type not ACK BA STATUS TLV we can deliver
  3754. * ppdu_info
  3755. */
  3756. if ((tlv_type ==
  3757. HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) &&
  3758. (ppdu_desc->htt_frame_type ==
  3759. HTT_STATS_FTYPE_SGEN_MU_BAR))
  3760. return ppdu_info;
  3761. dp_tx_ppdu_desc_deliver(pdev, ppdu_info);
  3762. } else {
  3763. return ppdu_info;
  3764. }
  3765. }
  3766. /**
  3767. * Flush the head ppdu descriptor if ppdu desc list reaches max
  3768. * threshold
  3769. */
  3770. if (mon_pdev->list_depth > HTT_PPDU_DESC_MAX_DEPTH) {
  3771. ppdu_info = TAILQ_FIRST(&mon_pdev->ppdu_info_list);
  3772. TAILQ_REMOVE(&mon_pdev->ppdu_info_list,
  3773. ppdu_info, ppdu_info_list_elem);
  3774. mon_pdev->list_depth--;
  3775. pdev->stats.ppdu_drop++;
  3776. qdf_nbuf_free(ppdu_info->nbuf);
  3777. ppdu_info->nbuf = NULL;
  3778. qdf_mem_free(ppdu_info);
  3779. }
  3780. size = sizeof(struct cdp_tx_completion_ppdu) +
  3781. (max_users * sizeof(struct cdp_tx_completion_ppdu_user));
  3782. /*
  3783. * Allocate new ppdu_info node
  3784. */
  3785. ppdu_info = qdf_mem_malloc(sizeof(struct ppdu_info));
  3786. if (!ppdu_info)
  3787. return NULL;
  3788. ppdu_info->nbuf = qdf_nbuf_alloc(pdev->soc->osdev, size,
  3789. 0, 4, TRUE);
  3790. if (!ppdu_info->nbuf) {
  3791. qdf_mem_free(ppdu_info);
  3792. return NULL;
  3793. }
  3794. ppdu_info->ppdu_desc =
  3795. (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_info->nbuf);
  3796. qdf_mem_zero(qdf_nbuf_data(ppdu_info->nbuf), size);
  3797. if (!qdf_nbuf_put_tail(ppdu_info->nbuf, size)) {
  3798. dp_mon_err("No tailroom for HTT PPDU");
  3799. qdf_nbuf_free(ppdu_info->nbuf);
  3800. ppdu_info->nbuf = NULL;
  3801. ppdu_info->last_user = 0;
  3802. qdf_mem_free(ppdu_info);
  3803. return NULL;
  3804. }
  3805. ppdu_info->ppdu_desc->max_users = max_users;
  3806. ppdu_info->tsf_l32 = tsf_l32;
  3807. /**
  3808. * No lock is needed because all PPDU TLVs are processed in
  3809. * same context and this list is updated in same context
  3810. */
  3811. TAILQ_INSERT_TAIL(&mon_pdev->ppdu_info_list, ppdu_info,
  3812. ppdu_info_list_elem);
  3813. mon_pdev->list_depth++;
  3814. return ppdu_info;
  3815. }
  3816. /**
  3817. * dp_htt_process_tlv(): Function to process each PPDU TLVs
  3818. * @pdev: DP pdev handle
  3819. * @htt_t2h_msg: HTT target to host message
  3820. *
  3821. * return: ppdu_info per ppdu tlv structure
  3822. */
  3823. static struct ppdu_info *dp_htt_process_tlv(struct dp_pdev *pdev,
  3824. qdf_nbuf_t htt_t2h_msg)
  3825. {
  3826. uint32_t length;
  3827. uint32_t ppdu_id;
  3828. uint8_t tlv_type;
  3829. uint32_t tlv_length, tlv_bitmap_expected;
  3830. uint8_t *tlv_buf;
  3831. struct ppdu_info *ppdu_info = NULL;
  3832. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  3833. uint8_t max_users = CDP_MU_MAX_USERS;
  3834. uint32_t tsf_l32;
  3835. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  3836. uint32_t *msg_word = (uint32_t *)qdf_nbuf_data(htt_t2h_msg);
  3837. length = HTT_T2H_PPDU_STATS_PAYLOAD_SIZE_GET(*msg_word);
  3838. msg_word = msg_word + 1;
  3839. ppdu_id = HTT_T2H_PPDU_STATS_PPDU_ID_GET(*msg_word);
  3840. msg_word = msg_word + 1;
  3841. tsf_l32 = (uint32_t)(*msg_word);
  3842. msg_word = msg_word + 2;
  3843. while (length > 0) {
  3844. tlv_buf = (uint8_t *)msg_word;
  3845. tlv_type = HTT_STATS_TLV_TAG_GET(*msg_word);
  3846. tlv_length = HTT_STATS_TLV_LENGTH_GET(*msg_word);
  3847. if (qdf_likely(tlv_type < CDP_PPDU_STATS_MAX_TAG))
  3848. pdev->stats.ppdu_stats_counter[tlv_type]++;
  3849. if (tlv_length == 0)
  3850. break;
  3851. tlv_length += HTT_TLV_HDR_LEN;
  3852. /**
  3853. * Not allocating separate ppdu descriptor for MGMT Payload
  3854. * TLV as this is sent as separate WDI indication and it
  3855. * doesn't contain any ppdu information
  3856. */
  3857. if (tlv_type == HTT_PPDU_STATS_TX_MGMTCTRL_PAYLOAD_TLV) {
  3858. mon_pdev->mgmtctrl_frm_info.mgmt_buf = tlv_buf;
  3859. mon_pdev->mgmtctrl_frm_info.ppdu_id = ppdu_id;
  3860. mon_pdev->mgmtctrl_frm_info.mgmt_buf_len =
  3861. HTT_PPDU_STATS_TX_MGMTCTRL_TLV_FRAME_LENGTH_GET
  3862. (*(msg_word + 1));
  3863. msg_word =
  3864. (uint32_t *)((uint8_t *)tlv_buf + tlv_length);
  3865. length -= (tlv_length);
  3866. continue;
  3867. }
  3868. /*
  3869. * retrieve max_users if it's USERS_INFO,
  3870. * else, it's 1 for COMPLTN_FLUSH,
  3871. * else, use CDP_MU_MAX_USERS
  3872. */
  3873. if (tlv_type == HTT_PPDU_STATS_USERS_INFO_TLV) {
  3874. max_users =
  3875. HTT_PPDU_STATS_USERS_INFO_TLV_MAX_USERS_GET(*(msg_word + 1));
  3876. } else if (tlv_type == HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV) {
  3877. max_users = 1;
  3878. }
  3879. ppdu_info = dp_get_ppdu_desc(pdev, ppdu_id, tlv_type,
  3880. tsf_l32, max_users);
  3881. if (!ppdu_info)
  3882. return NULL;
  3883. ppdu_info->ppdu_id = ppdu_id;
  3884. ppdu_info->tlv_bitmap |= (1 << tlv_type);
  3885. dp_process_ppdu_tag(pdev, msg_word, tlv_length, ppdu_info);
  3886. /**
  3887. * Increment pdev level tlv count to monitor
  3888. * missing TLVs
  3889. */
  3890. mon_pdev->tlv_count++;
  3891. ppdu_info->last_tlv_cnt = mon_pdev->tlv_count;
  3892. msg_word = (uint32_t *)((uint8_t *)tlv_buf + tlv_length);
  3893. length -= (tlv_length);
  3894. }
  3895. if (!ppdu_info)
  3896. return NULL;
  3897. mon_pdev->last_ppdu_id = ppdu_id;
  3898. tlv_bitmap_expected = HTT_PPDU_DEFAULT_TLV_BITMAP;
  3899. if (mon_pdev->tx_sniffer_enable || mon_pdev->mcopy_mode ||
  3900. mon_pdev->tx_capture_enabled) {
  3901. if (ppdu_info->is_ampdu)
  3902. tlv_bitmap_expected =
  3903. dp_htt_get_ppdu_sniffer_ampdu_tlv_bitmap(
  3904. ppdu_info->tlv_bitmap);
  3905. }
  3906. ppdu_desc = ppdu_info->ppdu_desc;
  3907. if (!ppdu_desc)
  3908. return NULL;
  3909. if (ppdu_desc->user[ppdu_desc->last_usr_index].completion_status !=
  3910. HTT_PPDU_STATS_USER_STATUS_OK) {
  3911. tlv_bitmap_expected = tlv_bitmap_expected & 0xFF;
  3912. }
  3913. /*
  3914. * for frame type DATA and BAR, we update stats based on MSDU,
  3915. * successful msdu and mpdu are populate from ACK BA STATUS TLV
  3916. * which comes out of order. successful mpdu also populated from
  3917. * COMPLTN COMMON TLV which comes in order. for every ppdu_info
  3918. * we store successful mpdu from both tlv and compare before delivering
  3919. * to make sure we received ACK BA STATUS TLV. For some self generated
  3920. * frame we won't get ack ba status tlv so no need to wait for
  3921. * ack ba status tlv.
  3922. */
  3923. if (ppdu_desc->frame_type != CDP_PPDU_FTYPE_CTRL &&
  3924. ppdu_desc->htt_frame_type != HTT_STATS_FTYPE_SGEN_QOS_NULL) {
  3925. /*
  3926. * most of the time bar frame will have duplicate ack ba
  3927. * status tlv
  3928. */
  3929. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_BAR &&
  3930. (ppdu_info->compltn_common_tlv != ppdu_info->ack_ba_tlv))
  3931. return NULL;
  3932. /*
  3933. * For data frame, compltn common tlv should match ack ba status
  3934. * tlv and completion status. Reason we are checking first user
  3935. * for ofdma, completion seen at next MU BAR frm, for mimo
  3936. * only for first user completion will be immediate.
  3937. */
  3938. if (ppdu_desc->frame_type == CDP_PPDU_FTYPE_DATA &&
  3939. (ppdu_desc->user[0].completion_status == 0 &&
  3940. (ppdu_info->compltn_common_tlv != ppdu_info->ack_ba_tlv)))
  3941. return NULL;
  3942. }
  3943. /**
  3944. * Once all the TLVs for a given PPDU has been processed,
  3945. * return PPDU status to be delivered to higher layer.
  3946. * tlv_bitmap_expected can't be available for different frame type.
  3947. * But SCHED CMD STATS TLV is the last TLV from the FW for a ppdu.
  3948. * apart from ACK BA TLV, FW sends other TLV in sequential order.
  3949. * flush tlv comes separate.
  3950. */
  3951. if ((ppdu_info->tlv_bitmap != 0 &&
  3952. (ppdu_info->tlv_bitmap &
  3953. (1 << HTT_PPDU_STATS_SCH_CMD_STATUS_TLV))) ||
  3954. (ppdu_info->tlv_bitmap &
  3955. (1 << HTT_PPDU_STATS_USR_COMPLTN_FLUSH_TLV))) {
  3956. ppdu_info->done = 1;
  3957. return ppdu_info;
  3958. }
  3959. return NULL;
  3960. }
  3961. #endif /* QCA_ENHANCED_STATS_SUPPORT */
  3962. #ifdef QCA_ENHANCED_STATS_SUPPORT
  3963. /**
  3964. * dp_tx_ppdu_stats_feat_enable_check() - Check if feature(s) is enabled to
  3965. * consume stats received from FW via HTT
  3966. * @pdev: Datapath pdev handle
  3967. *
  3968. * Return: void
  3969. */
  3970. static bool dp_tx_ppdu_stats_feat_enable_check(struct dp_pdev *pdev)
  3971. {
  3972. struct dp_soc *soc = pdev->soc;
  3973. struct dp_mon_ops *mon_ops = NULL;
  3974. mon_ops = dp_mon_ops_get(soc);
  3975. if (mon_ops && mon_ops->mon_ppdu_stats_feat_enable_check)
  3976. return mon_ops->mon_ppdu_stats_feat_enable_check(pdev);
  3977. else
  3978. return false;
  3979. }
  3980. #endif
  3981. #if defined(WDI_EVENT_ENABLE)
  3982. #ifdef QCA_ENHANCED_STATS_SUPPORT
  3983. /**
  3984. * dp_txrx_ppdu_stats_handler() - Function to process HTT PPDU stats from FW
  3985. * @soc: DP SOC handle
  3986. * @pdev_id: pdev id
  3987. * @htt_t2h_msg: HTT message nbuf
  3988. *
  3989. * return:void
  3990. */
  3991. static bool dp_txrx_ppdu_stats_handler(struct dp_soc *soc,
  3992. uint8_t pdev_id, qdf_nbuf_t htt_t2h_msg)
  3993. {
  3994. struct dp_pdev *pdev;
  3995. struct ppdu_info *ppdu_info = NULL;
  3996. bool free_buf = true;
  3997. struct dp_mon_pdev *mon_pdev;
  3998. if (pdev_id >= MAX_PDEV_CNT)
  3999. return true;
  4000. pdev = soc->pdev_list[pdev_id];
  4001. if (!pdev)
  4002. return true;
  4003. mon_pdev = pdev->monitor_pdev;
  4004. if (!mon_pdev)
  4005. return true;
  4006. if (!dp_tx_ppdu_stats_feat_enable_check(pdev))
  4007. return free_buf;
  4008. qdf_spin_lock_bh(&mon_pdev->ppdu_stats_lock);
  4009. ppdu_info = dp_htt_process_tlv(pdev, htt_t2h_msg);
  4010. if (mon_pdev->mgmtctrl_frm_info.mgmt_buf) {
  4011. if (dp_process_ppdu_stats_tx_mgmtctrl_payload_tlv
  4012. (pdev, htt_t2h_msg, mon_pdev->mgmtctrl_frm_info.ppdu_id) !=
  4013. QDF_STATUS_SUCCESS)
  4014. free_buf = false;
  4015. }
  4016. if (ppdu_info)
  4017. dp_tx_ppdu_desc_deliver(pdev, ppdu_info);
  4018. mon_pdev->mgmtctrl_frm_info.mgmt_buf = NULL;
  4019. mon_pdev->mgmtctrl_frm_info.mgmt_buf_len = 0;
  4020. mon_pdev->mgmtctrl_frm_info.ppdu_id = 0;
  4021. qdf_spin_unlock_bh(&mon_pdev->ppdu_stats_lock);
  4022. return free_buf;
  4023. }
  4024. #else
  4025. static bool dp_txrx_ppdu_stats_handler(struct dp_soc *soc,
  4026. uint8_t pdev_id, qdf_nbuf_t htt_t2h_msg)
  4027. {
  4028. return true;
  4029. }
  4030. #endif/* QCA_ENHANCED_STATS_SUPPORT */
  4031. #endif
  4032. #if defined(WDI_EVENT_ENABLE) &&\
  4033. (defined(QCA_ENHANCED_STATS_SUPPORT) || !defined(REMOVE_PKT_LOG))
  4034. /*
  4035. * dp_ppdu_stats_ind_handler() - PPDU stats msg handler
  4036. * @htt_soc: HTT SOC handle
  4037. * @msg_word: Pointer to payload
  4038. * @htt_t2h_msg: HTT msg nbuf
  4039. *
  4040. * Return: True if buffer should be freed by caller.
  4041. */
  4042. bool
  4043. dp_ppdu_stats_ind_handler(struct htt_soc *soc,
  4044. uint32_t *msg_word,
  4045. qdf_nbuf_t htt_t2h_msg)
  4046. {
  4047. u_int8_t pdev_id;
  4048. u_int8_t target_pdev_id;
  4049. bool free_buf;
  4050. target_pdev_id = HTT_T2H_PPDU_STATS_PDEV_ID_GET(*msg_word);
  4051. pdev_id = dp_get_host_pdev_id_for_target_pdev_id(soc->dp_soc,
  4052. target_pdev_id);
  4053. dp_wdi_event_handler(WDI_EVENT_LITE_T2H, soc->dp_soc,
  4054. htt_t2h_msg, HTT_INVALID_PEER, WDI_NO_VAL,
  4055. pdev_id);
  4056. free_buf = dp_txrx_ppdu_stats_handler(soc->dp_soc, pdev_id,
  4057. htt_t2h_msg);
  4058. return free_buf;
  4059. }
  4060. #endif
  4061. void
  4062. dp_mon_set_bsscolor(struct dp_pdev *pdev, uint8_t bsscolor)
  4063. {
  4064. pdev->monitor_pdev->rx_mon_recv_status.bsscolor = bsscolor;
  4065. }
  4066. bool dp_pdev_get_filter_ucast_data(struct cdp_pdev *pdev_handle)
  4067. {
  4068. struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
  4069. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  4070. if ((mon_pdev->fp_data_filter & FILTER_DATA_UCAST) ||
  4071. (mon_pdev->mo_data_filter & FILTER_DATA_UCAST))
  4072. return true;
  4073. return false;
  4074. }
  4075. bool dp_pdev_get_filter_mcast_data(struct cdp_pdev *pdev_handle)
  4076. {
  4077. struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
  4078. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  4079. if ((mon_pdev->fp_data_filter & FILTER_DATA_MCAST) ||
  4080. (mon_pdev->mo_data_filter & FILTER_DATA_MCAST))
  4081. return true;
  4082. return false;
  4083. }
  4084. bool dp_pdev_get_filter_non_data(struct cdp_pdev *pdev_handle)
  4085. {
  4086. struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
  4087. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  4088. if ((mon_pdev->fp_mgmt_filter & FILTER_MGMT_ALL) ||
  4089. (mon_pdev->mo_mgmt_filter & FILTER_MGMT_ALL)) {
  4090. if ((mon_pdev->fp_ctrl_filter & FILTER_CTRL_ALL) ||
  4091. (mon_pdev->mo_ctrl_filter & FILTER_CTRL_ALL)) {
  4092. return true;
  4093. }
  4094. }
  4095. return false;
  4096. }
  4097. QDF_STATUS dp_mon_soc_cfg_init(struct dp_soc *soc)
  4098. {
  4099. int target_type;
  4100. struct dp_mon_soc *mon_soc = soc->monitor_soc;
  4101. struct cdp_mon_ops *cdp_ops;
  4102. cdp_ops = dp_mon_cdp_ops_get(soc);
  4103. target_type = hal_get_target_type(soc->hal_soc);
  4104. switch (target_type) {
  4105. case TARGET_TYPE_QCA6290:
  4106. case TARGET_TYPE_QCA6390:
  4107. case TARGET_TYPE_QCA6490:
  4108. case TARGET_TYPE_QCA6750:
  4109. case TARGET_TYPE_KIWI:
  4110. /* do nothing */
  4111. break;
  4112. case TARGET_TYPE_QCA8074:
  4113. wlan_cfg_set_mon_delayed_replenish_entries(soc->wlan_cfg_ctx,
  4114. MON_BUF_MIN_ENTRIES);
  4115. break;
  4116. case TARGET_TYPE_QCA8074V2:
  4117. case TARGET_TYPE_QCA6018:
  4118. case TARGET_TYPE_QCA9574:
  4119. wlan_cfg_set_mon_delayed_replenish_entries(soc->wlan_cfg_ctx,
  4120. MON_BUF_MIN_ENTRIES);
  4121. mon_soc->hw_nac_monitor_support = 1;
  4122. break;
  4123. case TARGET_TYPE_QCN9000:
  4124. wlan_cfg_set_mon_delayed_replenish_entries(soc->wlan_cfg_ctx,
  4125. MON_BUF_MIN_ENTRIES);
  4126. mon_soc->hw_nac_monitor_support = 1;
  4127. if (cfg_get(soc->ctrl_psoc, CFG_DP_FULL_MON_MODE)) {
  4128. if (cdp_ops && cdp_ops->config_full_mon_mode)
  4129. cdp_ops->config_full_mon_mode((struct cdp_soc_t *)soc, 1);
  4130. }
  4131. break;
  4132. case TARGET_TYPE_QCA5018:
  4133. case TARGET_TYPE_QCN6122:
  4134. wlan_cfg_set_mon_delayed_replenish_entries(soc->wlan_cfg_ctx,
  4135. MON_BUF_MIN_ENTRIES);
  4136. mon_soc->hw_nac_monitor_support = 1;
  4137. break;
  4138. case TARGET_TYPE_QCN9224:
  4139. wlan_cfg_set_mon_delayed_replenish_entries(soc->wlan_cfg_ctx,
  4140. MON_BUF_MIN_ENTRIES);
  4141. mon_soc->hw_nac_monitor_support = 1;
  4142. mon_soc->monitor_mode_v2 = 1;
  4143. break;
  4144. default:
  4145. dp_mon_info("%s: Unknown tgt type %d\n", __func__, target_type);
  4146. qdf_assert_always(0);
  4147. break;
  4148. }
  4149. dp_mon_info("hw_nac_monitor_support = %d",
  4150. mon_soc->hw_nac_monitor_support);
  4151. return QDF_STATUS_SUCCESS;
  4152. }
  4153. /**
  4154. * dp_mon_pdev_per_target_config() - Target specific monitor pdev configuration
  4155. * @pdev: PDEV handle [Should be valid]
  4156. *
  4157. * Return: None
  4158. */
  4159. static void dp_mon_pdev_per_target_config(struct dp_pdev *pdev)
  4160. {
  4161. struct dp_soc *soc = pdev->soc;
  4162. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  4163. int target_type;
  4164. target_type = hal_get_target_type(soc->hal_soc);
  4165. switch (target_type) {
  4166. case TARGET_TYPE_KIWI:
  4167. mon_pdev->is_tlv_hdr_64_bit = true;
  4168. break;
  4169. default:
  4170. mon_pdev->is_tlv_hdr_64_bit = false;
  4171. break;
  4172. }
  4173. }
  4174. QDF_STATUS dp_mon_pdev_attach(struct dp_pdev *pdev)
  4175. {
  4176. struct dp_soc *soc;
  4177. struct dp_mon_pdev *mon_pdev;
  4178. struct dp_mon_ops *mon_ops;
  4179. qdf_size_t mon_pdev_context_size;
  4180. if (!pdev) {
  4181. dp_mon_err("pdev is NULL");
  4182. goto fail0;
  4183. }
  4184. soc = pdev->soc;
  4185. mon_pdev_context_size = soc->arch_ops.txrx_get_mon_context_size(DP_CONTEXT_TYPE_MON_PDEV);
  4186. mon_pdev = dp_context_alloc_mem(soc, DP_MON_PDEV_TYPE, mon_pdev_context_size);
  4187. if (!mon_pdev) {
  4188. dp_mon_err("%pK: MONITOR pdev allocation failed", pdev);
  4189. goto fail0;
  4190. }
  4191. pdev->monitor_pdev = mon_pdev;
  4192. mon_ops = dp_mon_ops_get(pdev->soc);
  4193. if (!mon_ops) {
  4194. dp_mon_err("%pK: Invalid monitor ops", pdev);
  4195. goto fail1;
  4196. }
  4197. if (mon_ops->mon_pdev_alloc) {
  4198. if (mon_ops->mon_pdev_alloc(pdev)) {
  4199. dp_mon_err("%pK: MONITOR pdev alloc failed", pdev);
  4200. goto fail1;
  4201. }
  4202. }
  4203. if (mon_ops->mon_rings_alloc) {
  4204. if (mon_ops->mon_rings_alloc(pdev)) {
  4205. dp_mon_err("%pK: MONITOR rings setup failed", pdev);
  4206. goto fail2;
  4207. }
  4208. }
  4209. /* Rx monitor mode specific init */
  4210. if (mon_ops->rx_mon_desc_pool_alloc) {
  4211. if (mon_ops->rx_mon_desc_pool_alloc(pdev)) {
  4212. dp_mon_err("%pK: dp_rx_pdev_mon_attach failed", pdev);
  4213. goto fail3;
  4214. }
  4215. }
  4216. pdev->monitor_pdev = mon_pdev;
  4217. dp_mon_pdev_per_target_config(pdev);
  4218. return QDF_STATUS_SUCCESS;
  4219. fail3:
  4220. if (mon_ops->mon_rings_free)
  4221. mon_ops->mon_rings_free(pdev);
  4222. fail2:
  4223. if (mon_ops->mon_pdev_free)
  4224. mon_ops->mon_pdev_free(pdev);
  4225. fail1:
  4226. pdev->monitor_pdev = NULL;
  4227. qdf_mem_free(mon_pdev);
  4228. fail0:
  4229. return QDF_STATUS_E_NOMEM;
  4230. }
  4231. QDF_STATUS dp_mon_pdev_detach(struct dp_pdev *pdev)
  4232. {
  4233. struct dp_mon_pdev *mon_pdev;
  4234. struct dp_mon_ops *mon_ops = NULL;
  4235. if (!pdev) {
  4236. dp_mon_err("pdev is NULL");
  4237. return QDF_STATUS_E_FAILURE;
  4238. }
  4239. mon_pdev = pdev->monitor_pdev;
  4240. if (!mon_pdev) {
  4241. dp_mon_err("Monitor pdev is NULL");
  4242. return QDF_STATUS_E_FAILURE;
  4243. }
  4244. mon_ops = dp_mon_ops_get(pdev->soc);
  4245. if (!mon_ops) {
  4246. dp_mon_err("Monitor ops is NULL");
  4247. return QDF_STATUS_E_FAILURE;
  4248. }
  4249. if (mon_ops->rx_mon_desc_pool_free)
  4250. mon_ops->rx_mon_desc_pool_free(pdev);
  4251. if (mon_ops->mon_rings_free)
  4252. mon_ops->mon_rings_free(pdev);
  4253. if (mon_ops->mon_pdev_free)
  4254. mon_ops->mon_pdev_free(pdev);
  4255. qdf_mem_free(mon_pdev);
  4256. pdev->monitor_pdev = NULL;
  4257. return QDF_STATUS_SUCCESS;
  4258. }
  4259. QDF_STATUS dp_mon_pdev_init(struct dp_pdev *pdev)
  4260. {
  4261. struct dp_soc *soc;
  4262. struct dp_mon_pdev *mon_pdev;
  4263. struct dp_mon_ops *mon_ops = NULL;
  4264. if (!pdev) {
  4265. dp_mon_err("pdev is NULL");
  4266. return QDF_STATUS_E_FAILURE;
  4267. }
  4268. soc = pdev->soc;
  4269. mon_pdev = pdev->monitor_pdev;
  4270. mon_pdev->invalid_mon_peer = qdf_mem_malloc(sizeof(struct dp_mon_peer));
  4271. if (!mon_pdev->invalid_mon_peer) {
  4272. dp_mon_err("%pK: Memory allocation failed for invalid "
  4273. "monitor peer", pdev);
  4274. return QDF_STATUS_E_NOMEM;
  4275. }
  4276. mon_ops = dp_mon_ops_get(pdev->soc);
  4277. if (!mon_ops) {
  4278. dp_mon_err("Monitor ops is NULL");
  4279. goto fail0;
  4280. }
  4281. mon_pdev->filter = dp_mon_filter_alloc(mon_pdev);
  4282. if (!mon_pdev->filter) {
  4283. dp_mon_err("%pK: Memory allocation failed for monitor filter",
  4284. pdev);
  4285. goto fail0;
  4286. }
  4287. if (mon_ops->tx_mon_filter_alloc) {
  4288. if (mon_ops->tx_mon_filter_alloc(pdev)) {
  4289. dp_mon_err("%pK: Memory allocation failed for tx monitor "
  4290. "filter", pdev);
  4291. goto fail1;
  4292. }
  4293. }
  4294. qdf_spinlock_create(&mon_pdev->ppdu_stats_lock);
  4295. qdf_spinlock_create(&mon_pdev->neighbour_peer_mutex);
  4296. mon_pdev->monitor_configured = false;
  4297. mon_pdev->mon_chan_band = REG_BAND_UNKNOWN;
  4298. TAILQ_INIT(&mon_pdev->neighbour_peers_list);
  4299. mon_pdev->neighbour_peers_added = false;
  4300. mon_pdev->monitor_configured = false;
  4301. /* Monitor filter init */
  4302. mon_pdev->mon_filter_mode = MON_FILTER_ALL;
  4303. mon_pdev->fp_mgmt_filter = FILTER_MGMT_ALL;
  4304. mon_pdev->fp_ctrl_filter = FILTER_CTRL_ALL;
  4305. mon_pdev->fp_data_filter = FILTER_DATA_ALL;
  4306. mon_pdev->mo_mgmt_filter = FILTER_MGMT_ALL;
  4307. mon_pdev->mo_ctrl_filter = FILTER_CTRL_ALL;
  4308. mon_pdev->mo_data_filter = FILTER_DATA_ALL;
  4309. /*
  4310. * initialize ppdu tlv list
  4311. */
  4312. TAILQ_INIT(&mon_pdev->ppdu_info_list);
  4313. TAILQ_INIT(&mon_pdev->sched_comp_ppdu_list);
  4314. mon_pdev->list_depth = 0;
  4315. mon_pdev->tlv_count = 0;
  4316. /* initlialize cal client timer */
  4317. dp_cal_client_attach(&mon_pdev->cal_client_ctx,
  4318. dp_pdev_to_cdp_pdev(pdev),
  4319. pdev->soc->osdev,
  4320. &dp_iterate_update_peer_list);
  4321. if (dp_htt_ppdu_stats_attach(pdev) != QDF_STATUS_SUCCESS)
  4322. goto fail2;
  4323. if (mon_ops->mon_lite_mon_alloc) {
  4324. if (mon_ops->mon_lite_mon_alloc(pdev) != QDF_STATUS_SUCCESS) {
  4325. dp_mon_err("%pK: lite mon alloc failed", pdev);
  4326. goto fail3;
  4327. }
  4328. }
  4329. if (mon_ops->mon_rings_init) {
  4330. if (mon_ops->mon_rings_init(pdev)) {
  4331. dp_mon_err("%pK: MONITOR rings setup failed", pdev);
  4332. goto fail4;
  4333. }
  4334. }
  4335. /* initialize sw monitor rx descriptors */
  4336. if (mon_ops->rx_mon_desc_pool_init)
  4337. mon_ops->rx_mon_desc_pool_init(pdev);
  4338. /* allocate buffers and replenish the monitor RxDMA ring */
  4339. if (mon_ops->rx_mon_buffers_alloc) {
  4340. if (mon_ops->rx_mon_buffers_alloc(pdev)) {
  4341. dp_mon_err("%pK: rx mon buffers alloc failed", pdev);
  4342. goto fail5;
  4343. }
  4344. }
  4345. /* attach monitor function */
  4346. dp_monitor_tx_ppdu_stats_attach(pdev);
  4347. /* mon pdev extended init */
  4348. if (mon_ops->mon_pdev_ext_init)
  4349. mon_ops->mon_pdev_ext_init(pdev);
  4350. mon_pdev->is_dp_mon_pdev_initialized = true;
  4351. return QDF_STATUS_SUCCESS;
  4352. fail5:
  4353. if (mon_ops->rx_mon_desc_pool_deinit)
  4354. mon_ops->rx_mon_desc_pool_deinit(pdev);
  4355. if (mon_ops->mon_rings_deinit)
  4356. mon_ops->mon_rings_deinit(pdev);
  4357. fail4:
  4358. if (mon_ops->mon_lite_mon_dealloc)
  4359. mon_ops->mon_lite_mon_dealloc(pdev);
  4360. fail3:
  4361. dp_htt_ppdu_stats_detach(pdev);
  4362. fail2:
  4363. qdf_spinlock_destroy(&mon_pdev->neighbour_peer_mutex);
  4364. qdf_spinlock_destroy(&mon_pdev->ppdu_stats_lock);
  4365. if (mon_ops->tx_mon_filter_dealloc)
  4366. mon_ops->tx_mon_filter_dealloc(pdev);
  4367. fail1:
  4368. dp_mon_filter_dealloc(mon_pdev);
  4369. fail0:
  4370. qdf_mem_free(mon_pdev->invalid_mon_peer);
  4371. return QDF_STATUS_E_FAILURE;
  4372. }
  4373. QDF_STATUS dp_mon_pdev_deinit(struct dp_pdev *pdev)
  4374. {
  4375. struct dp_mon_pdev *mon_pdev = pdev->monitor_pdev;
  4376. struct dp_mon_ops *mon_ops = NULL;
  4377. mon_ops = dp_mon_ops_get(pdev->soc);
  4378. if (!mon_ops) {
  4379. dp_mon_err("Monitor ops is NULL");
  4380. return QDF_STATUS_E_FAILURE;
  4381. }
  4382. if (!mon_pdev->is_dp_mon_pdev_initialized)
  4383. return QDF_STATUS_SUCCESS;
  4384. dp_mon_filters_reset(pdev);
  4385. /* detach monitor function */
  4386. dp_monitor_tx_ppdu_stats_detach(pdev);
  4387. if (mon_ops->rx_mon_buffers_free)
  4388. mon_ops->rx_mon_buffers_free(pdev);
  4389. if (mon_ops->rx_mon_desc_pool_deinit)
  4390. mon_ops->rx_mon_desc_pool_deinit(pdev);
  4391. if (mon_ops->mon_rings_deinit)
  4392. mon_ops->mon_rings_deinit(pdev);
  4393. dp_cal_client_detach(&mon_pdev->cal_client_ctx);
  4394. if (mon_ops->mon_lite_mon_dealloc)
  4395. mon_ops->mon_lite_mon_dealloc(pdev);
  4396. dp_htt_ppdu_stats_detach(pdev);
  4397. qdf_spinlock_destroy(&mon_pdev->ppdu_stats_lock);
  4398. dp_neighbour_peers_detach(pdev);
  4399. dp_pktlogmod_exit(pdev);
  4400. if (mon_ops->tx_mon_filter_dealloc)
  4401. mon_ops->tx_mon_filter_dealloc(pdev);
  4402. if (mon_pdev->filter)
  4403. dp_mon_filter_dealloc(mon_pdev);
  4404. if (mon_ops->mon_rings_deinit)
  4405. mon_ops->mon_rings_deinit(pdev);
  4406. if (mon_pdev->invalid_mon_peer)
  4407. qdf_mem_free(mon_pdev->invalid_mon_peer);
  4408. mon_pdev->is_dp_mon_pdev_initialized = false;
  4409. return QDF_STATUS_SUCCESS;
  4410. }
  4411. QDF_STATUS dp_mon_vdev_attach(struct dp_vdev *vdev)
  4412. {
  4413. struct dp_mon_vdev *mon_vdev;
  4414. struct dp_pdev *pdev = vdev->pdev;
  4415. mon_vdev = (struct dp_mon_vdev *)qdf_mem_malloc(sizeof(*mon_vdev));
  4416. if (!mon_vdev) {
  4417. dp_mon_err("%pK: Monitor vdev allocation failed", vdev);
  4418. return QDF_STATUS_E_NOMEM;
  4419. }
  4420. if (pdev->monitor_pdev->scan_spcl_vap_configured)
  4421. dp_scan_spcl_vap_stats_attach(mon_vdev);
  4422. vdev->monitor_vdev = mon_vdev;
  4423. return QDF_STATUS_SUCCESS;
  4424. }
  4425. QDF_STATUS dp_mon_vdev_detach(struct dp_vdev *vdev)
  4426. {
  4427. struct dp_mon_vdev *mon_vdev = vdev->monitor_vdev;
  4428. struct dp_pdev *pdev = vdev->pdev;
  4429. struct dp_mon_ops *mon_ops = dp_mon_ops_get(pdev->soc);
  4430. if (!mon_ops)
  4431. return QDF_STATUS_E_FAILURE;
  4432. if (!mon_vdev)
  4433. return QDF_STATUS_E_FAILURE;
  4434. if (pdev->monitor_pdev->scan_spcl_vap_configured)
  4435. dp_scan_spcl_vap_stats_detach(mon_vdev);
  4436. qdf_mem_free(mon_vdev);
  4437. vdev->monitor_vdev = NULL;
  4438. /* set mvdev to NULL only if detach is called for monitor/special vap
  4439. */
  4440. if (pdev->monitor_pdev->mvdev == vdev)
  4441. pdev->monitor_pdev->mvdev = NULL;
  4442. if (mon_ops->mon_lite_mon_vdev_delete)
  4443. mon_ops->mon_lite_mon_vdev_delete(pdev, vdev);
  4444. return QDF_STATUS_SUCCESS;
  4445. }
  4446. #if defined(FEATURE_PERPKT_INFO) && WDI_EVENT_ENABLE
  4447. /**
  4448. * dp_mon_peer_attach_notify() - Raise WDI event for peer create
  4449. * @peer: DP Peer handle
  4450. *
  4451. * Return: none
  4452. */
  4453. static inline
  4454. void dp_mon_peer_attach_notify(struct dp_peer *peer)
  4455. {
  4456. struct dp_mon_peer *mon_peer = peer->monitor_peer;
  4457. struct dp_pdev *pdev;
  4458. struct dp_soc *soc;
  4459. struct cdp_peer_cookie peer_cookie;
  4460. pdev = peer->vdev->pdev;
  4461. soc = pdev->soc;
  4462. qdf_mem_copy(peer_cookie.mac_addr, peer->mac_addr.raw,
  4463. QDF_MAC_ADDR_SIZE);
  4464. peer_cookie.ctx = NULL;
  4465. peer_cookie.pdev_id = pdev->pdev_id;
  4466. peer_cookie.cookie = pdev->next_peer_cookie++;
  4467. dp_wdi_event_handler(WDI_EVENT_PEER_CREATE, soc,
  4468. (void *)&peer_cookie,
  4469. peer->peer_id, WDI_NO_VAL, pdev->pdev_id);
  4470. if (soc->rdkstats_enabled) {
  4471. if (!peer_cookie.ctx) {
  4472. pdev->next_peer_cookie--;
  4473. qdf_err("Failed to initialize peer rate stats");
  4474. mon_peer->rdkstats_ctx = NULL;
  4475. } else {
  4476. mon_peer->rdkstats_ctx = (struct cdp_peer_rate_stats_ctx *)
  4477. peer_cookie.ctx;
  4478. }
  4479. }
  4480. }
  4481. /**
  4482. * dp_mon_peer_detach_notify() - Raise WDI event for peer destroy
  4483. * @peer: DP Peer handle
  4484. *
  4485. * Return: none
  4486. */
  4487. static inline
  4488. void dp_mon_peer_detach_notify(struct dp_peer *peer)
  4489. {
  4490. struct dp_mon_peer *mon_peer = peer->monitor_peer;
  4491. struct dp_pdev *pdev;
  4492. struct dp_soc *soc;
  4493. struct cdp_peer_cookie peer_cookie;
  4494. pdev = peer->vdev->pdev;
  4495. soc = pdev->soc;
  4496. /* send peer destroy event to upper layer */
  4497. qdf_mem_copy(peer_cookie.mac_addr, peer->mac_addr.raw,
  4498. QDF_MAC_ADDR_SIZE);
  4499. peer_cookie.ctx = NULL;
  4500. peer_cookie.ctx = (struct cdp_stats_cookie *)mon_peer->rdkstats_ctx;
  4501. dp_wdi_event_handler(WDI_EVENT_PEER_DESTROY,
  4502. soc,
  4503. (void *)&peer_cookie,
  4504. peer->peer_id,
  4505. WDI_NO_VAL,
  4506. pdev->pdev_id);
  4507. mon_peer->rdkstats_ctx = NULL;
  4508. }
  4509. #else
  4510. static inline
  4511. void dp_mon_peer_attach_notify(struct dp_peer *peer)
  4512. {
  4513. peer->monitor_peer->rdkstats_ctx = NULL;
  4514. }
  4515. static inline
  4516. void dp_mon_peer_detach_notify(struct dp_peer *peer)
  4517. {
  4518. peer->monitor_peer->rdkstats_ctx = NULL;
  4519. }
  4520. #endif
  4521. #if defined(WLAN_TX_PKT_CAPTURE_ENH) || defined(FEATURE_PERPKT_INFO)
  4522. QDF_STATUS dp_mon_peer_attach(struct dp_peer *peer)
  4523. {
  4524. struct dp_mon_peer *mon_peer;
  4525. struct dp_pdev *pdev;
  4526. mon_peer = (struct dp_mon_peer *)qdf_mem_malloc(sizeof(*mon_peer));
  4527. if (!mon_peer) {
  4528. dp_mon_err("%pK: MONITOR peer allocation failed", peer);
  4529. return QDF_STATUS_E_NOMEM;
  4530. }
  4531. peer->monitor_peer = mon_peer;
  4532. pdev = peer->vdev->pdev;
  4533. /*
  4534. * In tx_monitor mode, filter may be set for unassociated peer
  4535. * when unassociated peer get associated peer need to
  4536. * update tx_cap_enabled flag to support peer filter.
  4537. */
  4538. dp_monitor_peer_tx_capture_filter_check(pdev, peer);
  4539. DP_STATS_INIT(mon_peer);
  4540. DP_STATS_UPD(mon_peer, rx.avg_snr, CDP_INVALID_SNR);
  4541. dp_mon_peer_attach_notify(peer);
  4542. return QDF_STATUS_SUCCESS;
  4543. }
  4544. #endif
  4545. QDF_STATUS dp_mon_peer_detach(struct dp_peer *peer)
  4546. {
  4547. struct dp_mon_peer *mon_peer = peer->monitor_peer;
  4548. if (!mon_peer)
  4549. return QDF_STATUS_SUCCESS;
  4550. dp_mon_peer_detach_notify(peer);
  4551. qdf_mem_free(mon_peer);
  4552. peer->monitor_peer = NULL;
  4553. return QDF_STATUS_SUCCESS;
  4554. }
  4555. #ifndef DISABLE_MON_CONFIG
  4556. void dp_mon_register_intr_ops(struct dp_soc *soc)
  4557. {
  4558. struct dp_mon_ops *mon_ops = NULL;
  4559. mon_ops = dp_mon_ops_get(soc);
  4560. if (!mon_ops) {
  4561. dp_mon_err("Monitor ops is NULL");
  4562. return;
  4563. }
  4564. if (mon_ops->mon_register_intr_ops)
  4565. mon_ops->mon_register_intr_ops(soc);
  4566. }
  4567. #endif
  4568. struct cdp_peer_rate_stats_ctx *dp_mon_peer_get_rdkstats_ctx(struct dp_peer *peer)
  4569. {
  4570. struct dp_mon_peer *mon_peer = peer->monitor_peer;
  4571. if (mon_peer)
  4572. return mon_peer->rdkstats_ctx;
  4573. else
  4574. return NULL;
  4575. }
  4576. #ifdef QCA_ENHANCED_STATS_SUPPORT
  4577. void dp_mon_peer_reset_stats(struct dp_peer *peer)
  4578. {
  4579. struct dp_mon_peer *mon_peer = NULL;
  4580. mon_peer = peer->monitor_peer;
  4581. if (!mon_peer)
  4582. return;
  4583. DP_STATS_CLR(mon_peer);
  4584. DP_STATS_UPD(mon_peer, rx.avg_snr, CDP_INVALID_SNR);
  4585. }
  4586. void dp_mon_peer_get_stats(struct dp_peer *peer, void *arg,
  4587. enum cdp_stat_update_type type)
  4588. {
  4589. struct dp_mon_peer *mon_peer = peer->monitor_peer;
  4590. struct dp_mon_peer_stats *mon_peer_stats;
  4591. if (!mon_peer || !arg)
  4592. return;
  4593. mon_peer_stats = &mon_peer->stats;
  4594. switch (type) {
  4595. case UPDATE_PEER_STATS:
  4596. {
  4597. struct cdp_peer_stats *peer_stats =
  4598. (struct cdp_peer_stats *)arg;
  4599. DP_UPDATE_MON_STATS(peer_stats, mon_peer_stats);
  4600. break;
  4601. }
  4602. case UPDATE_VDEV_STATS:
  4603. {
  4604. struct cdp_vdev_stats *vdev_stats =
  4605. (struct cdp_vdev_stats *)arg;
  4606. DP_UPDATE_MON_STATS(vdev_stats, mon_peer_stats);
  4607. break;
  4608. }
  4609. default:
  4610. dp_mon_err("Invalid stats_update_type");
  4611. }
  4612. }
  4613. void dp_mon_invalid_peer_update_pdev_stats(struct dp_pdev *pdev)
  4614. {
  4615. struct dp_mon_peer *mon_peer;
  4616. struct dp_mon_peer_stats *mon_peer_stats;
  4617. struct cdp_pdev_stats *pdev_stats;
  4618. if (!pdev || !pdev->monitor_pdev)
  4619. return;
  4620. mon_peer = pdev->monitor_pdev->invalid_mon_peer;
  4621. if (!mon_peer)
  4622. return;
  4623. mon_peer_stats = &mon_peer->stats;
  4624. pdev_stats = &pdev->stats;
  4625. DP_UPDATE_MON_STATS(pdev_stats, mon_peer_stats);
  4626. }
  4627. QDF_STATUS
  4628. dp_mon_peer_get_stats_param(struct dp_peer *peer, enum cdp_peer_stats_type type,
  4629. cdp_peer_stats_param_t *buf)
  4630. {
  4631. QDF_STATUS ret = QDF_STATUS_SUCCESS;
  4632. struct dp_mon_peer *mon_peer;
  4633. mon_peer = peer->monitor_peer;
  4634. if (!mon_peer)
  4635. return QDF_STATUS_E_FAILURE;
  4636. switch (type) {
  4637. case cdp_peer_tx_rate:
  4638. buf->tx_rate = mon_peer->stats.tx.tx_rate;
  4639. break;
  4640. case cdp_peer_tx_last_tx_rate:
  4641. buf->last_tx_rate = mon_peer->stats.tx.last_tx_rate;
  4642. break;
  4643. case cdp_peer_tx_ratecode:
  4644. buf->tx_ratecode = mon_peer->stats.tx.tx_ratecode;
  4645. break;
  4646. case cdp_peer_rx_rate:
  4647. buf->rx_rate = mon_peer->stats.rx.rx_rate;
  4648. break;
  4649. case cdp_peer_rx_last_rx_rate:
  4650. buf->last_rx_rate = mon_peer->stats.rx.last_rx_rate;
  4651. break;
  4652. case cdp_peer_rx_ratecode:
  4653. buf->rx_ratecode = mon_peer->stats.rx.rx_ratecode;
  4654. break;
  4655. case cdp_peer_rx_avg_snr:
  4656. buf->rx_avg_snr = mon_peer->stats.rx.avg_snr;
  4657. break;
  4658. case cdp_peer_rx_snr:
  4659. buf->rx_snr = mon_peer->stats.rx.snr;
  4660. break;
  4661. default:
  4662. dp_err("Invalid stats type requested");
  4663. ret = QDF_STATUS_E_FAILURE;
  4664. }
  4665. return ret;
  4666. }
  4667. #endif
  4668. void dp_mon_ops_register(struct dp_soc *soc)
  4669. {
  4670. struct dp_mon_soc *mon_soc = soc->monitor_soc;
  4671. uint32_t target_type;
  4672. target_type = hal_get_target_type(soc->hal_soc);
  4673. switch (target_type) {
  4674. case TARGET_TYPE_QCA6290:
  4675. case TARGET_TYPE_QCA6390:
  4676. case TARGET_TYPE_QCA6490:
  4677. case TARGET_TYPE_QCA6750:
  4678. case TARGET_TYPE_KIWI:
  4679. case TARGET_TYPE_QCA8074:
  4680. case TARGET_TYPE_QCA8074V2:
  4681. case TARGET_TYPE_QCA6018:
  4682. case TARGET_TYPE_QCA9574:
  4683. case TARGET_TYPE_QCN9000:
  4684. case TARGET_TYPE_QCA5018:
  4685. case TARGET_TYPE_QCN6122:
  4686. dp_mon_ops_register_1_0(mon_soc);
  4687. break;
  4688. case TARGET_TYPE_QCN9224:
  4689. #ifdef QCA_MONITOR_2_0_SUPPORT
  4690. dp_mon_ops_register_2_0(mon_soc);
  4691. #endif
  4692. break;
  4693. default:
  4694. dp_mon_err("%s: Unknown tgt type %d", __func__, target_type);
  4695. qdf_assert_always(0);
  4696. break;
  4697. }
  4698. }
  4699. #ifdef QCA_MONITOR_OPS_PER_SOC_SUPPORT
  4700. void dp_mon_ops_free(struct dp_soc *soc)
  4701. {
  4702. struct cdp_ops *ops = soc->cdp_soc.ops;
  4703. struct cdp_mon_ops *cdp_mon_ops = ops->mon_ops;
  4704. struct dp_mon_soc *mon_soc = soc->monitor_soc;
  4705. struct dp_mon_ops *mon_ops = mon_soc->mon_ops;
  4706. if (cdp_mon_ops)
  4707. qdf_mem_free(cdp_mon_ops);
  4708. if (mon_ops)
  4709. qdf_mem_free(mon_ops);
  4710. }
  4711. #else
  4712. void dp_mon_ops_free(struct dp_soc *soc)
  4713. {
  4714. }
  4715. #endif
  4716. void dp_mon_cdp_ops_register(struct dp_soc *soc)
  4717. {
  4718. struct cdp_ops *ops = soc->cdp_soc.ops;
  4719. uint32_t target_type;
  4720. if (!ops) {
  4721. dp_mon_err("cdp_ops is NULL");
  4722. return;
  4723. }
  4724. target_type = hal_get_target_type(soc->hal_soc);
  4725. switch (target_type) {
  4726. case TARGET_TYPE_QCA6290:
  4727. case TARGET_TYPE_QCA6390:
  4728. case TARGET_TYPE_QCA6490:
  4729. case TARGET_TYPE_QCA6750:
  4730. case TARGET_TYPE_KIWI:
  4731. case TARGET_TYPE_QCA8074:
  4732. case TARGET_TYPE_QCA8074V2:
  4733. case TARGET_TYPE_QCA6018:
  4734. case TARGET_TYPE_QCA9574:
  4735. case TARGET_TYPE_QCN9000:
  4736. case TARGET_TYPE_QCA5018:
  4737. case TARGET_TYPE_QCN6122:
  4738. dp_mon_cdp_ops_register_1_0(ops);
  4739. break;
  4740. case TARGET_TYPE_QCN9224:
  4741. #ifdef QCA_MONITOR_2_0_SUPPORT
  4742. dp_mon_cdp_ops_register_2_0(ops);
  4743. #endif
  4744. break;
  4745. default:
  4746. dp_mon_err("%s: Unknown tgt type %d", __func__, target_type);
  4747. qdf_assert_always(0);
  4748. break;
  4749. }
  4750. #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE)
  4751. ops->cfr_ops->txrx_cfr_filter = dp_cfr_filter;
  4752. #endif
  4753. ops->cmn_drv_ops->txrx_set_monitor_mode = dp_vdev_set_monitor_mode;
  4754. ops->cmn_drv_ops->txrx_get_mon_vdev_from_pdev =
  4755. dp_get_mon_vdev_from_pdev_wifi3;
  4756. #ifdef DP_PEER_EXTENDED_API
  4757. ops->misc_ops->pkt_log_init = dp_pkt_log_init;
  4758. ops->misc_ops->pkt_log_con_service = dp_pkt_log_con_service;
  4759. ops->misc_ops->pkt_log_exit = dp_pkt_log_exit;
  4760. #endif
  4761. #ifdef ATH_SUPPORT_NAC_RSSI
  4762. ops->ctrl_ops->txrx_vdev_config_for_nac_rssi = dp_config_for_nac_rssi;
  4763. ops->ctrl_ops->txrx_vdev_get_neighbour_rssi =
  4764. dp_vdev_get_neighbour_rssi;
  4765. #endif
  4766. #if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
  4767. ops->ctrl_ops->txrx_update_filter_neighbour_peers =
  4768. dp_update_filter_neighbour_peers;
  4769. #endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */
  4770. ops->ctrl_ops->enable_peer_based_pktlog =
  4771. dp_enable_peer_based_pktlog;
  4772. #if defined(WLAN_TX_PKT_CAPTURE_ENH) || defined(WLAN_RX_PKT_CAPTURE_ENH)
  4773. ops->ctrl_ops->txrx_update_peer_pkt_capture_params =
  4774. dp_peer_update_pkt_capture_params;
  4775. #endif /* WLAN_TX_PKT_CAPTURE_ENH || WLAN_RX_PKT_CAPTURE_ENH */
  4776. #ifdef QCA_ENHANCED_STATS_SUPPORT
  4777. ops->host_stats_ops->txrx_enable_enhanced_stats =
  4778. dp_enable_enhanced_stats;
  4779. ops->host_stats_ops->txrx_disable_enhanced_stats =
  4780. dp_disable_enhanced_stats;
  4781. #endif /* QCA_ENHANCED_STATS_SUPPORT */
  4782. #ifdef WDI_EVENT_ENABLE
  4783. ops->ctrl_ops->txrx_get_pldev = dp_get_pldev;
  4784. #endif
  4785. #ifdef QCA_SUPPORT_SCAN_SPCL_VAP_STATS
  4786. ops->host_stats_ops->txrx_get_scan_spcl_vap_stats =
  4787. dp_get_scan_spcl_vap_stats;
  4788. #endif
  4789. return;
  4790. }
  4791. #ifdef QCA_MONITOR_OPS_PER_SOC_SUPPORT
  4792. static inline void
  4793. dp_mon_cdp_mon_ops_deregister(struct cdp_ops *ops)
  4794. {
  4795. if (ops->mon_ops) {
  4796. qdf_mem_free(ops->mon_ops);
  4797. ops->mon_ops = NULL;
  4798. }
  4799. }
  4800. #else
  4801. static inline void
  4802. dp_mon_cdp_mon_ops_deregister(struct cdp_ops *ops)
  4803. {
  4804. ops->mon_ops = NULL;
  4805. }
  4806. #endif
  4807. void dp_mon_cdp_ops_deregister(struct dp_soc *soc)
  4808. {
  4809. struct cdp_ops *ops = soc->cdp_soc.ops;
  4810. if (!ops) {
  4811. dp_mon_err("cdp_ops is NULL");
  4812. return;
  4813. }
  4814. dp_mon_cdp_mon_ops_deregister(ops);
  4815. #if defined(WLAN_CFR_ENABLE) && defined(WLAN_ENH_CFR_ENABLE)
  4816. ops->cfr_ops->txrx_cfr_filter = NULL;
  4817. #endif
  4818. ops->cmn_drv_ops->txrx_set_monitor_mode = NULL;
  4819. ops->cmn_drv_ops->txrx_get_mon_vdev_from_pdev = NULL;
  4820. #ifdef DP_PEER_EXTENDED_API
  4821. ops->misc_ops->pkt_log_init = NULL;
  4822. ops->misc_ops->pkt_log_con_service = NULL;
  4823. ops->misc_ops->pkt_log_exit = NULL;
  4824. #endif
  4825. #ifdef ATH_SUPPORT_NAC_RSSI
  4826. ops->ctrl_ops->txrx_vdev_config_for_nac_rssi = NULL;
  4827. ops->ctrl_ops->txrx_vdev_get_neighbour_rssi = NULL;
  4828. #endif
  4829. #if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
  4830. ops->ctrl_ops->txrx_update_filter_neighbour_peers = NULL;
  4831. #endif /* ATH_SUPPORT_NAC_RSSI || ATH_SUPPORT_NAC */
  4832. ops->ctrl_ops->enable_peer_based_pktlog = NULL;
  4833. #if defined(WLAN_TX_PKT_CAPTURE_ENH) || defined(WLAN_RX_PKT_CAPTURE_ENH)
  4834. ops->ctrl_ops->txrx_update_peer_pkt_capture_params = NULL;
  4835. #endif /* WLAN_TX_PKT_CAPTURE_ENH || WLAN_RX_PKT_CAPTURE_ENH */
  4836. #ifdef FEATURE_PERPKT_INFO
  4837. ops->host_stats_ops->txrx_enable_enhanced_stats = NULL;
  4838. ops->host_stats_ops->txrx_disable_enhanced_stats = NULL;
  4839. #endif /* FEATURE_PERPKT_INFO */
  4840. #ifdef WDI_EVENT_ENABLE
  4841. ops->ctrl_ops->txrx_get_pldev = NULL;
  4842. #endif
  4843. return;
  4844. }
  4845. void dp_mon_intr_ops_deregister(struct dp_soc *soc)
  4846. {
  4847. struct dp_mon_soc *mon_soc = soc->monitor_soc;
  4848. mon_soc->mon_rx_process = NULL;
  4849. }
  4850. void dp_mon_feature_ops_deregister(struct dp_soc *soc)
  4851. {
  4852. struct dp_mon_ops *mon_ops = dp_mon_ops_get(soc);
  4853. if (!mon_ops) {
  4854. dp_err("mon_ops is NULL");
  4855. return;
  4856. }
  4857. mon_ops->mon_config_debug_sniffer = NULL;
  4858. mon_ops->mon_peer_tx_init = NULL;
  4859. mon_ops->mon_peer_tx_cleanup = NULL;
  4860. mon_ops->mon_htt_ppdu_stats_attach = NULL;
  4861. mon_ops->mon_htt_ppdu_stats_detach = NULL;
  4862. mon_ops->mon_print_pdev_rx_mon_stats = NULL;
  4863. mon_ops->mon_set_bsscolor = NULL;
  4864. mon_ops->mon_pdev_get_filter_ucast_data = NULL;
  4865. mon_ops->mon_pdev_get_filter_mcast_data = NULL;
  4866. mon_ops->mon_pdev_get_filter_non_data = NULL;
  4867. mon_ops->mon_neighbour_peer_add_ast = NULL;
  4868. #ifdef WLAN_TX_PKT_CAPTURE_ENH
  4869. mon_ops->mon_peer_tid_peer_id_update = NULL;
  4870. mon_ops->mon_tx_ppdu_stats_attach = NULL;
  4871. mon_ops->mon_tx_ppdu_stats_detach = NULL;
  4872. mon_ops->mon_tx_capture_debugfs_init = NULL;
  4873. mon_ops->mon_tx_add_to_comp_queue = NULL;
  4874. mon_ops->mon_peer_tx_capture_filter_check = NULL;
  4875. mon_ops->mon_print_pdev_tx_capture_stats = NULL;
  4876. mon_ops->mon_config_enh_tx_capture = NULL;
  4877. #endif
  4878. #if defined(WDI_EVENT_ENABLE) &&\
  4879. (defined(QCA_ENHANCED_STATS_SUPPORT) || !defined(REMOVE_PKT_LOG))
  4880. mon_ops->mon_ppdu_stats_ind_handler = NULL;
  4881. #endif
  4882. #ifdef WLAN_RX_PKT_CAPTURE_ENH
  4883. mon_ops->mon_config_enh_rx_capture = NULL;
  4884. #endif
  4885. #ifdef QCA_SUPPORT_BPR
  4886. mon_ops->mon_set_bpr_enable = NULL;
  4887. #endif
  4888. #ifdef ATH_SUPPORT_NAC
  4889. mon_ops->mon_set_filter_neigh_peers = NULL;
  4890. #endif
  4891. #ifdef WLAN_ATF_ENABLE
  4892. mon_ops->mon_set_atf_stats_enable = NULL;
  4893. #endif
  4894. #ifdef FEATURE_NAC_RSSI
  4895. mon_ops->mon_filter_neighbour_peer = NULL;
  4896. #endif
  4897. #ifdef QCA_MCOPY_SUPPORT
  4898. mon_ops->mon_filter_setup_mcopy_mode = NULL;
  4899. mon_ops->mon_filter_reset_mcopy_mode = NULL;
  4900. mon_ops->mon_mcopy_check_deliver = NULL;
  4901. #endif
  4902. #ifdef QCA_ENHANCED_STATS_SUPPORT
  4903. mon_ops->mon_filter_setup_enhanced_stats = NULL;
  4904. mon_ops->mon_tx_enable_enhanced_stats = NULL;
  4905. mon_ops->mon_tx_disable_enhanced_stats = NULL;
  4906. mon_ops->mon_ppdu_desc_deliver = NULL;
  4907. mon_ops->mon_ppdu_desc_notify = NULL;
  4908. mon_ops->mon_ppdu_stats_feat_enable_check = NULL;
  4909. #ifdef WLAN_FEATURE_11BE
  4910. mon_ops->mon_tx_stats_update = NULL;
  4911. #endif
  4912. #endif
  4913. #if defined(ATH_SUPPORT_NAC_RSSI) || defined(ATH_SUPPORT_NAC)
  4914. mon_ops->mon_filter_setup_smart_monitor = NULL;
  4915. #endif
  4916. #ifdef WLAN_RX_PKT_CAPTURE_ENH
  4917. mon_ops->mon_filter_setup_rx_enh_capture = NULL;
  4918. #endif
  4919. #ifdef WDI_EVENT_ENABLE
  4920. mon_ops->mon_set_pktlog_wifi3 = NULL;
  4921. mon_ops->mon_filter_setup_rx_pkt_log_full = NULL;
  4922. mon_ops->mon_filter_reset_rx_pkt_log_full = NULL;
  4923. mon_ops->mon_filter_setup_rx_pkt_log_lite = NULL;
  4924. mon_ops->mon_filter_reset_rx_pkt_log_lite = NULL;
  4925. mon_ops->mon_filter_setup_rx_pkt_log_cbf = NULL;
  4926. mon_ops->mon_filter_reset_rx_pkt_log_cbf = NULL;
  4927. #ifdef BE_PKTLOG_SUPPORT
  4928. mon_ops->mon_filter_setup_pktlog_hybrid = NULL;
  4929. mon_ops->mon_filter_reset_pktlog_hybrid = NULL;
  4930. #endif
  4931. #endif
  4932. #if defined(DP_CON_MON) && !defined(REMOVE_PKT_LOG)
  4933. mon_ops->mon_pktlogmod_exit = NULL;
  4934. #endif
  4935. mon_ops->rx_packet_length_set = NULL;
  4936. mon_ops->rx_wmask_subscribe = NULL;
  4937. mon_ops->rx_enable_mpdu_logging = NULL;
  4938. mon_ops->mon_neighbour_peers_detach = NULL;
  4939. mon_ops->mon_vdev_set_monitor_mode_buf_rings = NULL;
  4940. mon_ops->mon_vdev_set_monitor_mode_rings = NULL;
  4941. #ifdef QCA_ENHANCED_STATS_SUPPORT
  4942. mon_ops->mon_rx_stats_update = NULL;
  4943. mon_ops->mon_rx_populate_ppdu_usr_info = NULL;
  4944. mon_ops->mon_rx_populate_ppdu_info = NULL;
  4945. #endif
  4946. }
  4947. QDF_STATUS dp_mon_soc_attach(struct dp_soc *soc)
  4948. {
  4949. struct dp_mon_soc *mon_soc;
  4950. if (!soc) {
  4951. dp_mon_err("dp_soc is NULL");
  4952. return QDF_STATUS_E_FAILURE;
  4953. }
  4954. mon_soc = (struct dp_mon_soc *)qdf_mem_malloc(sizeof(*mon_soc));
  4955. if (!mon_soc) {
  4956. dp_mon_err("%pK: mem allocation failed", soc);
  4957. return QDF_STATUS_E_NOMEM;
  4958. }
  4959. /* register monitor ops */
  4960. soc->monitor_soc = mon_soc;
  4961. dp_mon_ops_register(soc);
  4962. dp_mon_register_intr_ops(soc);
  4963. dp_mon_cdp_ops_register(soc);
  4964. dp_mon_register_feature_ops(soc);
  4965. return QDF_STATUS_SUCCESS;
  4966. }
  4967. QDF_STATUS dp_mon_soc_detach(struct dp_soc *soc)
  4968. {
  4969. struct dp_mon_soc *mon_soc;
  4970. if (!soc) {
  4971. dp_mon_err("dp_soc is NULL");
  4972. return QDF_STATUS_E_FAILURE;
  4973. }
  4974. mon_soc = soc->monitor_soc;
  4975. dp_monitor_vdev_timer_deinit(soc);
  4976. dp_mon_cdp_ops_deregister(soc);
  4977. soc->monitor_soc = NULL;
  4978. qdf_mem_free(mon_soc);
  4979. return QDF_STATUS_SUCCESS;
  4980. }