dp_mon.c 188 KB

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