dp_mon.c 164 KB

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