dp_mon.c 188 KB

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