dp_tx_capture.c 174 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199620062016202620362046205620662076208620962106211621262136214621562166217621862196220622162226223622462256226622762286229623062316232623362346235623662376238623962406241624262436244624562466247624862496250625162526253625462556256625762586259626062616262626362646265626662676268626962706271627262736274627562766277627862796280628162826283628462856286628762886289629062916292629362946295629662976298629963006301630263036304630563066307630863096310631163126313631463156316631763186319632063216322632363246325632663276328632963306331633263336334633563366337633863396340634163426343634463456346634763486349635063516352635363546355635663576358635963606361636263636364636563666367636863696370637163726373637463756376637763786379638063816382638363846385638663876388638963906391639263936394639563966397639863996400640164026403640464056406640764086409641064116412641364146415641664176418641964206421642264236424642564266427642864296430643164326433643464356436643764386439644064416442644364446445
  1. /*
  2. * Copyright (c) 2017-2020 The Linux Foundation. All rights reserved.
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for
  5. * any purpose with or without fee is hereby granted, provided that the
  6. * above copyright notice and this permission notice appear in all
  7. * copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16. * PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #include <htt.h>
  19. #include "qdf_trace.h"
  20. #include "qdf_nbuf.h"
  21. #include "dp_peer.h"
  22. #include "dp_types.h"
  23. #include "dp_internal.h"
  24. #include "htt_ppdu_stats.h"
  25. #include "dp_htt.h"
  26. #include "qdf_mem.h" /* qdf_mem_malloc,free */
  27. #include "cdp_txrx_cmn_struct.h"
  28. #include <enet.h>
  29. #include <linux/debugfs.h>
  30. #include <linux/uaccess.h>
  31. #include "qdf_lock.h"
  32. #include "qdf_debugfs.h"
  33. #include "dp_tx_capture.h"
  34. #define MAX_MONITOR_HEADER (512)
  35. #define MAX_DUMMY_FRM_BODY (128)
  36. #define DP_BA_ACK_FRAME_SIZE (sizeof(struct ieee80211_ctlframe_addr2) + 36)
  37. #define DP_ACK_FRAME_SIZE (sizeof(struct ieee80211_frame_min_one))
  38. #define DP_CTS_FRAME_SIZE (sizeof(struct ieee80211_frame_min_one))
  39. #define DP_ACKNOACK_FRAME_SIZE (sizeof(struct ieee80211_frame) + 16)
  40. #define DP_MAX_MPDU_64 64
  41. #define DP_NUM_WORDS_PER_PPDU_BITMAP_64 (DP_MAX_MPDU_64 >> 5)
  42. #define DP_NUM_BYTES_PER_PPDU_BITMAP_64 (DP_MAX_MPDU_64 >> 3)
  43. #define DP_NUM_BYTES_PER_PPDU_BITMAP (HAL_RX_MAX_MPDU >> 3)
  44. #define DP_IEEE80211_BAR_CTL_TID_S 12
  45. #define DP_IEEE80211_BAR_CTL_TID_M 0xf
  46. #define DP_IEEE80211_BAR_CTL_POLICY_S 0
  47. #define DP_IEEE80211_BAR_CTL_POLICY_M 0x1
  48. #define DP_IEEE80211_BA_S_SEQ_S 4
  49. #define DP_IEEE80211_BAR_CTL_COMBA 0x0004
  50. #define INVALID_PPDU_ID 0xFFFF
  51. #define MAX_END_TSF 0xFFFFFFFF
  52. #define DP_IEEE80211_CATEGORY_VHT (21)
  53. #define DP_NOACK_SOUNDING_TOKEN_POS (4)
  54. #define DP_NOACK_STOKEN_POS_SHIFT (2)
  55. #define DP_NDPA_TOKEN_POS (16)
  56. /* Macros to handle sequence number bitmaps */
  57. /* HW generated rts frame flag */
  58. #define SEND_WIFIRTS_LEGACY_E 1
  59. /* HW generated 11 AC static bw flag */
  60. #define SEND_WIFIRTS_11AC_STATIC_BW_E 2
  61. /* HW generated 11 AC dynamic bw flag */
  62. #define SEND_WIFIRTS_11AC_DYNAMIC_BW_E 3
  63. /* HW generated cts frame flag */
  64. #define SEND_WIFICTS2SELF_E 4
  65. /* Size (in bits) of a segment of sequence number bitmap */
  66. #define SEQ_SEG_SZ_BITS(_seqarr) (sizeof(_seqarr[0]) << 3)
  67. /* Array index of a segment of sequence number bitmap */
  68. #define SEQ_SEG_INDEX(_seqarr, _seqno) ((_seqno) / SEQ_SEG_SZ_BITS(_seqarr))
  69. /* Bit mask of a seqno within a segment of sequence bitmap */
  70. #define SEQ_SEG_MSK(_seqseg, _index) \
  71. (1 << ((_index) & ((sizeof(_seqseg) << 3) - 1)))
  72. /* Check seqno bit in a segment of sequence bitmap */
  73. #define SEQ_SEG_BIT(_seqseg, _index) \
  74. ((_seqseg) & SEQ_SEG_MSK((_seqseg), _index))
  75. /* Segment of sequence bitmap containing a given sequence number */
  76. #define SEQ_SEG(_seqarr, _seqno) \
  77. (_seqarr[(_seqno) / (sizeof(_seqarr[0]) << 3)])
  78. /* Check seqno bit in the sequence bitmap */
  79. #define SEQ_BIT(_seqarr, _seqno) \
  80. SEQ_SEG_BIT(SEQ_SEG(_seqarr, (_seqno)), (_seqno))
  81. /* Lower 32 mask for timestamp us as completion path has 32 bits timestamp */
  82. #define LOWER_32_MASK 0xFFFFFFFF
  83. /* Maximum time taken to enqueue next mgmt pkt */
  84. #define MAX_MGMT_ENQ_DELAY 10000
  85. /* Schedule id counter mask in ppdu_id */
  86. #define SCH_ID_MASK 0xFF
  87. #define IEEE80211_IS_ZERO(_a) \
  88. ((_a)[0] == 0x00 && \
  89. (_a)[1] == 0x00 && \
  90. (_a)[2] == 0x00 && \
  91. (_a)[3] == 0x00 && \
  92. (_a)[4] == 0x00 && \
  93. (_a)[5] == 0x00)
  94. /* Maximum number of retries */
  95. #define MAX_RETRY_Q_COUNT 20
  96. #define DP_PEER_TX_TID_INIT_DONE_BIT 0
  97. #ifdef WLAN_TX_PKT_CAPTURE_ENH
  98. /* stats counter */
  99. #ifdef WLAN_TX_PKT_CAPTURE_ENH_DEBUG
  100. /**
  101. * dp_tx_cap_stats_msdu_update() - update msdu level stats counter per peer
  102. * @peer: DP PEER object
  103. * @msdu_desc: msdu desc index
  104. * @count: count to update
  105. *
  106. * Return: void
  107. */
  108. static inline
  109. void dp_tx_cap_stats_msdu_update(struct dp_peer *peer,
  110. uint8_t msdu_desc, uint32_t count)
  111. {
  112. struct dp_peer_tx_capture_stats *stats;
  113. stats = &peer->tx_capture.stats;
  114. stats->msdu[msdu_desc] += count;
  115. }
  116. /**
  117. * dp_tx_cap_stats_mpdu_update() - update mpdu level stats counter per peer
  118. * @peer: DP PEER object
  119. * @mpdu_desc: mpdu desc index
  120. * @count: count to update
  121. *
  122. * Return: void
  123. */
  124. static inline
  125. void dp_tx_cap_stats_mpdu_update(struct dp_peer *peer,
  126. uint8_t mpdu_desc, uint32_t count)
  127. {
  128. struct dp_peer_tx_capture_stats *stats;
  129. stats = &peer->tx_capture.stats;
  130. stats->mpdu[mpdu_desc] += count;
  131. }
  132. /**
  133. * dp_tx_capture_print_stats() - print stats counter per peer
  134. * @peer: DP PEER object
  135. *
  136. * Return: void
  137. */
  138. static inline
  139. void dp_tx_capture_print_stats(struct dp_peer *peer)
  140. {
  141. struct dp_peer_tx_capture_stats *stats;
  142. stats = &peer->tx_capture.stats;
  143. DP_PRINT_STATS(" peer_id[%d] MSDU[S:%u E:%u D:%u F:%u DP:%u X:%u] MPDU[T:%u S:%u R:%u A:%u C:%u ST:%u]",
  144. peer->peer_id,
  145. stats->msdu[PEER_MSDU_SUCC],
  146. stats->msdu[PEER_MSDU_ENQ],
  147. stats->msdu[PEER_MSDU_DEQ],
  148. stats->msdu[PEER_MSDU_FLUSH],
  149. stats->msdu[PEER_MSDU_DROP],
  150. stats->msdu[PEER_MSDU_XRETRY],
  151. stats->mpdu[PEER_MPDU_TRI],
  152. stats->mpdu[PEER_MPDU_SUCC],
  153. stats->mpdu[PEER_MPDU_RESTITCH],
  154. stats->mpdu[PEER_MPDU_ARR],
  155. stats->mpdu[PEER_MPDU_CLONE],
  156. stats->mpdu[PEER_MPDU_TO_STACK]);
  157. }
  158. #else
  159. /**
  160. * dp_tx_cap_stats_msdu_update() - update msdu level stats counter per peer
  161. * @peer: DP PEER object
  162. * @msdu_desc: msdu desc index
  163. * @count: count to update
  164. *
  165. * Return: void
  166. */
  167. static inline
  168. void dp_tx_cap_stats_msdu_update(struct dp_peer *peer,
  169. uint8_t msdu_desc, uint32_t count)
  170. {
  171. }
  172. /**
  173. * dp_tx_cap_stats_mpdu_update() - update mpdu level stats counter per peer
  174. * @peer: DP PEER object
  175. * @mpdu_desc: mpdu desc index
  176. * @count: count to update
  177. *
  178. * Return: void
  179. */
  180. static inline
  181. void dp_tx_cap_stats_mpdu_update(struct dp_peer *peer,
  182. uint8_t mpdu_desc, uint32_t count)
  183. {
  184. }
  185. /**
  186. * dp_tx_capture_print_stats() - print stats counter per peer
  187. * @peer: DP PEER object
  188. *
  189. * Return: void
  190. */
  191. static inline
  192. void dp_tx_capture_print_stats(struct dp_peer *peer)
  193. {
  194. }
  195. #endif
  196. /*
  197. * dp_tx_capture_htt_frame_counter: increment counter for htt_frame_type
  198. * pdev: DP pdev handle
  199. * htt_frame_type: htt frame type received from fw
  200. *
  201. * return: void
  202. */
  203. void dp_tx_capture_htt_frame_counter(struct dp_pdev *pdev,
  204. uint32_t htt_frame_type)
  205. {
  206. if (htt_frame_type >= TX_CAP_HTT_MAX_FTYPE)
  207. return;
  208. pdev->tx_capture.htt_frame_type[htt_frame_type]++;
  209. }
  210. static void
  211. dp_peer_print_tid_qlen(struct dp_soc *soc,
  212. struct dp_peer *peer,
  213. void *arg)
  214. {
  215. int tid;
  216. struct dp_tx_tid *tx_tid;
  217. uint32_t msdu_len;
  218. uint32_t tasklet_msdu_len;
  219. uint32_t ppdu_len;
  220. struct tid_q_len *c_tid_q_len = (struct tid_q_len *)arg;
  221. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  222. tx_tid = &peer->tx_capture.tx_tid[tid];
  223. msdu_len = qdf_nbuf_queue_len(&tx_tid->defer_msdu_q);
  224. tasklet_msdu_len = qdf_nbuf_queue_len(&tx_tid->msdu_comp_q);
  225. ppdu_len = qdf_nbuf_queue_len(&tx_tid->pending_ppdu_q);
  226. /*
  227. * if not NULL requested for aggreated stats hence add and
  228. * return do not print individual peer stats
  229. */
  230. if (c_tid_q_len) {
  231. c_tid_q_len->defer_msdu_len += msdu_len;
  232. c_tid_q_len->tasklet_msdu_len += tasklet_msdu_len;
  233. c_tid_q_len->pending_q_len += ppdu_len;
  234. continue;
  235. }
  236. if (!msdu_len && !ppdu_len && !tasklet_msdu_len)
  237. continue;
  238. DP_PRINT_STATS(" peer_id[%d] tid[%d] msdu_comp_q[%d] defer_msdu_q[%d] pending_ppdu_q[%d]",
  239. peer->peer_id, tid,
  240. tasklet_msdu_len,
  241. msdu_len, ppdu_len);
  242. }
  243. dp_tx_capture_print_stats(peer);
  244. }
  245. /*
  246. * dp_iterate_print_tid_qlen_per_peer()- API to print peer tid msdu queue
  247. * @pdev_handle: DP_PDEV handle
  248. *
  249. * Return: void
  250. */
  251. void dp_print_tid_qlen_per_peer(void *pdev_hdl, uint8_t consolidated)
  252. {
  253. struct dp_pdev *pdev = (struct dp_pdev *)pdev_hdl;
  254. DP_PRINT_STATS("pending peer msdu and ppdu:");
  255. if (consolidated) {
  256. struct tid_q_len c_tid_q_len = {0};
  257. dp_pdev_iterate_peer(pdev, dp_peer_print_tid_qlen, &c_tid_q_len,
  258. DP_MOD_ID_TX_CAPTURE);
  259. DP_PRINT_STATS("consolidated: msdu_comp_q[%d] defer_msdu_q[%d] pending_ppdu_q[%d]",
  260. c_tid_q_len.tasklet_msdu_len, c_tid_q_len.defer_msdu_len,
  261. c_tid_q_len.pending_q_len);
  262. }
  263. dp_pdev_iterate_peer(pdev, dp_peer_print_tid_qlen, NULL,
  264. DP_MOD_ID_TX_CAPTURE);
  265. }
  266. static void
  267. dp_ppdu_queue_free(qdf_nbuf_t ppdu_nbuf, uint8_t usr_idx)
  268. {
  269. int i;
  270. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  271. struct cdp_tx_completion_ppdu_user *user;
  272. qdf_nbuf_t mpdu_nbuf = NULL;
  273. if (!ppdu_nbuf)
  274. return;
  275. ppdu_desc = (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(ppdu_nbuf);
  276. if (!ppdu_desc)
  277. return;
  278. user = &ppdu_desc->user[usr_idx];
  279. if (!user->mpdus)
  280. goto free_ppdu_desc_mpdu_q;
  281. for (i = 0; i < user->ba_size &&
  282. i < CDP_BA_256_BIT_MAP_SIZE_DWORDS; i++) {
  283. mpdu_nbuf = user->mpdus[i];
  284. if (mpdu_nbuf) {
  285. qdf_nbuf_free(mpdu_nbuf);
  286. user->mpdus[i] = NULL;
  287. }
  288. }
  289. free_ppdu_desc_mpdu_q:
  290. if (!qdf_nbuf_is_queue_empty(&user->mpdu_q))
  291. qdf_nbuf_queue_free(&user->mpdu_q);
  292. if (user->mpdus)
  293. qdf_mem_free(user->mpdus);
  294. user->mpdus = NULL;
  295. }
  296. /*
  297. * dp_tx_cature_stats: print tx capture stats
  298. * @pdev: DP PDEV handle
  299. *
  300. * return: void
  301. */
  302. void dp_print_pdev_tx_capture_stats(struct dp_pdev *pdev)
  303. {
  304. struct dp_pdev_tx_capture *ptr_tx_cap;
  305. uint8_t i = 0, j = 0;
  306. ptr_tx_cap = &(pdev->tx_capture);
  307. DP_PRINT_STATS("tx capture stats:");
  308. DP_PRINT_STATS(" pending ppdu dropped: %u",
  309. ptr_tx_cap->pend_ppdu_dropped);
  310. DP_PRINT_STATS(" ppdu stats queue depth: %u",
  311. ptr_tx_cap->ppdu_stats_queue_depth);
  312. DP_PRINT_STATS(" ppdu stats defer queue depth: %u",
  313. ptr_tx_cap->ppdu_stats_defer_queue_depth);
  314. DP_PRINT_STATS(" mgmt control enqueue stats:");
  315. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  316. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  317. if (ptr_tx_cap->ctl_mgmt_q[i][j].qlen)
  318. DP_PRINT_STATS(" ctl_mgmt_q[%d][%d] = queue_len[%d]",
  319. i, j, ptr_tx_cap->ctl_mgmt_q[i][j].qlen);
  320. }
  321. }
  322. DP_PRINT_STATS(" mgmt control retry queue stats:");
  323. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  324. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  325. if (ptr_tx_cap->retries_ctl_mgmt_q[i][j].qlen)
  326. DP_PRINT_STATS(" retries_ctl_mgmt_q[%d][%d] = queue_len[%d]",
  327. i, j,
  328. ptr_tx_cap->retries_ctl_mgmt_q[i][j].qlen);
  329. }
  330. }
  331. for (i = 0; i < TX_CAP_HTT_MAX_FTYPE; i++) {
  332. if (!ptr_tx_cap->htt_frame_type[i])
  333. continue;
  334. DP_PRINT_STATS(" sgen htt frame type[%d] = %d",
  335. i, ptr_tx_cap->htt_frame_type[i]);
  336. }
  337. dp_print_tid_qlen_per_peer(pdev, 0);
  338. }
  339. /**
  340. * dp_peer_or_pdev_tx_cap_enabled - Returns status of tx_cap_enabled
  341. * based on global per-pdev setting or per-peer setting
  342. * @pdev: Datapath pdev handle
  343. * @peer: Datapath peer
  344. * @mac_addr: peer mac address
  345. *
  346. * Return: true if feature is enabled on a per-pdev basis or if
  347. * enabled for the given peer when per-peer mode is set, false otherwise
  348. */
  349. inline bool
  350. dp_peer_or_pdev_tx_cap_enabled(struct dp_pdev *pdev,
  351. struct dp_peer *peer, uint8_t *mac_addr)
  352. {
  353. if (pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS) {
  354. return true;
  355. } else if (pdev->tx_capture_enabled ==
  356. CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) {
  357. if (peer && peer->tx_cap_enabled)
  358. return true;
  359. /* do search based on mac address */
  360. return is_dp_peer_mgmt_pkt_filter(pdev,
  361. HTT_INVALID_PEER,
  362. mac_addr);
  363. }
  364. return false;
  365. }
  366. /*
  367. * dp_tx_find_usr_idx_from_peer_id()- find user index based on peer_id
  368. * @ppdu_desc: pointer to ppdu_desc structure
  369. * @peer_id: peer id
  370. *
  371. * Return: user index
  372. */
  373. static uint8_t
  374. dp_tx_find_usr_idx_from_peer_id(struct cdp_tx_completion_ppdu *ppdu_desc,
  375. uint16_t peer_id)
  376. {
  377. uint8_t usr_idx = 0;
  378. bool found = false;
  379. for (usr_idx = 0; usr_idx < ppdu_desc->num_users; usr_idx++) {
  380. if (ppdu_desc->user[usr_idx].peer_id == peer_id) {
  381. found = true;
  382. break;
  383. }
  384. }
  385. if (!found) {
  386. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  387. QDF_TRACE_LEVEL_FATAL,
  388. "%s: %d peer_id: %d, ppdu_desc[%p][num_users: %d]\n",
  389. __func__, __LINE__, peer_id, ppdu_desc,
  390. ppdu_desc->num_users);
  391. qdf_assert_always(0);
  392. }
  393. return usr_idx;
  394. }
  395. /*
  396. * dp_peer_tid_peer_id_update() – update peer_id to tid structure
  397. * @peer: Datapath peer
  398. * @peer_id: peer_id
  399. *
  400. */
  401. void dp_peer_tid_peer_id_update(struct dp_peer *peer, uint16_t peer_id)
  402. {
  403. int tid;
  404. struct dp_tx_tid *tx_tid;
  405. dp_peer_tid_queue_init(peer);
  406. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  407. tx_tid = &peer->tx_capture.tx_tid[tid];
  408. tx_tid->peer_id = peer_id;
  409. if (tx_tid->tid != tid) {
  410. qdf_err("tx tid is corrupted for tid %d, peer_id %d", tid, peer_id);
  411. tx_tid->tid = tid;
  412. }
  413. }
  414. }
  415. /*
  416. * dp_peer_tid_queue_init() – Initialize ppdu stats queue per TID
  417. * @peer: Datapath peer
  418. *
  419. */
  420. void dp_peer_tid_queue_init(struct dp_peer *peer)
  421. {
  422. int tid;
  423. struct dp_tx_tid *tx_tid;
  424. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  425. tx_tid = &peer->tx_capture.tx_tid[tid];
  426. if (qdf_atomic_test_and_set_bit(DP_PEER_TX_TID_INIT_DONE_BIT,
  427. &tx_tid->tid_flags))
  428. continue;
  429. tx_tid->tid = tid;
  430. qdf_nbuf_queue_init(&tx_tid->defer_msdu_q);
  431. qdf_nbuf_queue_init(&tx_tid->msdu_comp_q);
  432. qdf_nbuf_queue_init(&tx_tid->pending_ppdu_q);
  433. tx_tid->max_ppdu_id = 0;
  434. tx_tid->xretry_ppdu =
  435. qdf_mem_malloc(sizeof(struct cdp_tx_completion_ppdu) +
  436. sizeof(struct cdp_tx_completion_ppdu_user));
  437. if (qdf_unlikely(!tx_tid->xretry_ppdu)) {
  438. int i;
  439. QDF_TRACE(QDF_MODULE_ID_TXRX,
  440. QDF_TRACE_LEVEL_ERROR,
  441. "Alloc failed");
  442. for (i = 0; i < tid; i++) {
  443. tx_tid = &peer->tx_capture.tx_tid[i];
  444. qdf_mem_free(tx_tid->xretry_ppdu);
  445. qdf_atomic_clear_bit(DP_PEER_TX_TID_INIT_DONE_BIT,
  446. &tx_tid->tid_flags);
  447. }
  448. QDF_ASSERT(0);
  449. return;
  450. }
  451. /* spinlock create */
  452. qdf_spinlock_create(&tx_tid->tid_lock);
  453. qdf_spinlock_create(&tx_tid->tasklet_tid_lock);
  454. }
  455. peer->tx_capture.is_tid_initialized = 1;
  456. }
  457. /*
  458. * dp_peer_tx_cap_tid_queue_flush() – flush peer tx cap per TID
  459. * @peer: Datapath peer
  460. *
  461. * return: void
  462. */
  463. static
  464. void dp_peer_tx_cap_tid_queue_flush(struct dp_peer *peer)
  465. {
  466. int tid;
  467. struct dp_tx_tid *tx_tid;
  468. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  469. tx_tid = &peer->tx_capture.tx_tid[tid];
  470. qdf_spin_lock_bh(&tx_tid->tid_lock);
  471. qdf_nbuf_queue_free(&tx_tid->defer_msdu_q);
  472. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  473. qdf_spin_lock_bh(&tx_tid->tasklet_tid_lock);
  474. qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
  475. qdf_spin_unlock_bh(&tx_tid->tasklet_tid_lock);
  476. tx_tid->max_ppdu_id = 0;
  477. }
  478. }
  479. /*
  480. * dp_peer_tid_queue_cleanup() – remove ppdu stats queue per TID
  481. * @peer: Datapath peer
  482. *
  483. */
  484. void dp_peer_tid_queue_cleanup(struct dp_peer *peer)
  485. {
  486. struct dp_tx_tid *tx_tid;
  487. struct cdp_tx_completion_ppdu *xretry_ppdu;
  488. struct cdp_tx_completion_ppdu_user *xretry_user;
  489. struct cdp_tx_completion_ppdu *ppdu_desc;
  490. struct cdp_tx_completion_ppdu_user *user;
  491. qdf_nbuf_t ppdu_nbuf = NULL;
  492. int tid;
  493. uint16_t peer_id;
  494. if (!peer->tx_capture.is_tid_initialized)
  495. return;
  496. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  497. tx_tid = &peer->tx_capture.tx_tid[tid];
  498. if (!qdf_atomic_test_and_clear_bit(DP_PEER_TX_TID_INIT_DONE_BIT,
  499. &tx_tid->tid_flags))
  500. continue;
  501. xretry_ppdu = tx_tid->xretry_ppdu;
  502. xretry_user = &xretry_ppdu->user[0];
  503. qdf_spin_lock_bh(&tx_tid->tid_lock);
  504. qdf_nbuf_queue_free(&tx_tid->defer_msdu_q);
  505. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  506. qdf_spin_lock_bh(&tx_tid->tasklet_tid_lock);
  507. qdf_nbuf_queue_free(&tx_tid->msdu_comp_q);
  508. qdf_spin_unlock_bh(&tx_tid->tasklet_tid_lock);
  509. /* spinlock destroy */
  510. qdf_spinlock_destroy(&tx_tid->tid_lock);
  511. qdf_spinlock_destroy(&tx_tid->tasklet_tid_lock);
  512. peer_id = tx_tid->peer_id;
  513. /* free pending ppdu_q and xretry mpdu_q */
  514. while ((ppdu_nbuf = qdf_nbuf_queue_remove(
  515. &tx_tid->pending_ppdu_q))) {
  516. uint8_t usr_idx;
  517. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  518. qdf_nbuf_data(ppdu_nbuf);
  519. /*
  520. * check if peer id is matching
  521. * the user peer_id
  522. */
  523. usr_idx = dp_tx_find_usr_idx_from_peer_id(ppdu_desc,
  524. peer_id);
  525. user = &ppdu_desc->user[usr_idx];
  526. /* free all the mpdu_q and mpdus for usr_idx */
  527. dp_ppdu_queue_free(ppdu_nbuf, usr_idx);
  528. qdf_nbuf_free(ppdu_nbuf);
  529. }
  530. qdf_nbuf_queue_free(&xretry_user->mpdu_q);
  531. qdf_mem_free(xretry_ppdu);
  532. tx_tid->max_ppdu_id = 0;
  533. }
  534. peer->tx_capture.is_tid_initialized = 0;
  535. }
  536. /*
  537. * dp_peer_update_80211_hdr: update 80211 hdr
  538. * @vdev: DP VDEV
  539. * @peer: DP PEER
  540. *
  541. * return: void
  542. */
  543. void dp_peer_update_80211_hdr(struct dp_vdev *vdev, struct dp_peer *peer)
  544. {
  545. struct ieee80211_frame *ptr_wh;
  546. ptr_wh = &peer->tx_capture.tx_wifi_hdr;
  547. /* i_addr1 - Receiver mac address */
  548. /* i_addr2 - Transmitter mac address */
  549. /* i_addr3 - Destination mac address */
  550. qdf_mem_copy(ptr_wh->i_addr1,
  551. peer->mac_addr.raw,
  552. QDF_MAC_ADDR_SIZE);
  553. qdf_mem_copy(ptr_wh->i_addr3,
  554. peer->mac_addr.raw,
  555. QDF_MAC_ADDR_SIZE);
  556. qdf_mem_copy(ptr_wh->i_addr2,
  557. vdev->mac_addr.raw,
  558. QDF_MAC_ADDR_SIZE);
  559. }
  560. /*
  561. * dp_deliver_mgmt_frm: Process
  562. * @pdev: DP PDEV handle
  563. * @nbuf: buffer containing the htt_ppdu_stats_tx_mgmtctrl_payload_tlv
  564. *
  565. * return: void
  566. */
  567. void dp_deliver_mgmt_frm(struct dp_pdev *pdev, qdf_nbuf_t nbuf)
  568. {
  569. if (pdev->tx_sniffer_enable || pdev->mcopy_mode) {
  570. dp_wdi_event_handler(WDI_EVENT_TX_MGMT_CTRL, pdev->soc,
  571. nbuf, HTT_INVALID_PEER,
  572. WDI_NO_VAL, pdev->pdev_id);
  573. return;
  574. }
  575. if (pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS ||
  576. pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENDIS_PER_PEER) {
  577. /* invoke WDI event handler here send mgmt pkt here */
  578. struct ieee80211_frame *wh;
  579. uint8_t type, subtype;
  580. struct cdp_tx_mgmt_comp_info *ptr_mgmt_hdr;
  581. ptr_mgmt_hdr = (struct cdp_tx_mgmt_comp_info *)
  582. qdf_nbuf_data(nbuf);
  583. wh = (struct ieee80211_frame *)(qdf_nbuf_data(nbuf) +
  584. sizeof(struct cdp_tx_mgmt_comp_info));
  585. type = (wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) >>
  586. IEEE80211_FC0_TYPE_SHIFT;
  587. subtype = (wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) >>
  588. IEEE80211_FC0_SUBTYPE_SHIFT;
  589. if (!ptr_mgmt_hdr->ppdu_id || !ptr_mgmt_hdr->tx_tsf ||
  590. (!type && !subtype)) {
  591. /*
  592. * if either ppdu_id and tx_tsf are zero then
  593. * storing the payload won't be useful
  594. * in constructing the packet
  595. * Hence freeing the packet
  596. */
  597. qdf_nbuf_free(nbuf);
  598. return;
  599. }
  600. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, NULL, wh->i_addr1)) {
  601. qdf_nbuf_free(nbuf);
  602. return;
  603. }
  604. if (((wh->i_fc[0] & IEEE80211_FC0_TYPE_MASK) ==
  605. IEEE80211_FC0_TYPE_MGT) &&
  606. ((wh->i_fc[0] & IEEE80211_FC0_SUBTYPE_MASK) ==
  607. IEEE80211_FC0_SUBTYPE_ACTION)) {
  608. uint8_t *frm;
  609. struct ieee80211_action *ia;
  610. frm = (u_int8_t *)&wh[1];
  611. ia = (struct ieee80211_action *)frm;
  612. if ((ia->ia_category == IEEE80211_ACTION_CAT_S1G) &&
  613. (ia->ia_action == IEEE80211_ACTION_TWT_SETUP)) {
  614. ptr_mgmt_hdr->is_sgen_pkt = false;
  615. }
  616. }
  617. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  618. "dlvr mgmt frm(%d 0x%08x): fc 0x%x %x, dur 0x%x%x tsf:%u, retries_count: %d, is_sgen: %d",
  619. ptr_mgmt_hdr->ppdu_id,
  620. ptr_mgmt_hdr->ppdu_id,
  621. wh->i_fc[1], wh->i_fc[0],
  622. wh->i_dur[1], wh->i_dur[0], ptr_mgmt_hdr->tx_tsf,
  623. ptr_mgmt_hdr->retries_count,
  624. ptr_mgmt_hdr->is_sgen_pkt);
  625. QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_TX_CAPTURE,
  626. QDF_TRACE_LEVEL_DEBUG,
  627. qdf_nbuf_data(nbuf), 64);
  628. qdf_spin_lock_bh(
  629. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  630. qdf_nbuf_queue_add(&pdev->tx_capture.ctl_mgmt_q[type][subtype],
  631. nbuf);
  632. qdf_spin_unlock_bh(
  633. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  634. } else {
  635. if (!pdev->bpr_enable)
  636. qdf_nbuf_free(nbuf);
  637. }
  638. }
  639. static inline int dp_peer_compare_mac_addr(void *addr1, void *addr2)
  640. {
  641. union dp_align_mac_addr *mac_addr1 = (union dp_align_mac_addr *)addr1;
  642. union dp_align_mac_addr *mac_addr2 = (union dp_align_mac_addr *)addr2;
  643. return !((mac_addr1->align4.bytes_abcd == mac_addr2->align4.bytes_abcd)
  644. & (mac_addr1->align4.bytes_ef == mac_addr2->align4.bytes_ef));
  645. }
  646. /*
  647. * dp_peer_tx_cap_search: filter mgmt pkt based on peer and mac address
  648. * @pdev: DP PDEV handle
  649. * @peer_id: DP PEER ID
  650. * @mac_addr: pointer to mac address
  651. *
  652. * return: true on matched and false on not found
  653. */
  654. static
  655. bool dp_peer_tx_cap_search(struct dp_pdev *pdev,
  656. uint16_t peer_id, uint8_t *mac_addr)
  657. {
  658. struct dp_pdev_tx_capture *tx_capture;
  659. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  660. uint8_t i = 0;
  661. bool found = false;
  662. tx_capture = &pdev->tx_capture;
  663. /* search based on mac address */
  664. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  665. uint8_t *peer_mac_addr;
  666. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  667. if (ptr_peer_mgmt_list->avail)
  668. continue;
  669. peer_mac_addr = ptr_peer_mgmt_list->mac_addr;
  670. if (!dp_peer_compare_mac_addr(mac_addr,
  671. peer_mac_addr)) {
  672. found = true;
  673. break;
  674. }
  675. }
  676. return found;
  677. }
  678. /*
  679. * dp_peer_tx_cap_add_filter: add peer filter mgmt pkt based on peer
  680. * and mac address
  681. * @pdev: DP PDEV handle
  682. * @peer_id: DP PEER ID
  683. * @mac_addr: pointer to mac address
  684. *
  685. * return: true on added and false on not failed
  686. */
  687. bool dp_peer_tx_cap_add_filter(struct dp_pdev *pdev,
  688. uint16_t peer_id, uint8_t *mac_addr)
  689. {
  690. struct dp_pdev_tx_capture *tx_capture;
  691. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  692. uint8_t i = 0;
  693. bool status = false;
  694. tx_capture = &pdev->tx_capture;
  695. if (dp_peer_tx_cap_search(pdev, peer_id, mac_addr)) {
  696. /* mac address and peer_id already there */
  697. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  698. "%s: %d peer_id[%d] mac_addr[%pM] already there\n",
  699. __func__, __LINE__, peer_id, mac_addr);
  700. return status;
  701. }
  702. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  703. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  704. if (!ptr_peer_mgmt_list->avail)
  705. continue;
  706. qdf_mem_copy(ptr_peer_mgmt_list->mac_addr,
  707. mac_addr, QDF_MAC_ADDR_SIZE);
  708. ptr_peer_mgmt_list->avail = false;
  709. ptr_peer_mgmt_list->peer_id = peer_id;
  710. status = true;
  711. break;
  712. }
  713. return status;
  714. }
  715. /*
  716. * dp_peer_tx_cap_del_all_filter: delete all peer filter mgmt pkt based on peer
  717. * and mac address
  718. * @pdev: DP PDEV handle
  719. * @peer_id: DP PEER ID
  720. * @mac_addr: pointer to mac address
  721. *
  722. * return: void
  723. */
  724. void dp_peer_tx_cap_del_all_filter(struct dp_pdev *pdev)
  725. {
  726. struct dp_pdev_tx_capture *tx_capture;
  727. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  728. uint8_t i = 0;
  729. tx_capture = &pdev->tx_capture;
  730. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  731. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  732. ptr_peer_mgmt_list->avail = true;
  733. ptr_peer_mgmt_list->peer_id = HTT_INVALID_PEER;
  734. qdf_mem_zero(ptr_peer_mgmt_list->mac_addr, QDF_MAC_ADDR_SIZE);
  735. }
  736. }
  737. /*
  738. * dp_peer_tx_cap_del_filter: delete peer filter mgmt pkt based on peer
  739. * and mac address
  740. * @pdev: DP PDEV handle
  741. * @peer_id: DP PEER ID
  742. * @mac_addr: pointer to mac address
  743. *
  744. * return: true on added and false on not failed
  745. */
  746. bool dp_peer_tx_cap_del_filter(struct dp_pdev *pdev,
  747. uint16_t peer_id, uint8_t *mac_addr)
  748. {
  749. struct dp_pdev_tx_capture *tx_capture;
  750. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  751. uint8_t i = 0;
  752. bool status = false;
  753. tx_capture = &pdev->tx_capture;
  754. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  755. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  756. if (!dp_peer_compare_mac_addr(mac_addr,
  757. ptr_peer_mgmt_list->mac_addr) &&
  758. (!ptr_peer_mgmt_list->avail)) {
  759. ptr_peer_mgmt_list->avail = true;
  760. ptr_peer_mgmt_list->peer_id = HTT_INVALID_PEER;
  761. qdf_mem_zero(ptr_peer_mgmt_list->mac_addr,
  762. QDF_MAC_ADDR_SIZE);
  763. status = true;
  764. break;
  765. }
  766. }
  767. if (!status)
  768. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  769. "unable to delete peer[%d] mac[%pM] filter list",
  770. peer_id, mac_addr);
  771. return status;
  772. }
  773. /*
  774. * dp_peer_tx_cap_print_mgmt_filter: pradd peer filter mgmt pkt based on peer
  775. * and mac address
  776. * @pdev: DP PDEV handle
  777. * @peer_id: DP PEER ID
  778. * @mac_addr: pointer to mac address
  779. *
  780. * return: true on added and false on not failed
  781. */
  782. void dp_peer_tx_cap_print_mgmt_filter(struct dp_pdev *pdev,
  783. uint16_t peer_id, uint8_t *mac_addr)
  784. {
  785. struct dp_pdev_tx_capture *tx_capture;
  786. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  787. uint8_t i = 0;
  788. tx_capture = &pdev->tx_capture;
  789. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  790. "peer filter list:");
  791. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  792. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  793. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  794. "peer_id[%d] mac_addr[%pM] avail[%d]",
  795. ptr_peer_mgmt_list->peer_id,
  796. ptr_peer_mgmt_list->mac_addr,
  797. ptr_peer_mgmt_list->avail);
  798. }
  799. }
  800. /*
  801. * dp_peer_mgmt_pkt_filter: filter mgmt pkt based on peer and mac address
  802. * @pdev: DP PDEV handle
  803. * @nbuf: buffer containing the ppdu_desc
  804. *
  805. * return: status
  806. */
  807. bool is_dp_peer_mgmt_pkt_filter(struct dp_pdev *pdev,
  808. uint32_t peer_id, uint8_t *mac_addr)
  809. {
  810. bool found = false;
  811. found = dp_peer_tx_cap_search(pdev, peer_id, mac_addr);
  812. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  813. "%s: %d peer_id[%d] mac_addr[%pM] found[%d]!",
  814. __func__, __LINE__, peer_id, mac_addr, found);
  815. return found;
  816. }
  817. /**
  818. * ppdu_desc_dbg_enqueue() - enqueue tx cap debug ppdu desc to the list
  819. * @ptr_log_info: tx capture log info
  820. * @ptr_dbg_ppdu: tx capture ppdu desc pointer
  821. *
  822. * Return: list size
  823. */
  824. static
  825. uint32_t ppdu_desc_dbg_enqueue(struct tx_cap_debug_log_info *ptr_log_info,
  826. struct dbg_tx_comp_ppdu *ptr_dbg_ppdu)
  827. {
  828. uint32_t list_size;
  829. qdf_spin_lock(&ptr_log_info->dbg_log_lock);
  830. qdf_list_insert_back_size(&ptr_log_info->ppdu_dbg_queue,
  831. &ptr_dbg_ppdu->node, &list_size);
  832. qdf_spin_unlock(&ptr_log_info->dbg_log_lock);
  833. return list_size;
  834. }
  835. /**
  836. * ppdu_desc_dbg_dequeue() - dequeue tx cap debug ppdu desc from list
  837. * @ptr_log_info: tx capture log info
  838. *
  839. * Return: tx capture ppdu desc pointer
  840. */
  841. static
  842. struct dbg_tx_comp_ppdu *
  843. ppdu_desc_dbg_dequeue(struct tx_cap_debug_log_info *ptr_log_info)
  844. {
  845. qdf_list_node_t *list_node = NULL;
  846. qdf_spin_lock(&ptr_log_info->dbg_log_lock);
  847. qdf_list_remove_front(&ptr_log_info->ppdu_dbg_queue, &list_node);
  848. qdf_spin_unlock(&ptr_log_info->dbg_log_lock);
  849. if (!list_node)
  850. return NULL;
  851. return qdf_container_of(list_node, struct dbg_tx_comp_ppdu, node);
  852. }
  853. /*
  854. * ppdu_desc_dbg_queue_init: ppdu desc logging debugfs queue init
  855. * @ptr_log_info: tx capture debugfs log structure
  856. *
  857. * return: void
  858. */
  859. static void ppdu_desc_dbg_queue_init(struct tx_cap_debug_log_info *ptr_log_info)
  860. {
  861. ptr_log_info->ppdu_queue_size = MAX_TX_CAP_QUEUE_SIZE;
  862. qdf_list_create(&ptr_log_info->ppdu_dbg_queue,
  863. ptr_log_info->ppdu_queue_size);
  864. qdf_spinlock_create(&ptr_log_info->dbg_log_lock);
  865. ptr_log_info->pause_dbg_log = 0;
  866. }
  867. /*
  868. * ppdu_desc_dbg_queue_deinit: ppdu desc logging debugfs queue deinit
  869. * @ptr_log_info: tx capture debugfs log structure
  870. *
  871. * return: void
  872. */
  873. static
  874. void ppdu_desc_dbg_queue_deinit(struct tx_cap_debug_log_info *ptr_log_info)
  875. {
  876. qdf_list_destroy(&ptr_log_info->ppdu_dbg_queue);
  877. qdf_spinlock_destroy(&ptr_log_info->dbg_log_lock);
  878. }
  879. /**
  880. * dp_tx_ppdu_stats_attach - Initialize Tx PPDU stats and enhanced capture
  881. * @pdev: DP PDEV
  882. *
  883. * Return: none
  884. */
  885. void dp_tx_ppdu_stats_attach(struct dp_pdev *pdev)
  886. {
  887. struct dp_peer_mgmt_list *ptr_peer_mgmt_list;
  888. struct dp_pdev_tx_capture *tx_capture;
  889. struct tx_cap_debug_log_info *ptr_log_info;
  890. int i, j;
  891. qdf_atomic_init(&pdev->tx_capture.tx_cap_usr_mode);
  892. qdf_atomic_set(&pdev->tx_capture.tx_cap_usr_mode, 0);
  893. tx_capture = &pdev->tx_capture;
  894. ptr_log_info = &tx_capture->log_info;
  895. /* Work queue setup for HTT stats and tx capture handling */
  896. qdf_create_work(0, &pdev->tx_capture.ppdu_stats_work,
  897. dp_tx_ppdu_stats_process,
  898. pdev);
  899. pdev->tx_capture.ppdu_stats_workqueue =
  900. qdf_alloc_unbound_workqueue("ppdu_stats_work_queue");
  901. STAILQ_INIT(&pdev->tx_capture.ppdu_stats_queue);
  902. STAILQ_INIT(&pdev->tx_capture.ppdu_stats_defer_queue);
  903. qdf_spinlock_create(&pdev->tx_capture.ppdu_stats_lock);
  904. pdev->tx_capture.ppdu_stats_queue_depth = 0;
  905. pdev->tx_capture.ppdu_stats_next_sched = 0;
  906. pdev->tx_capture.ppdu_stats_defer_queue_depth = 0;
  907. pdev->tx_capture.ppdu_dropped = 0;
  908. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  909. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  910. qdf_nbuf_queue_init(
  911. &pdev->tx_capture.ctl_mgmt_q[i][j]);
  912. qdf_spinlock_create(
  913. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  914. }
  915. }
  916. pdev->tx_capture.dummy_ppdu_desc = qdf_mem_malloc(
  917. sizeof(struct cdp_tx_completion_ppdu) +
  918. sizeof(struct cdp_tx_completion_ppdu_user));
  919. if (qdf_unlikely(!pdev->tx_capture.dummy_ppdu_desc)) {
  920. QDF_TRACE(QDF_MODULE_ID_TXRX,
  921. QDF_TRACE_LEVEL_ERROR,
  922. "Alloc failed");
  923. QDF_ASSERT(0);
  924. return;
  925. }
  926. pdev->tx_capture.ptr_peer_mgmt_list = (struct dp_peer_mgmt_list *)
  927. qdf_mem_malloc(sizeof(struct dp_peer_mgmt_list) *
  928. MAX_MGMT_PEER_FILTER);
  929. for (i = 0; i < MAX_MGMT_PEER_FILTER; i++) {
  930. ptr_peer_mgmt_list = &tx_capture->ptr_peer_mgmt_list[i];
  931. ptr_peer_mgmt_list->avail = true;
  932. }
  933. ppdu_desc_dbg_queue_init(ptr_log_info);
  934. }
  935. /**
  936. * dp_tx_ppdu_stats_detach - Cleanup Tx PPDU stats and enhanced capture
  937. * @pdev: DP PDEV
  938. *
  939. * Return: none
  940. */
  941. void dp_tx_ppdu_stats_detach(struct dp_pdev *pdev)
  942. {
  943. struct ppdu_info *ppdu_info, *tmp_ppdu_info = NULL;
  944. struct tx_cap_debug_log_info *ptr_log_info;
  945. int i, j;
  946. void *buf;
  947. if (!pdev || !pdev->tx_capture.ppdu_stats_workqueue)
  948. return;
  949. ptr_log_info = &pdev->tx_capture.log_info;
  950. qdf_flush_workqueue(0, pdev->tx_capture.ppdu_stats_workqueue);
  951. qdf_destroy_workqueue(0, pdev->tx_capture.ppdu_stats_workqueue);
  952. qdf_spinlock_destroy(&pdev->tx_capture.ppdu_stats_lock);
  953. STAILQ_FOREACH_SAFE(ppdu_info,
  954. &pdev->tx_capture.ppdu_stats_queue,
  955. ppdu_info_queue_elem, tmp_ppdu_info) {
  956. STAILQ_REMOVE(&pdev->tx_capture.ppdu_stats_queue,
  957. ppdu_info, ppdu_info, ppdu_info_queue_elem);
  958. qdf_nbuf_free(ppdu_info->nbuf);
  959. qdf_mem_free(ppdu_info);
  960. }
  961. STAILQ_FOREACH_SAFE(ppdu_info,
  962. &pdev->tx_capture.ppdu_stats_defer_queue,
  963. ppdu_info_queue_elem, tmp_ppdu_info) {
  964. STAILQ_REMOVE(&pdev->tx_capture.ppdu_stats_defer_queue,
  965. ppdu_info, ppdu_info, ppdu_info_queue_elem);
  966. qdf_nbuf_free(ppdu_info->nbuf);
  967. qdf_mem_free(ppdu_info);
  968. }
  969. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  970. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  971. qdf_nbuf_queue_t *retries_q;
  972. qdf_spin_lock_bh(
  973. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  974. qdf_nbuf_queue_free(
  975. &pdev->tx_capture.ctl_mgmt_q[i][j]);
  976. qdf_spin_unlock_bh(
  977. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  978. qdf_spinlock_destroy(
  979. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  980. retries_q = &pdev->tx_capture.retries_ctl_mgmt_q[i][j];
  981. if (!qdf_nbuf_is_queue_empty(retries_q))
  982. qdf_nbuf_queue_free(retries_q);
  983. }
  984. }
  985. qdf_mem_free(pdev->tx_capture.dummy_ppdu_desc);
  986. qdf_mem_free(pdev->tx_capture.ptr_peer_mgmt_list);
  987. /* disable the ppdu_desc_log to avoid storing further */
  988. ptr_log_info->ppdu_desc_log = 0;
  989. ptr_log_info->pause_dbg_log = 1;
  990. /* loop through the list and free the nbuf */
  991. while (!qdf_list_empty(&ptr_log_info->ppdu_dbg_queue)) {
  992. buf = ppdu_desc_dbg_dequeue(ptr_log_info);
  993. if (!buf)
  994. qdf_mem_free(buf);
  995. }
  996. ppdu_desc_dbg_queue_deinit(ptr_log_info);
  997. dp_tx_capture_debugfs_deinit(pdev);
  998. }
  999. #define MAX_MSDU_THRESHOLD_TSF 100000
  1000. #define MAX_MSDU_ENQUEUE_THRESHOLD 4096
  1001. /**
  1002. * dp_drop_enq_msdu_on_thresh(): Function to drop msdu when exceed
  1003. * storing threshold limit
  1004. * @peer: dp_peer
  1005. * @tx_tid: tx tid
  1006. * @ptr_msdu_comp_q: pointer to skb queue, it can be either tasklet or WQ msdu q
  1007. * @tsf: current timestamp
  1008. *
  1009. * return: status
  1010. */
  1011. QDF_STATUS
  1012. dp_drop_enq_msdu_on_thresh(struct dp_peer *peer,
  1013. struct dp_tx_tid *tx_tid,
  1014. qdf_nbuf_queue_t *ptr_msdu_comp_q,
  1015. uint32_t tsf)
  1016. {
  1017. struct msdu_completion_info *ptr_msdu_info = NULL;
  1018. qdf_nbuf_t nbuf;
  1019. qdf_nbuf_t head_msdu;
  1020. uint32_t tsf_delta;
  1021. uint32_t qlen;
  1022. /* take lock here */
  1023. qdf_spin_lock_bh(&tx_tid->tasklet_tid_lock);
  1024. while ((head_msdu = qdf_nbuf_queue_first(ptr_msdu_comp_q))) {
  1025. ptr_msdu_info =
  1026. (struct msdu_completion_info *)qdf_nbuf_data(head_msdu);
  1027. if (tsf > ptr_msdu_info->tsf)
  1028. tsf_delta = tsf - ptr_msdu_info->tsf;
  1029. else
  1030. tsf_delta = LOWER_32_MASK - ptr_msdu_info->tsf + tsf;
  1031. if (tsf_delta < MAX_MSDU_THRESHOLD_TSF)
  1032. break;
  1033. /* free head */
  1034. nbuf = qdf_nbuf_queue_remove(ptr_msdu_comp_q);
  1035. if (qdf_unlikely(!nbuf)) {
  1036. qdf_assert_always(0);
  1037. break;
  1038. }
  1039. qdf_nbuf_free(nbuf);
  1040. dp_tx_cap_stats_msdu_update(peer, PEER_MSDU_DROP, 1);
  1041. }
  1042. /* get queue length */
  1043. qlen = qdf_nbuf_queue_len(ptr_msdu_comp_q);
  1044. /* release lock here */
  1045. qdf_spin_unlock_bh(&tx_tid->tasklet_tid_lock);
  1046. /* take lock here */
  1047. qdf_spin_lock_bh(&tx_tid->tid_lock);
  1048. qlen += qdf_nbuf_queue_len(&tx_tid->defer_msdu_q);
  1049. if (qlen > MAX_MSDU_ENQUEUE_THRESHOLD) {
  1050. qdf_nbuf_t nbuf = NULL;
  1051. /* free head, nbuf will be NULL if queue empty */
  1052. nbuf = qdf_nbuf_queue_remove(&tx_tid->defer_msdu_q);
  1053. /* release lock here */
  1054. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  1055. if (qdf_likely(nbuf)) {
  1056. qdf_nbuf_free(nbuf);
  1057. dp_tx_cap_stats_msdu_update(peer, PEER_MSDU_DROP, 1);
  1058. return QDF_STATUS_SUCCESS;
  1059. }
  1060. /* take lock here */
  1061. qdf_spin_lock_bh(&tx_tid->tasklet_tid_lock);
  1062. if (!qdf_nbuf_is_queue_empty(ptr_msdu_comp_q)) {
  1063. /* free head, nbuf will be NULL if queue empty */
  1064. nbuf = qdf_nbuf_queue_remove(ptr_msdu_comp_q);
  1065. /* release lock here */
  1066. qdf_spin_unlock_bh(&tx_tid->tasklet_tid_lock);
  1067. if (qdf_unlikely(!nbuf)) {
  1068. qdf_assert_always(0);
  1069. return QDF_STATUS_E_ABORTED;
  1070. }
  1071. qdf_nbuf_free(nbuf);
  1072. dp_tx_cap_stats_msdu_update(peer, PEER_MSDU_DROP, 1);
  1073. } else {
  1074. /* release lock here */
  1075. qdf_spin_unlock_bh(&tx_tid->tasklet_tid_lock);
  1076. }
  1077. } else {
  1078. /* release lock here */
  1079. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  1080. }
  1081. return QDF_STATUS_SUCCESS;
  1082. }
  1083. /**
  1084. * dp_update_msdu_to_list(): Function to queue msdu from wbm
  1085. * @pdev: dp_pdev
  1086. * @peer: dp_peer
  1087. * @ts: hal tx completion status
  1088. * @netbuf: msdu
  1089. *
  1090. * return: status
  1091. */
  1092. QDF_STATUS
  1093. dp_update_msdu_to_list(struct dp_soc *soc,
  1094. struct dp_pdev *pdev,
  1095. struct dp_peer *peer,
  1096. struct hal_tx_completion_status *ts,
  1097. qdf_nbuf_t netbuf)
  1098. {
  1099. struct dp_tx_tid *tx_tid;
  1100. struct msdu_completion_info *msdu_comp_info;
  1101. if (!peer) {
  1102. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  1103. "%s: %d peer NULL !", __func__, __LINE__);
  1104. return QDF_STATUS_E_FAILURE;
  1105. }
  1106. if ((ts->tid > DP_MAX_TIDS) ||
  1107. (peer->bss_peer && ts->tid == DP_NON_QOS_TID)) {
  1108. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  1109. "%s: %d peer_id %d, tid %d > NON_QOS_TID!",
  1110. __func__, __LINE__, ts->peer_id, ts->tid);
  1111. return QDF_STATUS_E_FAILURE;
  1112. }
  1113. tx_tid = &peer->tx_capture.tx_tid[ts->tid];
  1114. if (!tx_tid) {
  1115. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  1116. "%s: %d tid[%d] NULL !", __func__, __LINE__, ts->tid);
  1117. return QDF_STATUS_E_FAILURE;
  1118. }
  1119. if (!qdf_nbuf_push_head(netbuf, sizeof(struct msdu_completion_info))) {
  1120. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_ERROR,
  1121. FL("No headroom"));
  1122. return QDF_STATUS_E_NOMEM;
  1123. }
  1124. qdf_nbuf_unmap(soc->osdev, netbuf, QDF_DMA_TO_DEVICE);
  1125. msdu_comp_info = (struct msdu_completion_info *)qdf_nbuf_data(netbuf);
  1126. /* copy msdu_completion_info to control buffer */
  1127. msdu_comp_info->ppdu_id = ts->ppdu_id;
  1128. msdu_comp_info->peer_id = ts->peer_id;
  1129. msdu_comp_info->tid = ts->tid;
  1130. msdu_comp_info->first_msdu = ts->first_msdu;
  1131. msdu_comp_info->last_msdu = ts->last_msdu;
  1132. msdu_comp_info->msdu_part_of_amsdu = ts->msdu_part_of_amsdu;
  1133. msdu_comp_info->transmit_cnt = ts->transmit_cnt;
  1134. msdu_comp_info->tsf = ts->tsf;
  1135. msdu_comp_info->status = ts->status;
  1136. if (tx_tid->max_ppdu_id != ts->ppdu_id)
  1137. dp_drop_enq_msdu_on_thresh(peer, tx_tid, &tx_tid->msdu_comp_q,
  1138. ts->tsf);
  1139. /* lock here */
  1140. qdf_spin_lock_bh(&tx_tid->tasklet_tid_lock);
  1141. /* add nbuf to tail queue per peer tid */
  1142. qdf_nbuf_queue_add(&tx_tid->msdu_comp_q, netbuf);
  1143. dp_tx_cap_stats_msdu_update(peer, PEER_MSDU_ENQ, 1);
  1144. /* unlock here */
  1145. qdf_spin_unlock_bh(&tx_tid->tasklet_tid_lock);
  1146. /* update max ppdu_id */
  1147. tx_tid->max_ppdu_id = ts->ppdu_id;
  1148. pdev->tx_capture.last_msdu_id = ts->ppdu_id;
  1149. pdev->tx_capture.last_peer_id = ts->peer_id;
  1150. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  1151. "msdu_completion: ppdu_id[%d] peer_id[%d] tid[%d] rel_src[%d] status[%d] tsf[%u] A[%d] CNT[%d]",
  1152. ts->ppdu_id, ts->peer_id, ts->tid, ts->release_src,
  1153. ts->status, ts->tsf, ts->msdu_part_of_amsdu,
  1154. ts->transmit_cnt);
  1155. return QDF_STATUS_SUCCESS;
  1156. }
  1157. /**
  1158. * dp_tx_add_to_comp_queue() - add completion msdu to queue
  1159. * @soc: DP Soc handle
  1160. * @tx_desc: software Tx descriptor
  1161. * @ts: Tx completion status from HAL/HTT descriptor
  1162. * @peer: DP peer
  1163. *
  1164. * Return: none
  1165. */
  1166. QDF_STATUS dp_tx_add_to_comp_queue(struct dp_soc *soc,
  1167. struct dp_tx_desc_s *desc,
  1168. struct hal_tx_completion_status *ts,
  1169. struct dp_peer *peer)
  1170. {
  1171. int ret = QDF_STATUS_E_FAILURE;
  1172. struct dp_pdev *pdev = desc->pdev;
  1173. if (peer &&
  1174. dp_peer_or_pdev_tx_cap_enabled(pdev, peer, peer->mac_addr.raw) &&
  1175. ((ts->status == HAL_TX_TQM_RR_FRAME_ACKED) ||
  1176. (ts->status == HAL_TX_TQM_RR_REM_CMD_TX) ||
  1177. ((ts->status == HAL_TX_TQM_RR_REM_CMD_AGED) && ts->transmit_cnt))) {
  1178. if (qdf_unlikely(desc->pkt_offset != 0) &&
  1179. (qdf_nbuf_pull_head(
  1180. desc->nbuf, desc->pkt_offset) == NULL)) {
  1181. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1182. QDF_TRACE_LEVEL_ERROR,
  1183. "netbuf %pK offset %d",
  1184. desc->nbuf, desc->pkt_offset);
  1185. return ret;
  1186. }
  1187. ret = dp_update_msdu_to_list(soc, pdev, peer, ts, desc->nbuf);
  1188. }
  1189. return ret;
  1190. }
  1191. /**
  1192. * dp_process_ppdu_stats_update_failed_bitmap(): update failed bitmap
  1193. * @pdev: dp_pdev
  1194. * @data: tx completion ppdu desc
  1195. * @ppdu_id: ppdu id
  1196. * @size: size of bitmap
  1197. *
  1198. * return: status
  1199. */
  1200. void dp_process_ppdu_stats_update_failed_bitmap(struct dp_pdev *pdev,
  1201. void *data,
  1202. uint32_t ppdu_id,
  1203. uint32_t size)
  1204. {
  1205. struct cdp_tx_completion_ppdu_user *user;
  1206. uint32_t mpdu_tried;
  1207. uint32_t ba_seq_no;
  1208. uint32_t start_seq;
  1209. uint32_t num_mpdu;
  1210. uint32_t diff;
  1211. uint32_t carry = 0;
  1212. uint32_t bitmask = 0;
  1213. uint32_t i;
  1214. uint32_t k;
  1215. uint32_t ba_bitmap = 0;
  1216. int last_set_bit;
  1217. user = (struct cdp_tx_completion_ppdu_user *)data;
  1218. /* get number of mpdu from ppdu_desc */
  1219. mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;
  1220. ba_seq_no = user->ba_seq_no;
  1221. start_seq = user->start_seq;
  1222. num_mpdu = user->num_mpdu;
  1223. /* assumption: number of mpdu will be less than 32 */
  1224. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  1225. "ppdu_id[%d] ba_seq_no[%d] start_seq_no[%d] mpdu_tried[%d]",
  1226. ppdu_id, ba_seq_no, start_seq, mpdu_tried);
  1227. for (i = 0; i < size; i++) {
  1228. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  1229. "ppdu_id[%d] ba_bitmap[%x] enqueue_bitmap[%x]",
  1230. ppdu_id, user->ba_bitmap[i], user->enq_bitmap[i]);
  1231. }
  1232. /* Handle sequence no. wraparound */
  1233. if (start_seq <= ba_seq_no) {
  1234. diff = ba_seq_no - start_seq;
  1235. /* Sequence delta of more than 2048 is considered wraparound
  1236. * and we extend start_seq to be more than ba_seq just to
  1237. * adjust failed_bitmap
  1238. */
  1239. if (qdf_unlikely(diff > (IEEE80211_SEQ_MAX / 2))) {
  1240. diff = (start_seq - ba_seq_no) &
  1241. (IEEE80211_SEQ_MAX - 1);
  1242. start_seq = ba_seq_no + diff;
  1243. }
  1244. } else {
  1245. diff = start_seq - ba_seq_no;
  1246. /* Sequence delta of more than 2048 is considered wraparound
  1247. * and we extend ba_seq to be more than start_seq just to
  1248. * adjust failed_bitmap
  1249. */
  1250. if (qdf_unlikely(diff > (IEEE80211_SEQ_MAX / 2))) {
  1251. diff = (ba_seq_no - start_seq) &
  1252. (IEEE80211_SEQ_MAX - 1);
  1253. ba_seq_no = start_seq + diff;
  1254. }
  1255. }
  1256. /* Adjust failed_bitmap to start from same seq_no as enq_bitmap */
  1257. last_set_bit = 0;
  1258. if (start_seq <= ba_seq_no) {
  1259. bitmask = (1 << diff) - 1;
  1260. for (i = 0; i < size; i++) {
  1261. ba_bitmap = user->ba_bitmap[i];
  1262. user->failed_bitmap[i] = (ba_bitmap << diff);
  1263. user->failed_bitmap[i] |= (bitmask & carry);
  1264. carry = ((ba_bitmap & (bitmask << (32 - diff))) >>
  1265. (32 - diff));
  1266. user->failed_bitmap[i] = user->enq_bitmap[i] &
  1267. user->failed_bitmap[i];
  1268. if (user->enq_bitmap[i]) {
  1269. last_set_bit = i * 32 +
  1270. qdf_fls(user->enq_bitmap[i]) - 1;
  1271. }
  1272. }
  1273. } else {
  1274. /* array index */
  1275. k = diff >> 5;
  1276. diff = diff & 0x1F;
  1277. bitmask = (1 << diff) - 1;
  1278. for (i = 0; i < size; i++, k++) {
  1279. ba_bitmap = user->ba_bitmap[k];
  1280. user->failed_bitmap[i] = ba_bitmap >> diff;
  1281. /* get next ba_bitmap */
  1282. ba_bitmap = user->ba_bitmap[k + 1];
  1283. carry = (ba_bitmap & bitmask);
  1284. user->failed_bitmap[i] |=
  1285. ((carry & bitmask) << (32 - diff));
  1286. user->failed_bitmap[i] = user->enq_bitmap[i] &
  1287. user->failed_bitmap[i];
  1288. if (user->enq_bitmap[i]) {
  1289. last_set_bit = i * 32 +
  1290. qdf_fls(user->enq_bitmap[i]) - 1;
  1291. }
  1292. }
  1293. }
  1294. user->last_enq_seq = user->start_seq + last_set_bit;
  1295. user->ba_size = user->last_enq_seq - user->start_seq + 1;
  1296. }
  1297. /*
  1298. * dp_soc_set_txrx_ring_map_single()
  1299. * @dp_soc: DP handler for soc
  1300. *
  1301. * Return: Void
  1302. */
  1303. static void dp_soc_set_txrx_ring_map_single(struct dp_soc *soc)
  1304. {
  1305. uint32_t i;
  1306. for (i = 0; i < WLAN_CFG_INT_NUM_CONTEXTS; i++) {
  1307. soc->tx_ring_map[i] =
  1308. dp_cpu_ring_map[DP_SINGLE_TX_RING_MAP][i];
  1309. }
  1310. }
  1311. static void dp_peer_free_msdu_q(struct dp_soc *soc,
  1312. struct dp_peer *peer,
  1313. void *arg)
  1314. {
  1315. dp_peer_tid_queue_cleanup(peer);
  1316. }
  1317. /*
  1318. * dp_soc_is_tx_capture_set_in_pdev() - API to get tx capture set in any pdev
  1319. * @soc_handle: DP_SOC handle
  1320. *
  1321. * return: true
  1322. */
  1323. uint8_t
  1324. dp_soc_is_tx_capture_set_in_pdev(struct dp_soc *soc)
  1325. {
  1326. struct dp_pdev *pdev;
  1327. uint8_t pdev_tx_capture = 0;
  1328. uint8_t i;
  1329. for (i = 0; i < MAX_PDEV_CNT; i++) {
  1330. pdev = soc->pdev_list[i];
  1331. if (!pdev)
  1332. continue;
  1333. if (!pdev->tx_capture_enabled)
  1334. continue;
  1335. pdev_tx_capture++;
  1336. }
  1337. return pdev_tx_capture;
  1338. }
  1339. /*
  1340. * dp_enh_tx_capture_disable()- API to disable enhanced tx capture
  1341. * @pdev_handle: DP_PDEV handle
  1342. * Return: void
  1343. */
  1344. void
  1345. dp_enh_tx_capture_disable(struct dp_pdev *pdev)
  1346. {
  1347. int i, j;
  1348. if (!dp_soc_is_tx_capture_set_in_pdev(pdev->soc))
  1349. dp_soc_set_txrx_ring_map(pdev->soc);
  1350. dp_h2t_cfg_stats_msg_send(pdev,
  1351. DP_PPDU_STATS_CFG_ENH_STATS,
  1352. pdev->pdev_id);
  1353. dp_pdev_iterate_peer(pdev, dp_peer_free_msdu_q, NULL,
  1354. DP_MOD_ID_TX_CAPTURE);
  1355. for (i = 0; i < TXCAP_MAX_TYPE; i++) {
  1356. for (j = 0; j < TXCAP_MAX_SUBTYPE; j++) {
  1357. qdf_nbuf_queue_t *retries_q;
  1358. qdf_spin_lock_bh(
  1359. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  1360. qdf_nbuf_queue_free(
  1361. &pdev->tx_capture.ctl_mgmt_q[i][j]);
  1362. qdf_spin_unlock_bh(
  1363. &pdev->tx_capture.ctl_mgmt_lock[i][j]);
  1364. retries_q = &pdev->tx_capture.retries_ctl_mgmt_q[i][j];
  1365. if (!qdf_nbuf_is_queue_empty(retries_q))
  1366. qdf_nbuf_queue_free(retries_q);
  1367. }
  1368. }
  1369. dp_peer_tx_cap_del_all_filter(pdev);
  1370. pdev->tx_capture_enabled = CDP_TX_ENH_CAPTURE_DISABLED;
  1371. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  1372. "Mode change request done cur mode - %d user_mode - %d\n",
  1373. pdev->tx_capture_enabled, CDP_TX_ENH_CAPTURE_DISABLED);
  1374. }
  1375. /*
  1376. * dp_enh_tx_capture_enable()- API to disable enhanced tx capture
  1377. * @pdev_handle: DP_PDEV handle
  1378. * @user_mode: user mode
  1379. *
  1380. * Return: void
  1381. */
  1382. void
  1383. dp_enh_tx_capture_enable(struct dp_pdev *pdev, uint8_t user_mode)
  1384. {
  1385. if (dp_soc_is_tx_capture_set_in_pdev(pdev->soc) == 1)
  1386. dp_soc_set_txrx_ring_map_single(pdev->soc);
  1387. if (!pdev->pktlog_ppdu_stats)
  1388. dp_h2t_cfg_stats_msg_send(pdev,
  1389. DP_PPDU_STATS_CFG_SNIFFER,
  1390. pdev->pdev_id);
  1391. pdev->tx_capture_enabled = user_mode;
  1392. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  1393. "Mode change request done cur mode - %d user_mode - %d\n",
  1394. pdev->tx_capture_enabled, user_mode);
  1395. }
  1396. /*
  1397. * dp_enh_tx_cap_mode_change()- API to enable/disable enhanced tx capture
  1398. * @pdev_handle: DP_PDEV handle
  1399. * @user_mode: user provided value
  1400. *
  1401. * Return: void
  1402. */
  1403. static void
  1404. dp_enh_tx_cap_mode_change(struct dp_pdev *pdev, uint8_t user_mode)
  1405. {
  1406. if (user_mode == CDP_TX_ENH_CAPTURE_DISABLED) {
  1407. dp_enh_tx_capture_disable(pdev);
  1408. } else {
  1409. dp_enh_tx_capture_enable(pdev, user_mode);
  1410. }
  1411. }
  1412. /*
  1413. * dp_config_enh_tx_capture()- API to enable/disable enhanced tx capture
  1414. * @pdev_handle: DP_PDEV handle
  1415. * @val: user provided value
  1416. *
  1417. * Return: QDF_STATUS
  1418. */
  1419. QDF_STATUS
  1420. dp_config_enh_tx_capture(struct dp_pdev *pdev, uint8_t val)
  1421. {
  1422. qdf_atomic_set(&pdev->tx_capture.tx_cap_usr_mode, val);
  1423. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_LOW,
  1424. "User mode change requested - %d\n",
  1425. qdf_atomic_read(&pdev->tx_capture.tx_cap_usr_mode));
  1426. return QDF_STATUS_SUCCESS;
  1427. }
  1428. /**
  1429. * get_number_of_1s(): Function to get number of 1s
  1430. * @value: value to find
  1431. *
  1432. * return: number of 1s
  1433. */
  1434. static
  1435. inline uint32_t get_number_of_1s(uint32_t value)
  1436. {
  1437. uint32_t shift[] = {1, 2, 4, 8, 16};
  1438. uint32_t magic_number[] = { 0x55555555, 0x33333333, 0x0F0F0F0F,
  1439. 0x00FF00FF, 0x0000FFFF};
  1440. uint8_t k = 0;
  1441. for (; k <= 4; k++) {
  1442. value = (value & magic_number[k]) +
  1443. ((value >> shift[k]) & magic_number[k]);
  1444. }
  1445. return value;
  1446. }
  1447. /**
  1448. * dp_tx_print_bitmap(): Function to print bitmap
  1449. * @pdev: dp_pdev
  1450. * @ppdu_desc: ppdu completion descriptor
  1451. * @user_inder: user index
  1452. * @ppdu_id: ppdu id
  1453. *
  1454. * return: status
  1455. */
  1456. static
  1457. QDF_STATUS dp_tx_print_bitmap(struct dp_pdev *pdev,
  1458. struct cdp_tx_completion_ppdu *ppdu_desc,
  1459. uint32_t user_index,
  1460. uint32_t ppdu_id)
  1461. {
  1462. struct cdp_tx_completion_ppdu_user *user;
  1463. uint8_t i;
  1464. uint32_t mpdu_tried;
  1465. uint32_t ba_seq_no;
  1466. uint32_t start_seq;
  1467. uint32_t num_mpdu;
  1468. uint32_t fail_num_mpdu = 0;
  1469. user = &ppdu_desc->user[user_index];
  1470. /* get number of mpdu from ppdu_desc */
  1471. mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;
  1472. ba_seq_no = user->ba_seq_no;
  1473. start_seq = user->start_seq;
  1474. num_mpdu = user->mpdu_success;
  1475. if (user->tid > DP_MAX_TIDS) {
  1476. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  1477. "%s: ppdu[%d] peer_id[%d] TID[%d] > NON_QOS_TID!",
  1478. __func__, ppdu_id, user->peer_id, user->tid);
  1479. return QDF_STATUS_E_FAILURE;
  1480. }
  1481. if (mpdu_tried != num_mpdu) {
  1482. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO,
  1483. "%s: ppdu[%d] peer[%d] tid[%d] ba[%d] start[%d] mpdu_tri[%d] num_mpdu[%d] is_mcast[%d]",
  1484. __func__, ppdu_id, user->peer_id, user->tid,
  1485. ba_seq_no, start_seq, mpdu_tried,
  1486. num_mpdu, user->is_mcast);
  1487. for (i = 0; i < CDP_BA_256_BIT_MAP_SIZE_DWORDS; i++) {
  1488. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1489. QDF_TRACE_LEVEL_INFO,
  1490. "ppdu_id[%d] ba_bitmap[0x%x] enqueue_bitmap[0x%x] failed_bitmap[0x%x]",
  1491. ppdu_id, user->ba_bitmap[i],
  1492. user->enq_bitmap[i],
  1493. user->failed_bitmap[i]);
  1494. fail_num_mpdu +=
  1495. get_number_of_1s(user->failed_bitmap[i]);
  1496. }
  1497. }
  1498. if (fail_num_mpdu == num_mpdu && num_mpdu)
  1499. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  1500. "%s: %d ppdu_id[%d] num_mpdu[%d, %d]",
  1501. __func__, __LINE__, ppdu_id, num_mpdu, fail_num_mpdu);
  1502. return QDF_STATUS_SUCCESS;
  1503. }
  1504. /**
  1505. * dp_ppdu_desc_debug_print(): Function to print ppdu_desc
  1506. * @ppdu_desc: ppdu desc pointer
  1507. * @usr_idx: user index
  1508. * @func: caller function name
  1509. * @line: caller function line number
  1510. *
  1511. * return: void
  1512. */
  1513. void dp_ppdu_desc_debug_print(struct cdp_tx_completion_ppdu *ppdu_desc,
  1514. uint8_t usr_idx, const char *func, uint32_t line)
  1515. {
  1516. struct cdp_tx_completion_ppdu_user *user;
  1517. uint8_t num_users;
  1518. num_users = ppdu_desc->num_users;
  1519. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_MED,
  1520. "%s: %d PID: %d, BPID: %d SCHED: %d usr_idx: %d TLV_BITMAP[0x%x] num_users:%d",
  1521. func, line,
  1522. ppdu_desc->ppdu_id, ppdu_desc->bar_ppdu_id,
  1523. ppdu_desc->sched_cmdid,
  1524. usr_idx, ppdu_desc->tlv_bitmap, ppdu_desc->num_users);
  1525. user = &ppdu_desc->user[usr_idx];
  1526. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_MED,
  1527. "%s: %d P[%d] CS:%d S_SEQ: %d L_ENQ_SEQ:%d BA_SEQ:%d BA_SZ:%d M[TRI: %d, SUC: %d] ENQ[%x:%x:%x:%x] BA[%x:%x:%x:%x] F[%x:%x:%x:%x] tlv[0x%x]",
  1528. func, line, user->peer_id,
  1529. user->completion_status,
  1530. user->start_seq, user->last_enq_seq,
  1531. user->ba_seq_no, user->ba_size,
  1532. user->mpdu_tried_ucast + user->mpdu_tried_mcast,
  1533. user->mpdu_success,
  1534. user->enq_bitmap[0], user->enq_bitmap[1],
  1535. user->enq_bitmap[2], user->enq_bitmap[3],
  1536. user->ba_bitmap[0], user->ba_bitmap[1],
  1537. user->ba_bitmap[2], user->ba_bitmap[3],
  1538. user->failed_bitmap[0], user->failed_bitmap[1],
  1539. user->failed_bitmap[2], user->failed_bitmap[3],
  1540. user->tlv_bitmap);
  1541. }
  1542. /*
  1543. * dp_peer_tx_wds_addr_add() – Update WDS peer to include 4th address
  1544. * @peer: Datapath peer
  1545. * @addr4_mac_addr: Source MAC address for WDS TX
  1546. *
  1547. */
  1548. static
  1549. void dp_peer_tx_wds_addr_add(struct dp_peer *peer, uint8_t *addr4_mac_addr)
  1550. {
  1551. struct ieee80211_frame_addr4 *ptr_wh;
  1552. if (!peer)
  1553. return;
  1554. ptr_wh = &peer->tx_capture.tx_wifi_addr4_hdr;
  1555. qdf_mem_copy(ptr_wh->i_addr4,
  1556. addr4_mac_addr,
  1557. QDF_MAC_ADDR_SIZE);
  1558. }
  1559. /*
  1560. * dp_peer_tx_update_80211_wds_hdr() – Update 80211 frame header to include a
  1561. * 4 address frame, and set QoS related information if necessary
  1562. * @pdev: Physical device reference
  1563. * @peer: Datapath peer
  1564. * @data: ppdu_descriptor
  1565. * @nbuf: 802.11 frame
  1566. * @ether_type: ethernet type
  1567. * @src_addr: ether shost address
  1568. * @usr_idx: user index
  1569. *
  1570. */
  1571. static uint32_t dp_tx_update_80211_wds_hdr(struct dp_pdev *pdev,
  1572. struct dp_peer *peer,
  1573. void *data,
  1574. qdf_nbuf_t nbuf,
  1575. uint16_t ether_type,
  1576. uint8_t *src_addr,
  1577. uint8_t usr_idx)
  1578. {
  1579. struct cdp_tx_completion_ppdu *ppdu_desc;
  1580. struct cdp_tx_completion_ppdu_user *user;
  1581. uint32_t mpdu_buf_len, frame_size;
  1582. uint8_t *ptr_hdr;
  1583. uint16_t eth_type = qdf_htons(ether_type);
  1584. struct ieee80211_qosframe_addr4 *ptr_wh;
  1585. ppdu_desc = (struct cdp_tx_completion_ppdu *)data;
  1586. user = &ppdu_desc->user[usr_idx];
  1587. ptr_wh = &peer->tx_capture.tx_wifi_addr4_qos_hdr;
  1588. /*
  1589. * update framectrl only for first ppdu_id
  1590. * rest of mpdu will have same frame ctrl
  1591. * mac address and duration
  1592. */
  1593. if (ppdu_desc->ppdu_id != peer->tx_capture.tx_wifi_ppdu_id) {
  1594. ptr_wh->i_fc[1] = (ppdu_desc->frame_ctrl & 0xFF00) >> 8;
  1595. ptr_wh->i_fc[0] = (ppdu_desc->frame_ctrl & 0xFF);
  1596. ptr_wh->i_dur[1] = (ppdu_desc->tx_duration & 0xFF00) >> 8;
  1597. ptr_wh->i_dur[0] = (ppdu_desc->tx_duration & 0xFF);
  1598. ptr_wh->i_qos[1] = (user->qos_ctrl & 0xFF00) >> 8;
  1599. ptr_wh->i_qos[0] = (user->qos_ctrl & 0xFF);
  1600. /* Update Addr 3 (SA) with SA derived from ether packet */
  1601. qdf_mem_copy(ptr_wh->i_addr3, src_addr, QDF_MAC_ADDR_SIZE);
  1602. peer->tx_capture.tx_wifi_ppdu_id = ppdu_desc->ppdu_id;
  1603. }
  1604. frame_size = (user->tid != DP_NON_QOS_TID) ?
  1605. sizeof(struct ieee80211_qosframe_addr4) :
  1606. sizeof(struct ieee80211_frame_addr4);
  1607. mpdu_buf_len = frame_size + LLC_SNAP_HDR_LEN;
  1608. nbuf->protocol = qdf_htons(ETH_P_802_2);
  1609. /* update ieee80211_frame header */
  1610. if (!qdf_nbuf_push_head(nbuf, mpdu_buf_len)) {
  1611. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  1612. FL("No headroom"));
  1613. return QDF_STATUS_E_NOMEM;
  1614. }
  1615. ptr_hdr = (void *)qdf_nbuf_data(nbuf);
  1616. qdf_mem_copy(ptr_hdr, ptr_wh, frame_size);
  1617. ptr_hdr = ptr_hdr + frame_size;
  1618. /* update LLC */
  1619. *ptr_hdr = LLC_SNAP_LSAP;
  1620. *(ptr_hdr + 1) = LLC_SNAP_LSAP;
  1621. *(ptr_hdr + 2) = LLC_UI;
  1622. *(ptr_hdr + 3) = 0x00;
  1623. *(ptr_hdr + 4) = 0x00;
  1624. *(ptr_hdr + 5) = 0x00;
  1625. *(ptr_hdr + 6) = (eth_type & 0xFF00) >> 8;
  1626. *(ptr_hdr + 7) = (eth_type & 0xFF);
  1627. qdf_nbuf_trim_tail(nbuf, qdf_nbuf_len(nbuf) - mpdu_buf_len);
  1628. return 0;
  1629. }
  1630. /**
  1631. * dp_tx_update_80211_hdr() – Update 80211 frame header to set QoS
  1632. * related information if necessary
  1633. * @pdev: Physical device reference
  1634. * @peer: Datapath peer
  1635. * @data: ppdu_descriptor
  1636. * @nbuf: 802.11 frame
  1637. * @ether_type: ethernet type
  1638. * @src_addr: ether shost address
  1639. *
  1640. */
  1641. static uint32_t dp_tx_update_80211_hdr(struct dp_pdev *pdev,
  1642. struct dp_peer *peer,
  1643. void *data,
  1644. qdf_nbuf_t nbuf,
  1645. uint16_t ether_type,
  1646. uint8_t *src_addr,
  1647. uint8_t usr_idx)
  1648. {
  1649. struct cdp_tx_completion_ppdu *ppdu_desc;
  1650. struct cdp_tx_completion_ppdu_user *user;
  1651. uint32_t mpdu_buf_len, frame_size;
  1652. uint8_t *ptr_hdr;
  1653. uint16_t eth_type = qdf_htons(ether_type);
  1654. struct ieee80211_qosframe *ptr_wh;
  1655. ppdu_desc = (struct cdp_tx_completion_ppdu *)data;
  1656. user = &ppdu_desc->user[usr_idx];
  1657. ptr_wh = &peer->tx_capture.tx_wifi_qos_hdr;
  1658. /*
  1659. * update framectrl only for first ppdu_id
  1660. * rest of mpdu will have same frame ctrl
  1661. * mac address and duration
  1662. */
  1663. if (ppdu_desc->ppdu_id != peer->tx_capture.tx_wifi_ppdu_id) {
  1664. ptr_wh->i_fc[1] = (user->frame_ctrl & 0xFF00) >> 8;
  1665. ptr_wh->i_fc[0] = (user->frame_ctrl & 0xFF);
  1666. ptr_wh->i_dur[1] = (ppdu_desc->tx_duration & 0xFF00) >> 8;
  1667. ptr_wh->i_dur[0] = (ppdu_desc->tx_duration & 0xFF);
  1668. ptr_wh->i_qos[1] = (user->qos_ctrl & 0xFF00) >> 8;
  1669. ptr_wh->i_qos[0] = (user->qos_ctrl & 0xFF);
  1670. /* Update Addr 3 (SA) with SA derived from ether packet */
  1671. qdf_mem_copy(ptr_wh->i_addr3, src_addr, QDF_MAC_ADDR_SIZE);
  1672. peer->tx_capture.tx_wifi_ppdu_id = ppdu_desc->ppdu_id;
  1673. }
  1674. frame_size = (user->tid != DP_NON_QOS_TID) ?
  1675. sizeof(struct ieee80211_qosframe) :
  1676. sizeof(struct ieee80211_frame);
  1677. mpdu_buf_len = frame_size + LLC_SNAP_HDR_LEN;
  1678. nbuf->protocol = qdf_htons(ETH_P_802_2);
  1679. /* update ieee80211_frame header */
  1680. if (!qdf_nbuf_push_head(nbuf, mpdu_buf_len)) {
  1681. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  1682. FL("No headroom"));
  1683. return QDF_STATUS_E_NOMEM;
  1684. }
  1685. ptr_hdr = (void *)qdf_nbuf_data(nbuf);
  1686. qdf_mem_copy(ptr_hdr, ptr_wh, frame_size);
  1687. ptr_hdr = ptr_hdr + frame_size;
  1688. /* update LLC */
  1689. *ptr_hdr = LLC_SNAP_LSAP;
  1690. *(ptr_hdr + 1) = LLC_SNAP_LSAP;
  1691. *(ptr_hdr + 2) = LLC_UI;
  1692. *(ptr_hdr + 3) = 0x00;
  1693. *(ptr_hdr + 4) = 0x00;
  1694. *(ptr_hdr + 5) = 0x00;
  1695. *(ptr_hdr + 6) = (eth_type & 0xFF00) >> 8;
  1696. *(ptr_hdr + 7) = (eth_type & 0xFF);
  1697. qdf_nbuf_trim_tail(nbuf, qdf_nbuf_len(nbuf) - mpdu_buf_len);
  1698. return 0;
  1699. }
  1700. /**
  1701. * dp_tx_mon_restitch_mpdu(): Function to restitch msdu to mpdu
  1702. * @pdev: dp_pdev
  1703. * @peer: dp_peer
  1704. * @head_msdu: head msdu queue
  1705. *
  1706. * return: status
  1707. */
  1708. static uint32_t
  1709. dp_tx_mon_restitch_mpdu(struct dp_pdev *pdev, struct dp_peer *peer,
  1710. struct cdp_tx_completion_ppdu *ppdu_desc,
  1711. qdf_nbuf_queue_t *head_msdu,
  1712. qdf_nbuf_queue_t *mpdu_q, uint8_t usr_idx)
  1713. {
  1714. qdf_nbuf_t curr_nbuf = NULL;
  1715. qdf_nbuf_t first_nbuf = NULL;
  1716. qdf_nbuf_t prev_nbuf = NULL;
  1717. qdf_nbuf_t mpdu_nbuf = NULL;
  1718. struct msdu_completion_info *ptr_msdu_info = NULL;
  1719. uint8_t first_msdu = 0;
  1720. uint8_t last_msdu = 0;
  1721. uint32_t frag_list_sum_len = 0;
  1722. uint8_t first_msdu_not_seen = 1;
  1723. uint16_t ether_type = 0;
  1724. qdf_ether_header_t *eh = NULL;
  1725. size_t msdu_comp_info_sz;
  1726. size_t ether_hdr_sz;
  1727. if (qdf_nbuf_is_queue_empty(head_msdu))
  1728. return 0;
  1729. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  1730. while (curr_nbuf) {
  1731. ptr_msdu_info =
  1732. (struct msdu_completion_info *)qdf_nbuf_data(curr_nbuf);
  1733. first_msdu = ptr_msdu_info->first_msdu;
  1734. last_msdu = ptr_msdu_info->last_msdu;
  1735. eh = (qdf_ether_header_t *)(curr_nbuf->data +
  1736. sizeof(struct msdu_completion_info));
  1737. ether_type = eh->ether_type;
  1738. msdu_comp_info_sz = sizeof(struct msdu_completion_info);
  1739. /* pull msdu_completion_info added in pre header */
  1740. if (NULL == qdf_nbuf_pull_head(curr_nbuf, msdu_comp_info_sz)) {
  1741. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1742. QDF_TRACE_LEVEL_FATAL,
  1743. " No Head space to pull !!\n");
  1744. qdf_assert_always(0);
  1745. }
  1746. if ((qdf_likely((peer->vdev->tx_encap_type !=
  1747. htt_cmn_pkt_type_raw))) &&
  1748. ((ppdu_desc->frame_ctrl & IEEE80211_FC1_DIR_MASK) &&
  1749. (IEEE80211_FC1_DIR_TODS | IEEE80211_FC1_DIR_FROMDS)))
  1750. dp_peer_tx_wds_addr_add(peer, eh->ether_shost);
  1751. if (first_msdu && first_msdu_not_seen) {
  1752. first_nbuf = curr_nbuf;
  1753. frag_list_sum_len = 0;
  1754. first_msdu_not_seen = 0;
  1755. ether_hdr_sz = sizeof(qdf_ether_header_t);
  1756. /* pull ethernet header from first MSDU alone */
  1757. if (NULL == qdf_nbuf_pull_head(curr_nbuf,
  1758. ether_hdr_sz)) {
  1759. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1760. QDF_TRACE_LEVEL_FATAL,
  1761. " No Head space to pull !!\n");
  1762. qdf_assert_always(0);
  1763. }
  1764. /* update first buffer to previous buffer */
  1765. prev_nbuf = curr_nbuf;
  1766. } else if (first_msdu && !first_msdu_not_seen) {
  1767. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1768. QDF_TRACE_LEVEL_ERROR,
  1769. "!!!!! NO LAST MSDU\n");
  1770. /*
  1771. * no last msdu in a mpdu
  1772. * handle this case
  1773. */
  1774. qdf_nbuf_free(curr_nbuf);
  1775. /*
  1776. * No last msdu found because WBM comes out
  1777. * of order, free the pkt
  1778. */
  1779. goto free_ppdu_desc_mpdu_q;
  1780. } else if (!first_msdu && first_msdu_not_seen) {
  1781. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1782. QDF_TRACE_LEVEL_ERROR,
  1783. "!!!!! NO FIRST MSDU\n");
  1784. /*
  1785. * no first msdu in a mpdu
  1786. * handle this case
  1787. */
  1788. qdf_nbuf_free(curr_nbuf);
  1789. /*
  1790. * no first msdu found beacuse WBM comes out
  1791. * of order, free the pkt
  1792. */
  1793. goto free_ppdu_desc_mpdu_q;
  1794. } else {
  1795. /* update current buffer to previous buffer next */
  1796. prev_nbuf->next = curr_nbuf;
  1797. /* move the previous buffer to next buffer */
  1798. prev_nbuf = prev_nbuf->next;
  1799. }
  1800. frag_list_sum_len += qdf_nbuf_len(curr_nbuf);
  1801. if (last_msdu) {
  1802. mpdu_nbuf = qdf_nbuf_alloc(pdev->soc->osdev,
  1803. MAX_MONITOR_HEADER,
  1804. MAX_MONITOR_HEADER,
  1805. 4, FALSE);
  1806. if (!mpdu_nbuf) {
  1807. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1808. QDF_TRACE_LEVEL_ERROR,
  1809. "MPDU head allocation failed !!!");
  1810. goto free_ppdu_desc_mpdu_q;
  1811. }
  1812. if (((ppdu_desc->frame_ctrl & IEEE80211_FC1_DIR_MASK) &&
  1813. (IEEE80211_FC1_DIR_TODS |
  1814. IEEE80211_FC1_DIR_FROMDS))) {
  1815. dp_tx_update_80211_wds_hdr(pdev, peer,
  1816. ppdu_desc, mpdu_nbuf,
  1817. ether_type,
  1818. eh->ether_shost,
  1819. usr_idx);
  1820. } else {
  1821. dp_tx_update_80211_hdr(pdev, peer,
  1822. ppdu_desc, mpdu_nbuf,
  1823. ether_type,
  1824. eh->ether_shost,
  1825. usr_idx);
  1826. }
  1827. /*
  1828. * first nbuf will hold list of msdu
  1829. * stored in prev_nbuf
  1830. */
  1831. qdf_nbuf_append_ext_list(mpdu_nbuf,
  1832. first_nbuf,
  1833. frag_list_sum_len);
  1834. /* add mpdu to mpdu queue */
  1835. qdf_nbuf_queue_add(mpdu_q, mpdu_nbuf);
  1836. first_nbuf = NULL;
  1837. mpdu_nbuf = NULL;
  1838. /* next msdu will start with first msdu */
  1839. first_msdu_not_seen = 1;
  1840. goto check_for_next_msdu;
  1841. }
  1842. /* get next msdu from the head_msdu */
  1843. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  1844. if (!curr_nbuf) {
  1845. /* msdu missed in list */
  1846. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  1847. QDF_TRACE_LEVEL_ERROR,
  1848. "!!!! WAITING for msdu but list empty !!!!");
  1849. /* for incomplete list, free up the queue */
  1850. goto free_ppdu_desc_mpdu_q;
  1851. }
  1852. continue;
  1853. check_for_next_msdu:
  1854. if (qdf_nbuf_is_queue_empty(head_msdu))
  1855. return 0;
  1856. curr_nbuf = qdf_nbuf_queue_remove(head_msdu);
  1857. }
  1858. return 0;
  1859. free_ppdu_desc_mpdu_q:
  1860. /* free already chained msdu pkt */
  1861. while (first_nbuf) {
  1862. curr_nbuf = first_nbuf;
  1863. first_nbuf = first_nbuf->next;
  1864. qdf_nbuf_free(curr_nbuf);
  1865. }
  1866. /* free allocated mpdu hdr */
  1867. if (mpdu_nbuf)
  1868. qdf_nbuf_free(mpdu_nbuf);
  1869. /* free queued remaining msdu pkt per ppdu */
  1870. qdf_nbuf_queue_free(head_msdu);
  1871. /* free queued mpdu per ppdu */
  1872. qdf_nbuf_queue_free(mpdu_q);
  1873. return 0;
  1874. }
  1875. /**
  1876. * dp_tx_msdu_dequeue(): Function to dequeue msdu from peer based tid
  1877. * @peer: dp_peer
  1878. * @ppdu_id: ppdu_id
  1879. * @tid: tid
  1880. * @num_msdu: number of msdu
  1881. * @head: head queue
  1882. * @start_tsf: start tsf from ppdu_desc
  1883. * @end_tsf: end tsf from ppdu_desc
  1884. *
  1885. * return: status
  1886. */
  1887. static
  1888. uint32_t dp_tx_msdu_dequeue(struct dp_peer *peer, uint32_t ppdu_id,
  1889. uint16_t tid, uint32_t num_msdu,
  1890. qdf_nbuf_queue_t *head,
  1891. qdf_nbuf_queue_t *head_xretries,
  1892. uint32_t start_tsf, uint32_t end_tsf)
  1893. {
  1894. struct dp_tx_tid *tx_tid = NULL;
  1895. uint32_t msdu_ppdu_id;
  1896. qdf_nbuf_t curr_msdu = NULL;
  1897. struct msdu_completion_info *ptr_msdu_info = NULL;
  1898. uint32_t wbm_tsf;
  1899. uint32_t matched = 0;
  1900. if (qdf_unlikely(!peer))
  1901. return 0;
  1902. /* Non-QOS frames are being indicated with TID 0
  1903. * in WBM completion path, an hence we should
  1904. * TID 0 to reap MSDUs from completion path
  1905. */
  1906. if (qdf_unlikely(tid == DP_NON_QOS_TID))
  1907. tid = 0;
  1908. tx_tid = &peer->tx_capture.tx_tid[tid];
  1909. if (qdf_unlikely(!tx_tid))
  1910. return 0;
  1911. /* lock here */
  1912. qdf_spin_lock_bh(&tx_tid->tasklet_tid_lock);
  1913. qdf_nbuf_queue_append(&tx_tid->defer_msdu_q, &tx_tid->msdu_comp_q);
  1914. qdf_nbuf_queue_init(&tx_tid->msdu_comp_q);
  1915. /* unlock here */
  1916. qdf_spin_unlock_bh(&tx_tid->tasklet_tid_lock);
  1917. /* lock here */
  1918. qdf_spin_lock_bh(&tx_tid->tid_lock);
  1919. if (qdf_nbuf_is_queue_empty(&tx_tid->defer_msdu_q)) {
  1920. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  1921. return 0;
  1922. }
  1923. curr_msdu = qdf_nbuf_queue_first(&tx_tid->defer_msdu_q);
  1924. while (curr_msdu) {
  1925. if (qdf_nbuf_queue_len(head) == num_msdu) {
  1926. matched = 1;
  1927. break;
  1928. }
  1929. ptr_msdu_info =
  1930. (struct msdu_completion_info *)qdf_nbuf_data(curr_msdu);
  1931. msdu_ppdu_id = ptr_msdu_info->ppdu_id;
  1932. wbm_tsf = ptr_msdu_info->tsf;
  1933. if ((ptr_msdu_info->status == HAL_TX_TQM_RR_REM_CMD_TX) ||
  1934. (ptr_msdu_info->status == HAL_TX_TQM_RR_REM_CMD_AGED)) {
  1935. /* Frames removed due to excessive retries */
  1936. qdf_nbuf_queue_remove(&tx_tid->defer_msdu_q);
  1937. qdf_nbuf_queue_add(head_xretries, curr_msdu);
  1938. dp_tx_cap_stats_msdu_update(peer, PEER_MSDU_XRETRY, 1);
  1939. curr_msdu = qdf_nbuf_queue_first(
  1940. &tx_tid->defer_msdu_q);
  1941. continue;
  1942. }
  1943. if (wbm_tsf > end_tsf) {
  1944. /* PPDU being matched is older than MSDU at head of
  1945. * completion queue. Return matched=1 to skip PPDU
  1946. */
  1947. matched = 1;
  1948. break;
  1949. }
  1950. if (wbm_tsf && (wbm_tsf < start_tsf)) {
  1951. /* remove the aged packet */
  1952. qdf_nbuf_queue_remove(&tx_tid->defer_msdu_q);
  1953. qdf_nbuf_free(curr_msdu);
  1954. dp_tx_cap_stats_msdu_update(peer, PEER_MSDU_DROP, 1);
  1955. curr_msdu = qdf_nbuf_queue_first(
  1956. &tx_tid->defer_msdu_q);
  1957. continue;
  1958. }
  1959. if (msdu_ppdu_id == ppdu_id) {
  1960. /* remove head */
  1961. qdf_nbuf_queue_remove(&tx_tid->defer_msdu_q);
  1962. /* add msdu to head queue */
  1963. qdf_nbuf_queue_add(head, curr_msdu);
  1964. dp_tx_cap_stats_msdu_update(peer, PEER_MSDU_DEQ,
  1965. 1);
  1966. /* get next msdu from defer_msdu_q */
  1967. curr_msdu = qdf_nbuf_queue_first(&tx_tid->defer_msdu_q);
  1968. continue;
  1969. } else {
  1970. /*
  1971. * at this point wbm_tsf is inbetween start_tsf and
  1972. * end tsf but there is a mismatch in ppdu_id
  1973. */
  1974. break;
  1975. }
  1976. }
  1977. qdf_spin_unlock_bh(&tx_tid->tid_lock);
  1978. return matched;
  1979. }
  1980. /**
  1981. * dp_tx_cap_nbuf_list_get_ref() - get nbuf_list reference
  1982. * @ptr_nbuf_list: dp_tx_cap_nbuf_list list
  1983. *
  1984. * Return: reference count
  1985. */
  1986. static inline uint8_t
  1987. dp_tx_cap_nbuf_list_get_ref(struct dp_tx_cap_nbuf_list *ptr_nbuf_list)
  1988. {
  1989. return ptr_nbuf_list->ref_cnt;
  1990. }
  1991. /**
  1992. * dp_tx_cap_nbuf_list_dec_ref() - dec nbuf_list reference
  1993. * @ptr_nbuf_list: dp_tx_cap_nbuf_list list
  1994. *
  1995. * Return: none
  1996. */
  1997. static inline
  1998. void dp_tx_cap_nbuf_list_dec_ref(struct dp_tx_cap_nbuf_list *ptr_nbuf_list)
  1999. {
  2000. ptr_nbuf_list->ref_cnt--;
  2001. if (!ptr_nbuf_list->ref_cnt)
  2002. ptr_nbuf_list->nbuf_ppdu = NULL;
  2003. }
  2004. /**
  2005. * dp_tx_cap_nbuf_list_inc_ref() - inc nbuf_list reference
  2006. * @ptr_nbuf_list: dp_tx_cap_nbuf_list list
  2007. *
  2008. * Return: none
  2009. */
  2010. static inline
  2011. void dp_tx_cap_nbuf_list_inc_ref(struct dp_tx_cap_nbuf_list *ptr_nbuf_list)
  2012. {
  2013. ptr_nbuf_list->ref_cnt++;
  2014. }
  2015. /**
  2016. * dp_tx_cap_nbuf_list_update_ref() - update nbuf_list reference
  2017. * @ptr_nbuf_list: dp_tx_cap_nbuf_list list
  2018. * @ref_cnt: reference count
  2019. *
  2020. * Return: none
  2021. */
  2022. static inline void
  2023. dp_tx_cap_nbuf_list_update_ref(struct dp_tx_cap_nbuf_list *ptr_nbuf_list,
  2024. uint8_t ref_cnt)
  2025. {
  2026. ptr_nbuf_list->ref_cnt = ref_cnt;
  2027. }
  2028. /**
  2029. * get_mpdu_clone_from_next_ppdu(): Function to clone missing mpdu from
  2030. * next ppdu
  2031. * @nbuf_ppdu_list: nbuf list
  2032. * @ppdu_desc_cnt: ppdu_desc_cnt
  2033. * @missed_seq_no:
  2034. * @ppdu_id: ppdu_id
  2035. * @mpdu_info: cdp_tx_indication_mpdu_info
  2036. *
  2037. * return: void
  2038. */
  2039. static qdf_nbuf_t
  2040. get_mpdu_clone_from_next_ppdu(struct dp_tx_cap_nbuf_list nbuf_list[],
  2041. uint32_t ppdu_desc_cnt,
  2042. uint16_t missed_seq_no,
  2043. uint16_t peer_id, uint32_t ppdu_id,
  2044. uint8_t usr_idx)
  2045. {
  2046. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  2047. struct cdp_tx_completion_ppdu_user *user;
  2048. qdf_nbuf_t mpdu = NULL;
  2049. struct dp_tx_cap_nbuf_list *ptr_nbuf_list;
  2050. qdf_nbuf_t nbuf_ppdu;
  2051. uint32_t i = 0;
  2052. uint32_t found = 0;
  2053. uint32_t seq_no = 0;
  2054. uint32_t mpdu_q_len;
  2055. for (i = 1; i < ppdu_desc_cnt; i++) {
  2056. ptr_nbuf_list = &nbuf_list[i];
  2057. nbuf_ppdu = ptr_nbuf_list->nbuf_ppdu;
  2058. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2059. qdf_nbuf_data(nbuf_ppdu);
  2060. user = &ppdu_desc->user[usr_idx];
  2061. if (user->skip == 1)
  2062. continue;
  2063. /* check if seq number is between the range */
  2064. if ((peer_id == user->peer_id) &&
  2065. ((missed_seq_no >= user->start_seq) &&
  2066. (missed_seq_no <= user->last_enq_seq))) {
  2067. seq_no = user->start_seq;
  2068. if (SEQ_BIT(user->failed_bitmap,
  2069. (missed_seq_no - seq_no))) {
  2070. found = 1;
  2071. break;
  2072. }
  2073. }
  2074. }
  2075. if (found == 0) {
  2076. /* mpdu not found in sched cmd id */
  2077. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  2078. "%s: peer_id[%d] missed seq_no[%d] ppdu_id[%d] [%d] not found!!!",
  2079. __func__, peer_id,
  2080. missed_seq_no, ppdu_id, ppdu_desc_cnt);
  2081. return NULL;
  2082. }
  2083. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_DEBUG,
  2084. "%s: peer_id[%d] seq_no[%d] missed ppdu_id[%d] m[%d] found in ppdu_id[%d]!!",
  2085. __func__, peer_id,
  2086. missed_seq_no, ppdu_id,
  2087. (missed_seq_no - seq_no), ppdu_desc->ppdu_id);
  2088. mpdu = qdf_nbuf_queue_first(&ppdu_desc->user[usr_idx].mpdu_q);
  2089. mpdu_q_len = qdf_nbuf_queue_len(&ppdu_desc->user[usr_idx].mpdu_q);
  2090. if (!mpdu) {
  2091. /* bitmap shows it found sequence number, but
  2092. * MPDU not found in PPDU
  2093. */
  2094. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  2095. "%s: missed seq_no[%d] ppdu_id[%d] [%d] found but queue empty!!!",
  2096. __func__, missed_seq_no, ppdu_id, ppdu_desc_cnt);
  2097. if (mpdu_q_len)
  2098. qdf_assert_always(0);
  2099. return NULL;
  2100. }
  2101. for (i = 0; i < (missed_seq_no - seq_no); i++) {
  2102. mpdu = mpdu->next;
  2103. if (!mpdu) {
  2104. /*
  2105. * bitmap shows it found sequence number,
  2106. * but queue empty, do we need to allocate
  2107. * skb and send instead of NULL ?
  2108. * add counter here:
  2109. */
  2110. return NULL;
  2111. }
  2112. }
  2113. if (!mpdu)
  2114. return NULL;
  2115. return qdf_nbuf_copy_expand_fraglist(mpdu, MAX_MONITOR_HEADER, 0);
  2116. }
  2117. /**
  2118. * dp_tx_update_user_mpdu_info(): Function to update mpdu info
  2119. * from ppdu_desc
  2120. * @ppdu_id: ppdu_id
  2121. * @mpdu_info: cdp_tx_indication_mpdu_info
  2122. * @user: cdp_tx_completion_ppdu_user
  2123. *
  2124. * return: void
  2125. */
  2126. static void
  2127. dp_tx_update_user_mpdu_info(uint32_t ppdu_id,
  2128. struct cdp_tx_indication_mpdu_info *mpdu_info,
  2129. struct cdp_tx_completion_ppdu_user *user)
  2130. {
  2131. mpdu_info->ppdu_id = ppdu_id;
  2132. mpdu_info->frame_ctrl = user->frame_ctrl;
  2133. mpdu_info->qos_ctrl = user->qos_ctrl;
  2134. mpdu_info->tid = user->tid;
  2135. mpdu_info->ltf_size = user->ltf_size;
  2136. mpdu_info->he_re = user->he_re;
  2137. mpdu_info->txbf = user->txbf;
  2138. mpdu_info->bw = user->bw;
  2139. mpdu_info->nss = user->nss;
  2140. mpdu_info->mcs = user->mcs;
  2141. mpdu_info->preamble = user->preamble;
  2142. mpdu_info->gi = user->gi;
  2143. mpdu_info->ack_rssi = user->ack_rssi[0];
  2144. mpdu_info->tx_rate = user->tx_rate;
  2145. mpdu_info->ldpc = user->ldpc;
  2146. mpdu_info->ppdu_cookie = user->ppdu_cookie;
  2147. mpdu_info->long_retries = user->long_retries;
  2148. mpdu_info->short_retries = user->short_retries;
  2149. mpdu_info->completion_status = user->completion_status;
  2150. qdf_mem_copy(mpdu_info->mac_address, user->mac_addr, 6);
  2151. mpdu_info->ba_start_seq = user->ba_seq_no;
  2152. qdf_mem_copy(mpdu_info->ba_bitmap, user->ba_bitmap,
  2153. CDP_BA_256_BIT_MAP_SIZE_DWORDS * sizeof(uint32_t));
  2154. }
  2155. static inline
  2156. void dp_tx_update_sequence_number(qdf_nbuf_t nbuf, uint32_t seq_no)
  2157. {
  2158. struct ieee80211_frame *ptr_wh = NULL;
  2159. uint16_t wh_seq = 0;
  2160. if (!nbuf)
  2161. return;
  2162. /* update sequence number in frame header */
  2163. ptr_wh = (struct ieee80211_frame *)qdf_nbuf_data(nbuf);
  2164. wh_seq = (seq_no & 0xFFF) << 4;
  2165. qdf_mem_copy(ptr_wh->i_seq, &wh_seq, sizeof(uint16_t));
  2166. }
  2167. static inline
  2168. void dp_update_frame_ctrl_from_frame_type(void *desc)
  2169. {
  2170. struct cdp_tx_completion_ppdu *ppdu_desc = desc;
  2171. /* frame control is not set properly, sometimes it is zero */
  2172. switch (ppdu_desc->htt_frame_type) {
  2173. case HTT_STATS_FTYPE_SGEN_NDPA:
  2174. case HTT_STATS_FTYPE_SGEN_NDP:
  2175. case HTT_STATS_FTYPE_SGEN_AX_NDPA:
  2176. case HTT_STATS_FTYPE_SGEN_AX_NDP:
  2177. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_NDPA |
  2178. IEEE80211_FC0_TYPE_CTL);
  2179. break;
  2180. case HTT_STATS_FTYPE_SGEN_BRP:
  2181. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_BRPOLL |
  2182. IEEE80211_FC0_TYPE_CTL);
  2183. break;
  2184. case HTT_STATS_FTYPE_SGEN_RTS:
  2185. case HTT_STATS_FTYPE_SGEN_MU_RTS:
  2186. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_RTS |
  2187. IEEE80211_FC0_TYPE_CTL);
  2188. break;
  2189. case HTT_STATS_FTYPE_SGEN_CTS:
  2190. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_CTS |
  2191. IEEE80211_FC0_TYPE_CTL);
  2192. break;
  2193. case HTT_STATS_FTYPE_SGEN_CFEND:
  2194. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_CF_END |
  2195. IEEE80211_FC0_TYPE_CTL);
  2196. break;
  2197. case HTT_STATS_FTYPE_SGEN_MU_TRIG:
  2198. case HTT_STATS_FTYPE_SGEN_MU_BAR:
  2199. case HTT_STATS_FTYPE_SGEN_MU_BRP:
  2200. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_TRIGGER |
  2201. IEEE80211_FC0_TYPE_CTL);
  2202. break;
  2203. case HTT_STATS_FTYPE_SGEN_BAR:
  2204. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_BAR |
  2205. IEEE80211_FC0_TYPE_CTL);
  2206. break;
  2207. }
  2208. }
  2209. /**
  2210. * dp_send_dummy_mpdu_info_to_stack(): send dummy payload to stack
  2211. * to upper layer if complete
  2212. * @pdev: DP pdev handle
  2213. * @desc: cdp tx completion ppdu desc
  2214. * @usr_idx: user index
  2215. *
  2216. * return: status
  2217. */
  2218. static inline
  2219. QDF_STATUS dp_send_dummy_mpdu_info_to_stack(struct dp_pdev *pdev,
  2220. void *desc, uint8_t usr_idx)
  2221. {
  2222. struct dp_peer *peer;
  2223. struct dp_vdev *vdev = NULL;
  2224. struct cdp_tx_completion_ppdu *ppdu_desc = desc;
  2225. struct cdp_tx_completion_ppdu_user *user = &ppdu_desc->user[usr_idx];
  2226. struct ieee80211_ctlframe_addr2 *wh_min;
  2227. uint16_t frame_ctrl_le, duration_le;
  2228. struct cdp_tx_indication_info tx_capture_info;
  2229. struct cdp_tx_indication_mpdu_info *mpdu_info;
  2230. uint8_t type, subtype;
  2231. qdf_mem_set(&tx_capture_info,
  2232. sizeof(struct cdp_tx_indication_info),
  2233. 0);
  2234. tx_capture_info.mpdu_nbuf =
  2235. qdf_nbuf_alloc(pdev->soc->osdev,
  2236. MAX_MONITOR_HEADER + MAX_DUMMY_FRM_BODY,
  2237. MAX_MONITOR_HEADER,
  2238. 4, FALSE);
  2239. if (!tx_capture_info.mpdu_nbuf)
  2240. return QDF_STATUS_E_ABORTED;
  2241. mpdu_info = &tx_capture_info.mpdu_info;
  2242. mpdu_info->resp_type = ppdu_desc->resp_type;
  2243. mpdu_info->mprot_type = ppdu_desc->mprot_type;
  2244. mpdu_info->rts_success = ppdu_desc->rts_success;
  2245. mpdu_info->rts_failure = ppdu_desc->rts_failure;
  2246. /* update cdp_tx_indication_mpdu_info */
  2247. dp_tx_update_user_mpdu_info(ppdu_desc->bar_ppdu_id,
  2248. &tx_capture_info.mpdu_info,
  2249. user);
  2250. tx_capture_info.ppdu_desc = ppdu_desc;
  2251. mpdu_info->ppdu_id = ppdu_desc->ppdu_id;
  2252. mpdu_info->channel_num = pdev->operating_channel.num;
  2253. mpdu_info->channel = ppdu_desc->channel;
  2254. mpdu_info->frame_type = ppdu_desc->frame_type;
  2255. mpdu_info->ppdu_start_timestamp = ppdu_desc->ppdu_start_timestamp;
  2256. mpdu_info->ppdu_end_timestamp = ppdu_desc->ppdu_end_timestamp;
  2257. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  2258. mpdu_info->seq_no = user->start_seq;
  2259. qdf_mem_copy(mpdu_info->mac_address, user->mac_addr, QDF_MAC_ADDR_SIZE);
  2260. mpdu_info->ba_start_seq = user->ba_seq_no;
  2261. qdf_mem_copy(mpdu_info->ba_bitmap, user->ba_bitmap,
  2262. CDP_BA_256_BIT_MAP_SIZE_DWORDS * sizeof(uint32_t));
  2263. mpdu_info->frame_ctrl = ppdu_desc->frame_ctrl;
  2264. type = (ppdu_desc->frame_ctrl & IEEE80211_FC0_TYPE_MASK);
  2265. subtype = (ppdu_desc->frame_ctrl & IEEE80211_FC0_SUBTYPE_MASK);
  2266. if (type == IEEE80211_FC0_TYPE_CTL &&
  2267. subtype == IEEE80211_FC0_SUBTYPE_BAR) {
  2268. mpdu_info->frame_ctrl = (IEEE80211_FC0_SUBTYPE_BAR |
  2269. IEEE80211_FC0_TYPE_CTL);
  2270. mpdu_info->ppdu_id = ppdu_desc->bar_ppdu_id;
  2271. mpdu_info->ppdu_start_timestamp =
  2272. ppdu_desc->bar_ppdu_start_timestamp;
  2273. mpdu_info->ppdu_end_timestamp =
  2274. ppdu_desc->bar_ppdu_end_timestamp;
  2275. mpdu_info->tx_duration = ppdu_desc->bar_tx_duration;
  2276. }
  2277. wh_min = (struct ieee80211_ctlframe_addr2 *)
  2278. qdf_nbuf_data(
  2279. tx_capture_info.mpdu_nbuf);
  2280. qdf_mem_zero(wh_min, MAX_DUMMY_FRM_BODY);
  2281. frame_ctrl_le =
  2282. qdf_cpu_to_le16(mpdu_info->frame_ctrl);
  2283. duration_le =
  2284. qdf_cpu_to_le16(mpdu_info->tx_duration);
  2285. wh_min->i_fc[1] = (frame_ctrl_le & 0xFF00) >> 8;
  2286. wh_min->i_fc[0] = (frame_ctrl_le & 0xFF);
  2287. wh_min->i_aidordur[1] = (duration_le & 0xFF00) >> 8;
  2288. wh_min->i_aidordur[0] = (duration_le & 0xFF);
  2289. qdf_mem_copy(wh_min->i_addr1,
  2290. mpdu_info->mac_address,
  2291. QDF_MAC_ADDR_SIZE);
  2292. if (subtype == IEEE80211_FC0_SUBTYPE_ACK)
  2293. qdf_nbuf_set_pktlen(tx_capture_info.mpdu_nbuf,
  2294. sizeof(struct ieee80211_frame_min_one));
  2295. else {
  2296. peer = dp_peer_get_ref_by_id(pdev->soc, user->peer_id,
  2297. DP_MOD_ID_TX_CAPTURE);
  2298. if (peer) {
  2299. vdev = peer->vdev;
  2300. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  2301. } else {
  2302. vdev =
  2303. dp_get_vdev_from_soc_vdev_id_wifi3(pdev->soc,
  2304. ppdu_desc->vdev_id);
  2305. }
  2306. if (vdev)
  2307. qdf_mem_copy(wh_min->i_addr2,
  2308. vdev->mac_addr.raw,
  2309. QDF_MAC_ADDR_SIZE);
  2310. qdf_nbuf_set_pktlen(tx_capture_info.mpdu_nbuf, sizeof(*wh_min));
  2311. }
  2312. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2313. QDF_TRACE_LEVEL_DEBUG,
  2314. "HTT_FTYPE[%d] frm(0x%08x): fc %x %x, dur 0x%x%x\n",
  2315. ppdu_desc->htt_frame_type, mpdu_info->ppdu_id,
  2316. wh_min->i_fc[1], wh_min->i_fc[0],
  2317. wh_min->i_aidordur[1], wh_min->i_aidordur[0]);
  2318. /*
  2319. * send MPDU to osif layer
  2320. */
  2321. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  2322. &tx_capture_info, HTT_INVALID_PEER,
  2323. WDI_NO_VAL, pdev->pdev_id);
  2324. if (tx_capture_info.mpdu_nbuf)
  2325. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  2326. return QDF_STATUS_SUCCESS;
  2327. }
  2328. /**
  2329. * dp_send_dummy_rts_cts_frame(): send dummy rts and cts frame out
  2330. * to upper layer if complete
  2331. * @pdev: DP pdev handle
  2332. * @cur_ppdu_desc: cdp tx completion ppdu desc
  2333. *
  2334. * return: void
  2335. */
  2336. static
  2337. void dp_send_dummy_rts_cts_frame(struct dp_pdev *pdev,
  2338. struct cdp_tx_completion_ppdu *cur_ppdu_desc,
  2339. uint8_t usr_idx)
  2340. {
  2341. struct cdp_tx_completion_ppdu *ppdu_desc;
  2342. struct dp_pdev_tx_capture *ptr_tx_cap;
  2343. struct dp_peer *peer;
  2344. uint8_t rts_send;
  2345. struct dp_vdev *vdev = NULL;
  2346. rts_send = 0;
  2347. ptr_tx_cap = &pdev->tx_capture;
  2348. ppdu_desc = ptr_tx_cap->dummy_ppdu_desc;
  2349. ppdu_desc->channel = cur_ppdu_desc->channel;
  2350. ppdu_desc->num_mpdu = 1;
  2351. ppdu_desc->num_msdu = 1;
  2352. ppdu_desc->user[usr_idx].ppdu_type = HTT_PPDU_STATS_PPDU_TYPE_SU;
  2353. ppdu_desc->bar_num_users = 0;
  2354. ppdu_desc->num_users = 1;
  2355. if (cur_ppdu_desc->mprot_type == SEND_WIFIRTS_LEGACY_E ||
  2356. cur_ppdu_desc->mprot_type == SEND_WIFIRTS_11AC_DYNAMIC_BW_E ||
  2357. cur_ppdu_desc->mprot_type == SEND_WIFIRTS_11AC_STATIC_BW_E) {
  2358. rts_send = 1;
  2359. /*
  2360. * send dummy RTS frame followed by CTS
  2361. * update frame_ctrl and htt_frame_type
  2362. */
  2363. ppdu_desc->htt_frame_type = HTT_STATS_FTYPE_SGEN_RTS;
  2364. ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
  2365. ppdu_desc->ppdu_start_timestamp =
  2366. cur_ppdu_desc->ppdu_start_timestamp;
  2367. ppdu_desc->ppdu_end_timestamp =
  2368. cur_ppdu_desc->ppdu_end_timestamp;
  2369. ppdu_desc->tx_duration = cur_ppdu_desc->tx_duration;
  2370. ppdu_desc->user[usr_idx].peer_id =
  2371. cur_ppdu_desc->user[usr_idx].peer_id;
  2372. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_RTS |
  2373. IEEE80211_FC0_TYPE_CTL);
  2374. qdf_mem_copy(&ppdu_desc->user[usr_idx].mac_addr,
  2375. &cur_ppdu_desc->user[usr_idx].mac_addr,
  2376. QDF_MAC_ADDR_SIZE);
  2377. dp_send_dummy_mpdu_info_to_stack(pdev, ppdu_desc, usr_idx);
  2378. }
  2379. if ((rts_send && cur_ppdu_desc->rts_success) ||
  2380. cur_ppdu_desc->mprot_type == SEND_WIFICTS2SELF_E) {
  2381. uint16_t peer_id;
  2382. peer_id = cur_ppdu_desc->user[usr_idx].peer_id;
  2383. /* send dummy CTS frame */
  2384. ppdu_desc->htt_frame_type = HTT_STATS_FTYPE_SGEN_CTS;
  2385. ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
  2386. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_CTS |
  2387. IEEE80211_FC0_TYPE_CTL);
  2388. ppdu_desc->ppdu_start_timestamp =
  2389. cur_ppdu_desc->ppdu_start_timestamp;
  2390. ppdu_desc->ppdu_end_timestamp =
  2391. cur_ppdu_desc->ppdu_end_timestamp;
  2392. ppdu_desc->tx_duration = cur_ppdu_desc->tx_duration -
  2393. (RTS_INTERVAL + SIFS_INTERVAL);
  2394. ppdu_desc->user[usr_idx].peer_id = peer_id;
  2395. peer = dp_peer_get_ref_by_id(pdev->soc, peer_id,
  2396. DP_MOD_ID_TX_CAPTURE);
  2397. if (peer) {
  2398. vdev = peer->vdev;
  2399. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  2400. } else {
  2401. uint8_t vdev_id;
  2402. vdev_id = ppdu_desc->vdev_id;
  2403. vdev = dp_get_vdev_from_soc_vdev_id_wifi3(pdev->soc,
  2404. vdev_id);
  2405. }
  2406. if (vdev)
  2407. qdf_mem_copy(&ppdu_desc->user[usr_idx].mac_addr,
  2408. vdev->mac_addr.raw, QDF_MAC_ADDR_SIZE);
  2409. dp_send_dummy_mpdu_info_to_stack(pdev, ppdu_desc, usr_idx);
  2410. }
  2411. }
  2412. static void dp_gen_ack_rx_frame(struct dp_pdev *pdev,
  2413. struct cdp_tx_indication_info *tx_capture_info)
  2414. {
  2415. struct cdp_tx_completion_ppdu *ppdu_desc;
  2416. struct dp_peer *peer;
  2417. struct dp_pdev_tx_capture *ptr_tx_cap;
  2418. ptr_tx_cap = &pdev->tx_capture;
  2419. ppdu_desc = ptr_tx_cap->dummy_ppdu_desc;
  2420. ppdu_desc->channel = tx_capture_info->ppdu_desc->channel;
  2421. ppdu_desc->num_mpdu = 1;
  2422. ppdu_desc->num_msdu = 1;
  2423. ppdu_desc->user[0].ppdu_type = HTT_PPDU_STATS_PPDU_TYPE_SU;
  2424. ppdu_desc->bar_num_users = 0;
  2425. ppdu_desc->num_users = 1;
  2426. ppdu_desc->frame_type = CDP_PPDU_FTYPE_CTRL;
  2427. ppdu_desc->frame_ctrl = (IEEE80211_FC0_SUBTYPE_ACK |
  2428. IEEE80211_FC0_TYPE_CTL);
  2429. ppdu_desc->ppdu_start_timestamp =
  2430. tx_capture_info->ppdu_desc->ppdu_start_timestamp;
  2431. ppdu_desc->ppdu_end_timestamp =
  2432. tx_capture_info->ppdu_desc->ppdu_end_timestamp;
  2433. ppdu_desc->user[0].peer_id =
  2434. tx_capture_info->ppdu_desc->user[0].peer_id;
  2435. peer = dp_peer_get_ref_by_id
  2436. (pdev->soc, tx_capture_info->ppdu_desc->user[0].peer_id,
  2437. DP_MOD_ID_TX_CAPTURE);
  2438. if (peer) {
  2439. struct dp_vdev *vdev = NULL;
  2440. vdev = peer->vdev;
  2441. if (vdev)
  2442. qdf_mem_copy(&ppdu_desc->user[0].mac_addr,
  2443. vdev->mac_addr.raw,
  2444. QDF_MAC_ADDR_SIZE);
  2445. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  2446. }
  2447. dp_send_dummy_mpdu_info_to_stack(pdev, ppdu_desc, 0);
  2448. }
  2449. /**
  2450. * dp_send_data_to_stack(): Function to deliver mpdu info to stack
  2451. * to upper layer
  2452. * @pdev: DP pdev handle
  2453. * @nbuf_ppdu_list: ppdu_desc_list per sched cmd id
  2454. * @ppdu_desc_cnt: number of ppdu_desc_cnt
  2455. *
  2456. * return: status
  2457. */
  2458. static
  2459. void dp_send_data_to_stack(struct dp_pdev *pdev,
  2460. struct cdp_tx_completion_ppdu *ppdu_desc,
  2461. uint8_t usr_idx)
  2462. {
  2463. struct cdp_tx_completion_ppdu_user *user = NULL;
  2464. struct cdp_tx_indication_info tx_capture_info;
  2465. struct cdp_tx_indication_mpdu_info *mpdu_info;
  2466. int i;
  2467. uint32_t seq_no, start_seq;
  2468. uint32_t ppdu_id;
  2469. uint32_t mpdu_tried;
  2470. uint32_t mpdu_enq = 0;
  2471. struct dp_peer *peer;
  2472. if (!ppdu_desc)
  2473. return;
  2474. ppdu_id = ppdu_desc->ppdu_id;
  2475. user = &ppdu_desc->user[usr_idx];
  2476. peer = dp_peer_get_ref_by_id(pdev->soc, user->peer_id,
  2477. DP_MOD_ID_TX_CAPTURE);
  2478. if (!peer) {
  2479. return;
  2480. }
  2481. qdf_mem_set(&tx_capture_info,
  2482. sizeof(struct cdp_tx_indication_info),
  2483. 0);
  2484. mpdu_info = &tx_capture_info.mpdu_info;
  2485. mpdu_info->usr_idx = usr_idx;
  2486. mpdu_info->channel = ppdu_desc->channel;
  2487. mpdu_info->frame_type = ppdu_desc->frame_type;
  2488. mpdu_info->ppdu_start_timestamp =
  2489. ppdu_desc->ppdu_start_timestamp;
  2490. mpdu_info->ppdu_end_timestamp =
  2491. ppdu_desc->ppdu_end_timestamp;
  2492. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  2493. mpdu_info->num_msdu = ppdu_desc->num_msdu;
  2494. mpdu_info->resp_type = ppdu_desc->resp_type;
  2495. mpdu_info->mprot_type = ppdu_desc->mprot_type;
  2496. mpdu_info->rts_success = ppdu_desc->rts_success;
  2497. mpdu_info->rts_failure = ppdu_desc->rts_failure;
  2498. /* update cdp_tx_indication_mpdu_info */
  2499. dp_tx_update_user_mpdu_info(ppdu_id,
  2500. &tx_capture_info.mpdu_info,
  2501. user);
  2502. tx_capture_info.ppdu_desc = ppdu_desc;
  2503. tx_capture_info.mpdu_info.channel_num = pdev->operating_channel.num;
  2504. if (ppdu_desc->mprot_type && (usr_idx == 0))
  2505. dp_send_dummy_rts_cts_frame(pdev, ppdu_desc, usr_idx);
  2506. start_seq = user->start_seq;
  2507. if (!user->mpdus)
  2508. goto return_send_to_stack;
  2509. mpdu_tried = user->mpdu_tried_ucast + user->mpdu_tried_mcast;
  2510. for (i = 0; i < CDP_BA_256_BIT_MAP_SIZE_DWORDS; i++)
  2511. mpdu_enq += get_number_of_1s(user->enq_bitmap[i]);
  2512. if (mpdu_tried > mpdu_enq)
  2513. dp_ppdu_desc_debug_print(ppdu_desc, usr_idx,
  2514. __func__, __LINE__);
  2515. for (i = 0; i < user->ba_size && mpdu_tried; i++) {
  2516. if (qdf_likely(user->tid != DP_NON_QOS_TID) &&
  2517. !(SEQ_BIT(user->enq_bitmap, i))) {
  2518. continue;
  2519. }
  2520. mpdu_tried--;
  2521. seq_no = start_seq + i;
  2522. if (!user->mpdus[i])
  2523. continue;
  2524. tx_capture_info.mpdu_nbuf = user->mpdus[i];
  2525. dp_tx_cap_stats_mpdu_update(peer, PEER_MPDU_TO_STACK, 1);
  2526. user->mpdus[i] = NULL;
  2527. mpdu_info->seq_no = seq_no;
  2528. dp_tx_update_sequence_number(tx_capture_info.mpdu_nbuf, seq_no);
  2529. /*
  2530. * send MPDU to osif layer
  2531. * do we need to update mpdu_info before tranmit
  2532. * get current mpdu_nbuf
  2533. */
  2534. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  2535. &tx_capture_info,
  2536. HTT_INVALID_PEER,
  2537. WDI_NO_VAL, pdev->pdev_id);
  2538. if (tx_capture_info.mpdu_nbuf)
  2539. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  2540. }
  2541. if (ppdu_desc->resp_type == HTT_PPDU_STATS_ACK_EXPECTED_E &&
  2542. ppdu_desc->user[usr_idx].completion_status ==
  2543. HTT_PPDU_STATS_USER_STATUS_OK)
  2544. dp_gen_ack_rx_frame(pdev, &tx_capture_info);
  2545. return_send_to_stack:
  2546. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  2547. return;
  2548. }
  2549. /**
  2550. * dp_ppdu_desc_free(): Function to free ppdu_desc and stored queue
  2551. * @ptr_nbuf_list: pointer to ptr_nbuf_list
  2552. * @usr_idx: user index
  2553. *
  2554. * return: void
  2555. */
  2556. static void dp_ppdu_desc_free(struct dp_tx_cap_nbuf_list *ptr_nbuf_list,
  2557. uint8_t usr_idx)
  2558. {
  2559. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  2560. qdf_nbuf_t tmp_nbuf;
  2561. if (!ptr_nbuf_list->nbuf_ppdu ||
  2562. !dp_tx_cap_nbuf_list_get_ref(ptr_nbuf_list))
  2563. return;
  2564. tmp_nbuf = ptr_nbuf_list->nbuf_ppdu;
  2565. if (tmp_nbuf) {
  2566. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2567. qdf_nbuf_data(tmp_nbuf);
  2568. dp_ppdu_queue_free(tmp_nbuf, usr_idx);
  2569. dp_tx_cap_nbuf_list_dec_ref(ptr_nbuf_list);
  2570. qdf_nbuf_free(tmp_nbuf);
  2571. }
  2572. }
  2573. /**
  2574. * dp_ppdu_desc_free_all(): Function to free all user in a ppdu_desc and
  2575. * its stored queue
  2576. * @ptr_nbuf_list: pointer to ptr_nbuf_list
  2577. * @max_users: maximum number of users
  2578. *
  2579. * return: void
  2580. */
  2581. static void dp_ppdu_desc_free_all(struct dp_tx_cap_nbuf_list *ptr_nbuf_list,
  2582. uint8_t max_users)
  2583. {
  2584. uint8_t i = 0;
  2585. for (i = 0; i < max_users; i++)
  2586. dp_ppdu_desc_free(ptr_nbuf_list, i);
  2587. }
  2588. /**
  2589. * dp_tx_mon_get_next_mpdu(): get next mpdu from retry queue.
  2590. * @xretry_user: pointer to ppdu_desc user.
  2591. * @mpdu_nbuf: mpdu nbuf
  2592. *
  2593. * return: qdf_nbuf_t
  2594. */
  2595. static qdf_nbuf_t
  2596. dp_tx_mon_get_next_mpdu(struct cdp_tx_completion_ppdu_user *xretry_user,
  2597. qdf_nbuf_t mpdu_nbuf)
  2598. {
  2599. qdf_nbuf_t next_nbuf = NULL;
  2600. qdf_nbuf_queue_t temp_xretries;
  2601. if (mpdu_nbuf != qdf_nbuf_queue_first(&xretry_user->mpdu_q)) {
  2602. qdf_err(" mpdu_nbuf is not the head");
  2603. next_nbuf = qdf_nbuf_queue_next(mpdu_nbuf);
  2604. /* Initialize temp list */
  2605. qdf_nbuf_queue_init(&temp_xretries);
  2606. /* Move entries into temp list till the mpdu_nbuf is found */
  2607. while ((qdf_nbuf_queue_first(&xretry_user->mpdu_q)) &&
  2608. (mpdu_nbuf !=
  2609. qdf_nbuf_queue_first(&xretry_user->mpdu_q))) {
  2610. qdf_nbuf_queue_add(&temp_xretries,
  2611. qdf_nbuf_queue_remove(&xretry_user->mpdu_q));
  2612. }
  2613. if ((qdf_nbuf_queue_first(&xretry_user->mpdu_q)) &&
  2614. (mpdu_nbuf == qdf_nbuf_queue_first(&xretry_user->mpdu_q))) {
  2615. /* Remove mpdu_nbuf from queue */
  2616. qdf_nbuf_queue_remove(&xretry_user->mpdu_q);
  2617. /* Add remaining nbufs into temp queue */
  2618. qdf_nbuf_queue_append(&temp_xretries,
  2619. &xretry_user->mpdu_q);
  2620. /* Reinit xretry_user->mpdu_q */
  2621. qdf_nbuf_queue_init(&xretry_user->mpdu_q);
  2622. /* append all the entries into original queue */
  2623. qdf_nbuf_queue_append(&xretry_user->mpdu_q,
  2624. &temp_xretries);
  2625. } else {
  2626. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2627. QDF_TRACE_LEVEL_FATAL,
  2628. "%s: This is buggy scenario, did not find nbuf in queue ",
  2629. __func__);
  2630. qdf_assert_always(0);
  2631. }
  2632. } else {
  2633. qdf_nbuf_queue_remove(&xretry_user->mpdu_q);
  2634. next_nbuf = qdf_nbuf_queue_first(&xretry_user->mpdu_q);
  2635. }
  2636. return next_nbuf;
  2637. }
  2638. static void
  2639. dp_tx_mon_proc_xretries(struct dp_pdev *pdev, struct dp_peer *peer,
  2640. uint16_t tid)
  2641. {
  2642. struct dp_tx_tid *tx_tid = &peer->tx_capture.tx_tid[tid];
  2643. struct cdp_tx_completion_ppdu *ppdu_desc;
  2644. struct cdp_tx_completion_ppdu *xretry_ppdu;
  2645. struct cdp_tx_completion_ppdu_user *user = NULL;
  2646. struct cdp_tx_completion_ppdu_user *xretry_user = NULL;
  2647. qdf_nbuf_t ppdu_nbuf;
  2648. qdf_nbuf_t mpdu_nbuf;
  2649. uint32_t mpdu_tried = 0;
  2650. int i;
  2651. uint32_t seq_no;
  2652. uint8_t usr_idx = 0;
  2653. xretry_ppdu = tx_tid->xretry_ppdu;
  2654. xretry_user = &xretry_ppdu->user[0];
  2655. if (qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q)) {
  2656. qdf_nbuf_queue_free(&xretry_user->mpdu_q);
  2657. return;
  2658. }
  2659. if (qdf_nbuf_is_queue_empty(&xretry_user->mpdu_q))
  2660. return;
  2661. ppdu_nbuf = qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q);
  2662. while (ppdu_nbuf) {
  2663. struct msdu_completion_info *ptr_msdu_info = NULL;
  2664. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2665. qdf_nbuf_data(ppdu_nbuf);
  2666. usr_idx = dp_tx_find_usr_idx_from_peer_id(ppdu_desc,
  2667. peer->peer_id);
  2668. user = &ppdu_desc->user[usr_idx];
  2669. if (user->pending_retries) {
  2670. uint32_t start_seq = user->start_seq;
  2671. mpdu_tried = user->mpdu_tried_ucast +
  2672. user->mpdu_tried_mcast;
  2673. mpdu_nbuf = qdf_nbuf_queue_first(&xretry_user->mpdu_q);
  2674. for (i = 0;
  2675. (i < user->ba_size) &&
  2676. (mpdu_tried > 0) && mpdu_nbuf;
  2677. i++) {
  2678. if (!(SEQ_BIT(user->enq_bitmap, i)))
  2679. continue;
  2680. mpdu_tried--;
  2681. /* missed seq number */
  2682. seq_no = start_seq + i;
  2683. if (SEQ_BIT(user->failed_bitmap, i))
  2684. continue;
  2685. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2686. QDF_TRACE_LEVEL_INFO,
  2687. "%s: fill seqno %d from xretries",
  2688. __func__, seq_no);
  2689. ptr_msdu_info = (struct msdu_completion_info *)
  2690. (qdf_nbuf_data(qdf_nbuf_get_ext_list(
  2691. mpdu_nbuf)) -
  2692. (sizeof(struct msdu_completion_info) +
  2693. sizeof(qdf_ether_header_t)));
  2694. ptr_msdu_info->transmit_cnt--;
  2695. SEQ_SEG(user->failed_bitmap, i) |=
  2696. SEQ_SEG_MSK(user->failed_bitmap[0], i);
  2697. user->pending_retries--;
  2698. if (ptr_msdu_info->transmit_cnt == 0) {
  2699. user->mpdus[seq_no - start_seq] =
  2700. mpdu_nbuf;
  2701. dp_tx_cap_stats_mpdu_update(peer,
  2702. PEER_MPDU_ARR, 1);
  2703. /*
  2704. * This API removes mpdu_nbuf from q
  2705. * and returns next mpdu from the queue
  2706. */
  2707. mpdu_nbuf = dp_tx_mon_get_next_mpdu(
  2708. xretry_user, mpdu_nbuf);
  2709. } else {
  2710. user->mpdus[seq_no - start_seq] =
  2711. qdf_nbuf_copy_expand_fraglist(
  2712. mpdu_nbuf,
  2713. MAX_MONITOR_HEADER, 0);
  2714. dp_tx_cap_stats_mpdu_update(peer,
  2715. PEER_MPDU_CLONE, 1);
  2716. mpdu_nbuf =
  2717. qdf_nbuf_queue_next(mpdu_nbuf);
  2718. }
  2719. }
  2720. }
  2721. if ((user->pending_retries == 0) &&
  2722. (ppdu_nbuf ==
  2723. qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q))) {
  2724. qdf_nbuf_queue_remove(&tx_tid->pending_ppdu_q);
  2725. /* Deliver PPDU */
  2726. dp_send_data_to_stack(pdev, ppdu_desc, usr_idx);
  2727. dp_ppdu_queue_free(ppdu_nbuf, usr_idx);
  2728. qdf_nbuf_free(ppdu_nbuf);
  2729. ppdu_nbuf = qdf_nbuf_queue_first(
  2730. &tx_tid->pending_ppdu_q);
  2731. } else {
  2732. ppdu_nbuf = qdf_nbuf_queue_next(ppdu_nbuf);
  2733. }
  2734. }
  2735. qdf_nbuf_queue_free(&xretry_user->mpdu_q);
  2736. }
  2737. static
  2738. struct cdp_tx_completion_ppdu *
  2739. check_subseq_ppdu_to_pending_q(struct dp_tx_cap_nbuf_list nbuf_ppdu_list[],
  2740. uint32_t ppdu_desc_cnt,
  2741. uint32_t *ppdu_cnt,
  2742. qdf_nbuf_queue_t *head_ppdu,
  2743. uint32_t peer_id, uint32_t cur_last_seq,
  2744. bool last_pend_ppdu)
  2745. {
  2746. struct cdp_tx_completion_ppdu *next_ppdu = NULL;
  2747. struct cdp_tx_completion_ppdu_user *next_user;
  2748. struct dp_tx_cap_nbuf_list *ptr_nbuf_list = NULL;
  2749. uint8_t cur_usr_idx;
  2750. while (*ppdu_cnt < (ppdu_desc_cnt - 1)) {
  2751. (*ppdu_cnt)++;
  2752. ptr_nbuf_list = &nbuf_ppdu_list[*ppdu_cnt];
  2753. if (!ptr_nbuf_list->nbuf_ppdu ||
  2754. !dp_tx_cap_nbuf_list_get_ref(ptr_nbuf_list))
  2755. continue;
  2756. next_ppdu = (struct cdp_tx_completion_ppdu *)
  2757. qdf_nbuf_data(ptr_nbuf_list->nbuf_ppdu);
  2758. if (!next_ppdu)
  2759. continue;
  2760. cur_usr_idx = dp_tx_find_usr_idx_from_peer_id(next_ppdu,
  2761. peer_id);
  2762. next_user = &next_ppdu->user[cur_usr_idx];
  2763. if ((next_user->skip == 1) || (peer_id != next_user->peer_id) ||
  2764. (next_user->mon_procd == 1))
  2765. continue;
  2766. if (last_pend_ppdu) {
  2767. qdf_nbuf_t tmp_pend_nbuf;
  2768. uint32_t ppdu_ref_cnt;
  2769. /*
  2770. * get reference count if it
  2771. * more than one do clone and
  2772. * add that to head_ppdu
  2773. */
  2774. ppdu_ref_cnt =
  2775. dp_tx_cap_nbuf_list_get_ref(ptr_nbuf_list);
  2776. if (ppdu_ref_cnt == 1) {
  2777. tmp_pend_nbuf = ptr_nbuf_list->nbuf_ppdu;
  2778. } else {
  2779. tmp_pend_nbuf = qdf_nbuf_clone(
  2780. ptr_nbuf_list->nbuf_ppdu);
  2781. if (qdf_unlikely(!tmp_pend_nbuf)) {
  2782. qdf_assert_always(0);
  2783. continue;
  2784. }
  2785. qdf_nbuf_free(ptr_nbuf_list->nbuf_ppdu);
  2786. }
  2787. qdf_nbuf_queue_add(head_ppdu, tmp_pend_nbuf);
  2788. /* decrement reference */
  2789. dp_tx_cap_nbuf_list_dec_ref(ptr_nbuf_list);
  2790. next_user->mon_procd = 1;
  2791. }
  2792. if (next_user->last_enq_seq > cur_last_seq)
  2793. return next_ppdu;
  2794. }
  2795. return NULL;
  2796. }
  2797. #define MAX_PENDING_PPDUS 32
  2798. static void
  2799. dp_tx_mon_proc_pending_ppdus(struct dp_pdev *pdev, struct dp_tx_tid *tx_tid,
  2800. struct dp_tx_cap_nbuf_list nbuf_ppdu_list[],
  2801. uint32_t ppdu_desc_cnt, qdf_nbuf_queue_t *head_ppdu,
  2802. uint32_t peer_id, uint8_t cur_usr_idx)
  2803. {
  2804. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  2805. struct cdp_tx_completion_ppdu *cur_ppdu_desc = NULL;
  2806. struct cdp_tx_completion_ppdu_user *user = NULL;
  2807. struct cdp_tx_completion_ppdu_user *cur_user = NULL;
  2808. struct dp_tx_cap_nbuf_list *ptr_nbuf_list = NULL;
  2809. qdf_nbuf_t pend_ppdu;
  2810. uint32_t ppdu_cnt;
  2811. uint32_t failed_seq;
  2812. uint32_t cur_index, cur_start_seq, cur_last_seq;
  2813. int i, k;
  2814. bool last_pend_ppdu = false;
  2815. uint8_t usr_idx;
  2816. pend_ppdu = qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q);
  2817. if (!pend_ppdu) {
  2818. for (ppdu_cnt = 0; ppdu_cnt < ppdu_desc_cnt; ppdu_cnt++) {
  2819. ptr_nbuf_list = &nbuf_ppdu_list[ppdu_cnt];
  2820. if (!dp_tx_cap_nbuf_list_get_ref(ptr_nbuf_list)) {
  2821. if (ptr_nbuf_list->nbuf_ppdu)
  2822. qdf_assert_always(0);
  2823. continue;
  2824. }
  2825. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2826. qdf_nbuf_data(ptr_nbuf_list->nbuf_ppdu);
  2827. if (!ppdu_desc)
  2828. continue;
  2829. user = &ppdu_desc->user[cur_usr_idx];
  2830. if ((user->skip == 1) || (peer_id != user->peer_id) ||
  2831. (tx_tid->tid != user->tid) || (user->mon_procd == 1))
  2832. continue;
  2833. if ((user->pending_retries == 0) &&
  2834. qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q) &&
  2835. qdf_nbuf_is_queue_empty(head_ppdu)) {
  2836. dp_send_data_to_stack(pdev, ppdu_desc,
  2837. cur_usr_idx);
  2838. user->mon_procd = 1;
  2839. /* free ppd_desc from list */
  2840. dp_ppdu_desc_free(ptr_nbuf_list, cur_usr_idx);
  2841. } else {
  2842. qdf_nbuf_t tmp_pend_nbuf;
  2843. uint32_t ppdu_ref_cnt;
  2844. /*
  2845. * get reference count if it more than one
  2846. * do clone and add that to head_ppdu
  2847. */
  2848. ppdu_ref_cnt =
  2849. dp_tx_cap_nbuf_list_get_ref(ptr_nbuf_list);
  2850. if (ppdu_ref_cnt == 1) {
  2851. tmp_pend_nbuf =
  2852. ptr_nbuf_list->nbuf_ppdu;
  2853. } else {
  2854. tmp_pend_nbuf =
  2855. qdf_nbuf_clone(
  2856. ptr_nbuf_list->nbuf_ppdu);
  2857. if (qdf_unlikely(!tmp_pend_nbuf)) {
  2858. qdf_assert_always(0);
  2859. continue;
  2860. }
  2861. /*
  2862. * free ppdu_desc to
  2863. * decrease reference
  2864. */
  2865. qdf_nbuf_free(ptr_nbuf_list->nbuf_ppdu);
  2866. }
  2867. qdf_nbuf_queue_add(head_ppdu, tmp_pend_nbuf);
  2868. /* decrement reference */
  2869. dp_tx_cap_nbuf_list_dec_ref(ptr_nbuf_list);
  2870. user->mon_procd = 1;
  2871. }
  2872. }
  2873. return;
  2874. }
  2875. while (pend_ppdu) {
  2876. qdf_nbuf_t mpdu_nbuf;
  2877. uint32_t mpdu_tried = 0;
  2878. /* Find missing mpdus from current schedule list */
  2879. ppdu_cnt = 0;
  2880. while (ppdu_cnt < ppdu_desc_cnt) {
  2881. ptr_nbuf_list = &nbuf_ppdu_list[ppdu_cnt];
  2882. ppdu_cnt++;
  2883. if (!dp_tx_cap_nbuf_list_get_ref(ptr_nbuf_list))
  2884. continue;
  2885. cur_ppdu_desc = (struct cdp_tx_completion_ppdu *)
  2886. qdf_nbuf_data(ptr_nbuf_list->nbuf_ppdu);
  2887. if (!cur_ppdu_desc)
  2888. continue;
  2889. cur_usr_idx = dp_tx_find_usr_idx_from_peer_id(
  2890. cur_ppdu_desc, peer_id);
  2891. cur_user = &cur_ppdu_desc->user[cur_usr_idx];
  2892. if ((cur_user->skip == 1) ||
  2893. (cur_user->mon_procd == 1))
  2894. continue;
  2895. /* to handle last ppdu case we need to decrement */
  2896. ppdu_cnt--;
  2897. break;
  2898. }
  2899. if (ppdu_cnt == ppdu_desc_cnt)
  2900. break;
  2901. if (qdf_unlikely(!cur_user))
  2902. break;
  2903. ppdu_desc = (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(
  2904. pend_ppdu);
  2905. usr_idx = dp_tx_find_usr_idx_from_peer_id(ppdu_desc,
  2906. peer_id);
  2907. user = &ppdu_desc->user[usr_idx];
  2908. if (pend_ppdu == qdf_nbuf_queue_last(
  2909. &tx_tid->pending_ppdu_q)) {
  2910. qdf_nbuf_t tmp_pend_nbuf;
  2911. uint32_t ppdu_ref_cnt;
  2912. last_pend_ppdu = true;
  2913. /*
  2914. * get reference count if it more than one
  2915. * do clone and add that to head_ppdu
  2916. */
  2917. ppdu_ref_cnt =
  2918. dp_tx_cap_nbuf_list_get_ref(ptr_nbuf_list);
  2919. if (ppdu_ref_cnt == 1) {
  2920. tmp_pend_nbuf =
  2921. ptr_nbuf_list->nbuf_ppdu;
  2922. } else {
  2923. tmp_pend_nbuf = qdf_nbuf_clone(
  2924. ptr_nbuf_list->nbuf_ppdu);
  2925. if (qdf_unlikely(!tmp_pend_nbuf)) {
  2926. qdf_assert_always(0);
  2927. break;
  2928. }
  2929. qdf_nbuf_free(ptr_nbuf_list->nbuf_ppdu);
  2930. }
  2931. qdf_nbuf_queue_add(head_ppdu, tmp_pend_nbuf);
  2932. /* decrement reference */
  2933. dp_tx_cap_nbuf_list_dec_ref(ptr_nbuf_list);
  2934. cur_user->mon_procd = 1;
  2935. }
  2936. cur_index = 0;
  2937. cur_start_seq = cur_user->start_seq;
  2938. cur_last_seq = cur_user->last_enq_seq;
  2939. if (qdf_unlikely(user->ba_size >
  2940. CDP_BA_256_BIT_MAP_SIZE_DWORDS *
  2941. SEQ_SEG_SZ_BITS(user->failed_bitmap))) {
  2942. dp_ppdu_desc_debug_print(ppdu_desc, usr_idx,
  2943. __func__, __LINE__);
  2944. qdf_assert_always(0);
  2945. return;
  2946. }
  2947. /* mpdu tried */
  2948. mpdu_tried = user->mpdu_tried_mcast + user->mpdu_tried_ucast;
  2949. for (i = 0; (i < user->ba_size) && cur_ppdu_desc &&
  2950. mpdu_tried && cur_index < cur_user->ba_size; i++) {
  2951. if (!(i & (SEQ_SEG_SZ_BITS(user->failed_bitmap) - 1))) {
  2952. k = SEQ_SEG_INDEX(user->failed_bitmap, i);
  2953. failed_seq = user->failed_bitmap[k] ^
  2954. user->enq_bitmap[k];
  2955. }
  2956. if (SEQ_BIT(user->enq_bitmap, i))
  2957. mpdu_tried--;
  2958. /* Skip to next bitmap segment if there are no
  2959. * more holes in current segment
  2960. */
  2961. if (!failed_seq) {
  2962. i = ((k + 1) *
  2963. SEQ_SEG_SZ_BITS(user->failed_bitmap)) - 1;
  2964. continue;
  2965. }
  2966. if (!(SEQ_SEG_BIT(failed_seq, i)))
  2967. continue;
  2968. failed_seq ^= SEQ_SEG_MSK(failed_seq, i);
  2969. if (!cur_user->mpdus) {
  2970. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2971. QDF_TRACE_LEVEL_INFO,
  2972. "%s: %d peer_id:%d usr_idx:%d cur_usr_idx:%d cur_usr_peer_id:%d\n",
  2973. __func__, __LINE__,
  2974. peer_id, usr_idx,
  2975. cur_usr_idx, cur_user->peer_id);
  2976. continue;
  2977. }
  2978. mpdu_nbuf = cur_user->mpdus[cur_index];
  2979. if (mpdu_nbuf) {
  2980. struct dp_peer *peer;
  2981. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  2982. QDF_TRACE_LEVEL_INFO,
  2983. "%s: fill seqno %d (%d) from swretries",
  2984. __func__,
  2985. user->start_seq + i,
  2986. ppdu_desc->ppdu_id);
  2987. user->mpdus[i] =
  2988. qdf_nbuf_copy_expand_fraglist(
  2989. mpdu_nbuf, MAX_MONITOR_HEADER, 0);
  2990. peer = dp_peer_get_ref_by_id
  2991. (pdev->soc, user->peer_id,
  2992. DP_MOD_ID_TX_CAPTURE);
  2993. if (peer) {
  2994. dp_tx_cap_stats_mpdu_update(peer,
  2995. PEER_MPDU_CLONE, 1);
  2996. dp_peer_unref_delete
  2997. (peer, DP_MOD_ID_TX_CAPTURE);
  2998. }
  2999. user->failed_bitmap[k] |=
  3000. SEQ_SEG_MSK(user->failed_bitmap[k], i);
  3001. user->pending_retries--;
  3002. }
  3003. cur_index++;
  3004. if (cur_index >= cur_user->ba_size) {
  3005. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3006. QDF_TRACE_LEVEL_INFO,
  3007. "%s: ba_size[%d] cur_index[%d]\n",
  3008. __func__,
  3009. cur_user->ba_size, cur_index);
  3010. break;
  3011. }
  3012. /* Skip through empty slots in current PPDU */
  3013. while (!(SEQ_BIT(cur_user->enq_bitmap, cur_index))) {
  3014. cur_index++;
  3015. if (cur_index <= (cur_last_seq - cur_start_seq))
  3016. continue;
  3017. cur_ppdu_desc = NULL;
  3018. /*
  3019. * Check if subsequent PPDUs in this schedule
  3020. * has higher sequence numbers enqueued
  3021. */
  3022. cur_ppdu_desc = check_subseq_ppdu_to_pending_q(
  3023. nbuf_ppdu_list,
  3024. ppdu_desc_cnt,
  3025. &ppdu_cnt,
  3026. head_ppdu,
  3027. peer_id,
  3028. cur_last_seq,
  3029. last_pend_ppdu);
  3030. if (!cur_ppdu_desc)
  3031. break;
  3032. cur_usr_idx = dp_tx_find_usr_idx_from_peer_id(
  3033. cur_ppdu_desc, peer_id);
  3034. cur_user = &cur_ppdu_desc->user[cur_usr_idx];
  3035. /* Start from seq. no following cur_last_seq
  3036. * since everything before is already populated
  3037. * from previous PPDU
  3038. */
  3039. cur_start_seq = cur_user->start_seq;
  3040. cur_index = (cur_last_seq >= cur_start_seq) ?
  3041. cur_last_seq - cur_start_seq + 1 : 0;
  3042. cur_last_seq = cur_user->last_enq_seq;
  3043. }
  3044. }
  3045. if ((pend_ppdu ==
  3046. qdf_nbuf_queue_first(&tx_tid->pending_ppdu_q)) &&
  3047. (user->pending_retries == 0)) {
  3048. qdf_nbuf_queue_remove(&tx_tid->pending_ppdu_q);
  3049. dp_send_data_to_stack(pdev, ppdu_desc, usr_idx);
  3050. dp_ppdu_queue_free(pend_ppdu, usr_idx);
  3051. qdf_nbuf_free(pend_ppdu);
  3052. pend_ppdu = qdf_nbuf_queue_first(
  3053. &tx_tid->pending_ppdu_q);
  3054. } else {
  3055. pend_ppdu = qdf_nbuf_queue_next(pend_ppdu);
  3056. }
  3057. }
  3058. }
  3059. static uint32_t
  3060. dp_send_mgmt_ctrl_to_stack(struct dp_pdev *pdev,
  3061. qdf_nbuf_t nbuf_ppdu_desc,
  3062. struct cdp_tx_indication_info *ptr_tx_cap_info,
  3063. qdf_nbuf_t mgmt_ctl_nbuf,
  3064. bool is_payload)
  3065. {
  3066. struct cdp_tx_completion_ppdu *ppdu_desc;
  3067. struct cdp_tx_completion_ppdu_user *user;
  3068. struct cdp_tx_indication_mpdu_info *mpdu_info;
  3069. struct ieee80211_frame *wh;
  3070. uint16_t duration_le, seq_le;
  3071. struct ieee80211_frame_min_one *wh_min;
  3072. uint16_t frame_ctrl_le;
  3073. uint8_t type, subtype;
  3074. mpdu_info = &ptr_tx_cap_info->mpdu_info;
  3075. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3076. qdf_nbuf_data(nbuf_ppdu_desc);
  3077. user = &ppdu_desc->user[0];
  3078. if (ppdu_desc->mprot_type)
  3079. dp_send_dummy_rts_cts_frame(pdev, ppdu_desc, 0);
  3080. type = (ppdu_desc->frame_ctrl &
  3081. IEEE80211_FC0_TYPE_MASK) >>
  3082. IEEE80211_FC0_TYPE_SHIFT;
  3083. subtype = (ppdu_desc->frame_ctrl &
  3084. IEEE80211_FC0_SUBTYPE_MASK) >>
  3085. IEEE80211_FC0_SUBTYPE_SHIFT;
  3086. if (is_payload) {
  3087. wh = (struct ieee80211_frame *)qdf_nbuf_data(mgmt_ctl_nbuf);
  3088. if (subtype != IEEE80211_FC0_SUBTYPE_BEACON) {
  3089. duration_le = qdf_cpu_to_le16(ppdu_desc->tx_duration);
  3090. wh->i_dur[1] = (duration_le & 0xFF00) >> 8;
  3091. wh->i_dur[0] = duration_le & 0xFF;
  3092. seq_le = qdf_cpu_to_le16(user->start_seq <<
  3093. IEEE80211_SEQ_SEQ_SHIFT);
  3094. wh->i_seq[1] = (seq_le & 0xFF00) >> 8;
  3095. wh->i_seq[0] = seq_le & 0xFF;
  3096. }
  3097. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3098. QDF_TRACE_LEVEL_DEBUG,
  3099. "ctrl/mgmt frm(0x%08x): fc 0x%x 0x%x\n",
  3100. ptr_tx_cap_info->mpdu_info.ppdu_id,
  3101. wh->i_fc[1], wh->i_fc[0]);
  3102. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3103. QDF_TRACE_LEVEL_DEBUG,
  3104. "desc->ppdu_id 0x%08x\n", ppdu_desc->ppdu_id);
  3105. /* append ext list */
  3106. qdf_nbuf_append_ext_list(ptr_tx_cap_info->mpdu_nbuf,
  3107. mgmt_ctl_nbuf,
  3108. qdf_nbuf_len(mgmt_ctl_nbuf));
  3109. } else {
  3110. wh_min = (struct ieee80211_frame_min_one *)
  3111. qdf_nbuf_data(ptr_tx_cap_info->mpdu_nbuf);
  3112. qdf_mem_zero(wh_min, MAX_DUMMY_FRM_BODY);
  3113. frame_ctrl_le = qdf_cpu_to_le16(ppdu_desc->frame_ctrl);
  3114. duration_le = qdf_cpu_to_le16(ppdu_desc->tx_duration);
  3115. wh_min->i_fc[1] = (frame_ctrl_le & 0xFF00) >> 8;
  3116. wh_min->i_fc[0] = (frame_ctrl_le & 0xFF);
  3117. wh_min->i_dur[1] = (duration_le & 0xFF00) >> 8;
  3118. wh_min->i_dur[0] = (duration_le & 0xFF);
  3119. qdf_mem_copy(wh_min->i_addr1, mpdu_info->mac_address,
  3120. QDF_MAC_ADDR_SIZE);
  3121. qdf_nbuf_set_pktlen(ptr_tx_cap_info->mpdu_nbuf,
  3122. sizeof(*wh_min));
  3123. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3124. QDF_TRACE_LEVEL_DEBUG,
  3125. "frm(0x%08x): fc %x %x, dur 0x%x%x\n",
  3126. ptr_tx_cap_info->mpdu_info.ppdu_id,
  3127. wh_min->i_fc[1], wh_min->i_fc[0],
  3128. wh_min->i_dur[1], wh_min->i_dur[0]);
  3129. }
  3130. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  3131. ptr_tx_cap_info, HTT_INVALID_PEER,
  3132. WDI_NO_VAL, pdev->pdev_id);
  3133. if (ptr_tx_cap_info->mpdu_nbuf)
  3134. qdf_nbuf_free(ptr_tx_cap_info->mpdu_nbuf);
  3135. return 0;
  3136. }
  3137. static uint32_t
  3138. dp_update_tx_cap_info(struct dp_pdev *pdev,
  3139. qdf_nbuf_t nbuf_ppdu_desc,
  3140. void *tx_info, bool is_payload,
  3141. bool bar_frm_with_data)
  3142. {
  3143. struct cdp_tx_completion_ppdu *ppdu_desc;
  3144. struct cdp_tx_completion_ppdu_user *user;
  3145. struct cdp_tx_indication_info *tx_capture_info =
  3146. (struct cdp_tx_indication_info *)tx_info;
  3147. struct cdp_tx_indication_mpdu_info *mpdu_info;
  3148. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3149. qdf_nbuf_data(nbuf_ppdu_desc);
  3150. user = &ppdu_desc->user[0];
  3151. qdf_mem_set(tx_capture_info, sizeof(struct cdp_tx_indication_info), 0);
  3152. mpdu_info = &tx_capture_info->mpdu_info;
  3153. mpdu_info->channel = ppdu_desc->channel;
  3154. mpdu_info->frame_type = ppdu_desc->frame_type;
  3155. mpdu_info->ppdu_start_timestamp = ppdu_desc->ppdu_start_timestamp;
  3156. mpdu_info->ppdu_end_timestamp = ppdu_desc->ppdu_end_timestamp;
  3157. mpdu_info->tx_duration = ppdu_desc->tx_duration;
  3158. /* update cdp_tx_indication_mpdu_info */
  3159. dp_tx_update_user_mpdu_info(ppdu_desc->ppdu_id,
  3160. &tx_capture_info->mpdu_info,
  3161. user);
  3162. if (bar_frm_with_data) {
  3163. mpdu_info->ppdu_start_timestamp =
  3164. ppdu_desc->bar_ppdu_start_timestamp;
  3165. mpdu_info->ppdu_end_timestamp =
  3166. ppdu_desc->bar_ppdu_end_timestamp;
  3167. mpdu_info->tx_duration = ppdu_desc->bar_tx_duration;
  3168. mpdu_info->preamble = ppdu_desc->phy_mode;
  3169. }
  3170. mpdu_info->seq_no = user->start_seq;
  3171. mpdu_info->num_msdu = ppdu_desc->num_msdu;
  3172. tx_capture_info->ppdu_desc = ppdu_desc;
  3173. tx_capture_info->mpdu_info.channel_num = pdev->operating_channel.num;
  3174. tx_capture_info->mpdu_info.ppdu_id = ppdu_desc->ppdu_id;
  3175. if (is_payload)
  3176. tx_capture_info->mpdu_nbuf = qdf_nbuf_alloc(pdev->soc->osdev,
  3177. MAX_MONITOR_HEADER,
  3178. MAX_MONITOR_HEADER,
  3179. 4, FALSE);
  3180. else
  3181. tx_capture_info->mpdu_nbuf = qdf_nbuf_alloc(pdev->soc->osdev,
  3182. MAX_MONITOR_HEADER +
  3183. MAX_DUMMY_FRM_BODY,
  3184. MAX_MONITOR_HEADER,
  3185. 4, FALSE);
  3186. return 0;
  3187. }
  3188. static uint32_t
  3189. dp_check_mgmt_ctrl_ppdu(struct dp_pdev *pdev,
  3190. qdf_nbuf_t nbuf_ppdu_desc, bool bar_frm_with_data)
  3191. {
  3192. struct cdp_tx_indication_info tx_capture_info;
  3193. qdf_nbuf_t mgmt_ctl_nbuf, tmp_nbuf;
  3194. uint8_t type, subtype;
  3195. uint8_t fc_type, fc_subtype;
  3196. bool is_sgen_pkt;
  3197. struct cdp_tx_mgmt_comp_info *ptr_comp_info;
  3198. qdf_nbuf_queue_t *retries_q;
  3199. struct cdp_tx_completion_ppdu *ppdu_desc, *retry_ppdu;
  3200. struct cdp_tx_completion_ppdu_user *user;
  3201. uint32_t ppdu_id;
  3202. uint32_t desc_ppdu_id;
  3203. size_t head_size;
  3204. uint32_t status = 1;
  3205. uint32_t tsf_delta;
  3206. uint64_t start_tsf;
  3207. uint64_t end_tsf;
  3208. uint16_t ppdu_desc_frame_ctrl;
  3209. struct dp_peer *peer;
  3210. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3211. qdf_nbuf_data(nbuf_ppdu_desc);
  3212. user = &ppdu_desc->user[0];
  3213. ppdu_desc_frame_ctrl = ppdu_desc->frame_ctrl;
  3214. if ((ppdu_desc->htt_frame_type == HTT_STATS_FTYPE_SGEN_MU_BAR) ||
  3215. (ppdu_desc->htt_frame_type == HTT_STATS_FTYPE_SGEN_MU_BRP))
  3216. ppdu_desc_frame_ctrl = (IEEE80211_FC0_SUBTYPE_TRIGGER |
  3217. IEEE80211_FC0_TYPE_CTL);
  3218. if (bar_frm_with_data) {
  3219. desc_ppdu_id = ppdu_desc->bar_ppdu_id;
  3220. start_tsf = ppdu_desc->bar_ppdu_start_timestamp;
  3221. end_tsf = ppdu_desc->bar_ppdu_end_timestamp;
  3222. } else {
  3223. desc_ppdu_id = ppdu_desc->ppdu_id;
  3224. start_tsf = ppdu_desc->ppdu_start_timestamp;
  3225. end_tsf = ppdu_desc->ppdu_end_timestamp;
  3226. }
  3227. /*
  3228. * only for host generated frame we do have
  3229. * timestamp and retries count.
  3230. */
  3231. head_size = sizeof(struct cdp_tx_mgmt_comp_info);
  3232. fc_type = (ppdu_desc_frame_ctrl &
  3233. IEEE80211_FC0_TYPE_MASK);
  3234. fc_subtype = (ppdu_desc_frame_ctrl &
  3235. IEEE80211_FC0_SUBTYPE_MASK);
  3236. type = (ppdu_desc_frame_ctrl &
  3237. IEEE80211_FC0_TYPE_MASK) >>
  3238. IEEE80211_FC0_TYPE_SHIFT;
  3239. subtype = (ppdu_desc_frame_ctrl &
  3240. IEEE80211_FC0_SUBTYPE_MASK) >>
  3241. IEEE80211_FC0_SUBTYPE_SHIFT;
  3242. if (ppdu_desc->htt_frame_type == HTT_STATS_FTYPE_SGEN_NDP) {
  3243. dp_update_frame_ctrl_from_frame_type(ppdu_desc);
  3244. type = 0;
  3245. subtype = 0;
  3246. }
  3247. peer = dp_peer_get_ref_by_id(pdev->soc, ppdu_desc->user[0].peer_id,
  3248. DP_MOD_ID_TX_CAPTURE);
  3249. if (peer && !peer->bss_peer) {
  3250. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, peer,
  3251. ppdu_desc->user[0].mac_addr
  3252. )) {
  3253. qdf_nbuf_free(nbuf_ppdu_desc);
  3254. status = 0;
  3255. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  3256. goto free_ppdu_desc;
  3257. }
  3258. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  3259. } else {
  3260. if (peer)
  3261. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  3262. if (!(type == IEEE80211_FC0_TYPE_MGT &&
  3263. (subtype == MGMT_SUBTYPE_PROBE_RESP >> 4 ||
  3264. subtype == MGMT_SUBTYPE_DISASSOC >> 4 ||
  3265. subtype == MGMT_SUBTYPE_DEAUTH >> 4))) {
  3266. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, NULL,
  3267. ppdu_desc->user[0]
  3268. .mac_addr)) {
  3269. qdf_nbuf_free(nbuf_ppdu_desc);
  3270. status = 0;
  3271. goto free_ppdu_desc;
  3272. }
  3273. }
  3274. }
  3275. switch (ppdu_desc->htt_frame_type) {
  3276. case HTT_STATS_FTYPE_TIDQ_DATA_SU:
  3277. case HTT_STATS_FTYPE_TIDQ_DATA_MU:
  3278. if ((fc_type == IEEE80211_FC0_TYPE_MGT) &&
  3279. (fc_subtype == IEEE80211_FC0_SUBTYPE_BEACON))
  3280. is_sgen_pkt = true;
  3281. else
  3282. is_sgen_pkt = false;
  3283. break;
  3284. default:
  3285. is_sgen_pkt = true;
  3286. break;
  3287. }
  3288. retries_q = &pdev->tx_capture.retries_ctl_mgmt_q[type][subtype];
  3289. if (!qdf_nbuf_is_queue_empty(retries_q)) {
  3290. tmp_nbuf = qdf_nbuf_queue_first(retries_q);
  3291. retry_ppdu = (struct cdp_tx_completion_ppdu *)
  3292. qdf_nbuf_data(tmp_nbuf);
  3293. if (ppdu_desc->sched_cmdid != retry_ppdu->sched_cmdid)
  3294. qdf_nbuf_queue_free(retries_q);
  3295. }
  3296. get_mgmt_pkt_from_queue:
  3297. qdf_spin_lock_bh(
  3298. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  3299. mgmt_ctl_nbuf = qdf_nbuf_queue_remove(
  3300. &pdev->tx_capture.ctl_mgmt_q[type][subtype]);
  3301. qdf_spin_unlock_bh(&pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  3302. if (mgmt_ctl_nbuf) {
  3303. qdf_nbuf_t tmp_mgmt_ctl_nbuf;
  3304. ptr_comp_info = (struct cdp_tx_mgmt_comp_info *)
  3305. qdf_nbuf_data(mgmt_ctl_nbuf);
  3306. is_sgen_pkt = ptr_comp_info->is_sgen_pkt;
  3307. ppdu_id = ptr_comp_info->ppdu_id;
  3308. if (!is_sgen_pkt && ptr_comp_info->tx_tsf < start_tsf) {
  3309. /*
  3310. * free the older mgmt buffer from
  3311. * the queue and get new mgmt buffer
  3312. */
  3313. qdf_nbuf_free(mgmt_ctl_nbuf);
  3314. goto get_mgmt_pkt_from_queue;
  3315. }
  3316. /*
  3317. * for sgen frame we won't have, retries count
  3318. * and 64 bits tsf in the head.
  3319. */
  3320. if (ppdu_id != desc_ppdu_id) {
  3321. if (is_sgen_pkt) {
  3322. start_tsf = (start_tsf & LOWER_32_MASK);
  3323. if (start_tsf > ptr_comp_info->tx_tsf)
  3324. tsf_delta = start_tsf -
  3325. ptr_comp_info->tx_tsf;
  3326. else
  3327. tsf_delta = LOWER_32_MASK -
  3328. ptr_comp_info->tx_tsf +
  3329. start_tsf;
  3330. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3331. QDF_TRACE_LEVEL_INFO,
  3332. "%s: ppdu_id[m:%d desc:%d] start_tsf: %u mgmt_tsf:%u tsf_delta:%u bar_frm_with_data:%d",
  3333. __func__, ppdu_id, desc_ppdu_id,
  3334. start_tsf, ptr_comp_info->tx_tsf,
  3335. tsf_delta, bar_frm_with_data);
  3336. if (tsf_delta > MAX_MGMT_ENQ_DELAY) {
  3337. /*
  3338. * free the older mgmt buffer from
  3339. * the queue and get new mgmt buffer
  3340. */
  3341. qdf_nbuf_free(mgmt_ctl_nbuf);
  3342. goto get_mgmt_pkt_from_queue;
  3343. } else {
  3344. /* drop the ppdu_desc */
  3345. qdf_nbuf_free(nbuf_ppdu_desc);
  3346. status = 0;
  3347. goto insert_mgmt_buf_to_queue;
  3348. }
  3349. }
  3350. /*
  3351. * only for the packets send over the air are handled
  3352. * packets drop by firmware is not handled in this
  3353. * feature
  3354. */
  3355. if (user->completion_status ==
  3356. HTT_PPDU_STATS_USER_STATUS_FILTERED) {
  3357. qdf_nbuf_free(nbuf_ppdu_desc);
  3358. status = 0;
  3359. goto insert_mgmt_buf_to_queue;
  3360. }
  3361. /* check for max retry count */
  3362. if (qdf_nbuf_queue_len(retries_q) >=
  3363. MAX_RETRY_Q_COUNT) {
  3364. qdf_nbuf_t nbuf_retry_ppdu;
  3365. nbuf_retry_ppdu =
  3366. qdf_nbuf_queue_remove(retries_q);
  3367. qdf_nbuf_free(nbuf_retry_ppdu);
  3368. }
  3369. /*
  3370. * add the ppdu_desc into retry queue
  3371. */
  3372. qdf_nbuf_queue_add(retries_q, nbuf_ppdu_desc);
  3373. /* flushing retry queue since completion status is
  3374. * in final state. meaning that even though ppdu_id are
  3375. * different there is a payload already.
  3376. */
  3377. if (qdf_unlikely(ppdu_desc->user[0].completion_status ==
  3378. HTT_PPDU_STATS_USER_STATUS_OK)) {
  3379. qdf_nbuf_queue_free(retries_q);
  3380. }
  3381. status = 0;
  3382. insert_mgmt_buf_to_queue:
  3383. /*
  3384. * insert the mgmt_ctl buffer back to
  3385. * the queue
  3386. */
  3387. qdf_spin_lock_bh(
  3388. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  3389. qdf_nbuf_queue_insert_head(
  3390. &pdev->tx_capture.ctl_mgmt_q[type][subtype],
  3391. mgmt_ctl_nbuf);
  3392. qdf_spin_unlock_bh(
  3393. &pdev->tx_capture.ctl_mgmt_lock[type][subtype]);
  3394. } else {
  3395. qdf_nbuf_t nbuf_retry_ppdu;
  3396. struct cdp_tx_completion_ppdu *tmp_ppdu_desc;
  3397. uint16_t frame_ctrl_le;
  3398. struct ieee80211_frame *wh;
  3399. uint32_t retry_len = 0;
  3400. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3401. QDF_TRACE_LEVEL_INFO,
  3402. "%s: ppdu_id[m:%d desc:%d] start_tsf: %u mgmt_tsf:%u bar_frm_with_data:%d is_sgen:%d",
  3403. __func__, ppdu_id, desc_ppdu_id,
  3404. start_tsf, ptr_comp_info->tx_tsf,
  3405. bar_frm_with_data, is_sgen_pkt);
  3406. /*
  3407. * only for the packets send over the air are handled
  3408. * packets drop by firmware is not handled in this
  3409. * feature
  3410. */
  3411. if (user->completion_status ==
  3412. HTT_PPDU_STATS_USER_STATUS_FILTERED) {
  3413. qdf_nbuf_free(nbuf_ppdu_desc);
  3414. qdf_nbuf_free(mgmt_ctl_nbuf);
  3415. status = 0;
  3416. goto free_ppdu_desc;
  3417. }
  3418. /* pull head based on sgen pkt or mgmt pkt */
  3419. if (NULL == qdf_nbuf_pull_head(mgmt_ctl_nbuf,
  3420. head_size)) {
  3421. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3422. QDF_TRACE_LEVEL_FATAL,
  3423. " No Head space to pull !!\n");
  3424. qdf_assert_always(0);
  3425. }
  3426. wh = (struct ieee80211_frame *)
  3427. (qdf_nbuf_data(mgmt_ctl_nbuf));
  3428. if (type == IEEE80211_FC0_TYPE_MGT &&
  3429. (subtype == MGMT_SUBTYPE_PROBE_RESP >> 4 ||
  3430. subtype == MGMT_SUBTYPE_DISASSOC >> 4 ||
  3431. subtype == MGMT_SUBTYPE_DEAUTH >> 4)) {
  3432. if (!dp_peer_or_pdev_tx_cap_enabled(pdev,
  3433. NULL,
  3434. wh->i_addr1
  3435. )) {
  3436. qdf_nbuf_free(nbuf_ppdu_desc);
  3437. qdf_nbuf_free(mgmt_ctl_nbuf);
  3438. qdf_nbuf_queue_free(retries_q);
  3439. status = 0;
  3440. goto free_ppdu_desc;
  3441. }
  3442. }
  3443. while (qdf_nbuf_queue_len(retries_q)) {
  3444. /*
  3445. * send retried packet stored
  3446. * in queue
  3447. */
  3448. nbuf_retry_ppdu =
  3449. qdf_nbuf_queue_remove(retries_q);
  3450. retry_len = qdf_nbuf_queue_len(retries_q);
  3451. if (!nbuf_retry_ppdu) {
  3452. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3453. QDF_TRACE_LEVEL_FATAL,
  3454. "%s: %d retry q type[%d][%d] retry q len = %d\n",
  3455. __func__, __LINE__,
  3456. type, subtype, retry_len);
  3457. qdf_assert_always(0);
  3458. break;
  3459. }
  3460. tmp_ppdu_desc =
  3461. (struct cdp_tx_completion_ppdu *)
  3462. qdf_nbuf_data(nbuf_retry_ppdu);
  3463. tmp_mgmt_ctl_nbuf =
  3464. qdf_nbuf_copy_expand(mgmt_ctl_nbuf,
  3465. 0, 0);
  3466. if (qdf_unlikely(!tmp_mgmt_ctl_nbuf)) {
  3467. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3468. QDF_TRACE_LEVEL_FATAL,
  3469. "No memory to do copy!!");
  3470. qdf_assert_always(0);
  3471. }
  3472. dp_update_tx_cap_info(pdev, nbuf_retry_ppdu,
  3473. &tx_capture_info, true,
  3474. bar_frm_with_data);
  3475. if (!tx_capture_info.mpdu_nbuf) {
  3476. qdf_nbuf_free(nbuf_retry_ppdu);
  3477. qdf_nbuf_free(tmp_mgmt_ctl_nbuf);
  3478. continue;
  3479. }
  3480. /*
  3481. * frame control from ppdu_desc has
  3482. * retry flag set
  3483. */
  3484. frame_ctrl_le =
  3485. qdf_cpu_to_le16(tmp_ppdu_desc->frame_ctrl);
  3486. wh = (struct ieee80211_frame *)
  3487. (qdf_nbuf_data(tmp_mgmt_ctl_nbuf));
  3488. wh->i_fc[1] = (frame_ctrl_le & 0xFF00) >> 8;
  3489. wh->i_fc[0] = (frame_ctrl_le & 0xFF);
  3490. tx_capture_info.ppdu_desc = tmp_ppdu_desc;
  3491. /*
  3492. * send MPDU to osif layer
  3493. */
  3494. dp_send_mgmt_ctrl_to_stack(pdev,
  3495. nbuf_retry_ppdu,
  3496. &tx_capture_info,
  3497. tmp_mgmt_ctl_nbuf,
  3498. true);
  3499. /* free retried queue nbuf ppdu_desc */
  3500. qdf_nbuf_free(nbuf_retry_ppdu);
  3501. }
  3502. dp_update_tx_cap_info(pdev, nbuf_ppdu_desc,
  3503. &tx_capture_info, true,
  3504. bar_frm_with_data);
  3505. if (!tx_capture_info.mpdu_nbuf) {
  3506. qdf_nbuf_free(mgmt_ctl_nbuf);
  3507. qdf_nbuf_free(nbuf_ppdu_desc);
  3508. status = 0;
  3509. goto free_ppdu_desc;
  3510. }
  3511. tx_capture_info.mpdu_info.ppdu_id =
  3512. *(uint32_t *)qdf_nbuf_data(mgmt_ctl_nbuf);
  3513. /* frame control from ppdu_desc has retry flag set */
  3514. frame_ctrl_le = qdf_cpu_to_le16(ppdu_desc_frame_ctrl);
  3515. wh = (struct ieee80211_frame *)
  3516. (qdf_nbuf_data(mgmt_ctl_nbuf));
  3517. wh->i_fc[1] = (frame_ctrl_le & 0xFF00) >> 8;
  3518. wh->i_fc[0] = (frame_ctrl_le & 0xFF);
  3519. tx_capture_info.ppdu_desc = ppdu_desc;
  3520. /*
  3521. * send MPDU to osif layer
  3522. */
  3523. dp_send_mgmt_ctrl_to_stack(pdev, nbuf_ppdu_desc,
  3524. &tx_capture_info,
  3525. mgmt_ctl_nbuf, true);
  3526. }
  3527. } else if (!is_sgen_pkt) {
  3528. /*
  3529. * only for the packets send over the air are handled
  3530. * packets drop by firmware is not handled in this
  3531. * feature
  3532. */
  3533. if (user->completion_status ==
  3534. HTT_PPDU_STATS_USER_STATUS_FILTERED) {
  3535. qdf_nbuf_free(nbuf_ppdu_desc);
  3536. status = 0;
  3537. goto free_ppdu_desc;
  3538. }
  3539. /* check for max retry count */
  3540. if (qdf_nbuf_queue_len(retries_q) >= MAX_RETRY_Q_COUNT) {
  3541. qdf_nbuf_t nbuf_retry_ppdu;
  3542. nbuf_retry_ppdu =
  3543. qdf_nbuf_queue_remove(retries_q);
  3544. qdf_nbuf_free(nbuf_retry_ppdu);
  3545. }
  3546. /*
  3547. * add the ppdu_desc into retry queue
  3548. */
  3549. qdf_nbuf_queue_add(retries_q, nbuf_ppdu_desc);
  3550. /* flushing retry queue since completion status is
  3551. * in final state. meaning that even though ppdu_id are
  3552. * different there is a payload already.
  3553. */
  3554. if (qdf_unlikely(ppdu_desc->user[0].completion_status ==
  3555. HTT_PPDU_STATS_USER_STATUS_OK)) {
  3556. qdf_nbuf_queue_free(retries_q);
  3557. }
  3558. status = 0;
  3559. } else if ((ppdu_desc_frame_ctrl &
  3560. IEEE80211_FC0_TYPE_MASK) ==
  3561. IEEE80211_FC0_TYPE_CTL) {
  3562. /*
  3563. * only for the packets send over the air are handled
  3564. * packets drop by firmware is not handled in this
  3565. * feature
  3566. */
  3567. if (user->completion_status ==
  3568. HTT_PPDU_STATS_USER_STATUS_FILTERED) {
  3569. qdf_nbuf_free(nbuf_ppdu_desc);
  3570. status = 0;
  3571. goto free_ppdu_desc;
  3572. }
  3573. dp_update_tx_cap_info(pdev, nbuf_ppdu_desc,
  3574. &tx_capture_info, false,
  3575. bar_frm_with_data);
  3576. if (!tx_capture_info.mpdu_nbuf) {
  3577. qdf_nbuf_free(nbuf_ppdu_desc);
  3578. status = 0;
  3579. goto free_ppdu_desc;
  3580. }
  3581. /*
  3582. * send MPDU to osif layer
  3583. */
  3584. dp_send_mgmt_ctrl_to_stack(pdev, nbuf_ppdu_desc,
  3585. &tx_capture_info, NULL, false);
  3586. }
  3587. free_ppdu_desc:
  3588. return status;
  3589. }
  3590. /**
  3591. * dp_peer_tx_cap_tid_queue_flush_tlv(): Function to dequeue peer queue
  3592. * @pdev: DP pdev handle
  3593. * @peer; DP peer handle
  3594. * @ppdu_desc: ppdu_desc
  3595. *
  3596. * return: void
  3597. */
  3598. static void
  3599. dp_peer_tx_cap_tid_queue_flush_tlv(struct dp_pdev *pdev,
  3600. struct dp_peer *peer,
  3601. struct cdp_tx_completion_ppdu *ppdu_desc,
  3602. uint8_t usr_idx)
  3603. {
  3604. int tid;
  3605. struct dp_tx_tid *tx_tid;
  3606. qdf_nbuf_queue_t head_xretries;
  3607. qdf_nbuf_queue_t head_msdu;
  3608. uint32_t qlen = 0;
  3609. uint32_t qlen_curr = 0;
  3610. struct cdp_tx_completion_ppdu_user *xretry_user;
  3611. xretry_user = &ppdu_desc->user[usr_idx];
  3612. tid = xretry_user->tid;
  3613. tx_tid = &peer->tx_capture.tx_tid[tid];
  3614. qdf_nbuf_queue_init(&head_msdu);
  3615. qdf_nbuf_queue_init(&head_xretries);
  3616. qlen = qdf_nbuf_queue_len(&tx_tid->defer_msdu_q);
  3617. dp_tx_msdu_dequeue(peer, INVALID_PPDU_ID,
  3618. tid, ppdu_desc->num_msdu,
  3619. &head_msdu,
  3620. &head_xretries,
  3621. 0, MAX_END_TSF);
  3622. dp_tx_cap_stats_msdu_update(peer, PEER_MSDU_FLUSH,
  3623. qdf_nbuf_queue_len(&head_msdu));
  3624. dp_tx_cap_stats_msdu_update(peer, PEER_MSDU_FLUSH,
  3625. qdf_nbuf_queue_len(&head_xretries));
  3626. if (!qdf_nbuf_is_queue_empty(&head_xretries)) {
  3627. struct cdp_tx_completion_ppdu *xretry_ppdu =
  3628. tx_tid->xretry_ppdu;
  3629. uint32_t xretry_qlen;
  3630. xretry_ppdu->ppdu_id = peer->tx_capture.tx_wifi_ppdu_id;
  3631. /* Restitch MPDUs from xretry MSDUs */
  3632. dp_tx_mon_restitch_mpdu(pdev, peer,
  3633. xretry_ppdu,
  3634. &head_xretries,
  3635. &xretry_user->mpdu_q,
  3636. 0);
  3637. xretry_qlen = qdf_nbuf_queue_len(&xretry_user->mpdu_q);
  3638. dp_tx_cap_stats_mpdu_update(peer, PEER_MPDU_RESTITCH,
  3639. xretry_qlen);
  3640. }
  3641. qdf_nbuf_queue_free(&head_msdu);
  3642. qdf_nbuf_queue_free(&head_xretries);
  3643. qlen_curr = qdf_nbuf_queue_len(&tx_tid->defer_msdu_q);
  3644. dp_tx_mon_proc_xretries(pdev, peer, tid);
  3645. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3646. QDF_TRACE_LEVEL_INFO_MED,
  3647. "peer_id [%d 0x%x] tid[%d] qlen[%d -> %d]",
  3648. ppdu_desc->user[usr_idx].peer_id, peer, tid, qlen, qlen_curr);
  3649. }
  3650. /**
  3651. * dp_tx_ppdu_stats_flush(): Function to flush pending retried ppdu desc
  3652. * @pdev: DP pdev handle
  3653. * @nbuf: ppdu_desc
  3654. *
  3655. * return: void
  3656. */
  3657. static void
  3658. dp_tx_ppdu_stats_flush(struct dp_pdev *pdev,
  3659. struct cdp_tx_completion_ppdu *ppdu_desc,
  3660. uint8_t usr_idx)
  3661. {
  3662. struct dp_peer *peer;
  3663. struct cdp_tx_completion_ppdu_user *user;
  3664. user = &ppdu_desc->user[usr_idx];
  3665. peer = dp_peer_get_ref_by_id(pdev->soc, user->peer_id,
  3666. DP_MOD_ID_TX_CAPTURE);
  3667. if (!peer)
  3668. return;
  3669. dp_peer_tx_cap_tid_queue_flush_tlv(pdev, peer, ppdu_desc, usr_idx);
  3670. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  3671. return;
  3672. }
  3673. /**
  3674. * dp_check_ppdu_and_deliver(): Check PPDUs for any holes and deliver
  3675. * to upper layer if complete
  3676. * @pdev: DP pdev handle
  3677. * @nbuf_ppdu_list: ppdu_desc_list per sched cmd id
  3678. * @ppdu_desc_cnt: number of ppdu_desc_cnt
  3679. *
  3680. * return: status
  3681. */
  3682. static void
  3683. dp_check_ppdu_and_deliver(struct dp_pdev *pdev,
  3684. struct dp_tx_cap_nbuf_list nbuf_ppdu_list[],
  3685. uint32_t ppdu_desc_cnt)
  3686. {
  3687. uint32_t ppdu_id;
  3688. uint32_t desc_cnt;
  3689. qdf_nbuf_t tmp_nbuf;
  3690. struct dp_tx_tid *tx_tid = NULL;
  3691. int i;
  3692. uint8_t max_num_users = 0;
  3693. uint8_t usr_idx;
  3694. struct dp_tx_cap_nbuf_list *ptr_nbuf_list;
  3695. for (desc_cnt = 0; desc_cnt < ppdu_desc_cnt; desc_cnt++) {
  3696. struct cdp_tx_completion_ppdu *ppdu_desc;
  3697. struct cdp_tx_completion_ppdu_user *user;
  3698. uint32_t num_mpdu;
  3699. uint16_t start_seq, seq_no = 0;
  3700. int i;
  3701. qdf_nbuf_t mpdu_nbuf;
  3702. struct dp_peer *peer;
  3703. uint8_t type;
  3704. uint8_t subtype;
  3705. uint8_t usr_type;
  3706. uint32_t mpdus_tried;
  3707. uint8_t num_users;
  3708. qdf_nbuf_t nbuf_ppdu;
  3709. bool is_bar_frm_with_data = false;
  3710. ptr_nbuf_list = &nbuf_ppdu_list[desc_cnt];
  3711. if (!dp_tx_cap_nbuf_list_get_ref(ptr_nbuf_list)) {
  3712. if (ptr_nbuf_list->nbuf_ppdu)
  3713. qdf_assert_always(0);
  3714. continue;
  3715. }
  3716. nbuf_ppdu = ptr_nbuf_list->nbuf_ppdu;
  3717. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3718. qdf_nbuf_data(nbuf_ppdu);
  3719. ppdu_id = ppdu_desc->ppdu_id;
  3720. num_users = ppdu_desc->num_users;
  3721. if (ppdu_desc->is_flush) {
  3722. dp_tx_ppdu_stats_flush(pdev, ppdu_desc, 0);
  3723. dp_ppdu_desc_free_all(ptr_nbuf_list, num_users);
  3724. continue;
  3725. }
  3726. if (max_num_users < ppdu_desc->num_users)
  3727. max_num_users = ppdu_desc->num_users;
  3728. type = (ppdu_desc->frame_ctrl & IEEE80211_FC0_TYPE_MASK);
  3729. subtype = (ppdu_desc->frame_ctrl &
  3730. IEEE80211_FC0_SUBTYPE_MASK);
  3731. usr_type = (ppdu_desc->user[0].frame_ctrl &
  3732. IEEE80211_FC0_TYPE_MASK);
  3733. /* handle management frame */
  3734. if ((type != IEEE80211_FC0_TYPE_DATA) ||
  3735. (ppdu_desc->htt_frame_type ==
  3736. HTT_STATS_FTYPE_SGEN_MU_BAR) ||
  3737. (ppdu_desc->htt_frame_type ==
  3738. HTT_STATS_FTYPE_SGEN_QOS_NULL)) {
  3739. qdf_nbuf_t tmp_nbuf_ppdu;
  3740. tmp_nbuf_ppdu = nbuf_ppdu;
  3741. /*
  3742. * take reference of ppdu_desc if the htt_frame_type is
  3743. * HTT_STATS_FTYPE_SGEN_MU_BAR, as there will be
  3744. * corresponding data frame
  3745. */
  3746. if (((type == IEEE80211_FC0_TYPE_CTL) &&
  3747. (subtype == IEEE80211_FC0_SUBTYPE_BAR) &&
  3748. (usr_type == IEEE80211_FC0_TYPE_DATA)) ||
  3749. (ppdu_desc->htt_frame_type ==
  3750. HTT_STATS_FTYPE_SGEN_MU_BAR)) {
  3751. /*
  3752. * clonning ppdu_desc additional reference as
  3753. * handling data frame
  3754. */
  3755. tmp_nbuf_ppdu = qdf_nbuf_clone(nbuf_ppdu);
  3756. if (qdf_unlikely(!tmp_nbuf_ppdu)) {
  3757. qdf_assert_always(0);
  3758. continue;
  3759. }
  3760. dp_tx_cap_nbuf_list_inc_ref(ptr_nbuf_list);
  3761. is_bar_frm_with_data = true;
  3762. }
  3763. if (dp_check_mgmt_ctrl_ppdu(pdev, tmp_nbuf_ppdu,
  3764. is_bar_frm_with_data)) {
  3765. dp_tx_cap_nbuf_list_dec_ref(ptr_nbuf_list);
  3766. qdf_nbuf_free(tmp_nbuf_ppdu);
  3767. } else {
  3768. dp_tx_cap_nbuf_list_dec_ref(ptr_nbuf_list);
  3769. }
  3770. if (!is_bar_frm_with_data)
  3771. continue;
  3772. }
  3773. /*
  3774. * process only data frame and other
  3775. */
  3776. for (usr_idx = 0; usr_idx < num_users; usr_idx++) {
  3777. uint32_t mpdu_enq = 0;
  3778. uint32_t mpdu_tried = 0;
  3779. if (!ptr_nbuf_list->nbuf_ppdu ||
  3780. !dp_tx_cap_nbuf_list_get_ref(ptr_nbuf_list)) {
  3781. continue;
  3782. }
  3783. nbuf_ppdu = ptr_nbuf_list->nbuf_ppdu;
  3784. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3785. qdf_nbuf_data(nbuf_ppdu);
  3786. user = &ppdu_desc->user[usr_idx];
  3787. if (user->delayed_ba || user->skip == 1)
  3788. continue;
  3789. peer = dp_peer_get_ref_by_id(pdev->soc,
  3790. user->peer_id,
  3791. DP_MOD_ID_TX_CAPTURE);
  3792. if (!peer) {
  3793. dp_ppdu_desc_free(ptr_nbuf_list, usr_idx);
  3794. user->skip = 1;
  3795. continue;
  3796. }
  3797. tx_tid = &peer->tx_capture.tx_tid[user->tid];
  3798. ppdu_id = ppdu_desc->ppdu_id;
  3799. /* find mpdu tried is same as success mpdu */
  3800. num_mpdu = user->mpdu_success;
  3801. /*
  3802. * ba_size is updated in BA bitmap TLVs,
  3803. * which are not received
  3804. * in case of non-QoS TID.
  3805. */
  3806. if (qdf_unlikely(user->tid == DP_NON_QOS_TID)) {
  3807. user->ba_size = 1;
  3808. user->last_enq_seq = user->start_seq;
  3809. }
  3810. if (user->ba_size == 0)
  3811. user->ba_size = 1;
  3812. /* find list of missing sequence */
  3813. user->mpdus = qdf_mem_malloc(sizeof(qdf_nbuf_t) *
  3814. user->ba_size);
  3815. if (qdf_unlikely(!user->mpdus)) {
  3816. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3817. QDF_TRACE_LEVEL_FATAL,
  3818. "%s: ppdu_desc->mpdus allocation failed",
  3819. __func__);
  3820. dp_ppdu_desc_free_all(ptr_nbuf_list, num_users);
  3821. dp_peer_unref_delete(peer,
  3822. DP_MOD_ID_TX_CAPTURE);
  3823. dp_print_pdev_tx_capture_stats(pdev);
  3824. qdf_assert_always(0);
  3825. return;
  3826. }
  3827. if (qdf_unlikely(user->ba_size >
  3828. CDP_BA_256_BIT_MAP_SIZE_DWORDS *
  3829. SEQ_SEG_SZ_BITS(user->failed_bitmap))) {
  3830. dp_peer_unref_delete(peer,
  3831. DP_MOD_ID_TX_CAPTURE);
  3832. qdf_assert_always(0);
  3833. return;
  3834. }
  3835. /* Fill seq holes within current schedule list */
  3836. start_seq = user->start_seq;
  3837. seq_no = 0;
  3838. mpdus_tried = user->mpdu_tried_mcast +
  3839. user->mpdu_tried_ucast;
  3840. for (i = 0; (i < user->ba_size) && mpdus_tried; i++) {
  3841. if (qdf_likely(user->tid != DP_NON_QOS_TID) &&
  3842. !(SEQ_BIT(user->enq_bitmap, i)))
  3843. continue;
  3844. mpdus_tried--;
  3845. /* missed seq number */
  3846. seq_no = start_seq + i;
  3847. /*
  3848. * Fill failed MPDUs in AMPDU if they're
  3849. * available in subsequent PPDUs in current
  3850. * burst schedule. This is not applicable
  3851. * for non-QoS TIDs (no AMPDUs)
  3852. */
  3853. if (qdf_likely(user->tid != DP_NON_QOS_TID) &&
  3854. !(SEQ_BIT(user->failed_bitmap, i))) {
  3855. uint8_t seq_idx;
  3856. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3857. QDF_TRACE_LEVEL_DEBUG,
  3858. "%s:find seq %d in next ppdu %d",
  3859. __func__, seq_no,
  3860. ppdu_desc_cnt);
  3861. mpdu_nbuf =
  3862. get_mpdu_clone_from_next_ppdu(
  3863. nbuf_ppdu_list +
  3864. desc_cnt,
  3865. ppdu_desc_cnt -
  3866. desc_cnt, seq_no,
  3867. user->peer_id,
  3868. ppdu_id, usr_idx);
  3869. seq_idx = seq_no - start_seq;
  3870. /* check mpdu_nbuf NULL */
  3871. if (!mpdu_nbuf) {
  3872. user->mpdus[seq_idx] = NULL;
  3873. user->pending_retries++;
  3874. continue;
  3875. }
  3876. dp_tx_cap_stats_mpdu_update(peer,
  3877. PEER_MPDU_CLONE, 1);
  3878. user->mpdus[seq_idx] = mpdu_nbuf;
  3879. SEQ_SEG(user->failed_bitmap, i) |=
  3880. SEQ_SEG_MSK(user->failed_bitmap[0], i);
  3881. } else {
  3882. qdf_nbuf_queue_t *tmp_q;
  3883. tmp_q = &user->mpdu_q;
  3884. /* any error case we need to handle */
  3885. mpdu_nbuf =
  3886. qdf_nbuf_queue_remove(tmp_q);
  3887. /* check mpdu_nbuf NULL */
  3888. if (!mpdu_nbuf)
  3889. continue;
  3890. user->mpdus[seq_no - start_seq] =
  3891. mpdu_nbuf;
  3892. dp_tx_cap_stats_mpdu_update(peer,
  3893. PEER_MPDU_ARR, 1);
  3894. }
  3895. }
  3896. mpdu_tried = user->mpdu_tried_ucast +
  3897. user->mpdu_tried_mcast;
  3898. for (i = 0; i < CDP_BA_256_BIT_MAP_SIZE_DWORDS; i++)
  3899. mpdu_enq +=
  3900. get_number_of_1s(user->enq_bitmap[i]);
  3901. if (mpdu_tried > mpdu_enq)
  3902. dp_ppdu_desc_debug_print(ppdu_desc, usr_idx,
  3903. __func__, __LINE__);
  3904. /*
  3905. * It is possible that enq_bitmap received has
  3906. * more bits than actual mpdus tried if HW was
  3907. * unable to send all MPDUs, and last_enq_seq
  3908. * and ba_size should be adjusted in that case
  3909. */
  3910. if (i < user->ba_size) {
  3911. user->last_enq_seq = seq_no;
  3912. user->ba_size = seq_no - start_seq + 1;
  3913. }
  3914. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  3915. }
  3916. }
  3917. for (usr_idx = 0; usr_idx < max_num_users; usr_idx++) {
  3918. for (i = 0; i < ppdu_desc_cnt; i++) {
  3919. uint32_t pending_ppdus;
  3920. struct cdp_tx_completion_ppdu *cur_ppdu_desc;
  3921. struct cdp_tx_completion_ppdu_user *cur_user;
  3922. struct dp_peer *peer;
  3923. qdf_nbuf_queue_t head_ppdu;
  3924. uint16_t peer_id;
  3925. ptr_nbuf_list = &nbuf_ppdu_list[i];
  3926. if (!ptr_nbuf_list->nbuf_ppdu ||
  3927. !dp_tx_cap_nbuf_list_get_ref(ptr_nbuf_list))
  3928. continue;
  3929. cur_ppdu_desc = (struct cdp_tx_completion_ppdu *)
  3930. qdf_nbuf_data(ptr_nbuf_list->nbuf_ppdu);
  3931. if (!cur_ppdu_desc)
  3932. continue;
  3933. if (usr_idx >= cur_ppdu_desc->num_users)
  3934. continue;
  3935. cur_user = &cur_ppdu_desc->user[usr_idx];
  3936. if ((cur_user->delayed_ba == 1) ||
  3937. (cur_user->skip == 1) || (cur_user->mon_procd == 1))
  3938. continue;
  3939. peer_id = cur_ppdu_desc->user[usr_idx].peer_id;
  3940. peer = dp_peer_get_ref_by_id(pdev->soc, peer_id,
  3941. DP_MOD_ID_TX_CAPTURE);
  3942. if (!peer) {
  3943. dp_ppdu_desc_free(ptr_nbuf_list, usr_idx);
  3944. continue;
  3945. }
  3946. tx_tid = &peer->tx_capture.tx_tid[cur_user->tid];
  3947. qdf_nbuf_queue_init(&head_ppdu);
  3948. dp_tx_mon_proc_pending_ppdus(pdev, tx_tid,
  3949. nbuf_ppdu_list + i,
  3950. ppdu_desc_cnt - i,
  3951. &head_ppdu,
  3952. cur_user->peer_id,
  3953. usr_idx);
  3954. if (qdf_nbuf_is_queue_empty(&tx_tid->pending_ppdu_q)) {
  3955. while ((tmp_nbuf =
  3956. qdf_nbuf_queue_first(&head_ppdu))) {
  3957. cur_ppdu_desc =
  3958. (struct cdp_tx_completion_ppdu *)
  3959. qdf_nbuf_data(tmp_nbuf);
  3960. cur_user =
  3961. &cur_ppdu_desc->user[usr_idx];
  3962. if (cur_user->pending_retries)
  3963. break;
  3964. dp_send_data_to_stack(pdev,
  3965. cur_ppdu_desc,
  3966. usr_idx);
  3967. dp_ppdu_queue_free(tmp_nbuf, usr_idx);
  3968. qdf_nbuf_queue_remove(&head_ppdu);
  3969. qdf_nbuf_free(tmp_nbuf);
  3970. }
  3971. }
  3972. qdf_nbuf_queue_append(&tx_tid->pending_ppdu_q,
  3973. &head_ppdu);
  3974. dp_tx_mon_proc_xretries(pdev, peer, tx_tid->tid);
  3975. pending_ppdus =
  3976. qdf_nbuf_queue_len(&tx_tid->pending_ppdu_q);
  3977. if (pending_ppdus > MAX_PENDING_PPDUS) {
  3978. struct cdp_tx_completion_ppdu *tmp_ppdu_desc;
  3979. uint8_t tmp_usr_idx;
  3980. qdf_nbuf_queue_t *tmp_ppdu_q;
  3981. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  3982. QDF_TRACE_LEVEL_ERROR,
  3983. "pending ppdus (%d, %d) : %d\n",
  3984. peer_id,
  3985. tx_tid->tid, pending_ppdus);
  3986. tmp_ppdu_q = &tx_tid->pending_ppdu_q;
  3987. tmp_nbuf = qdf_nbuf_queue_remove(tmp_ppdu_q);
  3988. if (qdf_unlikely(!tmp_nbuf)) {
  3989. dp_peer_unref_delete
  3990. (peer, DP_MOD_ID_TX_CAPTURE);
  3991. qdf_assert_always(0);
  3992. return;
  3993. }
  3994. tmp_ppdu_desc =
  3995. (struct cdp_tx_completion_ppdu *)
  3996. qdf_nbuf_data(tmp_nbuf);
  3997. tmp_usr_idx = dp_tx_find_usr_idx_from_peer_id(
  3998. tmp_ppdu_desc, peer_id);
  3999. dp_send_data_to_stack(pdev, tmp_ppdu_desc,
  4000. tmp_usr_idx);
  4001. dp_ppdu_queue_free(tmp_nbuf, tmp_usr_idx);
  4002. qdf_nbuf_free(tmp_nbuf);
  4003. pdev->tx_capture.pend_ppdu_dropped++;
  4004. }
  4005. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  4006. }
  4007. }
  4008. }
  4009. static uint32_t
  4010. dp_tx_cap_proc_per_ppdu_info(struct dp_pdev *pdev, qdf_nbuf_t nbuf_ppdu,
  4011. struct dp_tx_cap_nbuf_list nbuf_ppdu_list[],
  4012. uint32_t ppdu_desc_cnt)
  4013. {
  4014. struct dp_tx_cap_nbuf_list *ptr_nbuf_list;
  4015. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  4016. struct dp_peer *peer = NULL;
  4017. qdf_nbuf_queue_t head_msdu;
  4018. qdf_nbuf_queue_t head_xretries;
  4019. uint32_t retries = 0;
  4020. uint32_t ret = 0;
  4021. uint32_t start_tsf = 0;
  4022. uint32_t end_tsf = 0;
  4023. uint32_t bar_start_tsf = 0;
  4024. uint32_t bar_end_tsf = 0;
  4025. uint16_t tid = 0;
  4026. uint32_t num_msdu = 0;
  4027. uint32_t qlen = 0;
  4028. uint16_t peer_id;
  4029. uint8_t type, subtype;
  4030. uint8_t usr_idx;
  4031. bool is_bar_frm_with_data = false;
  4032. uint8_t usr_type;
  4033. uint8_t usr_subtype;
  4034. qdf_nbuf_queue_init(&head_msdu);
  4035. qdf_nbuf_queue_init(&head_xretries);
  4036. ppdu_desc = (struct cdp_tx_completion_ppdu *)qdf_nbuf_data(nbuf_ppdu);
  4037. type = (ppdu_desc->frame_ctrl &
  4038. IEEE80211_FC0_TYPE_MASK);
  4039. subtype = (ppdu_desc->frame_ctrl &
  4040. IEEE80211_FC0_SUBTYPE_MASK);
  4041. if ((type == IEEE80211_FC0_TYPE_DATA) &&
  4042. (subtype == IEEE80211_FC0_SUBTYPE_QOS_NULL) &&
  4043. (ppdu_desc->htt_frame_type ==
  4044. HTT_STATS_FTYPE_TIDQ_DATA_SU)) {
  4045. ppdu_desc->htt_frame_type =
  4046. HTT_STATS_FTYPE_SGEN_QOS_NULL;
  4047. }
  4048. usr_type = (ppdu_desc->user[0].frame_ctrl &
  4049. IEEE80211_FC0_TYPE_MASK);
  4050. usr_subtype = (ppdu_desc->user[0].frame_ctrl &
  4051. IEEE80211_FC0_SUBTYPE_MASK);
  4052. if (((type == IEEE80211_FC0_TYPE_CTL) &&
  4053. (subtype == IEEE80211_FC0_SUBTYPE_BAR) &&
  4054. (usr_type == IEEE80211_FC0_TYPE_DATA)) ||
  4055. ppdu_desc->htt_frame_type == HTT_STATS_FTYPE_SGEN_MU_BAR)
  4056. is_bar_frm_with_data = true;
  4057. ptr_nbuf_list = &nbuf_ppdu_list[ppdu_desc_cnt];
  4058. /* ppdu start timestamp */
  4059. start_tsf = ppdu_desc->ppdu_start_timestamp;
  4060. end_tsf = ppdu_desc->ppdu_end_timestamp;
  4061. bar_start_tsf = ppdu_desc->bar_ppdu_start_timestamp;
  4062. bar_end_tsf = ppdu_desc->bar_ppdu_end_timestamp;
  4063. if (((ppdu_desc->frame_type == CDP_PPDU_FTYPE_DATA) &&
  4064. (ppdu_desc->htt_frame_type !=
  4065. HTT_STATS_FTYPE_SGEN_QOS_NULL)) ||
  4066. is_bar_frm_with_data) {
  4067. uint32_t mpdu_suc;
  4068. uint32_t mpdu_tri;
  4069. uint8_t ref_cnt = 0;
  4070. uint8_t num_users = ppdu_desc->num_users;
  4071. struct dp_tx_tid *tx_tid;
  4072. struct cdp_tx_completion_ppdu *xretry_ppdu;
  4073. struct cdp_tx_completion_ppdu_user *xretry_user;
  4074. struct cdp_tx_completion_ppdu_user *user;
  4075. qdf_nbuf_queue_t *mpdu_q;
  4076. qdf_nbuf_queue_t *x_mpdu_q;
  4077. for (usr_idx = 0; usr_idx < num_users;
  4078. usr_idx++) {
  4079. uint32_t ppdu_id;
  4080. peer = NULL;
  4081. user = &ppdu_desc->user[usr_idx];
  4082. if (usr_idx + 1 != num_users)
  4083. qdf_nbuf_ref(nbuf_ppdu);
  4084. if (user->delayed_ba == 1) {
  4085. user->skip = 1;
  4086. goto free_nbuf_dec_ref;
  4087. }
  4088. peer_id = user->peer_id;
  4089. peer = dp_peer_get_ref_by_id(pdev->soc,
  4090. peer_id,
  4091. DP_MOD_ID_TX_CAPTURE);
  4092. /**
  4093. * peer can be NULL
  4094. */
  4095. if (!peer || !peer->tx_capture.is_tid_initialized) {
  4096. user->skip = 1;
  4097. goto free_nbuf_dec_ref;
  4098. }
  4099. /**
  4100. * check whether it is bss peer,
  4101. * if bss_peer no need to process
  4102. * further check whether tx_capture
  4103. * feature is enabled for this peer
  4104. * or globally for all peers
  4105. */
  4106. if (peer->bss_peer ||
  4107. !dp_peer_or_pdev_tx_cap_enabled(pdev,
  4108. NULL, peer->mac_addr.raw) || user->is_mcast) {
  4109. user->skip = 1;
  4110. goto free_nbuf_dec_ref;
  4111. }
  4112. /* update failed bitmap */
  4113. dp_process_ppdu_stats_update_failed_bitmap(
  4114. pdev, user, ppdu_desc->ppdu_id,
  4115. CDP_BA_256_BIT_MAP_SIZE_DWORDS);
  4116. /* print the bit map */
  4117. dp_tx_print_bitmap(pdev, ppdu_desc,
  4118. usr_idx,
  4119. ppdu_desc->ppdu_id);
  4120. if (user->tid > DP_MAX_TIDS) {
  4121. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  4122. QDF_TRACE_LEVEL_ERROR,
  4123. "%s: ppdu[%d] peer_id[%d] TID[%d] > NON_QOS_TID!",
  4124. __func__,
  4125. ppdu_desc->ppdu_id,
  4126. user->peer_id,
  4127. user->tid);
  4128. user->skip = 1;
  4129. goto free_nbuf_dec_ref;
  4130. }
  4131. if (is_bar_frm_with_data)
  4132. ppdu_id = ppdu_desc->bar_ppdu_id;
  4133. else
  4134. ppdu_id = ppdu_desc->ppdu_id;
  4135. tid = user->tid;
  4136. num_msdu = user->num_msdu;
  4137. dequeue_msdu_again:
  4138. /*
  4139. * retrieve msdu buffer based on ppdu_id & tid
  4140. * based msdu queue and store it in local queue
  4141. * sometimes, wbm comes later than per ppdu
  4142. * stats. Assumption: all packets are SU,
  4143. * and packets comes in order
  4144. */
  4145. ret = dp_tx_msdu_dequeue(peer,
  4146. ppdu_id,
  4147. tid,
  4148. num_msdu,
  4149. &head_msdu,
  4150. &head_xretries,
  4151. start_tsf,
  4152. end_tsf);
  4153. if (!ret && (++retries < 2)) {
  4154. /* wait for wbm to complete */
  4155. qdf_mdelay(2);
  4156. goto dequeue_msdu_again;
  4157. }
  4158. /*
  4159. * restitch mpdu from xretry msdu
  4160. * xretry msdu queue empty check is
  4161. * done inside restitch function
  4162. */
  4163. tx_tid = &peer->tx_capture.tx_tid[tid];
  4164. xretry_ppdu = tx_tid->xretry_ppdu;
  4165. xretry_user = &xretry_ppdu->user[0];
  4166. xretry_ppdu->ppdu_id =
  4167. peer->tx_capture.tx_wifi_ppdu_id;
  4168. x_mpdu_q = &xretry_user->mpdu_q;
  4169. /* Restitch MPDUs from xretry MSDUs */
  4170. dp_tx_mon_restitch_mpdu(pdev, peer,
  4171. xretry_ppdu,
  4172. &head_xretries,
  4173. x_mpdu_q, 0);
  4174. qlen = qdf_nbuf_queue_len(x_mpdu_q);
  4175. dp_tx_cap_stats_mpdu_update(peer, PEER_MPDU_RESTITCH,
  4176. qlen);
  4177. if (qdf_nbuf_is_queue_empty(
  4178. &head_msdu)) {
  4179. user->skip = 1;
  4180. goto free_nbuf_dec_ref;
  4181. }
  4182. mpdu_q = &user->mpdu_q;
  4183. /*
  4184. * now head_msdu hold - msdu list for
  4185. * that particular ppdu_id, restitch
  4186. * mpdu from msdu and create a mpdu
  4187. * queue
  4188. */
  4189. dp_tx_mon_restitch_mpdu(pdev,
  4190. peer,
  4191. ppdu_desc,
  4192. &head_msdu,
  4193. mpdu_q,
  4194. usr_idx);
  4195. /*
  4196. * sanity: free local head msdu queue
  4197. * do we need this ?
  4198. */
  4199. qdf_nbuf_queue_free(&head_msdu);
  4200. qlen = qdf_nbuf_queue_len(mpdu_q);
  4201. dp_tx_cap_stats_mpdu_update(peer, PEER_MPDU_RESTITCH,
  4202. qlen);
  4203. if (!qlen) {
  4204. dp_ppdu_queue_free(nbuf_ppdu,
  4205. usr_idx);
  4206. user->skip = 1;
  4207. goto free_nbuf_dec_ref;
  4208. }
  4209. mpdu_suc = user->mpdu_success;
  4210. mpdu_tri = user->mpdu_tried_ucast +
  4211. user->mpdu_tried_mcast;
  4212. /* print ppdu_desc info for debugging purpose */
  4213. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  4214. QDF_TRACE_LEVEL_INFO,
  4215. "%s: ppdu[%d] b_ppdu_id[%d] p_id[%d], tid[%d], n_mpdu[%d %d] n_msdu[%d] retr[%d] qlen[%d] tsf[%u - %u] b_tsf[%u - %u] dur[%u] seq[%d] ppdu_desc_cnt[%d]",
  4216. __func__,
  4217. ppdu_desc->ppdu_id,
  4218. ppdu_desc->bar_ppdu_id,
  4219. user->peer_id,
  4220. user->tid,
  4221. ppdu_desc->num_mpdu,
  4222. mpdu_suc,
  4223. ppdu_desc->num_msdu, retries,
  4224. qlen,
  4225. start_tsf, end_tsf,
  4226. bar_start_tsf, bar_end_tsf,
  4227. ppdu_desc->tx_duration,
  4228. user->start_seq,
  4229. ppdu_desc_cnt);
  4230. dp_tx_cap_stats_mpdu_update(peer, PEER_MPDU_SUCC,
  4231. mpdu_suc);
  4232. dp_tx_cap_stats_mpdu_update(peer, PEER_MPDU_TRI,
  4233. mpdu_tri);
  4234. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  4235. /* get reference count */
  4236. ref_cnt = qdf_nbuf_get_users(nbuf_ppdu);
  4237. continue;
  4238. free_nbuf_dec_ref:
  4239. /* get reference before free */
  4240. ref_cnt = qdf_nbuf_get_users(nbuf_ppdu);
  4241. qdf_nbuf_free(nbuf_ppdu);
  4242. ref_cnt--;
  4243. if (peer)
  4244. dp_peer_unref_delete(peer,
  4245. DP_MOD_ID_TX_CAPTURE);
  4246. continue;
  4247. }
  4248. if (ref_cnt == 0)
  4249. return ppdu_desc_cnt;
  4250. ptr_nbuf_list->nbuf_ppdu = nbuf_ppdu;
  4251. dp_tx_cap_nbuf_list_update_ref(ptr_nbuf_list, ref_cnt);
  4252. ppdu_desc_cnt++;
  4253. } else {
  4254. /*
  4255. * other packet frame also added to
  4256. * descriptor list
  4257. */
  4258. /* print ppdu_desc info for debugging purpose */
  4259. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  4260. QDF_TRACE_LEVEL_INFO_HIGH,
  4261. "%s: ppdu[%d], p_id[%d], tid[%d], fctrl[0x%x 0x%x] ftype[%d] h_frm_t[%d] seq[%d] tsf[%u b %u] dur[%u]",
  4262. __func__, ppdu_desc->ppdu_id,
  4263. ppdu_desc->user[0].peer_id,
  4264. ppdu_desc->user[0].tid,
  4265. ppdu_desc->frame_ctrl,
  4266. ppdu_desc->user[0].frame_ctrl,
  4267. ppdu_desc->frame_type,
  4268. ppdu_desc->htt_frame_type,
  4269. ppdu_desc->user[0].start_seq,
  4270. ppdu_desc->ppdu_start_timestamp,
  4271. ppdu_desc->bar_ppdu_start_timestamp,
  4272. ppdu_desc->tx_duration);
  4273. ptr_nbuf_list->nbuf_ppdu = nbuf_ppdu;
  4274. dp_tx_cap_nbuf_list_update_ref(ptr_nbuf_list,
  4275. 1);
  4276. ppdu_desc_cnt++;
  4277. }
  4278. return ppdu_desc_cnt;
  4279. }
  4280. /**
  4281. * dp_tx_ppdu_stats_process - Deferred PPDU stats handler
  4282. * @context: Opaque work context (PDEV)
  4283. *
  4284. * Return: none
  4285. */
  4286. void dp_tx_ppdu_stats_process(void *context)
  4287. {
  4288. uint32_t curr_sched_cmdid;
  4289. uint32_t last_ppdu_id;
  4290. uint32_t ppdu_cnt;
  4291. uint32_t ppdu_desc_cnt = 0;
  4292. struct dp_pdev *pdev = (struct dp_pdev *)context;
  4293. struct ppdu_info *ppdu_info, *tmp_ppdu_info = NULL;
  4294. uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
  4295. struct ppdu_info *sched_ppdu_info = NULL;
  4296. STAILQ_HEAD(, ppdu_info) sched_ppdu_queue;
  4297. struct ppdu_info *sched_ppdu_list_last_ptr;
  4298. struct dp_tx_cap_nbuf_list *nbuf_ppdu_list;
  4299. struct dp_tx_cap_nbuf_list *ptr_nbuf_list;
  4300. qdf_nbuf_t tmp_nbuf;
  4301. qdf_nbuf_t nbuf_ppdu;
  4302. struct dp_pdev_tx_capture *ptr_tx_cap = &pdev->tx_capture;
  4303. size_t nbuf_list_sz;
  4304. uint8_t user_mode;
  4305. STAILQ_INIT(&sched_ppdu_queue);
  4306. /* Move the PPDU entries to defer list */
  4307. qdf_spin_lock_bh(&ptr_tx_cap->ppdu_stats_lock);
  4308. STAILQ_CONCAT(&ptr_tx_cap->ppdu_stats_defer_queue,
  4309. &ptr_tx_cap->ppdu_stats_queue);
  4310. ptr_tx_cap->ppdu_stats_defer_queue_depth +=
  4311. ptr_tx_cap->ppdu_stats_queue_depth;
  4312. ptr_tx_cap->ppdu_stats_queue_depth = 0;
  4313. qdf_spin_unlock_bh(&ptr_tx_cap->ppdu_stats_lock);
  4314. while (!STAILQ_EMPTY(&ptr_tx_cap->ppdu_stats_defer_queue)) {
  4315. ppdu_info =
  4316. STAILQ_FIRST(&ptr_tx_cap->ppdu_stats_defer_queue);
  4317. curr_sched_cmdid = ppdu_info->sched_cmdid;
  4318. ppdu_cnt = 0;
  4319. STAILQ_FOREACH_SAFE(ppdu_info,
  4320. &ptr_tx_cap->ppdu_stats_defer_queue,
  4321. ppdu_info_queue_elem, tmp_ppdu_info) {
  4322. if (curr_sched_cmdid != ppdu_info->sched_cmdid)
  4323. break;
  4324. sched_ppdu_list_last_ptr = ppdu_info;
  4325. ppdu_cnt++;
  4326. }
  4327. if (ppdu_info && (curr_sched_cmdid == ppdu_info->sched_cmdid) &&
  4328. ptr_tx_cap->ppdu_stats_next_sched < now_ms)
  4329. break;
  4330. last_ppdu_id = sched_ppdu_list_last_ptr->ppdu_id;
  4331. STAILQ_FIRST(&sched_ppdu_queue) =
  4332. STAILQ_FIRST(&ptr_tx_cap->ppdu_stats_defer_queue);
  4333. STAILQ_REMOVE_HEAD_UNTIL(&ptr_tx_cap->ppdu_stats_defer_queue,
  4334. sched_ppdu_list_last_ptr,
  4335. ppdu_info_queue_elem);
  4336. STAILQ_NEXT(sched_ppdu_list_last_ptr,
  4337. ppdu_info_queue_elem) = NULL;
  4338. ptr_tx_cap->ppdu_stats_defer_queue_depth -= ppdu_cnt;
  4339. nbuf_list_sz = sizeof(struct dp_tx_cap_nbuf_list);
  4340. nbuf_ppdu_list = (struct dp_tx_cap_nbuf_list *)
  4341. qdf_mem_malloc(nbuf_list_sz * ppdu_cnt);
  4342. /*
  4343. * if there is no memory allocated we need to free sched ppdu
  4344. * list, no ppdu stats will be updated.
  4345. */
  4346. if (!nbuf_ppdu_list) {
  4347. STAILQ_FOREACH_SAFE(sched_ppdu_info,
  4348. &sched_ppdu_queue,
  4349. ppdu_info_queue_elem,
  4350. tmp_ppdu_info) {
  4351. ppdu_info = sched_ppdu_info;
  4352. tmp_nbuf = ppdu_info->nbuf;
  4353. qdf_mem_free(ppdu_info);
  4354. qdf_nbuf_free(tmp_nbuf);
  4355. }
  4356. continue;
  4357. }
  4358. ppdu_desc_cnt = 0;
  4359. STAILQ_FOREACH_SAFE(sched_ppdu_info,
  4360. &sched_ppdu_queue,
  4361. ppdu_info_queue_elem, tmp_ppdu_info) {
  4362. ppdu_info = sched_ppdu_info;
  4363. pdev->stats.tx_ppdu_proc++;
  4364. /* update ppdu desc user stats */
  4365. dp_ppdu_desc_user_stats_update(pdev, ppdu_info);
  4366. /*
  4367. * While processing/corelating Tx buffers, we should
  4368. * hold the entire PPDU list for the give sched_cmdid
  4369. * instead of freeing below.
  4370. */
  4371. nbuf_ppdu = ppdu_info->nbuf;
  4372. qdf_mem_free(ppdu_info);
  4373. qdf_assert_always(nbuf_ppdu);
  4374. /* check tx capture disable */
  4375. if (pdev->tx_capture_enabled ==
  4376. CDP_TX_ENH_CAPTURE_DISABLED) {
  4377. struct cdp_tx_completion_ppdu *ppdu_desc;
  4378. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  4379. qdf_nbuf_data(nbuf_ppdu);
  4380. /**
  4381. * Deliver PPDU stats only for valid (acked)
  4382. * data frames if sniffer mode is not enabled.
  4383. * If sniffer mode is enabled,
  4384. * PPDU stats for all frames including
  4385. * mgmt/control frames should be delivered
  4386. * to upper layer
  4387. */
  4388. if (pdev->tx_sniffer_enable ||
  4389. pdev->mcopy_mode) {
  4390. dp_wdi_event_handler(
  4391. WDI_EVENT_TX_PPDU_DESC,
  4392. pdev->soc,
  4393. nbuf_ppdu,
  4394. HTT_INVALID_PEER,
  4395. WDI_NO_VAL,
  4396. pdev->pdev_id);
  4397. } else {
  4398. if (ppdu_desc->num_mpdu != 0 &&
  4399. ppdu_desc->num_users != 0 &&
  4400. (ppdu_desc->frame_ctrl &
  4401. HTT_FRAMECTRL_DATATYPE)) {
  4402. dp_wdi_event_handler(
  4403. WDI_EVENT_TX_PPDU_DESC,
  4404. pdev->soc,
  4405. nbuf_ppdu,
  4406. HTT_INVALID_PEER,
  4407. WDI_NO_VAL,
  4408. pdev->pdev_id);
  4409. } else {
  4410. qdf_nbuf_free(nbuf_ppdu);
  4411. }
  4412. }
  4413. continue;
  4414. } else {
  4415. tx_cap_debugfs_log_ppdu_desc(pdev, nbuf_ppdu);
  4416. /* process ppdu_info on tx capture turned on */
  4417. ppdu_desc_cnt = dp_tx_cap_proc_per_ppdu_info(
  4418. pdev,
  4419. nbuf_ppdu,
  4420. nbuf_ppdu_list,
  4421. ppdu_desc_cnt);
  4422. }
  4423. }
  4424. /*
  4425. * At this point we have mpdu queued per ppdu_desc
  4426. * based on packet capture flags send mpdu info to upper stack
  4427. */
  4428. if (ppdu_desc_cnt) {
  4429. uint32_t i;
  4430. dp_check_ppdu_and_deliver(pdev, nbuf_ppdu_list,
  4431. ppdu_desc_cnt);
  4432. for (i = 0; i < ppdu_desc_cnt; i++) {
  4433. ptr_nbuf_list = &nbuf_ppdu_list[i];
  4434. if (dp_tx_cap_nbuf_list_get_ref(
  4435. ptr_nbuf_list)) {
  4436. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  4437. QDF_TRACE_LEVEL_FATAL,
  4438. "%s: %d missing handling of ppdu_desc ref_cnt:%d ,i : %d ptr %p, ppdu_desc_cnt %d!!!\n",
  4439. __func__, __LINE__,
  4440. ptr_nbuf_list->ref_cnt, i, ptr_nbuf_list, ppdu_desc_cnt);
  4441. QDF_BUG(0);
  4442. }
  4443. }
  4444. }
  4445. qdf_mem_free(nbuf_ppdu_list);
  4446. /* get user mode */
  4447. user_mode = qdf_atomic_read(&pdev->tx_capture.tx_cap_usr_mode);
  4448. /*
  4449. * invoke mode change if user mode value is
  4450. * different from driver mode value,
  4451. * this was done to reduce config lock
  4452. */
  4453. if (user_mode != pdev->tx_capture_enabled)
  4454. dp_enh_tx_cap_mode_change(pdev, user_mode);
  4455. }
  4456. }
  4457. /**
  4458. * dp_ppdu_desc_deliver(): Function to deliver Tx PPDU status descriptor
  4459. * to upper layer
  4460. * @pdev: DP pdev handle
  4461. * @ppdu_info: per PPDU TLV descriptor
  4462. *
  4463. * return: void
  4464. */
  4465. void dp_ppdu_desc_deliver(struct dp_pdev *pdev,
  4466. struct ppdu_info *ppdu_info)
  4467. {
  4468. struct ppdu_info *s_ppdu_info = NULL;
  4469. struct ppdu_info *ppdu_info_next = NULL;
  4470. uint32_t now_ms = qdf_system_ticks_to_msecs(qdf_system_ticks());
  4471. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  4472. uint32_t time_delta = 0;
  4473. bool starved = 0;
  4474. bool matched = 0;
  4475. bool recv_ack_ba_done = 0;
  4476. if (ppdu_info->tlv_bitmap & (1 << HTT_PPDU_STATS_USR_COMPLTN_ACK_BA_STATUS_TLV) && ppdu_info->done)
  4477. recv_ack_ba_done = 1;
  4478. pdev->last_sched_cmdid = ppdu_info->sched_cmdid;
  4479. s_ppdu_info = TAILQ_FIRST(&pdev->sched_comp_ppdu_list);
  4480. TAILQ_FOREACH_SAFE(s_ppdu_info, &pdev->sched_comp_ppdu_list,
  4481. ppdu_info_list_elem, ppdu_info_next) {
  4482. if (s_ppdu_info->tsf_l32 > ppdu_info->tsf_l32)
  4483. time_delta = (MAX_TSF_32 - s_ppdu_info->tsf_l32) +
  4484. ppdu_info->tsf_l32;
  4485. else
  4486. time_delta = ppdu_info->tsf_l32 - s_ppdu_info->tsf_l32;
  4487. if (!s_ppdu_info->done && !recv_ack_ba_done) {
  4488. if (time_delta < MAX_SCHED_STARVE) {
  4489. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  4490. QDF_TRACE_LEVEL_INFO_MED,
  4491. "pdev[%d] ppdu_id[0x%x %d] sched_cmdid[0x%x %d] TLV_B[0x%x] TSF[%u] D[%d]",
  4492. pdev->pdev_id,
  4493. s_ppdu_info->ppdu_id, s_ppdu_info->ppdu_id,
  4494. s_ppdu_info->sched_cmdid, s_ppdu_info->sched_cmdid,
  4495. s_ppdu_info->tlv_bitmap, s_ppdu_info->tsf_l32,
  4496. s_ppdu_info->done);
  4497. break;
  4498. } else {
  4499. starved = 1;
  4500. }
  4501. }
  4502. pdev->delivered_sched_cmdid = s_ppdu_info->sched_cmdid;
  4503. TAILQ_REMOVE(&pdev->sched_comp_ppdu_list, s_ppdu_info,
  4504. ppdu_info_list_elem);
  4505. pdev->sched_comp_list_depth--;
  4506. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  4507. qdf_nbuf_data(s_ppdu_info->nbuf);
  4508. ppdu_desc->tlv_bitmap = s_ppdu_info->tlv_bitmap;
  4509. ppdu_desc->sched_cmdid = ppdu_info->sched_cmdid;
  4510. if (starved) {
  4511. qdf_err("ppdu starved fc[0x%x] h_ftype[%d] tlv_bitmap[0x%x] cs[%d]\n",
  4512. ppdu_desc->frame_ctrl,
  4513. ppdu_desc->htt_frame_type,
  4514. ppdu_desc->tlv_bitmap,
  4515. ppdu_desc->user[0].completion_status);
  4516. starved = 0;
  4517. }
  4518. if (ppdu_info->ppdu_id == s_ppdu_info->ppdu_id &&
  4519. ppdu_info->sched_cmdid == s_ppdu_info->sched_cmdid)
  4520. matched = 1;
  4521. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  4522. QDF_TRACE_LEVEL_INFO_MED,
  4523. "pdev[%d] vdev[%d] ppdu_id[0x%x %d] sched_cmdid[0x%x %d] FC[0x%x] H_FTYPE[0x%x] TLV_B[0x%x] TSF[%u] cs[%d] M[%d] R_PID[%d S %d]",
  4524. pdev->pdev_id, ppdu_desc->vdev_id,
  4525. s_ppdu_info->ppdu_id, s_ppdu_info->ppdu_id,
  4526. s_ppdu_info->sched_cmdid, s_ppdu_info->sched_cmdid,
  4527. ppdu_desc->frame_ctrl,
  4528. ppdu_desc->htt_frame_type,
  4529. ppdu_desc->tlv_bitmap, s_ppdu_info->tsf_l32,
  4530. ppdu_desc->user[0].completion_status, matched,
  4531. ppdu_info->ppdu_id, ppdu_info->sched_cmdid);
  4532. qdf_spin_lock_bh(&pdev->tx_capture.ppdu_stats_lock);
  4533. if (qdf_unlikely(!pdev->tx_capture_enabled &&
  4534. (pdev->tx_capture.ppdu_stats_queue_depth +
  4535. pdev->tx_capture.ppdu_stats_defer_queue_depth) >
  4536. DP_TX_PPDU_PROC_MAX_DEPTH)) {
  4537. qdf_nbuf_free(s_ppdu_info->nbuf);
  4538. qdf_mem_free(s_ppdu_info);
  4539. pdev->tx_capture.ppdu_dropped++;
  4540. } else {
  4541. STAILQ_INSERT_TAIL(&pdev->tx_capture.ppdu_stats_queue,
  4542. s_ppdu_info, ppdu_info_queue_elem);
  4543. pdev->tx_capture.ppdu_stats_queue_depth++;
  4544. }
  4545. qdf_spin_unlock_bh(&pdev->tx_capture.ppdu_stats_lock);
  4546. if (matched)
  4547. break;
  4548. }
  4549. if ((pdev->tx_capture.ppdu_stats_queue_depth >
  4550. DP_TX_PPDU_PROC_THRESHOLD) ||
  4551. (pdev->tx_capture.ppdu_stats_next_sched <= now_ms)) {
  4552. qdf_queue_work(0, pdev->tx_capture.ppdu_stats_workqueue,
  4553. &pdev->tx_capture.ppdu_stats_work);
  4554. pdev->tx_capture.ppdu_stats_next_sched =
  4555. now_ms + DP_TX_PPDU_PROC_TIMEOUT;
  4556. }
  4557. }
  4558. static void set_mpdu_info(
  4559. struct cdp_tx_indication_info *tx_capture_info,
  4560. struct mon_rx_status *rx_status,
  4561. struct mon_rx_user_status *rx_user_status)
  4562. {
  4563. struct cdp_tx_indication_mpdu_info *mpdu_info;
  4564. qdf_mem_set(tx_capture_info,
  4565. sizeof(struct cdp_tx_indication_info), 0);
  4566. mpdu_info = &tx_capture_info->mpdu_info;
  4567. mpdu_info->ppdu_start_timestamp = rx_status->tsft + 16;
  4568. mpdu_info->channel_num = rx_status->chan_num;
  4569. mpdu_info->channel = rx_status->chan_freq;
  4570. mpdu_info->bw = 0;
  4571. if (rx_status->preamble_type == HAL_RX_PKT_TYPE_11B) {
  4572. mpdu_info->preamble = DOT11_B;
  4573. mpdu_info->mcs = CDP_LEGACY_MCS3;
  4574. } else if (rx_status->preamble_type == HAL_RX_PKT_TYPE_11A) {
  4575. mpdu_info->preamble = DOT11_A;
  4576. mpdu_info->mcs = CDP_LEGACY_MCS3;
  4577. } else {
  4578. mpdu_info->preamble = DOT11_A;
  4579. mpdu_info->mcs = CDP_LEGACY_MCS1;
  4580. }
  4581. }
  4582. static void dp_gen_ack_frame(struct hal_rx_ppdu_info *ppdu_info,
  4583. struct dp_peer *peer,
  4584. qdf_nbuf_t mpdu_nbuf)
  4585. {
  4586. struct ieee80211_frame_min_one *wh_addr1;
  4587. wh_addr1 = (struct ieee80211_frame_min_one *)
  4588. qdf_nbuf_data(mpdu_nbuf);
  4589. wh_addr1->i_fc[0] = 0;
  4590. wh_addr1->i_fc[1] = 0;
  4591. wh_addr1->i_fc[0] = IEEE80211_FC0_VERSION_0 |
  4592. IEEE80211_FC0_TYPE_CTL |
  4593. IEEE80211_FC0_SUBTYPE_ACK;
  4594. if (peer) {
  4595. qdf_mem_copy(wh_addr1->i_addr1,
  4596. &peer->mac_addr.raw[0],
  4597. QDF_MAC_ADDR_SIZE);
  4598. } else {
  4599. qdf_mem_copy(wh_addr1->i_addr1,
  4600. &ppdu_info->nac_info.mac_addr2[0],
  4601. QDF_MAC_ADDR_SIZE);
  4602. }
  4603. *(u_int16_t *)(&wh_addr1->i_dur) = qdf_cpu_to_le16(0x0000);
  4604. qdf_nbuf_set_pktlen(mpdu_nbuf, sizeof(*wh_addr1));
  4605. }
  4606. static void dp_gen_block_ack_frame(
  4607. struct hal_rx_ppdu_info *ppdu_info,
  4608. struct mon_rx_user_status *rx_user_status,
  4609. struct mon_rx_user_info *rx_user_info,
  4610. struct dp_peer *peer,
  4611. qdf_nbuf_t mpdu_nbuf)
  4612. {
  4613. struct dp_vdev *vdev = NULL;
  4614. uint32_t tid;
  4615. struct dp_tx_tid *tx_tid;
  4616. struct ieee80211_ctlframe_addr2 *wh_addr2;
  4617. uint8_t *frm;
  4618. tid = rx_user_status->tid;
  4619. tx_tid = &peer->tx_capture.tx_tid[tid];
  4620. if (ppdu_info->sw_frame_group_id != HAL_MPDU_SW_FRAME_GROUP_CTRL_BAR) {
  4621. tx_tid->first_data_seq_ctrl =
  4622. rx_user_status->first_data_seq_ctrl;
  4623. tx_tid->mpdu_cnt = rx_user_status->mpdu_cnt_fcs_ok +
  4624. rx_user_status->mpdu_cnt_fcs_err;
  4625. if (tx_tid->mpdu_cnt > DP_MAX_MPDU_64)
  4626. qdf_mem_copy(tx_tid->mpdu_fcs_ok_bitmap,
  4627. rx_user_status->mpdu_fcs_ok_bitmap,
  4628. HAL_RX_NUM_WORDS_PER_PPDU_BITMAP * sizeof(
  4629. rx_user_status->mpdu_fcs_ok_bitmap[0]));
  4630. else
  4631. qdf_mem_copy(tx_tid->mpdu_fcs_ok_bitmap,
  4632. rx_user_status->mpdu_fcs_ok_bitmap,
  4633. DP_NUM_WORDS_PER_PPDU_BITMAP_64 * sizeof(
  4634. rx_user_status->mpdu_fcs_ok_bitmap[0]));
  4635. }
  4636. wh_addr2 = (struct ieee80211_ctlframe_addr2 *)
  4637. qdf_nbuf_data(mpdu_nbuf);
  4638. qdf_mem_zero(wh_addr2, DP_BA_ACK_FRAME_SIZE);
  4639. wh_addr2->i_fc[0] = 0;
  4640. wh_addr2->i_fc[1] = 0;
  4641. wh_addr2->i_fc[0] = IEEE80211_FC0_VERSION_0 |
  4642. IEEE80211_FC0_TYPE_CTL |
  4643. IEEE80211_FC0_BLOCK_ACK;
  4644. *(u_int16_t *)(&wh_addr2->i_aidordur) = qdf_cpu_to_le16(0x0000);
  4645. vdev = peer->vdev;
  4646. if (vdev)
  4647. qdf_mem_copy(wh_addr2->i_addr2, vdev->mac_addr.raw,
  4648. QDF_MAC_ADDR_SIZE);
  4649. qdf_mem_copy(wh_addr2->i_addr1, &peer->mac_addr.raw[0],
  4650. QDF_MAC_ADDR_SIZE);
  4651. frm = (uint8_t *)&wh_addr2[1];
  4652. *((uint16_t *)frm) =
  4653. qdf_cpu_to_le16((rx_user_status->tid <<
  4654. DP_IEEE80211_BAR_CTL_TID_S) |
  4655. DP_IEEE80211_BAR_CTL_COMBA);
  4656. frm += 2;
  4657. *((uint16_t *)frm) =
  4658. tx_tid->first_data_seq_ctrl;
  4659. frm += 2;
  4660. if (tx_tid->mpdu_cnt > DP_MAX_MPDU_64) {
  4661. qdf_mem_copy(frm,
  4662. tx_tid->mpdu_fcs_ok_bitmap,
  4663. HAL_RX_NUM_WORDS_PER_PPDU_BITMAP *
  4664. sizeof(rx_user_status->mpdu_fcs_ok_bitmap[0]));
  4665. frm += DP_NUM_BYTES_PER_PPDU_BITMAP;
  4666. } else {
  4667. qdf_mem_copy(frm,
  4668. tx_tid->mpdu_fcs_ok_bitmap,
  4669. DP_NUM_WORDS_PER_PPDU_BITMAP_64 *
  4670. sizeof(rx_user_status->mpdu_fcs_ok_bitmap[0]));
  4671. frm += DP_NUM_BYTES_PER_PPDU_BITMAP_64;
  4672. }
  4673. qdf_nbuf_set_pktlen(mpdu_nbuf,
  4674. (frm - (uint8_t *)qdf_nbuf_data(mpdu_nbuf)));
  4675. }
  4676. static void dp_gen_cts_frame(struct hal_rx_ppdu_info *ppdu_info,
  4677. struct dp_peer *peer,
  4678. qdf_nbuf_t mpdu_nbuf)
  4679. {
  4680. struct ieee80211_frame_min_one *wh_addr1;
  4681. uint16_t duration;
  4682. wh_addr1 = (struct ieee80211_frame_min_one *)
  4683. qdf_nbuf_data(mpdu_nbuf);
  4684. wh_addr1->i_fc[0] = 0;
  4685. wh_addr1->i_fc[1] = 0;
  4686. wh_addr1->i_fc[0] = IEEE80211_FC0_VERSION_0 |
  4687. IEEE80211_FC0_TYPE_CTL |
  4688. IEEE80211_FC0_SUBTYPE_CTS;
  4689. qdf_mem_copy(wh_addr1->i_addr1, &peer->mac_addr.raw[0],
  4690. QDF_MAC_ADDR_SIZE);
  4691. duration = (ppdu_info->rx_status.duration > SIFS_INTERVAL) ?
  4692. ppdu_info->rx_status.duration - SIFS_INTERVAL : 0;
  4693. wh_addr1->i_dur[0] = duration & 0xff;
  4694. wh_addr1->i_dur[1] = (duration >> 8) & 0xff;
  4695. qdf_nbuf_set_pktlen(mpdu_nbuf, sizeof(*wh_addr1));
  4696. }
  4697. /**
  4698. * dp_send_cts_frame_to_stack(): Function to deliver HW generated CTS frame
  4699. * in reponse to RTS
  4700. * @soc: core txrx main context
  4701. * @pdev: DP pdev object
  4702. * @ppdu_info: HAL RX PPDU info retrieved from status ring TLV
  4703. *
  4704. * return: status
  4705. */
  4706. QDF_STATUS dp_send_cts_frame_to_stack(struct dp_soc *soc,
  4707. struct dp_pdev *pdev,
  4708. struct hal_rx_ppdu_info *ppdu_info)
  4709. {
  4710. struct cdp_tx_indication_info tx_capture_info;
  4711. struct mon_rx_user_status *rx_user_status =
  4712. &ppdu_info->rx_user_status[0];
  4713. struct dp_ast_entry *ast_entry;
  4714. uint32_t peer_id;
  4715. struct dp_peer *peer;
  4716. struct dp_vdev *vdev = NULL;
  4717. if (rx_user_status->ast_index >=
  4718. wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
  4719. return QDF_STATUS_E_FAILURE;
  4720. }
  4721. qdf_spin_lock_bh(&soc->ast_lock);
  4722. ast_entry = soc->ast_table[rx_user_status->ast_index];
  4723. if (!ast_entry) {
  4724. qdf_spin_unlock_bh(&soc->ast_lock);
  4725. return QDF_STATUS_E_FAILURE;
  4726. }
  4727. peer_id = ast_entry->peer_id;
  4728. qdf_spin_unlock_bh(&soc->ast_lock);
  4729. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_TX_CAPTURE);
  4730. if (!peer)
  4731. return QDF_STATUS_E_FAILURE;
  4732. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, NULL, peer->mac_addr.raw)) {
  4733. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  4734. return QDF_STATUS_E_FAILURE;
  4735. }
  4736. if (pdev->tx_capture_enabled == CDP_TX_ENH_CAPTURE_ENABLE_ALL_PEERS) {
  4737. int8_t match = 0;
  4738. TAILQ_FOREACH(vdev, &pdev->vdev_list, vdev_list_elem) {
  4739. if (!qdf_mem_cmp(vdev->mac_addr.raw,
  4740. ppdu_info->rx_info.mac_addr1,
  4741. QDF_MAC_ADDR_SIZE)) {
  4742. match = 1;
  4743. break;
  4744. }
  4745. }
  4746. if (!match) {
  4747. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  4748. return QDF_STATUS_E_FAILURE;
  4749. }
  4750. }
  4751. set_mpdu_info(&tx_capture_info,
  4752. &ppdu_info->rx_status, rx_user_status);
  4753. /* ppdu_desc is not required for legacy frames */
  4754. tx_capture_info.ppdu_desc = NULL;
  4755. tx_capture_info.mpdu_nbuf =
  4756. qdf_nbuf_alloc(pdev->soc->osdev,
  4757. MAX_MONITOR_HEADER +
  4758. DP_CTS_FRAME_SIZE,
  4759. MAX_MONITOR_HEADER,
  4760. 4, FALSE);
  4761. if (!tx_capture_info.mpdu_nbuf) {
  4762. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  4763. return QDF_STATUS_E_NOMEM;
  4764. }
  4765. dp_gen_cts_frame(ppdu_info, peer,
  4766. tx_capture_info.mpdu_nbuf);
  4767. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  4768. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  4769. &tx_capture_info, HTT_INVALID_PEER,
  4770. WDI_NO_VAL, pdev->pdev_id);
  4771. if (tx_capture_info.mpdu_nbuf)
  4772. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  4773. return QDF_STATUS_SUCCESS;
  4774. }
  4775. /**
  4776. * dp_send_usr_ack_frm_to_stack(): Function to generate BA or ACK frame and
  4777. * send to upper layer
  4778. * @soc: core txrx main context
  4779. * @pdev: DP pdev object
  4780. * @ppdu_info: HAL RX PPDU info retrieved from status ring TLV
  4781. * @rx_status: variable for rx status
  4782. * @rx_user_status: variable for rx user status
  4783. * @rx_user_info: variable for rx user info
  4784. *
  4785. * return: no
  4786. */
  4787. void dp_send_usr_ack_frm_to_stack(struct dp_soc *soc,
  4788. struct dp_pdev *pdev,
  4789. struct hal_rx_ppdu_info *ppdu_info,
  4790. struct mon_rx_status *rx_status,
  4791. struct mon_rx_user_status *rx_user_status,
  4792. struct mon_rx_user_info *rx_user_info)
  4793. {
  4794. struct cdp_tx_indication_info tx_capture_info;
  4795. struct dp_peer *peer;
  4796. struct dp_ast_entry *ast_entry;
  4797. uint32_t peer_id;
  4798. uint32_t ast_index;
  4799. uint8_t *ptr_mac_addr;
  4800. if (rx_user_info->qos_control_info_valid &&
  4801. ((rx_user_info->qos_control &
  4802. IEEE80211_QOS_ACKPOLICY) >> IEEE80211_QOS_ACKPOLICY_S)
  4803. == IEEE80211_BAR_CTL_NOACK)
  4804. return;
  4805. ast_index = rx_user_status->ast_index;
  4806. if (ast_index >=
  4807. wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
  4808. if (ppdu_info->sw_frame_group_id ==
  4809. HAL_MPDU_SW_FRAME_GROUP_CTRL_BAR)
  4810. return;
  4811. ptr_mac_addr = &ppdu_info->nac_info.mac_addr2[0];
  4812. if (!dp_peer_or_pdev_tx_cap_enabled(pdev,
  4813. NULL, ptr_mac_addr))
  4814. return;
  4815. if (IEEE80211_IS_ZERO(ppdu_info->nac_info.mac_addr2))
  4816. return;
  4817. set_mpdu_info(&tx_capture_info,
  4818. rx_status, rx_user_status);
  4819. tx_capture_info.mpdu_nbuf =
  4820. qdf_nbuf_alloc(pdev->soc->osdev,
  4821. MAX_MONITOR_HEADER +
  4822. DP_BA_ACK_FRAME_SIZE,
  4823. MAX_MONITOR_HEADER,
  4824. 4, FALSE);
  4825. if (!tx_capture_info.mpdu_nbuf)
  4826. return;
  4827. dp_gen_ack_frame(ppdu_info, NULL,
  4828. tx_capture_info.mpdu_nbuf);
  4829. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  4830. &tx_capture_info, HTT_INVALID_PEER,
  4831. WDI_NO_VAL, pdev->pdev_id);
  4832. if (tx_capture_info.mpdu_nbuf)
  4833. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  4834. return;
  4835. }
  4836. qdf_spin_lock_bh(&soc->ast_lock);
  4837. ast_entry = soc->ast_table[ast_index];
  4838. if (!ast_entry) {
  4839. qdf_spin_unlock_bh(&soc->ast_lock);
  4840. return;
  4841. }
  4842. peer_id = ast_entry->peer_id;
  4843. qdf_spin_unlock_bh(&soc->ast_lock);
  4844. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_TX_CAPTURE);
  4845. if (!peer)
  4846. return;
  4847. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, peer,
  4848. peer->mac_addr.raw)) {
  4849. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  4850. return;
  4851. }
  4852. set_mpdu_info(&tx_capture_info,
  4853. rx_status, rx_user_status);
  4854. tx_capture_info.mpdu_nbuf =
  4855. qdf_nbuf_alloc(pdev->soc->osdev,
  4856. MAX_MONITOR_HEADER +
  4857. DP_BA_ACK_FRAME_SIZE,
  4858. MAX_MONITOR_HEADER,
  4859. 4, FALSE);
  4860. if (!tx_capture_info.mpdu_nbuf) {
  4861. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  4862. return;
  4863. }
  4864. if (peer->rx_tid[rx_user_status->tid].ba_status == DP_RX_BA_ACTIVE ||
  4865. ppdu_info->sw_frame_group_id == HAL_MPDU_SW_FRAME_GROUP_CTRL_BAR) {
  4866. dp_gen_block_ack_frame(ppdu_info,
  4867. rx_user_status,
  4868. rx_user_info,
  4869. peer,
  4870. tx_capture_info.mpdu_nbuf);
  4871. tx_capture_info.mpdu_info.tid = rx_user_status->tid;
  4872. } else {
  4873. dp_gen_ack_frame(ppdu_info, peer,
  4874. tx_capture_info.mpdu_nbuf);
  4875. }
  4876. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  4877. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  4878. &tx_capture_info, HTT_INVALID_PEER,
  4879. WDI_NO_VAL, pdev->pdev_id);
  4880. if (tx_capture_info.mpdu_nbuf)
  4881. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  4882. }
  4883. /**
  4884. * dp_send_ack_frame_to_stack(): Function to generate BA or ACK frame and
  4885. * send to upper layer on received unicast frame
  4886. * @soc: core txrx main context
  4887. * @pdev: DP pdev object
  4888. * @ppdu_info: HAL RX PPDU info retrieved from status ring TLV
  4889. *
  4890. * return: status
  4891. */
  4892. QDF_STATUS dp_send_ack_frame_to_stack(struct dp_soc *soc,
  4893. struct dp_pdev *pdev,
  4894. struct hal_rx_ppdu_info *ppdu_info)
  4895. {
  4896. struct mon_rx_status *rx_status;
  4897. struct mon_rx_user_status *rx_user_status;
  4898. struct mon_rx_user_info *rx_user_info;
  4899. uint32_t i;
  4900. rx_status = &ppdu_info->rx_status;
  4901. if (ppdu_info->sw_frame_group_id ==
  4902. HAL_MPDU_SW_FRAME_GROUP_CTRL_RTS) {
  4903. return dp_send_cts_frame_to_stack(soc, pdev, ppdu_info);
  4904. }
  4905. if (!rx_status->rxpcu_filter_pass)
  4906. return QDF_STATUS_SUCCESS;
  4907. if (ppdu_info->sw_frame_group_id ==
  4908. HAL_MPDU_SW_FRAME_GROUP_MGMT_BEACON ||
  4909. ppdu_info->sw_frame_group_id ==
  4910. HAL_MPDU_SW_FRAME_GROUP_CTRL_NDPA)
  4911. return QDF_STATUS_SUCCESS;
  4912. if (ppdu_info->sw_frame_group_id == HAL_MPDU_SW_FRAME_GROUP_MGMT_PROBE_REQ &&
  4913. (ppdu_info->rx_info.mac_addr1[0] & 1)) {
  4914. return QDF_STATUS_SUCCESS;
  4915. }
  4916. if (ppdu_info->sw_frame_group_id == HAL_MPDU_SW_FRAME_GROUP_CTRL_BAR)
  4917. return QDF_STATUS_SUCCESS;
  4918. for (i = 0; i < ppdu_info->com_info.num_users; i++) {
  4919. if (i > OFDMA_NUM_USERS)
  4920. return QDF_STATUS_E_FAULT;
  4921. rx_user_status = &ppdu_info->rx_user_status[i];
  4922. rx_user_info = &ppdu_info->rx_user_info[i];
  4923. dp_send_usr_ack_frm_to_stack(soc, pdev, ppdu_info, rx_status,
  4924. rx_user_status, rx_user_info);
  4925. }
  4926. return QDF_STATUS_SUCCESS;
  4927. }
  4928. /**
  4929. * dp_bar_send_ack_frm_to_stack(): send BA or ACK frame
  4930. * to upper layers on received BAR packet for tx capture feature
  4931. *
  4932. * @soc: soc handle
  4933. * @pdev: pdev handle
  4934. * @nbuf: received packet
  4935. *
  4936. * Return: QDF_STATUS_SUCCESS on success
  4937. * others on error
  4938. */
  4939. QDF_STATUS
  4940. dp_bar_send_ack_frm_to_stack(struct dp_soc *soc,
  4941. struct dp_pdev *pdev,
  4942. qdf_nbuf_t nbuf)
  4943. {
  4944. struct ieee80211_ctlframe_addr2 *wh;
  4945. uint8_t *frm;
  4946. struct hal_rx_ppdu_info *ppdu_info;
  4947. struct mon_rx_status *rx_status;
  4948. struct mon_rx_user_status *rx_user_status;
  4949. struct mon_rx_user_info *rx_user_info;
  4950. uint16_t bar_ctl;
  4951. uint32_t user_id;
  4952. uint8_t tid;
  4953. if (!nbuf)
  4954. return QDF_STATUS_E_INVAL;
  4955. wh = (struct ieee80211_ctlframe_addr2 *)qdf_nbuf_data(nbuf);
  4956. if (wh->i_fc[0] != (IEEE80211_FC0_VERSION_0 |
  4957. IEEE80211_FC0_TYPE_CTL | IEEE80211_FC0_SUBTYPE_BAR)) {
  4958. return QDF_STATUS_SUCCESS;
  4959. }
  4960. frm = (uint8_t *)&wh[1];
  4961. bar_ctl = qdf_le16_to_cpu(*(uint16_t *)frm);
  4962. if (bar_ctl & DP_IEEE80211_BAR_CTL_POLICY_M)
  4963. return QDF_STATUS_SUCCESS;
  4964. tid = (bar_ctl >> DP_IEEE80211_BAR_CTL_TID_S) &
  4965. DP_IEEE80211_BAR_CTL_TID_M;
  4966. ppdu_info = &pdev->ppdu_info;
  4967. user_id = ppdu_info->rx_info.user_id;
  4968. rx_status = &ppdu_info->rx_status;
  4969. rx_user_status = &ppdu_info->rx_user_status[user_id];
  4970. rx_user_info = &ppdu_info->rx_user_info[user_id];
  4971. rx_user_status->tid = tid;
  4972. dp_send_usr_ack_frm_to_stack(soc, pdev, ppdu_info, rx_status,
  4973. rx_user_status, rx_user_info);
  4974. return QDF_STATUS_SUCCESS;
  4975. }
  4976. /**
  4977. * dp_gen_noack_frame: generate noack Action frame by using parameters
  4978. * from received NDPA frame
  4979. * @ppdu_info: pointer to ppdu_info
  4980. * @peer: pointer to peer structure
  4981. * @mpdu_nbuf: buffer for the generated noack frame
  4982. * @mon_mpdu: mpdu from monitor destination path
  4983. *
  4984. * Return: QDF_STATUS
  4985. */
  4986. static void dp_gen_noack_frame(struct hal_rx_ppdu_info *ppdu_info,
  4987. struct dp_peer *peer, qdf_nbuf_t mpdu_nbuf,
  4988. qdf_nbuf_t mon_mpdu)
  4989. {
  4990. struct ieee80211_frame *wh;
  4991. uint16_t duration;
  4992. struct dp_vdev *vdev = NULL;
  4993. char *ndpa_buf = qdf_nbuf_data(mon_mpdu);
  4994. uint8_t token = 0;
  4995. uint8_t *frm;
  4996. wh = (struct ieee80211_frame *)qdf_nbuf_data(mpdu_nbuf);
  4997. qdf_mem_zero(((char *)wh), DP_ACKNOACK_FRAME_SIZE);
  4998. wh->i_fc[0] = IEEE80211_FC0_VERSION_0 |
  4999. IEEE80211_FC0_TYPE_MGT |
  5000. IEEE80211_FCO_SUBTYPE_ACTION_NO_ACK;
  5001. qdf_mem_copy(wh->i_addr1, &peer->mac_addr.raw[0], QDF_MAC_ADDR_SIZE);
  5002. vdev = peer->vdev;
  5003. if (vdev) {
  5004. qdf_mem_copy(wh->i_addr2,
  5005. vdev->mac_addr.raw,
  5006. QDF_MAC_ADDR_SIZE);
  5007. qdf_mem_copy(wh->i_addr3,
  5008. vdev->mac_addr.raw,
  5009. QDF_MAC_ADDR_SIZE);
  5010. }
  5011. duration = (ppdu_info->rx_status.duration > SIFS_INTERVAL) ?
  5012. ppdu_info->rx_status.duration - SIFS_INTERVAL : 0;
  5013. wh->i_dur[0] = duration & 0xff;
  5014. wh->i_dur[1] = (duration >> 8) & 0xff;
  5015. frm = (uint8_t *)&wh[1];
  5016. /*
  5017. * Update category field
  5018. */
  5019. *frm = DP_IEEE80211_CATEGORY_VHT;
  5020. /*
  5021. * Update sounding token obtained from NDPA,
  5022. * shift to get upper six bits
  5023. */
  5024. frm += DP_NOACK_SOUNDING_TOKEN_POS;
  5025. token = ndpa_buf[DP_NDPA_TOKEN_POS] >> DP_NOACK_STOKEN_POS_SHIFT;
  5026. *frm = (token) << DP_NOACK_STOKEN_POS_SHIFT;
  5027. qdf_nbuf_set_pktlen(mpdu_nbuf, DP_ACKNOACK_FRAME_SIZE);
  5028. }
  5029. /**
  5030. * dp_send_noack_frame_to_stack: Sends noack Action frame to upper stack
  5031. * in response to received NDPA frame.
  5032. * @soc: SoC handle
  5033. * @pdev: PDEV pointer
  5034. * @mon_mpdu: mpdu from monitor destination path
  5035. *
  5036. * Return: QDF_STATUS
  5037. */
  5038. QDF_STATUS dp_send_noack_frame_to_stack(struct dp_soc *soc,
  5039. struct dp_pdev *pdev,
  5040. qdf_nbuf_t mon_mpdu)
  5041. {
  5042. struct hal_rx_ppdu_info *ppdu_info = &pdev->ppdu_info;
  5043. struct mon_rx_user_status *rx_user_status =
  5044. &ppdu_info->rx_user_status[0];
  5045. struct dp_ast_entry *ast_entry;
  5046. uint32_t peer_id;
  5047. struct dp_peer *peer;
  5048. struct cdp_tx_indication_info tx_capture_info;
  5049. if (rx_user_status->ast_index >=
  5050. wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
  5051. return QDF_STATUS_E_FAILURE;
  5052. }
  5053. qdf_spin_lock_bh(&soc->ast_lock);
  5054. ast_entry = soc->ast_table[rx_user_status->ast_index];
  5055. if (!ast_entry) {
  5056. qdf_spin_unlock_bh(&soc->ast_lock);
  5057. return QDF_STATUS_E_FAILURE;
  5058. }
  5059. peer_id = ast_entry->peer_id;
  5060. qdf_spin_unlock_bh(&soc->ast_lock);
  5061. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_TX_CAPTURE);
  5062. if (!peer) {
  5063. return QDF_STATUS_E_FAILURE;
  5064. }
  5065. if (!dp_peer_or_pdev_tx_cap_enabled(pdev, peer, peer->mac_addr.raw)) {
  5066. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  5067. return QDF_STATUS_E_FAILURE;
  5068. }
  5069. set_mpdu_info(&tx_capture_info,
  5070. &ppdu_info->rx_status, rx_user_status);
  5071. tx_capture_info.mpdu_info.mcs = rx_user_status->mcs;
  5072. /*
  5073. *ppdu_desc is not required for legacy frames
  5074. */
  5075. tx_capture_info.ppdu_desc = NULL;
  5076. tx_capture_info.mpdu_nbuf =
  5077. qdf_nbuf_alloc(pdev->soc->osdev,
  5078. MAX_MONITOR_HEADER +
  5079. DP_ACKNOACK_FRAME_SIZE,
  5080. MAX_MONITOR_HEADER,
  5081. 4, FALSE);
  5082. if (!tx_capture_info.mpdu_nbuf) {
  5083. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  5084. return QDF_STATUS_E_NOMEM;
  5085. }
  5086. dp_gen_noack_frame(ppdu_info, peer,
  5087. tx_capture_info.mpdu_nbuf, mon_mpdu);
  5088. dp_peer_unref_delete(peer, DP_MOD_ID_TX_CAPTURE);
  5089. dp_wdi_event_handler(WDI_EVENT_TX_DATA, pdev->soc,
  5090. &tx_capture_info, HTT_INVALID_PEER,
  5091. WDI_NO_VAL, pdev->pdev_id);
  5092. if (tx_capture_info.mpdu_nbuf)
  5093. qdf_nbuf_free(tx_capture_info.mpdu_nbuf);
  5094. return QDF_STATUS_SUCCESS;
  5095. }
  5096. /**
  5097. * dp_handle_tx_capture_from_dest: Handle any TX capture frames from
  5098. * monitor destination path.
  5099. * @soc: SoC handle
  5100. * @pdev: PDEV pointer
  5101. * @mon_mpdu: mpdu from monitor destination path
  5102. *
  5103. * Return: QDF_STATUS
  5104. */
  5105. QDF_STATUS dp_handle_tx_capture_from_dest(struct dp_soc *soc,
  5106. struct dp_pdev *pdev,
  5107. qdf_nbuf_t mon_mpdu)
  5108. {
  5109. struct hal_rx_ppdu_info *ppdu_info = &pdev->ppdu_info;
  5110. /*
  5111. * The below switch case can be extended to
  5112. * add more frame types as needed
  5113. */
  5114. switch (ppdu_info->sw_frame_group_id) {
  5115. case HAL_MPDU_SW_FRAME_GROUP_CTRL_NDPA:
  5116. return dp_send_noack_frame_to_stack(soc, pdev, mon_mpdu);
  5117. case HAL_MPDU_SW_FRAME_GROUP_CTRL_BAR:
  5118. return dp_bar_send_ack_frm_to_stack(soc, pdev, mon_mpdu);
  5119. default:
  5120. break;
  5121. }
  5122. return QDF_STATUS_SUCCESS;
  5123. }
  5124. /**
  5125. * dp_peer_set_tx_capture_enabled: Set tx_cap_enabled bit in peer
  5126. * @pdev: DP PDEV handle
  5127. * @peer: Peer handle
  5128. * @value: Enable/disable setting for tx_cap_enabled
  5129. * @peer_mac: peer mac address
  5130. *
  5131. * Return: QDF_STATUS
  5132. */
  5133. QDF_STATUS
  5134. dp_peer_set_tx_capture_enabled(struct dp_pdev *pdev,
  5135. struct dp_peer *peer, uint8_t value,
  5136. uint8_t *peer_mac)
  5137. {
  5138. uint32_t peer_id = HTT_INVALID_PEER;
  5139. QDF_STATUS status = QDF_STATUS_E_FAILURE;
  5140. if (value) {
  5141. if (dp_peer_tx_cap_add_filter(pdev, peer_id, peer_mac)) {
  5142. if (peer)
  5143. peer->tx_cap_enabled = value;
  5144. status = QDF_STATUS_SUCCESS;
  5145. }
  5146. } else {
  5147. if (dp_peer_tx_cap_del_filter(pdev, peer_id, peer_mac)) {
  5148. if (peer)
  5149. peer->tx_cap_enabled = value;
  5150. status = QDF_STATUS_SUCCESS;
  5151. }
  5152. }
  5153. return status;
  5154. }
  5155. /*
  5156. * dp_peer_tx_capture_filter_check: check filter is enable for the filter
  5157. * and update tx_cap_enabled flag
  5158. * @pdev: DP PDEV handle
  5159. * @peer: DP PEER handle
  5160. *
  5161. * return: void
  5162. */
  5163. void dp_peer_tx_capture_filter_check(struct dp_pdev *pdev,
  5164. struct dp_peer *peer)
  5165. {
  5166. if (!peer)
  5167. return;
  5168. if (dp_peer_tx_cap_search(pdev, peer->peer_id,
  5169. peer->mac_addr.raw)) {
  5170. peer->tx_cap_enabled = 1;
  5171. }
  5172. return;
  5173. }
  5174. /*
  5175. * dbg_copy_ppdu_desc: copy ppdu_desc to tx capture debugfs
  5176. * @nbuf_ppdu: nbuf ppdu
  5177. *
  5178. * return: void
  5179. */
  5180. void *dbg_copy_ppdu_desc(qdf_nbuf_t nbuf_ppdu)
  5181. {
  5182. struct dbg_tx_comp_ppdu *ptr_dbg_ppdu = NULL;
  5183. struct cdp_tx_completion_ppdu *ppdu_desc = NULL;
  5184. uint8_t i = 0;
  5185. uint8_t num_users = 0;
  5186. ppdu_desc = (struct cdp_tx_completion_ppdu *)
  5187. qdf_nbuf_data(nbuf_ppdu);
  5188. ptr_dbg_ppdu = qdf_mem_malloc(sizeof(struct dbg_tx_comp_ppdu) +
  5189. (ppdu_desc->num_users *
  5190. sizeof(struct dbg_tx_comp_ppdu_user)));
  5191. if (!ptr_dbg_ppdu)
  5192. return NULL;
  5193. num_users = ppdu_desc->num_users;
  5194. ptr_dbg_ppdu->ppdu_id = ppdu_desc->ppdu_id;
  5195. ptr_dbg_ppdu->bar_ppdu_id = ppdu_desc->bar_ppdu_id;
  5196. ptr_dbg_ppdu->vdev_id = ppdu_desc->vdev_id;
  5197. ptr_dbg_ppdu->bar_num_users = ppdu_desc->bar_num_users;
  5198. ptr_dbg_ppdu->num_users = ppdu_desc->num_users;
  5199. ptr_dbg_ppdu->sched_cmdid = ppdu_desc->sched_cmdid;
  5200. ptr_dbg_ppdu->tlv_bitmap = ppdu_desc->tlv_bitmap;
  5201. ptr_dbg_ppdu->htt_frame_type = ppdu_desc->htt_frame_type;
  5202. ptr_dbg_ppdu->frame_ctrl = ppdu_desc->frame_ctrl;
  5203. ptr_dbg_ppdu->ppdu_start_timestamp = ppdu_desc->ppdu_start_timestamp;
  5204. ptr_dbg_ppdu->ppdu_end_timestamp = ppdu_desc->ppdu_end_timestamp;
  5205. ptr_dbg_ppdu->bar_ppdu_start_timestamp =
  5206. ppdu_desc->bar_ppdu_start_timestamp;
  5207. ptr_dbg_ppdu->bar_ppdu_end_timestamp =
  5208. ppdu_desc->bar_ppdu_end_timestamp;
  5209. for (i = 0; i < ppdu_desc->num_users; i++) {
  5210. ptr_dbg_ppdu->user[i].completion_status =
  5211. ppdu_desc->user[i].completion_status;
  5212. ptr_dbg_ppdu->user[i].tid = ppdu_desc->user[i].tid;
  5213. ptr_dbg_ppdu->user[i].peer_id = ppdu_desc->user[i].peer_id;
  5214. qdf_mem_copy(ptr_dbg_ppdu->user[i].mac_addr,
  5215. ppdu_desc->user[i].mac_addr, 6);
  5216. ptr_dbg_ppdu->user[i].frame_ctrl =
  5217. ppdu_desc->user[i].frame_ctrl;
  5218. ptr_dbg_ppdu->user[i].qos_ctrl = ppdu_desc->user[i].qos_ctrl;
  5219. ptr_dbg_ppdu->user[i].mpdu_tried =
  5220. ppdu_desc->user[i].mpdu_tried_ucast +
  5221. ppdu_desc->user[i].mpdu_tried_mcast;
  5222. ptr_dbg_ppdu->user[i].mpdu_success =
  5223. ppdu_desc->user[i].mpdu_success;
  5224. ptr_dbg_ppdu->user[i].ltf_size = ppdu_desc->user[i].ltf_size;
  5225. ptr_dbg_ppdu->user[i].stbc = ppdu_desc->user[i].stbc;
  5226. ptr_dbg_ppdu->user[i].he_re = ppdu_desc->user[i].he_re;
  5227. ptr_dbg_ppdu->user[i].txbf = ppdu_desc->user[i].txbf;
  5228. ptr_dbg_ppdu->user[i].bw = ppdu_desc->user[i].bw;
  5229. ptr_dbg_ppdu->user[i].nss = ppdu_desc->user[i].nss;
  5230. ptr_dbg_ppdu->user[i].mcs = ppdu_desc->user[i].mcs;
  5231. ptr_dbg_ppdu->user[i].preamble = ppdu_desc->user[i].preamble;
  5232. ptr_dbg_ppdu->user[i].gi = ppdu_desc->user[i].gi;
  5233. ptr_dbg_ppdu->user[i].dcm = ppdu_desc->user[i].dcm;
  5234. ptr_dbg_ppdu->user[i].ldpc = ppdu_desc->user[i].ldpc;
  5235. ptr_dbg_ppdu->user[i].delayed_ba =
  5236. ppdu_desc->user[i].delayed_ba;
  5237. ptr_dbg_ppdu->user[i].ack_ba_tlv =
  5238. ppdu_desc->user[i].ack_ba_tlv;
  5239. ptr_dbg_ppdu->user[i].ba_seq_no = ppdu_desc->user[i].ba_seq_no;
  5240. ptr_dbg_ppdu->user[i].start_seq = ppdu_desc->user[i].start_seq;
  5241. qdf_mem_copy(ptr_dbg_ppdu->user[i].ba_bitmap,
  5242. ppdu_desc->user[i].ba_bitmap,
  5243. CDP_BA_256_BIT_MAP_SIZE_DWORDS);
  5244. qdf_mem_copy(ptr_dbg_ppdu->user[i].enq_bitmap,
  5245. ppdu_desc->user[i].enq_bitmap,
  5246. CDP_BA_256_BIT_MAP_SIZE_DWORDS);
  5247. ptr_dbg_ppdu->user[i].num_mpdu = ppdu_desc->user[i].num_mpdu;
  5248. ptr_dbg_ppdu->user[i].num_msdu = ppdu_desc->user[i].num_msdu;
  5249. ptr_dbg_ppdu->user[i].is_mcast = ppdu_desc->user[i].is_mcast;
  5250. ptr_dbg_ppdu->user[i].tlv_bitmap =
  5251. ppdu_desc->user[i].tlv_bitmap;
  5252. }
  5253. return ptr_dbg_ppdu;
  5254. }
  5255. /**
  5256. * debug_ppdu_log_enable_show() - debugfs function to display ppdu_desc
  5257. * @file: qdf debugfs handler
  5258. * @arg: priv data used to get htt_logger_handler
  5259. *
  5260. * Return: QDF_STATUS
  5261. */
  5262. static QDF_STATUS debug_ppdu_desc_log_show(qdf_debugfs_file_t file, void *arg)
  5263. {
  5264. struct dp_pdev *pdev;
  5265. struct dp_pdev_tx_capture *ptr_tx_cap;
  5266. struct tx_cap_debug_log_info *ptr_log_info;
  5267. struct dbg_tx_comp_ppdu *ptr_dbg_ppdu;
  5268. uint8_t k = 0;
  5269. uint8_t i = 0;
  5270. pdev = (struct dp_pdev *)arg;
  5271. ptr_tx_cap = &pdev->tx_capture;
  5272. ptr_log_info = &ptr_tx_cap->log_info;
  5273. if ((ptr_log_info->stop_seq & (0x1 << PPDU_LOG_DISPLAY_LIST)) &&
  5274. !ptr_log_info->ppdu_desc_log) {
  5275. ptr_log_info->stop_seq &= ~(0x1 << PPDU_LOG_DISPLAY_LIST);
  5276. return QDF_STATUS_SUCCESS;
  5277. }
  5278. if (!ptr_log_info->ppdu_desc_log) {
  5279. ptr_log_info->pause_dbg_log = 0;
  5280. ptr_log_info->stop_seq |= (0x1 << PPDU_LOG_DISPLAY_LIST);
  5281. return QDF_STATUS_SUCCESS;
  5282. }
  5283. ptr_log_info->pause_dbg_log = 1;
  5284. ptr_dbg_ppdu = ppdu_desc_dbg_dequeue(ptr_log_info);
  5285. if (!ptr_dbg_ppdu) {
  5286. ptr_log_info->pause_dbg_log = 0;
  5287. ptr_log_info->stop_seq |= (0x1 << PPDU_LOG_DISPLAY_LIST);
  5288. return QDF_STATUS_SUCCESS;
  5289. }
  5290. qdf_debugfs_printf(file,
  5291. "===============================================\n");
  5292. qdf_debugfs_printf(file,
  5293. "P_ID:%d B_P_ID:%d VDEV:%d N_USR[%d %d] SCH_ID:%d\n",
  5294. ptr_dbg_ppdu->ppdu_id,
  5295. ptr_dbg_ppdu->bar_ppdu_id,
  5296. ptr_dbg_ppdu->vdev_id,
  5297. ptr_dbg_ppdu->num_users,
  5298. ptr_dbg_ppdu->bar_num_users,
  5299. ptr_dbg_ppdu->sched_cmdid);
  5300. qdf_debugfs_printf(file,
  5301. "TLV:0x%x H_FRM:%d FCTRL:0x%x\n",
  5302. ptr_dbg_ppdu->tlv_bitmap,
  5303. ptr_dbg_ppdu->htt_frame_type,
  5304. ptr_dbg_ppdu->frame_ctrl);
  5305. qdf_debugfs_printf(file,
  5306. "TSF[%llu - %llu] B_TSF[%llu - %llu]\n",
  5307. ptr_dbg_ppdu->ppdu_start_timestamp,
  5308. ptr_dbg_ppdu->ppdu_end_timestamp,
  5309. ptr_dbg_ppdu->bar_ppdu_start_timestamp,
  5310. ptr_dbg_ppdu->bar_ppdu_end_timestamp);
  5311. for (k = 0; k < ptr_dbg_ppdu->num_users; k++) {
  5312. struct dbg_tx_comp_ppdu_user *user;
  5313. user = &ptr_dbg_ppdu->user[k];
  5314. qdf_debugfs_printf(file, "USER: %d\n", k);
  5315. qdf_debugfs_printf(file,
  5316. "\tPEER:%d TID:%d CS:%d TLV:0x%x\n",
  5317. user->peer_id,
  5318. user->tid,
  5319. user->completion_status,
  5320. user->tlv_bitmap);
  5321. qdf_debugfs_printf(file,
  5322. "\tFCTRL:0x%x QOS:0x%x\n",
  5323. user->frame_ctrl,
  5324. user->qos_ctrl);
  5325. qdf_debugfs_printf(file,
  5326. "\tMPDU[T:%d S:%d] N_MPDU:%d N_MSDU:%d\n",
  5327. user->mpdu_tried,
  5328. user->mpdu_success,
  5329. user->num_mpdu,
  5330. user->num_msdu);
  5331. qdf_debugfs_printf(file,
  5332. "\tMCS:%d NSS:%d PRE:%d BW:%d D_BA:%d\n",
  5333. user->mcs,
  5334. user->nss,
  5335. user->preamble,
  5336. user->bw,
  5337. user->delayed_ba);
  5338. qdf_debugfs_printf(file,
  5339. "\tS_SEQ:%d ENQ_BITMAP[",
  5340. user->start_seq);
  5341. for (i = 0; i < CDP_BA_256_BIT_MAP_SIZE_DWORDS; i++)
  5342. qdf_debugfs_printf(file, " 0x%x",
  5343. user->enq_bitmap[i]);
  5344. qdf_debugfs_printf(file, "]\n");
  5345. qdf_debugfs_printf(file,
  5346. "\tBA_SEQ:%d BA_BITMAP[",
  5347. user->ba_seq_no);
  5348. for (i = 0; i < CDP_BA_256_BIT_MAP_SIZE_DWORDS; i++)
  5349. qdf_debugfs_printf(file, " 0x%x",
  5350. user->ba_bitmap[i]);
  5351. qdf_debugfs_printf(file, "]\n");
  5352. }
  5353. qdf_debugfs_printf(file,
  5354. "===============================================\n");
  5355. /* free the dequeued dbg ppdu_desc */
  5356. qdf_mem_free(ptr_dbg_ppdu);
  5357. return QDF_STATUS_E_AGAIN;
  5358. }
  5359. /**
  5360. * debug_ppdu_desc_log_write() - write is not allowed in ppdu_desc_log.
  5361. * @priv: file handler to access tx capture log info
  5362. * @buf: received data buffer
  5363. * @len: length of received buffer
  5364. *
  5365. * Return: QDF_STATUS
  5366. */
  5367. static QDF_STATUS debug_ppdu_desc_log_write(void *priv,
  5368. const char *buf,
  5369. qdf_size_t len)
  5370. {
  5371. return -EINVAL;
  5372. }
  5373. /**
  5374. * debug_ppdu_log_enable_show() - debugfs function to show the
  5375. * enable/disable flag.
  5376. * @file: qdf debugfs handler
  5377. * @arg: priv data used to get htt_logger_handler
  5378. *
  5379. * Return: QDF_STATUS
  5380. */
  5381. static QDF_STATUS debug_ppdu_log_enable_show(qdf_debugfs_file_t file, void *arg)
  5382. {
  5383. struct dp_pdev *pdev;
  5384. struct dp_pdev_tx_capture *ptr_tx_cap;
  5385. struct tx_cap_debug_log_info *ptr_log_info;
  5386. pdev = (struct dp_pdev *)arg;
  5387. ptr_tx_cap = &pdev->tx_capture;
  5388. ptr_log_info = &ptr_tx_cap->log_info;
  5389. if ((ptr_log_info->stop_seq & (0x1 << PPDU_LOG_ENABLE_LIST))) {
  5390. ptr_log_info->stop_seq &= ~(0x1 << PPDU_LOG_ENABLE_LIST);
  5391. return QDF_STATUS_SUCCESS;
  5392. }
  5393. qdf_debugfs_printf(file, "%u\n", ptr_log_info->ppdu_desc_log);
  5394. ptr_log_info->stop_seq |= (0x1 << PPDU_LOG_ENABLE_LIST);
  5395. return QDF_STATUS_SUCCESS;
  5396. }
  5397. /**
  5398. * debug_ppdu_log_enable_write() - debugfs function to enable/disable
  5399. * the debugfs flag.
  5400. * @priv: file handler to access tx capture log info
  5401. * @buf: received data buffer
  5402. * @len: length of received buffer
  5403. *
  5404. * Return: QDF_STATUS
  5405. */
  5406. static QDF_STATUS debug_ppdu_log_enable_write(void *priv,
  5407. const char *buf,
  5408. qdf_size_t len)
  5409. {
  5410. struct dp_pdev *pdev;
  5411. struct dp_pdev_tx_capture *ptr_tx_cap;
  5412. struct tx_cap_debug_log_info *ptr_log_info;
  5413. int k, ret;
  5414. pdev = (struct dp_pdev *)priv;
  5415. ptr_tx_cap = &pdev->tx_capture;
  5416. ptr_log_info = &ptr_tx_cap->log_info;
  5417. ret = kstrtoint(buf, 0, &k);
  5418. if ((ret != 0) || ((k != 0) && (k != 1)))
  5419. return QDF_STATUS_E_PERM;
  5420. if (k == 1) {
  5421. /* if ppdu_desc log already 1 return success */
  5422. if (ptr_log_info->ppdu_desc_log)
  5423. return QDF_STATUS_SUCCESS;
  5424. /* initialize ppdu_desc_log to 1 */
  5425. ptr_log_info->ppdu_desc_log = 1;
  5426. } else {
  5427. /* if ppdu_desc log already 1 return success */
  5428. if (ptr_log_info->ppdu_desc_log)
  5429. return QDF_STATUS_SUCCESS;
  5430. /* initialize ppdu_desc_log to 1 */
  5431. ptr_log_info->ppdu_desc_log = 0;
  5432. }
  5433. return QDF_STATUS_SUCCESS;
  5434. }
  5435. /*
  5436. * tx_cap_debugfs_log_ppdu_desc: tx capture logging ppdu desc
  5437. * @pdev: DP PDEV handle
  5438. * @nbuf_ppdu: nbuf ppdu
  5439. *
  5440. * return: void
  5441. */
  5442. void tx_cap_debugfs_log_ppdu_desc(struct dp_pdev *pdev, qdf_nbuf_t nbuf_ppdu)
  5443. {
  5444. struct dp_pdev_tx_capture *ptr_tx_cap;
  5445. struct tx_cap_debug_log_info *ptr_log_info;
  5446. struct dbg_tx_comp_ppdu *ptr_dbg_ppdu;
  5447. struct dbg_tx_comp_ppdu *ptr_tmp_ppdu;
  5448. uint32_t list_size;
  5449. ptr_tx_cap = &pdev->tx_capture;
  5450. ptr_log_info = &ptr_tx_cap->log_info;
  5451. if (!ptr_log_info->ppdu_desc_log || ptr_log_info->pause_dbg_log)
  5452. return;
  5453. ptr_dbg_ppdu = dbg_copy_ppdu_desc(nbuf_ppdu);
  5454. if (!ptr_dbg_ppdu)
  5455. return;
  5456. list_size = ppdu_desc_dbg_enqueue(ptr_log_info, ptr_dbg_ppdu);
  5457. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_INFO_MED,
  5458. "%s: enqueue list_size:%d\n", __func__, list_size);
  5459. if (list_size >= ptr_log_info->ppdu_queue_size) {
  5460. ptr_tmp_ppdu = ppdu_desc_dbg_dequeue(ptr_log_info);
  5461. qdf_mem_free(ptr_tmp_ppdu);
  5462. }
  5463. }
  5464. #define DEBUGFS_FOPS(func_base) \
  5465. { \
  5466. .name = #func_base, \
  5467. .ops = { \
  5468. .show = debug_##func_base##_show, \
  5469. .write = debug_##func_base##_write, \
  5470. .priv = NULL, \
  5471. } \
  5472. }
  5473. struct tx_cap_debugfs_info tx_cap_debugfs_infos[NUM_TX_CAP_DEBUG_INFOS] = {
  5474. DEBUGFS_FOPS(ppdu_log_enable),
  5475. DEBUGFS_FOPS(ppdu_desc_log),
  5476. };
  5477. /*
  5478. * tx_cap_debugfs_remove: remove dentry and file created.
  5479. * @ptr_log_info: tx capture debugfs log structure
  5480. *
  5481. * return: void
  5482. */
  5483. static void tx_cap_debugfs_remove(struct tx_cap_debug_log_info *ptr_log_info)
  5484. {
  5485. qdf_dentry_t dentry;
  5486. uint8_t i = 0;
  5487. for (i = 0; i < NUM_TX_CAP_DEBUG_INFOS; ++i) {
  5488. dentry = ptr_log_info->debugfs_de[i];
  5489. if (dentry) {
  5490. qdf_debugfs_remove_file(dentry);
  5491. ptr_log_info->debugfs_de[i] = NULL;
  5492. }
  5493. }
  5494. dentry = ptr_log_info->tx_cap_debugfs_dir;
  5495. if (dentry) {
  5496. qdf_debugfs_remove_dir(dentry);
  5497. ptr_log_info->tx_cap_debugfs_dir = NULL;
  5498. }
  5499. }
  5500. /*
  5501. * dp_tx_capture_debugfs_init: tx capture debugfs init
  5502. * @pdev: DP PDEV handle
  5503. *
  5504. * return: QDF_STATUS
  5505. */
  5506. QDF_STATUS dp_tx_capture_debugfs_init(struct dp_pdev *pdev)
  5507. {
  5508. qdf_dentry_t dentry;
  5509. struct dp_soc *soc;
  5510. struct dp_pdev_tx_capture *ptr_tx_cap;
  5511. struct tx_cap_debug_log_info *ptr_log_info;
  5512. struct tx_cap_debugfs_info *ptr_debugfs_info;
  5513. uint8_t i = 0;
  5514. char buf[32];
  5515. char *name = NULL;
  5516. soc = pdev->soc;
  5517. ptr_tx_cap = &pdev->tx_capture;
  5518. ptr_log_info = &ptr_tx_cap->log_info;
  5519. if (soc->cdp_soc.ol_ops->get_device_name) {
  5520. name = soc->cdp_soc.ol_ops->get_device_name(
  5521. pdev->soc->ctrl_psoc, pdev->pdev_id);
  5522. }
  5523. if (name == NULL)
  5524. return QDF_STATUS_E_FAILURE;
  5525. /* directory creation with name */
  5526. snprintf(buf, sizeof(buf), "tx_cap_log_%s", name);
  5527. dentry = qdf_debugfs_create_dir(buf, NULL);
  5528. if (!dentry) {
  5529. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE, QDF_TRACE_LEVEL_ERROR,
  5530. "error while creating debugfs dir for %s", buf);
  5531. goto out;
  5532. }
  5533. ptr_log_info->tx_cap_debugfs_dir = dentry;
  5534. qdf_mem_copy(ptr_log_info->tx_cap_debugfs_infos,
  5535. tx_cap_debugfs_infos,
  5536. (sizeof(struct tx_cap_debugfs_info) *
  5537. NUM_TX_CAP_DEBUG_INFOS));
  5538. for (i = 0; i < NUM_TX_CAP_DEBUG_INFOS; i++) {
  5539. ptr_debugfs_info = &ptr_log_info->tx_cap_debugfs_infos[i];
  5540. /* store pdev tx capture pointer to private data pointer */
  5541. ptr_debugfs_info->ops.priv = pdev;
  5542. ptr_log_info->debugfs_de[i] = qdf_debugfs_create_file(
  5543. ptr_debugfs_info->name,
  5544. TX_CAP_DBG_FILE_PERM,
  5545. ptr_log_info->tx_cap_debugfs_dir,
  5546. &ptr_debugfs_info->ops);
  5547. if (!ptr_log_info->debugfs_de[i]) {
  5548. QDF_TRACE(QDF_MODULE_ID_TX_CAPTURE,
  5549. QDF_TRACE_LEVEL_ERROR,
  5550. "debug Entry creation failed[%s]!",
  5551. ptr_debugfs_info->name);
  5552. goto out;
  5553. }
  5554. }
  5555. return QDF_STATUS_SUCCESS;
  5556. out:
  5557. tx_cap_debugfs_remove(ptr_log_info);
  5558. return QDF_STATUS_E_FAILURE;
  5559. }
  5560. /*
  5561. * dp_tx_capture_debugfs_deinit: tx capture debugfs deinit
  5562. * @pdev: DP PDEV handle
  5563. *
  5564. * return: void
  5565. */
  5566. void dp_tx_capture_debugfs_deinit(struct dp_pdev *pdev)
  5567. {
  5568. struct dp_pdev_tx_capture *ptr_tx_cap;
  5569. struct tx_cap_debug_log_info *ptr_log_info;
  5570. ptr_tx_cap = &pdev->tx_capture;
  5571. ptr_log_info = &ptr_tx_cap->log_info;
  5572. tx_cap_debugfs_remove(ptr_log_info);
  5573. }
  5574. #endif