dp_mon.c 176 KB

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