wmi_unified_non_tlv.c 286 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849285028512852285328542855285628572858285928602861286228632864286528662867286828692870287128722873287428752876287728782879288028812882288328842885288628872888288928902891289228932894289528962897289828992900290129022903290429052906290729082909291029112912291329142915291629172918291929202921292229232924292529262927292829292930293129322933293429352936293729382939294029412942294329442945294629472948294929502951295229532954295529562957295829592960296129622963296429652966296729682969297029712972297329742975297629772978297929802981298229832984298529862987298829892990299129922993299429952996299729982999300030013002300330043005300630073008300930103011301230133014301530163017301830193020302130223023302430253026302730283029303030313032303330343035303630373038303930403041304230433044304530463047304830493050305130523053305430553056305730583059306030613062306330643065306630673068306930703071307230733074307530763077307830793080308130823083308430853086308730883089309030913092309330943095309630973098309931003101310231033104310531063107310831093110311131123113311431153116311731183119312031213122312331243125312631273128312931303131313231333134313531363137313831393140314131423143314431453146314731483149315031513152315331543155315631573158315931603161316231633164316531663167316831693170317131723173317431753176317731783179318031813182318331843185318631873188318931903191319231933194319531963197319831993200320132023203320432053206320732083209321032113212321332143215321632173218321932203221322232233224322532263227322832293230323132323233323432353236323732383239324032413242324332443245324632473248324932503251325232533254325532563257325832593260326132623263326432653266326732683269327032713272327332743275327632773278327932803281328232833284328532863287328832893290329132923293329432953296329732983299330033013302330333043305330633073308330933103311331233133314331533163317331833193320332133223323332433253326332733283329333033313332333333343335333633373338333933403341334233433344334533463347334833493350335133523353335433553356335733583359336033613362336333643365336633673368336933703371337233733374337533763377337833793380338133823383338433853386338733883389339033913392339333943395339633973398339934003401340234033404340534063407340834093410341134123413341434153416341734183419342034213422342334243425342634273428342934303431343234333434343534363437343834393440344134423443344434453446344734483449345034513452345334543455345634573458345934603461346234633464346534663467346834693470347134723473347434753476347734783479348034813482348334843485348634873488348934903491349234933494349534963497349834993500350135023503350435053506350735083509351035113512351335143515351635173518351935203521352235233524352535263527352835293530353135323533353435353536353735383539354035413542354335443545354635473548354935503551355235533554355535563557355835593560356135623563356435653566356735683569357035713572357335743575357635773578357935803581358235833584358535863587358835893590359135923593359435953596359735983599360036013602360336043605360636073608360936103611361236133614361536163617361836193620362136223623362436253626362736283629363036313632363336343635363636373638363936403641364236433644364536463647364836493650365136523653365436553656365736583659366036613662366336643665366636673668366936703671367236733674367536763677367836793680368136823683368436853686368736883689369036913692369336943695369636973698369937003701370237033704370537063707370837093710371137123713371437153716371737183719372037213722372337243725372637273728372937303731373237333734373537363737373837393740374137423743374437453746374737483749375037513752375337543755375637573758375937603761376237633764376537663767376837693770377137723773377437753776377737783779378037813782378337843785378637873788378937903791379237933794379537963797379837993800380138023803380438053806380738083809381038113812381338143815381638173818381938203821382238233824382538263827382838293830383138323833383438353836383738383839384038413842384338443845384638473848384938503851385238533854385538563857385838593860386138623863386438653866386738683869387038713872387338743875387638773878387938803881388238833884388538863887388838893890389138923893389438953896389738983899390039013902390339043905390639073908390939103911391239133914391539163917391839193920392139223923392439253926392739283929393039313932393339343935393639373938393939403941394239433944394539463947394839493950395139523953395439553956395739583959396039613962396339643965396639673968396939703971397239733974397539763977397839793980398139823983398439853986398739883989399039913992399339943995399639973998399940004001400240034004400540064007400840094010401140124013401440154016401740184019402040214022402340244025402640274028402940304031403240334034403540364037403840394040404140424043404440454046404740484049405040514052405340544055405640574058405940604061406240634064406540664067406840694070407140724073407440754076407740784079408040814082408340844085408640874088408940904091409240934094409540964097409840994100410141024103410441054106410741084109411041114112411341144115411641174118411941204121412241234124412541264127412841294130413141324133413441354136413741384139414041414142414341444145414641474148414941504151415241534154415541564157415841594160416141624163416441654166416741684169417041714172417341744175417641774178417941804181418241834184418541864187418841894190419141924193419441954196419741984199420042014202420342044205420642074208420942104211421242134214421542164217421842194220422142224223422442254226422742284229423042314232423342344235423642374238423942404241424242434244424542464247424842494250425142524253425442554256425742584259426042614262426342644265426642674268426942704271427242734274427542764277427842794280428142824283428442854286428742884289429042914292429342944295429642974298429943004301430243034304430543064307430843094310431143124313431443154316431743184319432043214322432343244325432643274328432943304331433243334334433543364337433843394340434143424343434443454346434743484349435043514352435343544355435643574358435943604361436243634364436543664367436843694370437143724373437443754376437743784379438043814382438343844385438643874388438943904391439243934394439543964397439843994400440144024403440444054406440744084409441044114412441344144415441644174418441944204421442244234424442544264427442844294430443144324433443444354436443744384439444044414442444344444445444644474448444944504451445244534454445544564457445844594460446144624463446444654466446744684469447044714472447344744475447644774478447944804481448244834484448544864487448844894490449144924493449444954496449744984499450045014502450345044505450645074508450945104511451245134514451545164517451845194520452145224523452445254526452745284529453045314532453345344535453645374538453945404541454245434544454545464547454845494550455145524553455445554556455745584559456045614562456345644565456645674568456945704571457245734574457545764577457845794580458145824583458445854586458745884589459045914592459345944595459645974598459946004601460246034604460546064607460846094610461146124613461446154616461746184619462046214622462346244625462646274628462946304631463246334634463546364637463846394640464146424643464446454646464746484649465046514652465346544655465646574658465946604661466246634664466546664667466846694670467146724673467446754676467746784679468046814682468346844685468646874688468946904691469246934694469546964697469846994700470147024703470447054706470747084709471047114712471347144715471647174718471947204721472247234724472547264727472847294730473147324733473447354736473747384739474047414742474347444745474647474748474947504751475247534754475547564757475847594760476147624763476447654766476747684769477047714772477347744775477647774778477947804781478247834784478547864787478847894790479147924793479447954796479747984799480048014802480348044805480648074808480948104811481248134814481548164817481848194820482148224823482448254826482748284829483048314832483348344835483648374838483948404841484248434844484548464847484848494850485148524853485448554856485748584859486048614862486348644865486648674868486948704871487248734874487548764877487848794880488148824883488448854886488748884889489048914892489348944895489648974898489949004901490249034904490549064907490849094910491149124913491449154916491749184919492049214922492349244925492649274928492949304931493249334934493549364937493849394940494149424943494449454946494749484949495049514952495349544955495649574958495949604961496249634964496549664967496849694970497149724973497449754976497749784979498049814982498349844985498649874988498949904991499249934994499549964997499849995000500150025003500450055006500750085009501050115012501350145015501650175018501950205021502250235024502550265027502850295030503150325033503450355036503750385039504050415042504350445045504650475048504950505051505250535054505550565057505850595060506150625063506450655066506750685069507050715072507350745075507650775078507950805081508250835084508550865087508850895090509150925093509450955096509750985099510051015102510351045105510651075108510951105111511251135114511551165117511851195120512151225123512451255126512751285129513051315132513351345135513651375138513951405141514251435144514551465147514851495150515151525153515451555156515751585159516051615162516351645165516651675168516951705171517251735174517551765177517851795180518151825183518451855186518751885189519051915192519351945195519651975198519952005201520252035204520552065207520852095210521152125213521452155216521752185219522052215222522352245225522652275228522952305231523252335234523552365237523852395240524152425243524452455246524752485249525052515252525352545255525652575258525952605261526252635264526552665267526852695270527152725273527452755276527752785279528052815282528352845285528652875288528952905291529252935294529552965297529852995300530153025303530453055306530753085309531053115312531353145315531653175318531953205321532253235324532553265327532853295330533153325333533453355336533753385339534053415342534353445345534653475348534953505351535253535354535553565357535853595360536153625363536453655366536753685369537053715372537353745375537653775378537953805381538253835384538553865387538853895390539153925393539453955396539753985399540054015402540354045405540654075408540954105411541254135414541554165417541854195420542154225423542454255426542754285429543054315432543354345435543654375438543954405441544254435444544554465447544854495450545154525453545454555456545754585459546054615462546354645465546654675468546954705471547254735474547554765477547854795480548154825483548454855486548754885489549054915492549354945495549654975498549955005501550255035504550555065507550855095510551155125513551455155516551755185519552055215522552355245525552655275528552955305531553255335534553555365537553855395540554155425543554455455546554755485549555055515552555355545555555655575558555955605561556255635564556555665567556855695570557155725573557455755576557755785579558055815582558355845585558655875588558955905591559255935594559555965597559855995600560156025603560456055606560756085609561056115612561356145615561656175618561956205621562256235624562556265627562856295630563156325633563456355636563756385639564056415642564356445645564656475648564956505651565256535654565556565657565856595660566156625663566456655666566756685669567056715672567356745675567656775678567956805681568256835684568556865687568856895690569156925693569456955696569756985699570057015702570357045705570657075708570957105711571257135714571557165717571857195720572157225723572457255726572757285729573057315732573357345735573657375738573957405741574257435744574557465747574857495750575157525753575457555756575757585759576057615762576357645765576657675768576957705771577257735774577557765777577857795780578157825783578457855786578757885789579057915792579357945795579657975798579958005801580258035804580558065807580858095810581158125813581458155816581758185819582058215822582358245825582658275828582958305831583258335834583558365837583858395840584158425843584458455846584758485849585058515852585358545855585658575858585958605861586258635864586558665867586858695870587158725873587458755876587758785879588058815882588358845885588658875888588958905891589258935894589558965897589858995900590159025903590459055906590759085909591059115912591359145915591659175918591959205921592259235924592559265927592859295930593159325933593459355936593759385939594059415942594359445945594659475948594959505951595259535954595559565957595859595960596159625963596459655966596759685969597059715972597359745975597659775978597959805981598259835984598559865987598859895990599159925993599459955996599759985999600060016002600360046005600660076008600960106011601260136014601560166017601860196020602160226023602460256026602760286029603060316032603360346035603660376038603960406041604260436044604560466047604860496050605160526053605460556056605760586059606060616062606360646065606660676068606960706071607260736074607560766077607860796080608160826083608460856086608760886089609060916092609360946095609660976098609961006101610261036104610561066107610861096110611161126113611461156116611761186119612061216122612361246125612661276128612961306131613261336134613561366137613861396140614161426143614461456146614761486149615061516152615361546155615661576158615961606161616261636164616561666167616861696170617161726173617461756176617761786179618061816182618361846185618661876188618961906191619261936194619561966197619861996200620162026203620462056206620762086209621062116212621362146215621662176218621962206221622262236224622562266227622862296230623162326233623462356236623762386239624062416242624362446245624662476248624962506251625262536254625562566257625862596260626162626263626462656266626762686269627062716272627362746275627662776278627962806281628262836284628562866287628862896290629162926293629462956296629762986299630063016302630363046305630663076308630963106311631263136314631563166317631863196320632163226323632463256326632763286329633063316332633363346335633663376338633963406341634263436344634563466347634863496350635163526353635463556356635763586359636063616362636363646365636663676368636963706371637263736374637563766377637863796380638163826383638463856386638763886389639063916392639363946395639663976398639964006401640264036404640564066407640864096410641164126413641464156416641764186419642064216422642364246425642664276428642964306431643264336434643564366437643864396440644164426443644464456446644764486449645064516452645364546455645664576458645964606461646264636464646564666467646864696470647164726473647464756476647764786479648064816482648364846485648664876488648964906491649264936494649564966497649864996500650165026503650465056506650765086509651065116512651365146515651665176518651965206521652265236524652565266527652865296530653165326533653465356536653765386539654065416542654365446545654665476548654965506551655265536554655565566557655865596560656165626563656465656566656765686569657065716572657365746575657665776578657965806581658265836584658565866587658865896590659165926593659465956596659765986599660066016602660366046605660666076608660966106611661266136614661566166617661866196620662166226623662466256626662766286629663066316632663366346635663666376638663966406641664266436644664566466647664866496650665166526653665466556656665766586659666066616662666366646665666666676668666966706671667266736674667566766677667866796680668166826683668466856686668766886689669066916692669366946695669666976698669967006701670267036704670567066707670867096710671167126713671467156716671767186719672067216722672367246725672667276728672967306731673267336734673567366737673867396740674167426743674467456746674767486749675067516752675367546755675667576758675967606761676267636764676567666767676867696770677167726773677467756776677767786779678067816782678367846785678667876788678967906791679267936794679567966797679867996800680168026803680468056806680768086809681068116812681368146815681668176818681968206821682268236824682568266827682868296830683168326833683468356836683768386839684068416842684368446845684668476848684968506851685268536854685568566857685868596860686168626863686468656866686768686869687068716872687368746875687668776878687968806881688268836884688568866887688868896890689168926893689468956896689768986899690069016902690369046905690669076908690969106911691269136914691569166917691869196920692169226923692469256926692769286929693069316932693369346935693669376938693969406941694269436944694569466947694869496950695169526953695469556956695769586959696069616962696369646965696669676968696969706971697269736974697569766977697869796980698169826983698469856986698769886989699069916992699369946995699669976998699970007001700270037004700570067007700870097010701170127013701470157016701770187019702070217022702370247025702670277028702970307031703270337034703570367037703870397040704170427043704470457046704770487049705070517052705370547055705670577058705970607061706270637064706570667067706870697070707170727073707470757076707770787079708070817082708370847085708670877088708970907091709270937094709570967097709870997100710171027103710471057106710771087109711071117112711371147115711671177118711971207121712271237124712571267127712871297130713171327133713471357136713771387139714071417142714371447145714671477148714971507151715271537154715571567157715871597160716171627163716471657166716771687169717071717172717371747175717671777178717971807181718271837184718571867187718871897190719171927193719471957196719771987199720072017202720372047205720672077208720972107211721272137214721572167217721872197220722172227223722472257226722772287229723072317232723372347235723672377238723972407241724272437244724572467247724872497250725172527253725472557256725772587259726072617262726372647265726672677268726972707271727272737274727572767277727872797280728172827283728472857286728772887289729072917292729372947295729672977298729973007301730273037304730573067307730873097310731173127313731473157316731773187319732073217322732373247325732673277328732973307331733273337334733573367337733873397340734173427343734473457346734773487349735073517352735373547355735673577358735973607361736273637364736573667367736873697370737173727373737473757376737773787379738073817382738373847385738673877388738973907391739273937394739573967397739873997400740174027403740474057406740774087409741074117412741374147415741674177418741974207421742274237424742574267427742874297430743174327433743474357436743774387439744074417442744374447445744674477448744974507451745274537454745574567457745874597460746174627463746474657466746774687469747074717472747374747475747674777478747974807481748274837484748574867487748874897490749174927493749474957496749774987499750075017502750375047505750675077508750975107511751275137514751575167517751875197520752175227523752475257526752775287529753075317532753375347535753675377538753975407541754275437544754575467547754875497550755175527553755475557556755775587559756075617562756375647565756675677568756975707571757275737574757575767577757875797580758175827583758475857586758775887589759075917592759375947595759675977598759976007601760276037604760576067607760876097610761176127613761476157616761776187619762076217622762376247625762676277628762976307631763276337634763576367637763876397640764176427643764476457646764776487649765076517652765376547655765676577658765976607661766276637664766576667667766876697670767176727673767476757676767776787679768076817682768376847685768676877688768976907691769276937694769576967697769876997700770177027703770477057706770777087709771077117712771377147715771677177718771977207721772277237724772577267727772877297730773177327733773477357736773777387739774077417742774377447745774677477748774977507751775277537754775577567757775877597760776177627763776477657766776777687769777077717772777377747775777677777778777977807781778277837784778577867787778877897790779177927793779477957796779777987799780078017802780378047805780678077808780978107811781278137814781578167817781878197820782178227823782478257826782778287829783078317832783378347835783678377838783978407841784278437844784578467847784878497850785178527853785478557856785778587859786078617862786378647865786678677868786978707871787278737874787578767877787878797880788178827883788478857886788778887889789078917892789378947895789678977898789979007901790279037904790579067907790879097910791179127913791479157916791779187919792079217922792379247925792679277928792979307931793279337934793579367937793879397940794179427943794479457946794779487949795079517952795379547955795679577958795979607961796279637964796579667967796879697970797179727973797479757976797779787979798079817982798379847985798679877988798979907991799279937994799579967997799879998000800180028003800480058006800780088009801080118012801380148015801680178018801980208021802280238024802580268027802880298030803180328033803480358036803780388039804080418042804380448045804680478048804980508051805280538054805580568057805880598060806180628063806480658066806780688069807080718072807380748075807680778078807980808081808280838084808580868087808880898090809180928093809480958096809780988099810081018102810381048105810681078108810981108111811281138114811581168117811881198120812181228123812481258126812781288129813081318132813381348135813681378138813981408141814281438144814581468147814881498150815181528153815481558156815781588159816081618162816381648165816681678168816981708171817281738174817581768177817881798180818181828183818481858186818781888189819081918192819381948195819681978198819982008201820282038204820582068207820882098210821182128213821482158216821782188219822082218222822382248225822682278228822982308231823282338234823582368237823882398240824182428243824482458246824782488249825082518252825382548255825682578258825982608261826282638264826582668267826882698270827182728273827482758276827782788279828082818282828382848285828682878288828982908291829282938294829582968297829882998300830183028303830483058306830783088309831083118312831383148315831683178318831983208321832283238324832583268327832883298330833183328333833483358336833783388339834083418342834383448345834683478348834983508351835283538354835583568357835883598360836183628363836483658366836783688369837083718372837383748375837683778378837983808381838283838384838583868387838883898390839183928393839483958396839783988399840084018402840384048405840684078408840984108411841284138414841584168417841884198420842184228423842484258426842784288429843084318432843384348435843684378438843984408441844284438444844584468447844884498450845184528453845484558456845784588459846084618462846384648465846684678468846984708471847284738474847584768477847884798480848184828483848484858486848784888489849084918492849384948495849684978498849985008501850285038504850585068507850885098510851185128513851485158516851785188519852085218522852385248525852685278528852985308531853285338534853585368537853885398540854185428543854485458546854785488549855085518552855385548555855685578558855985608561856285638564856585668567856885698570857185728573857485758576857785788579858085818582858385848585858685878588858985908591859285938594859585968597859885998600860186028603860486058606860786088609861086118612861386148615861686178618861986208621862286238624862586268627862886298630863186328633863486358636863786388639864086418642864386448645864686478648864986508651865286538654865586568657865886598660866186628663866486658666866786688669867086718672867386748675867686778678867986808681868286838684868586868687868886898690869186928693869486958696869786988699870087018702870387048705870687078708870987108711871287138714871587168717871887198720872187228723872487258726872787288729873087318732873387348735873687378738873987408741874287438744874587468747874887498750875187528753875487558756875787588759876087618762876387648765876687678768876987708771877287738774877587768777877887798780878187828783878487858786878787888789879087918792879387948795879687978798879988008801880288038804880588068807880888098810881188128813881488158816881788188819882088218822882388248825882688278828882988308831883288338834883588368837883888398840884188428843884488458846884788488849885088518852885388548855885688578858885988608861886288638864886588668867886888698870887188728873887488758876887788788879888088818882888388848885888688878888888988908891889288938894889588968897889888998900890189028903890489058906890789088909891089118912891389148915891689178918891989208921892289238924892589268927892889298930893189328933893489358936893789388939894089418942894389448945894689478948894989508951895289538954895589568957895889598960896189628963896489658966896789688969897089718972897389748975897689778978897989808981898289838984898589868987898889898990899189928993899489958996899789988999900090019002900390049005900690079008900990109011901290139014901590169017901890199020902190229023902490259026902790289029903090319032903390349035903690379038903990409041904290439044904590469047904890499050905190529053905490559056905790589059906090619062906390649065906690679068906990709071907290739074907590769077907890799080908190829083908490859086908790889089909090919092909390949095909690979098909991009101910291039104910591069107910891099110911191129113911491159116911791189119912091219122912391249125912691279128912991309131913291339134913591369137913891399140914191429143914491459146914791489149915091519152915391549155915691579158915991609161916291639164916591669167916891699170917191729173917491759176917791789179918091819182918391849185918691879188918991909191919291939194919591969197919891999200920192029203920492059206920792089209921092119212921392149215921692179218921992209221922292239224922592269227922892299230
  1. /*
  2. * Copyright (c) 2016-2018 The Linux Foundation. All rights reserved.
  3. *
  4. * Previously licensed under the ISC license by Qualcomm Atheros, Inc.
  5. *
  6. *
  7. * Permission to use, copy, modify, and/or distribute this software for
  8. * any purpose with or without fee is hereby granted, provided that the
  9. * above copyright notice and this permission notice appear in all
  10. * copies.
  11. *
  12. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  13. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  14. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  15. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  16. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  17. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  18. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  19. * PERFORMANCE OF THIS SOFTWARE.
  20. */
  21. /*
  22. * This file was originally distributed by Qualcomm Atheros, Inc.
  23. * under proprietary terms before Copyright ownership was assigned
  24. * to the Linux Foundation.
  25. */
  26. #include "wmi_unified_api.h"
  27. #include "wmi_unified_priv.h"
  28. #include "target_type.h"
  29. #if defined(WMI_NON_TLV_SUPPORT) || defined(WMI_TLV_AND_NON_TLV_SUPPORT)
  30. #include "wmi.h"
  31. #include "wmi_unified.h"
  32. /* pdev_id is used to distinguish the radio for which event
  33. * is recieved. Since non-tlv target has only one radio, setting
  34. * default pdev_id to one to keep rest of the code using WMI APIs unfiorm.
  35. */
  36. #define WMI_NON_TLV_DEFAULT_PDEV_ID WMI_HOST_PDEV_ID_0
  37. /**
  38. * send_vdev_create_cmd_non_tlv() - send VDEV create command to fw
  39. * @wmi_handle: wmi handle
  40. * @param: pointer to hold vdev create parameter
  41. * @macaddr: vdev mac address
  42. *
  43. * Return: 0 for success or error code
  44. */
  45. static QDF_STATUS send_vdev_create_cmd_non_tlv(wmi_unified_t wmi_handle,
  46. uint8_t macaddr[IEEE80211_ADDR_LEN],
  47. struct vdev_create_params *param)
  48. {
  49. wmi_vdev_create_cmd *cmd;
  50. wmi_buf_t buf;
  51. int32_t len = sizeof(wmi_vdev_create_cmd);
  52. buf = wmi_buf_alloc(wmi_handle, len);
  53. if (!buf) {
  54. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  55. return QDF_STATUS_E_NOMEM;
  56. }
  57. cmd = (wmi_vdev_create_cmd *)wmi_buf_data(buf);
  58. cmd->vdev_id = param->if_id;
  59. cmd->vdev_type = param->type;
  60. cmd->vdev_subtype = param->subtype;
  61. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->vdev_macaddr);
  62. qdf_print("%s: ID = %d Type = %d, Subtype = %d "
  63. "VAP Addr = %02x:%02x:%02x:%02x:%02x:%02x:\n",
  64. __func__, param->if_id, param->type, param->subtype,
  65. macaddr[0], macaddr[1], macaddr[2],
  66. macaddr[3], macaddr[4], macaddr[5]);
  67. return wmi_unified_cmd_send(wmi_handle, buf, len,
  68. WMI_VDEV_CREATE_CMDID);
  69. }
  70. /**
  71. * send_vdev_delete_cmd_non_tlv() - send VDEV delete command to fw
  72. * @wmi_handle: wmi handle
  73. * @if_id: vdev id
  74. *
  75. * Return: 0 for success or error code
  76. */
  77. static QDF_STATUS send_vdev_delete_cmd_non_tlv(wmi_unified_t wmi_handle,
  78. uint8_t if_id)
  79. {
  80. wmi_vdev_delete_cmd *cmd;
  81. wmi_buf_t buf;
  82. int32_t len = sizeof(wmi_vdev_delete_cmd);
  83. buf = wmi_buf_alloc(wmi_handle, len);
  84. if (!buf) {
  85. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  86. return QDF_STATUS_E_NOMEM;
  87. }
  88. cmd = (wmi_vdev_delete_cmd *)wmi_buf_data(buf);
  89. cmd->vdev_id = if_id;
  90. qdf_print("%s for vap %d (%pK)\n", __func__, if_id, wmi_handle);
  91. return wmi_unified_cmd_send(wmi_handle, buf, len,
  92. WMI_VDEV_DELETE_CMDID);
  93. }
  94. /**
  95. * send_vdev_stop_cmd_non_tlv() - send vdev stop command to fw
  96. * @wmi: wmi handle
  97. * @vdev_id: vdev id
  98. *
  99. * Return: 0 for success or erro code
  100. */
  101. static QDF_STATUS send_vdev_stop_cmd_non_tlv(wmi_unified_t wmi,
  102. uint8_t vdev_id)
  103. {
  104. wmi_vdev_stop_cmd *cmd;
  105. wmi_buf_t buf;
  106. int len = sizeof(wmi_vdev_stop_cmd);
  107. buf = wmi_buf_alloc(wmi, len);
  108. if (!buf) {
  109. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  110. return QDF_STATUS_E_NOMEM;
  111. }
  112. cmd = (wmi_vdev_stop_cmd *)wmi_buf_data(buf);
  113. cmd->vdev_id = vdev_id;
  114. return wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_STOP_CMDID);
  115. }
  116. /**
  117. * send_vdev_down_cmd_non_tlv() - send vdev down command to fw
  118. * @wmi_handle: wmi handle
  119. * @vdev_id: vdev id
  120. *
  121. * Return: 0 for success or error code
  122. */
  123. static QDF_STATUS send_vdev_down_cmd_non_tlv(wmi_unified_t wmi_handle,
  124. uint8_t vdev_id)
  125. {
  126. wmi_vdev_down_cmd *cmd;
  127. wmi_buf_t buf;
  128. int len = sizeof(wmi_vdev_down_cmd);
  129. buf = wmi_buf_alloc(wmi_handle, len);
  130. if (!buf) {
  131. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  132. return QDF_STATUS_E_NOMEM;
  133. }
  134. cmd = (wmi_vdev_down_cmd *)wmi_buf_data(buf);
  135. cmd->vdev_id = vdev_id;
  136. qdf_print("%s for vap %d (%pK)\n", __func__, vdev_id, wmi_handle);
  137. return wmi_unified_cmd_send(wmi_handle, buf, len, WMI_VDEV_DOWN_CMDID);
  138. }
  139. /**
  140. * send_vdev_start_cmd_non_tlv() - send vdev start command to fw
  141. * @wmi: wmi handle
  142. * @vdev_id: vdev id
  143. *
  144. * Return: 0 for success or error code
  145. */
  146. static QDF_STATUS send_vdev_start_cmd_non_tlv(wmi_unified_t wmi,
  147. struct vdev_start_params *param)
  148. {
  149. wmi_vdev_start_request_cmd *cmd;
  150. wmi_buf_t buf;
  151. int len = sizeof(wmi_vdev_start_request_cmd);
  152. int ret;
  153. buf = wmi_buf_alloc(wmi, len);
  154. if (!buf) {
  155. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  156. return QDF_STATUS_E_NOMEM;
  157. }
  158. cmd = (wmi_vdev_start_request_cmd *)wmi_buf_data(buf);
  159. cmd->vdev_id = param->vdev_id;
  160. cmd->chan.mhz = param->channel.mhz;
  161. WMI_SET_CHANNEL_MODE(&cmd->chan, param->channel.phy_mode);
  162. cmd->chan.band_center_freq1 = param->channel.cfreq1;
  163. cmd->chan.band_center_freq2 = param->channel.cfreq2;
  164. cmd->disable_hw_ack = param->disable_hw_ack;
  165. WMI_SET_CHANNEL_MIN_POWER(&cmd->chan, param->channel.minpower);
  166. WMI_SET_CHANNEL_MAX_POWER(&cmd->chan, param->channel.maxpower);
  167. WMI_SET_CHANNEL_REG_POWER(&cmd->chan, param->channel.maxregpower);
  168. WMI_SET_CHANNEL_ANTENNA_MAX(&cmd->chan, param->channel.antennamax);
  169. WMI_SET_CHANNEL_REG_CLASSID(&cmd->chan, param->channel.reg_class_id);
  170. if (param->channel.dfs_set)
  171. WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_DFS);
  172. if (param->channel.dfs_set_cfreq2)
  173. WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_DFS_CFREQ2);
  174. if (param->channel.set_agile)
  175. WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_AGILE_MODE);
  176. if (param->channel.half_rate)
  177. WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_HALF);
  178. if (param->channel.quarter_rate)
  179. WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_QUARTER);
  180. if (param->is_restart) {
  181. qdf_print("VDEV RESTART\n");
  182. ret = wmi_unified_cmd_send(wmi, buf, len,
  183. WMI_VDEV_RESTART_REQUEST_CMDID);
  184. } else {
  185. qdf_print("VDEV START\n");
  186. ret = wmi_unified_cmd_send(wmi, buf, len,
  187. WMI_VDEV_START_REQUEST_CMDID);
  188. }
  189. return ret;
  190. /*
  191. For VDEV_RESTART command, the sequence of code remains the same except the
  192. command sent as WMI_VDEV_RESTART_REQUEST_CMDID instead of START_REQUEST.
  193. In that case, can we introduce a flag that takes in to check if start or
  194. restart and use the same function?? Currently implemented as two separate
  195. functions in OL layer
  196. */
  197. }
  198. /**
  199. * send_vdev_set_neighbour_rx_cmd_non_tlv() - set neighbour rx param in fw
  200. * @wmi_handle: wmi handle
  201. * @macaddr: vdev mac address
  202. * @param: pointer to hold neigbour rx param
  203. * Return: 0 for success or error code
  204. */
  205. static QDF_STATUS send_vdev_set_neighbour_rx_cmd_non_tlv(wmi_unified_t wmi_handle,
  206. uint8_t macaddr[IEEE80211_ADDR_LEN],
  207. struct set_neighbour_rx_params *param)
  208. {
  209. wmi_vdev_filter_nrp_config_cmd *cmd;
  210. wmi_buf_t buf;
  211. int len = sizeof(wmi_vdev_filter_nrp_config_cmd);
  212. buf = wmi_buf_alloc(wmi_handle, len);
  213. if (!buf) {
  214. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  215. return QDF_STATUS_E_FAILURE;
  216. }
  217. cmd = (wmi_vdev_filter_nrp_config_cmd *)wmi_buf_data(buf);
  218. cmd->vdev_id = param->vdev_id;
  219. cmd->bssid_idx = param->idx;
  220. cmd->action = param->action;
  221. cmd->type = param->type;
  222. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->addr);
  223. return wmi_unified_cmd_send(wmi_handle, buf, len,
  224. WMI_VDEV_FILTER_NEIGHBOR_RX_PACKETS_CMDID);
  225. }
  226. /**
  227. * send_vdev_set_fwtest_param_cmd_non_tlv() - send fwtest param in fw
  228. * @wmi_handle: wmi handle
  229. * @param: pointer to hold fwtest param
  230. *
  231. * Return: 0 for success or error code
  232. */
  233. static QDF_STATUS send_vdev_set_fwtest_param_cmd_non_tlv(wmi_unified_t wmi_handle,
  234. struct set_fwtest_params *param)
  235. {
  236. wmi_fwtest_set_param_cmd *cmd;
  237. wmi_buf_t buf;
  238. int len = sizeof(wmi_fwtest_set_param_cmd);
  239. buf = wmi_buf_alloc(wmi_handle, len);
  240. if (!buf) {
  241. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  242. return QDF_STATUS_E_FAILURE;
  243. }
  244. cmd = (wmi_fwtest_set_param_cmd *)wmi_buf_data(buf);
  245. cmd->param_id = param->arg;
  246. cmd->param_value = param->value;
  247. return wmi_unified_cmd_send(wmi_handle, buf, len, WMI_FWTEST_CMDID);
  248. }
  249. /**
  250. * send_vdev_config_ratemask_cmd_non_tlv() - config ratemask param in fw
  251. * @wmi_handle: wmi handle
  252. * @param: pointer to hold config ratemask params
  253. *
  254. * Return: 0 for success or error code
  255. */
  256. static QDF_STATUS send_vdev_config_ratemask_cmd_non_tlv(wmi_unified_t wmi_handle,
  257. struct config_ratemask_params *param)
  258. {
  259. wmi_vdev_config_ratemask *cmd;
  260. wmi_buf_t buf;
  261. int len = sizeof(wmi_vdev_config_ratemask);
  262. buf = wmi_buf_alloc(wmi_handle, len);
  263. if (!buf) {
  264. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  265. return QDF_STATUS_E_FAILURE;
  266. }
  267. cmd = (wmi_vdev_config_ratemask *)wmi_buf_data(buf);
  268. cmd->vdev_id = param->vdev_id;
  269. cmd->type = param->type;
  270. cmd->mask_lower32 = param->lower32;
  271. cmd->mask_higher32 = param->higher32;
  272. qdf_print("Setting vdev ratemask vdev id = 0x%X, type = 0x%X,"
  273. "mask_l32 = 0x%X mask_h32 = 0x%X\n",
  274. param->vdev_id, param->type, param->lower32, param->higher32);
  275. return wmi_unified_cmd_send(wmi_handle, buf, len,
  276. WMI_VDEV_RATEMASK_CMDID);
  277. }
  278. /**
  279. * send_setup_install_key_cmd_non_tlv() - config security key in fw
  280. * @wmi_handle: wmi handle
  281. * @param: pointer to hold key params
  282. * @macaddr: vdev mac address
  283. *
  284. * Return: 0 for success or error code
  285. */
  286. static QDF_STATUS send_setup_install_key_cmd_non_tlv(wmi_unified_t wmi_handle,
  287. struct set_key_params *param)
  288. {
  289. wmi_vdev_install_key_cmd *cmd;
  290. wmi_buf_t buf;
  291. /* length depends on ieee key length */
  292. int len = sizeof(wmi_vdev_install_key_cmd) + param->key_len;
  293. uint8_t wmi_cipher_type;
  294. int i;
  295. wmi_cipher_type = param->key_cipher;
  296. /* ieee_key length does not have mic keylen */
  297. if ((wmi_cipher_type == WMI_CIPHER_TKIP) ||
  298. (wmi_cipher_type == WMI_CIPHER_WAPI))
  299. len = len + IEEE80211_MICBUF_SIZE;
  300. len = roundup(len, sizeof(u_int32_t));
  301. buf = wmi_buf_alloc(wmi_handle, len);
  302. if (!buf) {
  303. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  304. return QDF_STATUS_E_NOMEM;
  305. }
  306. cmd = (wmi_vdev_install_key_cmd *)wmi_buf_data(buf);
  307. cmd->vdev_id = param->vdev_id;
  308. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_mac, &cmd->peer_macaddr);
  309. cmd->key_ix = param->key_idx;
  310. /* If this WEP key is the default xmit key, TX_USAGE flag is enabled */
  311. cmd->key_flags = param->key_flags;
  312. cmd->key_len = param->key_len;
  313. cmd->key_cipher = wmi_cipher_type;
  314. cmd->key_txmic_len = param->key_txmic_len;
  315. cmd->key_rxmic_len = param->key_rxmic_len;
  316. /* target will use the same rsc counter for
  317. various tids from from ieee key rsc */
  318. if ((wmi_cipher_type == WMI_CIPHER_TKIP) ||
  319. (wmi_cipher_type == WMI_CIPHER_AES_OCB)
  320. || (wmi_cipher_type == WMI_CIPHER_AES_CCM)) {
  321. qdf_mem_copy(&cmd->key_rsc_counter, &param->key_rsc_counter[0],
  322. sizeof(param->key_rsc_counter[0]));
  323. qdf_mem_copy(&cmd->key_tsc_counter, &param->key_tsc_counter,
  324. sizeof(param->key_tsc_counter));
  325. }
  326. #ifdef ATH_SUPPORT_WAPI
  327. if (wmi_cipher_type == WMI_CIPHER_WAPI) {
  328. int j;
  329. /* For WAPI, TSC and RSC has to be initialized with predefined
  330. * value.Here, Indicating TSC, RSC to target as part of set
  331. * key message
  332. */
  333. /* since wk_recviv and wk_txiv initialized in reverse order,
  334. * Before indicating the Target FW, Reversing TSC and RSC
  335. */
  336. for (i = (WPI_IV_LEN-1), j = 0; i >= 0; i--, j++) {
  337. cmd->wpi_key_rsc_counter[j] =
  338. param->rx_iv[i];
  339. cmd->wpi_key_tsc_counter[j] =
  340. param->tx_iv[i];
  341. }
  342. qdf_print("RSC:");
  343. for (i = 0; i < 16; i++)
  344. qdf_print("0x%x ",
  345. *(((uint8_t *)&cmd->wpi_key_rsc_counter)+i));
  346. qdf_print("\n");
  347. qdf_print("TSC:");
  348. for (i = 0; i < 16; i++)
  349. qdf_print("0x%x ",
  350. *(((uint8_t *)&cmd->wpi_key_tsc_counter)+i));
  351. qdf_print("\n");
  352. }
  353. #endif
  354. /* for big endian host, copy engine byte_swap is enabled
  355. * But the key data content is in network byte order
  356. * Need to byte swap the key data content - so when copy engine
  357. * does byte_swap - target gets key_data content in the correct order
  358. */
  359. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(cmd->key_data, param->key_data,
  360. cmd->key_len);
  361. return wmi_unified_cmd_send(wmi_handle, buf, len,
  362. WMI_VDEV_INSTALL_KEY_CMDID);
  363. }
  364. /**
  365. * send_peer_flush_tids_cmd_non_tlv() - flush peer tids packets in fw
  366. * @wmi_handle: wmi handle
  367. * @peer_addr: peer mac address
  368. * @param: pointer to hold peer flush tid parameter
  369. *
  370. * Return: 0 for sucess or error code
  371. */
  372. static QDF_STATUS send_peer_flush_tids_cmd_non_tlv(wmi_unified_t wmi_handle,
  373. uint8_t peer_addr[IEEE80211_ADDR_LEN],
  374. struct peer_flush_params *param)
  375. {
  376. wmi_peer_flush_tids_cmd *cmd;
  377. wmi_buf_t buf;
  378. int len = sizeof(wmi_peer_flush_tids_cmd);
  379. buf = wmi_buf_alloc(wmi_handle, len);
  380. if (!buf) {
  381. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  382. return QDF_STATUS_E_NOMEM;
  383. }
  384. cmd = (wmi_peer_flush_tids_cmd *)wmi_buf_data(buf);
  385. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  386. cmd->peer_tid_bitmap = param->peer_tid_bitmap;
  387. cmd->vdev_id = param->vdev_id;
  388. return wmi_unified_cmd_send(wmi_handle, buf, len,
  389. WMI_PEER_FLUSH_TIDS_CMDID);
  390. }
  391. /**
  392. * send_peer_delete_cmd_non_tlv() - send PEER delete command to fw
  393. * @wmi_handle: wmi handle
  394. * @peer_addr: peer mac addr
  395. * @vdev_id: vdev id
  396. *
  397. * Return: 0 for success or error code
  398. */
  399. static QDF_STATUS send_peer_delete_cmd_non_tlv(wmi_unified_t wmi_handle,
  400. uint8_t
  401. peer_addr[IEEE80211_ADDR_LEN],
  402. uint8_t vdev_id)
  403. {
  404. wmi_peer_delete_cmd *cmd;
  405. wmi_buf_t buf;
  406. int len = sizeof(wmi_peer_delete_cmd);
  407. buf = wmi_buf_alloc(wmi_handle, len);
  408. if (!buf) {
  409. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  410. return QDF_STATUS_E_NOMEM;
  411. }
  412. cmd = (wmi_peer_delete_cmd *)wmi_buf_data(buf);
  413. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  414. cmd->vdev_id = vdev_id;
  415. return wmi_unified_cmd_send(wmi_handle, buf, len,
  416. WMI_PEER_DELETE_CMDID);
  417. }
  418. /**
  419. * convert_host_peer_id_to_target_id_non_tlv - convert host peer param_id
  420. * to target id.
  421. * @targ_paramid: Target parameter id to hold the result.
  422. * @peer_param_id: host param id.
  423. *
  424. * Return: QDF_STATUS_SUCCESS for success
  425. * QDF_STATUS_E_NOSUPPORT when the param_id in not supported in tareget
  426. */
  427. static QDF_STATUS convert_host_peer_id_to_target_id_non_tlv(
  428. uint32_t *targ_paramid,
  429. uint32_t peer_param_id)
  430. {
  431. switch (peer_param_id) {
  432. case WMI_HOST_PEER_MIMO_PS_STATE:
  433. *targ_paramid = WMI_PEER_MIMO_PS_STATE;
  434. break;
  435. case WMI_HOST_PEER_AMPDU:
  436. *targ_paramid = WMI_PEER_AMPDU;
  437. break;
  438. case WMI_HOST_PEER_AUTHORIZE:
  439. *targ_paramid = WMI_PEER_AUTHORIZE;
  440. break;
  441. case WMI_HOST_PEER_CHWIDTH:
  442. *targ_paramid = WMI_PEER_CHWIDTH;
  443. break;
  444. case WMI_HOST_PEER_NSS:
  445. *targ_paramid = WMI_PEER_NSS;
  446. break;
  447. case WMI_HOST_PEER_USE_4ADDR:
  448. *targ_paramid = WMI_PEER_USE_4ADDR;
  449. break;
  450. case WMI_HOST_PEER_USE_FIXED_PWR:
  451. *targ_paramid = WMI_PEER_USE_FIXED_PWR;
  452. break;
  453. case WMI_HOST_PEER_PARAM_FIXED_RATE:
  454. *targ_paramid = WMI_PEER_PARAM_FIXED_RATE;
  455. break;
  456. case WMI_HOST_PEER_SET_MU_WHITELIST:
  457. *targ_paramid = WMI_PEER_SET_MU_WHITELIST;
  458. break;
  459. case WMI_HOST_PEER_EXT_STATS_ENABLE:
  460. *targ_paramid = WMI_PEER_EXT_STATS_ENABLE;
  461. break;
  462. case WMI_HOST_PEER_NSS_VHT160:
  463. *targ_paramid = WMI_PEER_NSS_VHT160;
  464. break;
  465. case WMI_HOST_PEER_NSS_VHT80_80:
  466. *targ_paramid = WMI_PEER_NSS_VHT80_80;
  467. break;
  468. default:
  469. return QDF_STATUS_E_NOSUPPORT;
  470. }
  471. return QDF_STATUS_SUCCESS;
  472. }
  473. /**
  474. * send_peer_param_cmd_non_tlv() - set peer parameter in fw
  475. * @wmi_handle: wmi handle
  476. * @peer_addr: peer mac address
  477. * @param : pointer to hold peer set parameter
  478. *
  479. * Return: 0 for success or error code
  480. */
  481. static QDF_STATUS send_peer_param_cmd_non_tlv(wmi_unified_t wmi_handle,
  482. uint8_t peer_addr[IEEE80211_ADDR_LEN],
  483. struct peer_set_params *param)
  484. {
  485. wmi_peer_set_param_cmd *cmd;
  486. wmi_buf_t buf;
  487. int len = sizeof(wmi_peer_set_param_cmd);
  488. uint32_t param_id;
  489. if (convert_host_peer_id_to_target_id_non_tlv(&param_id,
  490. param->param_id) != QDF_STATUS_SUCCESS)
  491. return QDF_STATUS_E_NOSUPPORT;
  492. buf = wmi_buf_alloc(wmi_handle, len);
  493. if (!buf) {
  494. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  495. return QDF_STATUS_E_NOMEM;
  496. }
  497. cmd = (wmi_peer_set_param_cmd *)wmi_buf_data(buf);
  498. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  499. cmd->param_id = param_id;
  500. cmd->param_value = param->param_value;
  501. cmd->vdev_id = param->vdev_id;
  502. return wmi_unified_cmd_send(wmi_handle, buf, len,
  503. WMI_PEER_SET_PARAM_CMDID);
  504. }
  505. /**
  506. * send_vdev_up_cmd_non_tlv() - send vdev up command in fw
  507. * @wmi_handle: wmi handle
  508. * @bssid: bssid
  509. * @vdev_up_params: pointer to hold vdev up parameter
  510. *
  511. * Return: 0 for success or error code
  512. */
  513. static QDF_STATUS send_vdev_up_cmd_non_tlv(wmi_unified_t wmi_handle,
  514. uint8_t bssid[IEEE80211_ADDR_LEN],
  515. struct vdev_up_params *param)
  516. {
  517. wmi_vdev_up_cmd *cmd;
  518. wmi_buf_t buf;
  519. int len = sizeof(wmi_vdev_up_cmd);
  520. buf = wmi_buf_alloc(wmi_handle, len);
  521. if (!buf) {
  522. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  523. return QDF_STATUS_E_NOMEM;
  524. }
  525. cmd = (wmi_vdev_up_cmd *)wmi_buf_data(buf);
  526. cmd->vdev_id = param->vdev_id;
  527. cmd->vdev_assoc_id = param->assoc_id;
  528. WMI_CHAR_ARRAY_TO_MAC_ADDR(bssid, &cmd->vdev_bssid);
  529. qdf_print("%s for vap %d (%pK)\n", __func__, param->vdev_id, wmi_handle);
  530. return wmi_unified_cmd_send(wmi_handle, buf, len, WMI_VDEV_UP_CMDID);
  531. }
  532. /**
  533. * send_peer_create_cmd_non_tlv() - send peer create command to fw
  534. * @wmi_handle: wmi handle
  535. * @param: pointer to hold peer create parameter
  536. *
  537. * Return: 0 for success or error code
  538. */
  539. static QDF_STATUS send_peer_create_cmd_non_tlv(wmi_unified_t wmi_handle,
  540. struct peer_create_params *param)
  541. {
  542. wmi_peer_create_cmd *cmd;
  543. wmi_buf_t buf;
  544. int len = sizeof(wmi_peer_create_cmd);
  545. buf = wmi_buf_alloc(wmi_handle, len);
  546. if (!buf) {
  547. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  548. return QDF_STATUS_E_NOMEM;
  549. }
  550. cmd = (wmi_peer_create_cmd *)wmi_buf_data(buf);
  551. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr);
  552. cmd->vdev_id = param->vdev_id;
  553. return wmi_unified_cmd_send(wmi_handle, buf, len,
  554. WMI_PEER_CREATE_CMDID);
  555. }
  556. /**
  557. * send_peer_add_wds_entry_cmd_non_tlv() - send peer add command to fw
  558. * @wmi_handle: wmi handle
  559. * @param: pointer holding peer details
  560. *
  561. * Return: 0 for success or error code
  562. */
  563. static QDF_STATUS send_peer_add_wds_entry_cmd_non_tlv(wmi_unified_t wmi_handle,
  564. struct peer_add_wds_entry_params *param)
  565. {
  566. wmi_peer_add_wds_entry_cmd *cmd;
  567. wmi_buf_t buf;
  568. int len = sizeof(wmi_peer_add_wds_entry_cmd);
  569. buf = wmi_buf_alloc(wmi_handle, len);
  570. if (!buf) {
  571. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  572. return QDF_STATUS_E_FAILURE;
  573. }
  574. cmd = (wmi_peer_add_wds_entry_cmd *)wmi_buf_data(buf);
  575. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->dest_addr, &cmd->wds_macaddr);
  576. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr);
  577. cmd->flags = param->flags;
  578. return wmi_unified_cmd_send(wmi_handle, buf, len,
  579. WMI_PEER_ADD_WDS_ENTRY_CMDID);
  580. }
  581. /**
  582. * send_peer_del_wds_entry_cmd_non_tlv() - send peer delete command to fw
  583. * @wmi_handle: wmi handle
  584. * @param: pointer holding peer details
  585. *
  586. * Return: 0 for success or error code
  587. */
  588. static QDF_STATUS send_peer_del_wds_entry_cmd_non_tlv(wmi_unified_t wmi_handle,
  589. struct peer_del_wds_entry_params *param)
  590. {
  591. wmi_peer_remove_wds_entry_cmd *cmd;
  592. wmi_buf_t buf;
  593. int len = sizeof(wmi_peer_remove_wds_entry_cmd);
  594. buf = wmi_buf_alloc(wmi_handle, len);
  595. if (!buf) {
  596. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  597. return QDF_STATUS_E_NOMEM;
  598. }
  599. cmd = (wmi_peer_remove_wds_entry_cmd *)wmi_buf_data(buf);
  600. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->dest_addr, &cmd->wds_macaddr);
  601. return wmi_unified_cmd_send(wmi_handle, buf, len,
  602. WMI_PEER_REMOVE_WDS_ENTRY_CMDID);
  603. }
  604. /**
  605. * send_set_bridge_mac_addr_cmd_non_tlv() - send set bridge MAC addr command to fw
  606. * @wmi_handle: wmi handle
  607. * @param: pointer holding bridge addr details
  608. *
  609. * Return: 0 for success or error code
  610. */
  611. QDF_STATUS send_set_bridge_mac_addr_cmd_non_tlv(wmi_unified_t wmi_handle,
  612. struct set_bridge_mac_addr_params *param)
  613. {
  614. wmi_peer_add_wds_entry_cmd *cmd;
  615. wmi_buf_t buf;
  616. uint8_t null_macaddr[IEEE80211_ADDR_LEN];
  617. int len = sizeof(wmi_peer_add_wds_entry_cmd);
  618. buf = wmi_buf_alloc(wmi_handle, len);
  619. if (!buf) {
  620. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  621. return QDF_STATUS_E_NOMEM;
  622. }
  623. qdf_mem_zero(null_macaddr, IEEE80211_ADDR_LEN);
  624. cmd = (wmi_peer_add_wds_entry_cmd *)wmi_buf_data(buf);
  625. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->bridge_addr, &cmd->wds_macaddr);
  626. WMI_CHAR_ARRAY_TO_MAC_ADDR(null_macaddr, &cmd->peer_macaddr);
  627. cmd->flags = 0xffffffff;
  628. return wmi_unified_cmd_send(wmi_handle, buf, len,
  629. WMI_PEER_ADD_WDS_ENTRY_CMDID);
  630. }
  631. /**
  632. * send_peer_update_wds_entry_cmd_non_tlv() - send peer update command to fw
  633. * @wmi_handle: wmi handle
  634. * @param: pointer holding peer details
  635. *
  636. * Return: 0 for success or error code
  637. */
  638. static QDF_STATUS send_peer_update_wds_entry_cmd_non_tlv(wmi_unified_t wmi_handle,
  639. struct peer_update_wds_entry_params *param)
  640. {
  641. wmi_peer_update_wds_entry_cmd *cmd;
  642. wmi_buf_t buf;
  643. int len = sizeof(wmi_peer_update_wds_entry_cmd);
  644. buf = wmi_buf_alloc(wmi_handle, len);
  645. if (!buf) {
  646. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  647. return QDF_STATUS_E_NOMEM;
  648. }
  649. /* wmi_buf_alloc returns zeroed command buffer */
  650. cmd = (wmi_peer_update_wds_entry_cmd *)wmi_buf_data(buf);
  651. cmd->flags = (param->flags) ? WMI_WDS_FLAG_STATIC : 0;
  652. if (param->wds_macaddr)
  653. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->wds_macaddr,
  654. &cmd->wds_macaddr);
  655. if (param->peer_macaddr)
  656. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_macaddr,
  657. &cmd->peer_macaddr);
  658. return wmi_unified_cmd_send(wmi_handle, buf, len,
  659. WMI_PEER_UPDATE_WDS_ENTRY_CMDID);
  660. }
  661. #ifdef WLAN_SUPPORT_GREEN_AP
  662. /**
  663. * send_green_ap_ps_cmd_non_tlv() - enable green ap powersave command
  664. * @wmi_handle: wmi handle
  665. * @value: value
  666. * @pdev_id: pdev id to have radio context
  667. *
  668. * Return: 0 for success or error code
  669. */
  670. static QDF_STATUS send_green_ap_ps_cmd_non_tlv(wmi_unified_t wmi_handle,
  671. uint32_t value, uint8_t pdev_id)
  672. {
  673. wmi_pdev_green_ap_ps_enable_cmd *cmd;
  674. wmi_buf_t buf;
  675. int len = 0;
  676. int ret;
  677. len = sizeof(wmi_pdev_green_ap_ps_enable_cmd);
  678. buf = wmi_buf_alloc(wmi_handle, len);
  679. if (!buf) {
  680. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  681. return QDF_STATUS_E_NOMEM;
  682. }
  683. cmd = (wmi_pdev_green_ap_ps_enable_cmd *)wmi_buf_data(buf);
  684. cmd->enable = value;
  685. ret = wmi_unified_cmd_send(wmi_handle,
  686. buf,
  687. len,
  688. WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID);
  689. #ifdef OL_GREEN_AP_DEBUG_CONFIG_INTERACTIONS
  690. qdf_print("%s: Sent WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID.\n"
  691. "enable=%u status=%d\n",
  692. __func__,
  693. value,
  694. ret);
  695. #endif /* OL_GREEN_AP_DEBUG_CONFIG_INTERACTIONS */
  696. return ret;
  697. }
  698. #endif
  699. /**
  700. * send_pdev_utf_cmd_non_tlv() - send utf command to fw
  701. * @wmi_handle: wmi handle
  702. * @param: pointer to pdev_utf_params
  703. * @mac_id: mac id to have radio context
  704. *
  705. * Return: 0 for success or error code
  706. */
  707. static QDF_STATUS
  708. send_pdev_utf_cmd_non_tlv(wmi_unified_t wmi_handle,
  709. struct pdev_utf_params *param,
  710. uint8_t mac_id)
  711. {
  712. wmi_buf_t buf;
  713. u_int8_t *cmd;
  714. int ret = 0;
  715. /* We can initialize the value and increment.*/
  716. static uint8_t msgref = 1;
  717. uint8_t segNumber = 0, segInfo, numSegments;
  718. uint16_t chunkLen, totalBytes;
  719. uint8_t *bufpos;
  720. struct seg_hdr_info segHdrInfo;
  721. bufpos = param->utf_payload;
  722. totalBytes = param->len;
  723. numSegments = (uint8_t) (totalBytes / MAX_WMI_UTF_LEN);
  724. if (param->len - (numSegments * MAX_WMI_UTF_LEN))
  725. numSegments++;
  726. while (param->len) {
  727. if (param->len > MAX_WMI_UTF_LEN)
  728. chunkLen = MAX_WMI_UTF_LEN; /* MAX messsage.. */
  729. else
  730. chunkLen = param->len;
  731. buf = wmi_buf_alloc(wmi_handle,
  732. (chunkLen + sizeof(segHdrInfo)));
  733. if (!buf) {
  734. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  735. return QDF_STATUS_E_FAILURE;
  736. }
  737. cmd = (uint8_t *)wmi_buf_data(buf);
  738. segHdrInfo.len = totalBytes;
  739. segHdrInfo.msgref = msgref;
  740. segInfo = ((numSegments << 4) & 0xF0) | (segNumber & 0xF);
  741. segHdrInfo.segmentInfo = segInfo;
  742. segNumber++;
  743. qdf_mem_copy(cmd, &segHdrInfo, sizeof(segHdrInfo));
  744. #ifdef BIG_ENDIAN_HOST
  745. if (param->is_ar900b) {
  746. /* for big endian host, copy engine byte_swap is
  747. * enable But this ART command frame buffer content is
  748. * in network byte order.
  749. * Need to byte swap the mgmt frame buffer content - so
  750. * when copy engine does byte_swap - target gets buffer
  751. * content in the correct order
  752. */
  753. int i;
  754. uint32_t *destp, *srcp;
  755. destp = (uint32_t *)(&(cmd[sizeof(segHdrInfo)]));
  756. srcp = (uint32_t *)bufpos;
  757. for (i = 0; i < (roundup(chunkLen,
  758. sizeof(uint32_t)) / 4); i++) {
  759. *destp = qdf_le32_to_cpu(*srcp);
  760. destp++; srcp++;
  761. }
  762. } else {
  763. qdf_mem_copy(&cmd[sizeof(segHdrInfo)],
  764. bufpos, chunkLen);
  765. }
  766. #else
  767. qdf_mem_copy(&cmd[sizeof(segHdrInfo)], bufpos, chunkLen);
  768. #endif
  769. ret = wmi_unified_cmd_send(wmi_handle, buf,
  770. (chunkLen + sizeof(segHdrInfo)),
  771. WMI_PDEV_UTF_CMDID);
  772. if (ret != 0)
  773. break;
  774. param->len -= chunkLen;
  775. bufpos += chunkLen;
  776. }
  777. msgref++;
  778. return ret;
  779. }
  780. /**
  781. * send_pdev_qvit_cmd_non_tlv() - send qvit command to fw
  782. * @wmi_handle: wmi handle
  783. * @param: pointer to pdev_qvit_params
  784. *
  785. * Return: 0 for success or error code
  786. */
  787. static QDF_STATUS
  788. send_pdev_qvit_cmd_non_tlv(wmi_unified_t wmi_handle,
  789. struct pdev_qvit_params *param)
  790. {
  791. wmi_buf_t buf;
  792. u_int8_t *cmd;
  793. int ret = 0;
  794. /* We can initialize the value and increment.*/
  795. static u_int8_t msgref = 1;
  796. u_int8_t segNumber = 0, segInfo, numSegments;
  797. u_int16_t chunkLen, totalBytes;
  798. u_int8_t *bufpos;
  799. QVIT_SEG_HDR_INFO_STRUCT segHdrInfo;
  800. /*
  801. #ifdef QVIT_DEBUG
  802. qdf_print(KERN_INFO "QVIT: %s: called\n", __func__);
  803. #endif
  804. */
  805. bufpos = param->utf_payload;
  806. totalBytes = param->len;
  807. numSegments = (totalBytes / MAX_WMI_QVIT_LEN);
  808. if (param->len - (numSegments * MAX_WMI_QVIT_LEN))
  809. numSegments++;
  810. while (param->len) {
  811. if (param->len > MAX_WMI_QVIT_LEN)
  812. chunkLen = MAX_WMI_QVIT_LEN; /* MAX messsage.. */
  813. else
  814. chunkLen = param->len;
  815. buf = wmi_buf_alloc(wmi_handle,
  816. (chunkLen + sizeof(segHdrInfo)));
  817. if (!buf) {
  818. qdf_print(KERN_ERR "QVIT: %s: wmi_buf_alloc failed\n",
  819. __func__);
  820. return QDF_STATUS_E_FAILURE;
  821. }
  822. cmd = (u_int8_t *)wmi_buf_data(buf);
  823. segHdrInfo.len = totalBytes;
  824. segHdrInfo.msgref = msgref;
  825. segInfo = ((numSegments << 4) & 0xF0) | (segNumber & 0xF);
  826. segHdrInfo.segmentInfo = segInfo;
  827. segNumber++;
  828. qdf_mem_copy(cmd, &segHdrInfo, sizeof(segHdrInfo));
  829. qdf_mem_copy(&cmd[sizeof(segHdrInfo)], bufpos, chunkLen);
  830. ret = wmi_unified_cmd_send(wmi_handle, buf,
  831. (chunkLen + sizeof(segHdrInfo)),
  832. WMI_PDEV_QVIT_CMDID);
  833. if (ret != 0) {
  834. qdf_print
  835. (KERN_ERR "QVIT: %s: wmi_unified_cmd_send failed\n",
  836. __func__);
  837. break;
  838. }
  839. param->len -= chunkLen;
  840. bufpos += chunkLen;
  841. }
  842. msgref++;
  843. return ret;
  844. }
  845. /**
  846. * send_pdev_param_cmd_non_tlv() - set pdev parameters
  847. * @wmi_handle: wmi handle
  848. * @param: pointer to pdev parameter
  849. * @mac_id: radio context
  850. *
  851. * Return: 0 on success, errno on failure
  852. */
  853. static QDF_STATUS
  854. send_pdev_param_cmd_non_tlv(wmi_unified_t wmi_handle,
  855. struct pdev_params *param, uint8_t mac_id)
  856. {
  857. wmi_pdev_set_param_cmd *cmd;
  858. wmi_buf_t buf;
  859. int len = sizeof(wmi_pdev_set_param_cmd);
  860. if ((param->param_id < wmi_pdev_param_max) &&
  861. (wmi_handle->pdev_param[param->param_id]
  862. != WMI_UNAVAILABLE_PARAM)) {
  863. buf = wmi_buf_alloc(wmi_handle, len);
  864. if (!buf) {
  865. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  866. return QDF_STATUS_E_FAILURE;
  867. }
  868. cmd = (wmi_pdev_set_param_cmd *)wmi_buf_data(buf);
  869. cmd->param_id = wmi_handle->pdev_param[param->param_id];
  870. cmd->param_value = param->param_value;
  871. return wmi_unified_cmd_send(wmi_handle, buf, len,
  872. WMI_PDEV_SET_PARAM_CMDID);
  873. }
  874. return QDF_STATUS_E_FAILURE;
  875. }
  876. /**
  877. * send_suspend_cmd_non_tlv() - WMI suspend function
  878. *
  879. * @param wmi_handle : handle to WMI.
  880. * @param param : pointer to hold suspend parameter
  881. * @mac_id: radio context
  882. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  883. */
  884. static QDF_STATUS send_suspend_cmd_non_tlv(wmi_unified_t wmi_handle,
  885. struct suspend_params *param,
  886. uint8_t mac_id)
  887. {
  888. wmi_pdev_suspend_cmd *cmd;
  889. wmi_buf_t wmibuf;
  890. uint32_t len = sizeof(wmi_pdev_suspend_cmd);
  891. /*send the comand to Target to ignore the
  892. * PCIE reset so as to ensure that Host and target
  893. * states are in sync*/
  894. wmibuf = wmi_buf_alloc(wmi_handle, len);
  895. if (wmibuf == NULL)
  896. return QDF_STATUS_E_FAILURE;
  897. cmd = (wmi_pdev_suspend_cmd *)wmi_buf_data(wmibuf);
  898. if (param->disable_target_intr)
  899. cmd->suspend_opt = WMI_PDEV_SUSPEND_AND_DISABLE_INTR;
  900. else
  901. cmd->suspend_opt = WMI_PDEV_SUSPEND;
  902. /*
  903. * Flush pending packets in HTC endpoint queue
  904. *
  905. */
  906. wmi_flush_endpoint(wmi_handle);
  907. return wmi_unified_cmd_send(wmi_handle, wmibuf, len,
  908. WMI_PDEV_SUSPEND_CMDID);
  909. }
  910. /**
  911. * send_resume_cmd_non_tlv() - WMI resume function
  912. *
  913. * @param wmi_handle : handle to WMI.
  914. * @mac_id: radio context
  915. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  916. */
  917. static QDF_STATUS send_resume_cmd_non_tlv(wmi_unified_t wmi_handle,
  918. uint8_t mac_id)
  919. {
  920. wmi_buf_t wmibuf;
  921. wmibuf = wmi_buf_alloc(wmi_handle, 0);
  922. if (wmibuf == NULL)
  923. return QDF_STATUS_E_NOMEM;
  924. return wmi_unified_cmd_send(wmi_handle, wmibuf, 0,
  925. WMI_PDEV_RESUME_CMDID);
  926. }
  927. /**
  928. * send_wow_enable_cmd_non_tlv() - WMI wow enable function
  929. *
  930. * @param wmi_handle : handle to WMI.
  931. * @param param : pointer to hold wow enable parameter
  932. * @mac_id: radio context
  933. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  934. */
  935. static QDF_STATUS send_wow_enable_cmd_non_tlv(wmi_unified_t wmi_handle,
  936. struct wow_cmd_params *param, uint8_t mac_id)
  937. {
  938. QDF_STATUS res;
  939. wmi_buf_t buf = NULL;
  940. buf = wmi_buf_alloc(wmi_handle, 4);
  941. if (!buf) {
  942. qdf_print("buf alloc failed\n");
  943. return QDF_STATUS_E_NOMEM;
  944. }
  945. res = wmi_unified_cmd_send(wmi_handle, buf, 4, WMI_WOW_ENABLE_CMDID);
  946. qdf_print("send_wow_enable result: %d\n", res);
  947. return (res == QDF_STATUS_SUCCESS) ?
  948. QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
  949. }
  950. /**
  951. * send_wow_wakeup_cmd_non_tlv() - WMI wow wakeup function
  952. *
  953. * @param wmi_handle : handle to WMI.
  954. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  955. */
  956. static QDF_STATUS send_wow_wakeup_cmd_non_tlv(wmi_unified_t wmi_handle)
  957. {
  958. QDF_STATUS res;
  959. wmi_buf_t buf = NULL;
  960. buf = wmi_buf_alloc(wmi_handle, 4);
  961. if (!buf) {
  962. qdf_print("buf alloc failed\n");
  963. return QDF_STATUS_E_NOMEM;
  964. }
  965. res = wmi_unified_cmd_send(wmi_handle, buf, 4,
  966. WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID);
  967. qdf_print("ol_wow_wakeup result: %d\n", res);
  968. return (res == QDF_STATUS_SUCCESS) ?
  969. QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
  970. }
  971. /**
  972. * send_wow_add_wakeup_event_cmd_non_tlv() - WMI wow add wakeup event function
  973. *
  974. * @param wmi_handle : handle to WMI.
  975. * @param param : pointer to hold wow wakeup event parameter
  976. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  977. */
  978. static QDF_STATUS send_wow_add_wakeup_event_cmd_non_tlv(wmi_unified_t wmi_handle,
  979. struct wow_add_wakeup_params *param)
  980. {
  981. QDF_STATUS res;
  982. WMI_WOW_ADD_DEL_EVT_CMD *cmd;
  983. wmi_buf_t buf = NULL;
  984. int len = sizeof(WMI_WOW_ADD_DEL_EVT_CMD);
  985. buf = wmi_buf_alloc(wmi_handle, len);
  986. if (!buf) {
  987. qdf_print("buf alloc failed\n");
  988. return QDF_STATUS_E_NOMEM;
  989. }
  990. cmd = (WMI_WOW_ADD_DEL_EVT_CMD *)wmi_buf_data(buf);
  991. cmd->is_add = 1;
  992. cmd->event_bitmap = param->type;
  993. res = wmi_unified_cmd_send(wmi_handle, buf, len,
  994. WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID);
  995. return (res == QDF_STATUS_SUCCESS) ?
  996. QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
  997. }
  998. /**
  999. * send_wow_add_wakeup_pattern_cmd_non_tlv() - WMI wow add wakeup pattern function
  1000. *
  1001. * @param wmi_handle : handle to WMI.
  1002. * @param param : pointer to hold wow wakeup pattern parameter
  1003. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1004. */
  1005. static QDF_STATUS send_wow_add_wakeup_pattern_cmd_non_tlv(wmi_unified_t wmi_handle,
  1006. struct wow_add_wakeup_pattern_params *param)
  1007. {
  1008. WOW_BITMAP_PATTERN_T bitmap_pattern;
  1009. uint32_t j;
  1010. /*
  1011. struct ol_wow_info *wowInfo;
  1012. OL_WOW_PATTERN *pattern;
  1013. struct ol_ath_softc_net80211 *scn = OL_ATH_SOFTC_NET80211(ic);
  1014. */
  1015. QDF_STATUS res;
  1016. WMI_WOW_ADD_PATTERN_CMD *cmd;
  1017. wmi_buf_t buf = NULL;
  1018. int len = sizeof(WMI_WOW_ADD_PATTERN_CMD);
  1019. buf = wmi_buf_alloc(wmi_handle, len);
  1020. if (!buf) {
  1021. qdf_print("buf alloc failed\n");
  1022. return QDF_STATUS_E_NOMEM;
  1023. }
  1024. cmd = (WMI_WOW_ADD_PATTERN_CMD *)wmi_buf_data(buf);
  1025. cmd->pattern_id = param->pattern_id;
  1026. cmd->pattern_type = WOW_BITMAP_PATTERN;
  1027. for (j = 0; j < WOW_DEFAULT_BITMAP_PATTERN_SIZE; j++)
  1028. bitmap_pattern.patternbuf[j] = param->pattern_bytes[j];
  1029. for (j = 0; j < WOW_DEFAULT_BITMASK_SIZE; j++)
  1030. bitmap_pattern.bitmaskbuf[j] = param->mask_bytes[j];
  1031. bitmap_pattern.pattern_offset = 0;
  1032. cmd->pattern_info.bitmap = bitmap_pattern;
  1033. res = wmi_unified_cmd_send(wmi_handle, buf, len,
  1034. WMI_WOW_ADD_WAKE_PATTERN_CMDID);
  1035. return (res == QDF_STATUS_SUCCESS) ?
  1036. QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
  1037. }
  1038. /**
  1039. * send_wow_remove_wakeup_pattern_cmd_non_tlv() - WMI wow remove wakeup
  1040. * pattern function
  1041. *
  1042. * @param wmi_handle : handle to WMI.
  1043. * @param param : pointer to hold wow wakeup pattern parameter
  1044. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1045. */
  1046. static QDF_STATUS send_wow_remove_wakeup_pattern_cmd_non_tlv(wmi_unified_t wmi_handle,
  1047. struct wow_remove_wakeup_pattern_params *param)
  1048. {
  1049. WMI_WOW_DEL_PATTERN_CMD *cmd;
  1050. QDF_STATUS res;
  1051. wmi_buf_t buf = NULL;
  1052. int len = sizeof(WMI_WOW_DEL_PATTERN_CMD);
  1053. buf = wmi_buf_alloc(wmi_handle, len);
  1054. if (!buf) {
  1055. qdf_print("buf alloc failed\n");
  1056. return QDF_STATUS_E_NOMEM;
  1057. }
  1058. cmd = (WMI_WOW_DEL_PATTERN_CMD *)wmi_buf_data(buf);
  1059. cmd->pattern_id = param->pattern_id;
  1060. cmd->pattern_type = WOW_BITMAP_PATTERN;
  1061. res = wmi_unified_cmd_send(wmi_handle, buf, len,
  1062. WMI_WOW_DEL_WAKE_PATTERN_CMDID);
  1063. return (res == QDF_STATUS_SUCCESS) ?
  1064. QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
  1065. }
  1066. /**
  1067. * send_set_ap_ps_param_cmd_non_tlv() - set ap powersave parameters
  1068. * @param wmi_handle : handle to WMI.
  1069. * @peer_addr: peer mac address
  1070. * @param: pointer to ap_ps parameter structure
  1071. *
  1072. * Return: 0 for success or error code
  1073. */
  1074. static QDF_STATUS send_set_ap_ps_param_cmd_non_tlv(wmi_unified_t wmi_handle,
  1075. uint8_t *peer_addr,
  1076. struct ap_ps_params *param)
  1077. {
  1078. wmi_ap_ps_peer_cmd *cmd;
  1079. wmi_buf_t buf;
  1080. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  1081. if (!buf) {
  1082. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  1083. return QDF_STATUS_E_FAILURE;
  1084. }
  1085. cmd = (wmi_ap_ps_peer_cmd *)wmi_buf_data(buf);
  1086. cmd->vdev_id = param->vdev_id;
  1087. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  1088. cmd->param = param->param;
  1089. cmd->value = param->value;
  1090. return wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
  1091. WMI_AP_PS_PEER_PARAM_CMDID);
  1092. }
  1093. /**
  1094. * send_set_sta_ps_param_cmd_non_tlv() - set sta powersave parameters
  1095. * @param wmi_handle : handle to WMI.
  1096. * @param: pointer to sta_ps parameter structure
  1097. *
  1098. * Return: 0 for success or error code
  1099. */
  1100. static QDF_STATUS send_set_sta_ps_param_cmd_non_tlv(wmi_unified_t wmi_handle,
  1101. struct sta_ps_params *param)
  1102. {
  1103. wmi_sta_powersave_param_cmd *cmd;
  1104. wmi_buf_t buf;
  1105. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  1106. if (!buf) {
  1107. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  1108. return QDF_STATUS_E_FAILURE;
  1109. }
  1110. cmd = (wmi_sta_powersave_param_cmd *)wmi_buf_data(buf);
  1111. cmd->vdev_id = param->vdev_id;
  1112. cmd->param = param->param;
  1113. cmd->value = param->value;
  1114. return wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
  1115. WMI_STA_POWERSAVE_PARAM_CMDID);
  1116. }
  1117. /**
  1118. * send_set_ps_mode_cmd_non_tlv() - set powersave mode
  1119. * @wmi_handle: wmi handle
  1120. * @param: pointer to ps_mode parameter structure
  1121. *
  1122. * Return: 0 for success or error code
  1123. */
  1124. static QDF_STATUS send_set_ps_mode_cmd_non_tlv(wmi_unified_t wmi_handle,
  1125. struct set_ps_mode_params *param)
  1126. {
  1127. wmi_sta_powersave_mode_cmd *cmd;
  1128. wmi_buf_t buf;
  1129. int ret;
  1130. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  1131. if (!buf) {
  1132. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  1133. return QDF_STATUS_E_FAILURE;
  1134. }
  1135. qdf_print("%s:set psmode=%d\n", __func__, param->psmode);
  1136. cmd = (wmi_sta_powersave_mode_cmd *)wmi_buf_data(buf);
  1137. cmd->vdev_id = param->vdev_id;
  1138. cmd->sta_ps_mode = param->psmode;
  1139. ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
  1140. WMI_STA_POWERSAVE_MODE_CMDID);
  1141. return ret;
  1142. }
  1143. /**
  1144. * send_crash_inject_cmd_non_tlv() - inject fw crash
  1145. * @param wmi_handle : handle to WMI.
  1146. * @param: ponirt to crash inject paramter structure
  1147. *
  1148. * Return: 0 for success or return error
  1149. */
  1150. static QDF_STATUS send_crash_inject_cmd_non_tlv(wmi_unified_t wmi_handle,
  1151. struct crash_inject *param)
  1152. {
  1153. WMI_FORCE_FW_HANG_CMD *cmd;
  1154. wmi_buf_t buf;
  1155. int32_t len = sizeof(WMI_FORCE_FW_HANG_CMD);
  1156. buf = wmi_buf_alloc(wmi_handle, len);
  1157. if (!buf) {
  1158. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  1159. return QDF_STATUS_E_FAILURE;
  1160. }
  1161. cmd = (WMI_FORCE_FW_HANG_CMD *)wmi_buf_data(buf);
  1162. cmd->type = 1;
  1163. /* Should this be param->type ? */
  1164. cmd->delay_time_ms = param->delay_time_ms;
  1165. return wmi_unified_cmd_send(wmi_handle, buf, len,
  1166. WMI_FORCE_FW_HANG_CMDID);
  1167. }
  1168. /**
  1169. * send_dbglog_cmd_non_tlv() - set debug log level
  1170. *
  1171. * @param wmi_handle : handle to WMI.
  1172. * @param param : pointer to hold dbglog level parameter
  1173. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1174. */
  1175. static QDF_STATUS
  1176. send_dbglog_cmd_non_tlv(wmi_unified_t wmi_handle,
  1177. struct dbglog_params *dbglog_param)
  1178. {
  1179. wmi_buf_t osbuf;
  1180. WMI_DBGLOG_CFG_CMD *cmd;
  1181. QDF_STATUS status;
  1182. osbuf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  1183. if (osbuf == NULL)
  1184. return QDF_STATUS_E_NOMEM;
  1185. qdf_nbuf_put_tail(osbuf, sizeof(*cmd));
  1186. cmd = (WMI_DBGLOG_CFG_CMD *)(wmi_buf_data(osbuf));
  1187. qdf_print("wmi_dbg_cfg_send: mod[0]%08x dbgcfg%08x cfgvalid[0] %08x"
  1188. " cfgvalid[1] %08x\n",
  1189. dbglog_param->module_id_bitmap[0],
  1190. dbglog_param->val, dbglog_param->cfgvalid[0],
  1191. dbglog_param->cfgvalid[1]);
  1192. cmd->config.cfgvalid[0] = dbglog_param->cfgvalid[0];
  1193. cmd->config.cfgvalid[1] = dbglog_param->cfgvalid[1];
  1194. qdf_mem_copy(&cmd->config.config.mod_id[0],
  1195. dbglog_param->module_id_bitmap,
  1196. sizeof(cmd->config.config.mod_id));
  1197. cmd->config.config.dbg_config = dbglog_param->val;
  1198. status = wmi_unified_cmd_send(wmi_handle, osbuf,
  1199. sizeof(WMI_DBGLOG_CFG_CMD),
  1200. WMI_DBGLOG_CFG_CMDID);
  1201. return status;
  1202. }
  1203. /**
  1204. * send_vdev_set_param_cmd_non_tlv() - WMI vdev set parameter function
  1205. *
  1206. * @param wmi_handle : handle to WMI.
  1207. * @param param : pointer to hold vdev set parameter
  1208. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1209. */
  1210. static QDF_STATUS send_vdev_set_param_cmd_non_tlv(wmi_unified_t wmi_handle,
  1211. struct vdev_set_params *param)
  1212. {
  1213. wmi_vdev_set_param_cmd *cmd;
  1214. wmi_buf_t buf;
  1215. int len = sizeof(wmi_vdev_set_param_cmd);
  1216. if ((param->param_id < wmi_vdev_param_max) &&
  1217. (wmi_handle->vdev_param[param->param_id] !=
  1218. WMI_UNAVAILABLE_PARAM)) {
  1219. buf = wmi_buf_alloc(wmi_handle, len);
  1220. if (!buf) {
  1221. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  1222. return QDF_STATUS_E_FAILURE;
  1223. }
  1224. cmd = (wmi_vdev_set_param_cmd *)wmi_buf_data(buf);
  1225. cmd->vdev_id = param->if_id;
  1226. cmd->param_id = wmi_handle->vdev_param[param->param_id];
  1227. cmd->param_value = param->param_value;
  1228. return wmi_unified_cmd_send(wmi_handle, buf, len,
  1229. WMI_VDEV_SET_PARAM_CMDID);
  1230. }
  1231. return QDF_STATUS_E_FAILURE;
  1232. }
  1233. /**
  1234. * get_stats_id_non_tlv() - Get stats identifier function
  1235. *
  1236. * @param host_stats_id: host stats identifier value
  1237. * @return stats_id based on host_stats_id
  1238. */
  1239. static uint32_t get_stats_id_non_tlv(wmi_host_stats_id host_stats_id)
  1240. {
  1241. uint32_t stats_id = 0;
  1242. if (host_stats_id & WMI_HOST_REQUEST_PEER_STAT)
  1243. stats_id |= WMI_REQUEST_PEER_STAT;
  1244. if (host_stats_id & WMI_HOST_REQUEST_AP_STAT)
  1245. stats_id |= WMI_REQUEST_AP_STAT;
  1246. if (host_stats_id & WMI_HOST_REQUEST_INST_STAT)
  1247. stats_id |= WMI_REQUEST_INST_STAT;
  1248. if (host_stats_id & WMI_HOST_REQUEST_PEER_EXTD_STAT)
  1249. stats_id |= WMI_REQUEST_PEER_EXTD_STAT;
  1250. return stats_id;
  1251. }
  1252. /**
  1253. * send_stats_request_cmd_non_tlv() - WMI request stats function
  1254. *
  1255. * @param wmi_handle : handle to WMI.
  1256. * @param macaddr : MAC address
  1257. * @param param : pointer to hold stats request parameter
  1258. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1259. */
  1260. static QDF_STATUS send_stats_request_cmd_non_tlv(wmi_unified_t wmi_handle,
  1261. uint8_t macaddr[IEEE80211_ADDR_LEN],
  1262. struct stats_request_params *param)
  1263. {
  1264. wmi_buf_t buf;
  1265. wmi_request_stats_cmd *cmd;
  1266. uint8_t len = sizeof(wmi_request_stats_cmd);
  1267. buf = wmi_buf_alloc(wmi_handle, len);
  1268. if (!buf) {
  1269. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  1270. return QDF_STATUS_E_INVAL;
  1271. }
  1272. cmd = (wmi_request_stats_cmd *)wmi_buf_data(buf);
  1273. cmd->stats_id = get_stats_id_non_tlv(param->stats_id);
  1274. cmd->vdev_id = param->vdev_id;
  1275. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
  1276. cmd->inst_rssi_args.cfg_retry_count = param->rssi_args.cfg_retry_count;
  1277. cmd->inst_rssi_args.retry_count = param->rssi_args.retry_count;
  1278. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1279. WMI_REQUEST_STATS_CMDID)) {
  1280. return QDF_STATUS_E_INVAL;
  1281. }
  1282. return QDF_STATUS_SUCCESS;
  1283. }
  1284. /**
  1285. * send_bss_chan_info_request_cmd_non_tlv() - WMI request bss chan info
  1286. *
  1287. * @param wmi_handle : handle to WMI.
  1288. * @param param : pointer to hold bss chan info request parameter
  1289. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1290. */
  1291. static QDF_STATUS send_bss_chan_info_request_cmd_non_tlv(wmi_unified_t wmi_handle,
  1292. struct bss_chan_info_request_params *param)
  1293. {
  1294. wmi_buf_t buf;
  1295. wmi_pdev_bss_chan_info_request *cmd;
  1296. u_int8_t len = sizeof(wmi_pdev_bss_chan_info_request);
  1297. buf = wmi_buf_alloc(wmi_handle, len);
  1298. if (!buf) {
  1299. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  1300. return QDF_STATUS_E_INVAL;
  1301. }
  1302. cmd = (wmi_pdev_bss_chan_info_request *)wmi_buf_data(buf);
  1303. cmd->param = param->param;
  1304. cmd->reserved = 0;
  1305. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1306. WMI_PDEV_BSS_CHAN_INFO_REQUEST_CMDID)) {
  1307. return QDF_STATUS_E_INVAL;
  1308. }
  1309. return QDF_STATUS_SUCCESS;
  1310. }
  1311. /**
  1312. * send_packet_log_enable_cmd_non_tlv() - WMI request stats function
  1313. *
  1314. * @param wmi_handle : handle to WMI.
  1315. * @param PKTLOG_EVENT : packet log event
  1316. * @mac_id: mac id to have radio context
  1317. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1318. */
  1319. static QDF_STATUS send_packet_log_enable_cmd_non_tlv(wmi_unified_t wmi_handle,
  1320. WMI_HOST_PKTLOG_EVENT PKTLOG_EVENT, uint8_t mac_id)
  1321. {
  1322. wmi_pdev_pktlog_enable_cmd *cmd;
  1323. int len = 0;
  1324. wmi_buf_t buf;
  1325. len = sizeof(wmi_pdev_pktlog_enable_cmd);
  1326. buf = wmi_buf_alloc(wmi_handle, len);
  1327. if (!buf) {
  1328. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  1329. return QDF_STATUS_E_NOMEM;
  1330. }
  1331. cmd = (wmi_pdev_pktlog_enable_cmd *)wmi_buf_data(buf);
  1332. cmd->evlist = PKTLOG_EVENT;
  1333. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1334. WMI_PDEV_PKTLOG_ENABLE_CMDID)) {
  1335. return QDF_STATUS_E_FAILURE;
  1336. }
  1337. return QDF_STATUS_SUCCESS;
  1338. }
  1339. /**
  1340. * send_packet_log_disable_cmd_non_tlv() - WMI disable packet log send function
  1341. *
  1342. * @param wmi_handle : handle to WMI.
  1343. * @mac_id: mac id to have radio context
  1344. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1345. */
  1346. static QDF_STATUS send_packet_log_disable_cmd_non_tlv(wmi_unified_t wmi_handle,
  1347. uint8_t mac_id)
  1348. {
  1349. int len = 0;
  1350. wmi_buf_t buf;
  1351. buf = wmi_buf_alloc(wmi_handle, 0);
  1352. if (!buf) {
  1353. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  1354. return QDF_STATUS_E_NOMEM;
  1355. }
  1356. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1357. WMI_PDEV_PKTLOG_DISABLE_CMDID)) {
  1358. return QDF_STATUS_E_FAILURE;
  1359. }
  1360. return QDF_STATUS_SUCCESS;
  1361. }
  1362. /**
  1363. * send_beacon_send_cmd_non_tlv() - WMI beacon send function
  1364. *
  1365. * @param wmi_handle : handle to WMI.
  1366. * @param param : pointer to hold beacon send cmd parameter
  1367. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1368. */
  1369. static QDF_STATUS send_beacon_send_cmd_non_tlv(wmi_unified_t wmi_handle,
  1370. struct beacon_params *param)
  1371. {
  1372. if (param->is_high_latency) {
  1373. wmi_bcn_tx_cmd *cmd;
  1374. wmi_buf_t wmi_buf;
  1375. int bcn_len = qdf_nbuf_len(param->wbuf);
  1376. int len = sizeof(wmi_bcn_tx_hdr) + bcn_len;
  1377. /*************************************************************
  1378. * TODO: Once we have the host target transport framework for
  1379. * sending management frames this wmi function will be replaced
  1380. * with calls to HTT. The buffer will changed to match the right
  1381. * format to be used with HTT.
  1382. *************************************************************/
  1383. wmi_buf = wmi_buf_alloc(wmi_handle, roundup(len,
  1384. sizeof(u_int32_t)));
  1385. if (!wmi_buf) {
  1386. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  1387. return QDF_STATUS_E_NOMEM;
  1388. }
  1389. cmd = (wmi_bcn_tx_cmd *)wmi_buf_data(wmi_buf);
  1390. cmd->hdr.vdev_id = param->vdev_id;
  1391. cmd->hdr.buf_len = bcn_len;
  1392. #ifdef BIG_ENDIAN_HOST
  1393. {
  1394. /* for big endian host, copy engine byte_swap is enabled
  1395. * But the beacon buffer content is in network byte
  1396. * order Need to byte swap the beacon buffer content -
  1397. * so when copy engine does byte_swap - target gets
  1398. * buffer content in the correct order
  1399. */
  1400. int i;
  1401. u_int32_t *destp, *srcp;
  1402. destp = (u_int32_t *)cmd->bufp;
  1403. srcp = (u_int32_t *)wmi_buf_data(param->wbuf);
  1404. for (i = 0; i < (roundup(bcn_len,
  1405. sizeof(u_int32_t))/4); i++) {
  1406. *destp = qdf_le32_to_cpu(*srcp);
  1407. destp++; srcp++;
  1408. }
  1409. }
  1410. #else
  1411. qdf_mem_copy(cmd->bufp, wmi_buf_data(param->wbuf), bcn_len);
  1412. #endif
  1413. #ifdef DEBUG_BEACON
  1414. qdf_print("%s frm length %d\n", __func__, bcn_len);
  1415. #endif
  1416. wmi_unified_cmd_send(wmi_handle, wmi_buf,
  1417. roundup(len, sizeof(u_int32_t)), WMI_BCN_TX_CMDID);
  1418. } else {
  1419. wmi_bcn_send_from_host_cmd_t *cmd;
  1420. wmi_buf_t wmi_buf;
  1421. int bcn_len = qdf_nbuf_len(param->wbuf);
  1422. int len = sizeof(wmi_bcn_send_from_host_cmd_t);
  1423. A_UINT32 dtim_flag = 0;
  1424. /* get the DTIM count */
  1425. if (param->is_dtim_count_zero) {
  1426. dtim_flag |= WMI_BCN_SEND_DTIM_ZERO;
  1427. if (param->is_bitctl_reqd) {
  1428. /* deliver CAB traffic in next DTIM beacon */
  1429. dtim_flag |= WMI_BCN_SEND_DTIM_BITCTL_SET;
  1430. }
  1431. }
  1432. /* Map the beacon buffer to DMA region */
  1433. wmi_buf = wmi_buf_alloc(wmi_handle, roundup(len,
  1434. sizeof(u_int32_t)));
  1435. if (!wmi_buf) {
  1436. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  1437. return QDF_STATUS_E_NOMEM;
  1438. }
  1439. cmd = (wmi_bcn_send_from_host_cmd_t *)wmi_buf_data(wmi_buf);
  1440. cmd->vdev_id = param->vdev_id;
  1441. cmd->data_len = bcn_len;
  1442. cmd->frame_ctrl = param->frame_ctrl;
  1443. cmd->dtim_flag = dtim_flag;
  1444. cmd->frag_ptr = qdf_nbuf_get_frag_paddr(param->wbuf, 0);
  1445. cmd->virt_addr = (uintptr_t)param->wbuf;
  1446. cmd->bcn_antenna = param->bcn_txant;
  1447. wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  1448. WMI_PDEV_SEND_BCN_CMDID);
  1449. }
  1450. return QDF_STATUS_SUCCESS;
  1451. }
  1452. #if 0
  1453. /**
  1454. * send_bcn_prb_template_cmd_non_tlv() - WMI beacon probe template function
  1455. *
  1456. * @param wmi_handle : handle to WMI.
  1457. * @param macaddr : MAC address
  1458. * @param param : pointer to hold beacon prb template cmd parameter
  1459. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1460. */
  1461. static QDF_STATUS send_bcn_prb_template_cmd_non_tlv(wmi_unified_t wmi_handle,
  1462. struct bcn_prb_template_params *param)
  1463. {
  1464. wmi_bcn_prb_tmpl_cmd *cmd;
  1465. wmi_buf_t buf;
  1466. wmi_bcn_prb_info *template;
  1467. int len = sizeof(wmi_bcn_prb_tmpl_cmd);
  1468. int ret;
  1469. /*
  1470. * The target will store this information for use with
  1471. * the beacons and probes.
  1472. */
  1473. buf = wmi_buf_alloc(wmi_handle, len);
  1474. if (!buf) {
  1475. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  1476. return QDF_STATUS_E_NOMEM;
  1477. }
  1478. cmd = (wmi_bcn_prb_tmpl_cmd *)wmi_buf_data(buf);
  1479. cmd->vdev_id = param->vdev_id;
  1480. cmd->buf_len = param->buf_len;
  1481. template = &cmd->bcn_prb_info;
  1482. template->caps = param->caps;
  1483. template->erp = param->erp;
  1484. /* TODO: Few more elements to be added and copied to the template
  1485. * buffer */
  1486. /* Send the beacon probe template to the target */
  1487. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1488. WMI_BCN_PRB_TMPL_CMDID);
  1489. return ret;
  1490. }
  1491. #endif
  1492. /**
  1493. * send_peer_assoc_cmd_non_tlv() - WMI peer assoc function
  1494. *
  1495. * @param wmi_handle : handle to WMI.
  1496. * @param param : pointer to peer assoc parameter
  1497. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1498. */
  1499. static QDF_STATUS send_peer_assoc_cmd_non_tlv(wmi_unified_t wmi_handle,
  1500. struct peer_assoc_params *param)
  1501. {
  1502. wmi_peer_assoc_complete_cmd *cmd;
  1503. int len = sizeof(wmi_peer_assoc_complete_cmd);
  1504. #ifdef BIG_ENDIAN_HOST
  1505. int i;
  1506. #endif
  1507. wmi_buf_t buf;
  1508. buf = wmi_buf_alloc(wmi_handle, len);
  1509. if (!buf) {
  1510. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  1511. return QDF_STATUS_E_FAILURE;
  1512. }
  1513. cmd = (wmi_peer_assoc_complete_cmd *)wmi_buf_data(buf);
  1514. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_mac, &cmd->peer_macaddr);
  1515. cmd->vdev_id = param->vdev_id;
  1516. cmd->peer_new_assoc = param->peer_new_assoc;
  1517. cmd->peer_associd = param->peer_associd;
  1518. cmd->peer_bw_rxnss_override = 0;
  1519. /*
  1520. * The target only needs a subset of the flags maintained in the host.
  1521. * Just populate those flags and send it down
  1522. */
  1523. cmd->peer_flags = 0;
  1524. if (param->is_pmf_enabled)
  1525. cmd->peer_flags |= WMI_PEER_PMF_ENABLED;
  1526. /*
  1527. * Do not enable HT/VHT if WMM/wme is disabled for vap.
  1528. */
  1529. if (param->is_wme_set) {
  1530. if (param->qos_flag)
  1531. cmd->peer_flags |= WMI_PEER_QOS;
  1532. if (param->apsd_flag)
  1533. cmd->peer_flags |= WMI_PEER_APSD;
  1534. if (param->ht_flag)
  1535. cmd->peer_flags |= WMI_PEER_HT;
  1536. if (param->bw_40)
  1537. cmd->peer_flags |= WMI_PEER_40MHZ;
  1538. if (param->bw_80)
  1539. cmd->peer_flags |= WMI_PEER_80MHZ;
  1540. if (param->bw_160)
  1541. cmd->peer_flags |= WMI_PEER_160MHZ;
  1542. /* Typically if STBC is enabled for VHT it should be enabled
  1543. * for HT as well */
  1544. if (param->stbc_flag)
  1545. cmd->peer_flags |= WMI_PEER_STBC;
  1546. /* Typically if LDPC is enabled for VHT it should be enabled
  1547. * for HT as well */
  1548. if (param->ldpc_flag)
  1549. cmd->peer_flags |= WMI_PEER_LDPC;
  1550. if (param->static_mimops_flag)
  1551. cmd->peer_flags |= WMI_PEER_STATIC_MIMOPS;
  1552. if (param->dynamic_mimops_flag)
  1553. cmd->peer_flags |= WMI_PEER_DYN_MIMOPS;
  1554. if (param->spatial_mux_flag)
  1555. cmd->peer_flags |= WMI_PEER_SPATIAL_MUX;
  1556. if (param->vht_flag)
  1557. cmd->peer_flags |= WMI_PEER_VHT;
  1558. if (param->vht_ng_flag)
  1559. cmd->peer_flags |= WMI_PEER_VHT_2G;
  1560. }
  1561. /*
  1562. * Suppress authorization for all AUTH modes that need 4-way handshake
  1563. * (during re-association).
  1564. * Authorization will be done for these modes on key installation.
  1565. */
  1566. if (param->auth_flag)
  1567. cmd->peer_flags |= WMI_PEER_AUTH;
  1568. if (param->need_ptk_4_way)
  1569. cmd->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
  1570. else
  1571. cmd->peer_flags &= ~WMI_PEER_NEED_PTK_4_WAY;
  1572. if (param->need_gtk_2_way)
  1573. cmd->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
  1574. /* safe mode bypass the 4-way handshake */
  1575. if (param->safe_mode_enabled)
  1576. cmd->peer_flags &=
  1577. ~(WMI_PEER_NEED_PTK_4_WAY | WMI_PEER_NEED_GTK_2_WAY);
  1578. /* Disable AMSDU for station transmit, if user configures it */
  1579. /* Disable AMSDU for AP transmit to 11n Stations, if user configures
  1580. * it */
  1581. if (param->amsdu_disable)
  1582. cmd->peer_flags |= WMI_PEER_AMSDU_DISABLE;
  1583. cmd->peer_caps = param->peer_caps;
  1584. cmd->peer_listen_intval = param->peer_listen_intval;
  1585. cmd->peer_ht_caps = param->peer_ht_caps;
  1586. cmd->peer_max_mpdu = param->peer_max_mpdu;
  1587. cmd->peer_mpdu_density = param->peer_mpdu_density;
  1588. cmd->peer_vht_caps = param->peer_vht_caps;
  1589. /* Update peer rate information */
  1590. cmd->peer_rate_caps = param->peer_rate_caps;
  1591. cmd->peer_legacy_rates.num_rates = param->peer_legacy_rates.num_rates;
  1592. /* NOTE: cmd->peer_legacy_rates.rates is of type A_UINT32 */
  1593. /* ni->ni_rates.rs_rates is of type u_int8_t */
  1594. /**
  1595. * for cmd->peer_legacy_rates.rates:
  1596. * rates (each 8bit value) packed into a 32 bit word.
  1597. * the rates are filled from least significant byte to most
  1598. * significant byte.
  1599. */
  1600. qdf_mem_copy(cmd->peer_legacy_rates.rates,
  1601. param->peer_legacy_rates.rates,
  1602. param->peer_legacy_rates.num_rates);
  1603. #ifdef BIG_ENDIAN_HOST
  1604. for (i = 0;
  1605. i < param->peer_legacy_rates.num_rates/sizeof(A_UINT32) + 1;
  1606. i++)
  1607. cmd->peer_legacy_rates.rates[i] =
  1608. qdf_le32_to_cpu(cmd->peer_legacy_rates.rates[i]);
  1609. #endif
  1610. cmd->peer_ht_rates.num_rates = param->peer_ht_rates.num_rates;
  1611. qdf_mem_copy(cmd->peer_ht_rates.rates, param->peer_ht_rates.rates,
  1612. param->peer_ht_rates.num_rates);
  1613. #ifdef BIG_ENDIAN_HOST
  1614. for (i = 0; i < param->peer_ht_rates.num_rates/sizeof(A_UINT32) + 1;
  1615. i++)
  1616. cmd->peer_ht_rates.rates[i] =
  1617. qdf_le32_to_cpu(cmd->peer_ht_rates.rates[i]);
  1618. #endif
  1619. if (param->ht_flag &&
  1620. (param->peer_ht_rates.num_rates == 0)) {
  1621. /* Workaround for EV 116382: The node is marked HT but with
  1622. * supported rx mcs set is set to 0. 11n spec mandates MCS0-7
  1623. * for a HT STA. So forcing the supported rx mcs rate to MCS
  1624. * 0-7.
  1625. * This workaround will be removed once we get clarification
  1626. * from WFA regarding this STA behavior
  1627. */
  1628. u_int8_t temp_ni_rates[8] = {
  1629. 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7};
  1630. cmd->peer_ht_rates.num_rates = 8;
  1631. qdf_mem_copy(cmd->peer_ht_rates.rates, temp_ni_rates,
  1632. cmd->peer_ht_rates.num_rates);
  1633. }
  1634. /* Target asserts if node is marked HT and all MCS is set to 0.
  1635. Mark the node as non-HT if all the mcs rates are disabled through
  1636. iwpriv */
  1637. if (cmd->peer_ht_rates.num_rates == 0)
  1638. cmd->peer_flags &= ~WMI_PEER_HT;
  1639. cmd->peer_nss = param->peer_nss;
  1640. if (param->vht_capable) {
  1641. wmi_vht_rate_set *mcs;
  1642. mcs = &cmd->peer_vht_rates;
  1643. mcs->rx_max_rate = param->rx_max_rate;
  1644. mcs->rx_mcs_set = param->rx_mcs_set;
  1645. mcs->tx_max_rate = param->tx_max_rate;
  1646. mcs->tx_mcs_set = param->tx_mcs_set;
  1647. mcs->tx_max_mcs_nss = param->tx_max_mcs_nss;
  1648. }
  1649. cmd->peer_phymode = param->peer_phymode;
  1650. /*Send bandwidth-NSS mapping to FW*/
  1651. cmd->peer_bw_rxnss_override |= param->peer_bw_rxnss_override;
  1652. return wmi_unified_cmd_send(wmi_handle, buf, len, WMI_PEER_ASSOC_CMDID);
  1653. }
  1654. /**
  1655. * send_scan_start_cmd_non_tlv() - WMI scan start function
  1656. *
  1657. * @param wmi_handle : handle to WMI.
  1658. * @param param : pointer to hold scan start cmd parameter
  1659. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1660. */
  1661. static QDF_STATUS send_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle,
  1662. struct scan_req_params *param)
  1663. {
  1664. wmi_start_scan_cmd *cmd;
  1665. wmi_buf_t buf;
  1666. wmi_chan_list *chan_list;
  1667. wmi_bssid_list *bssid_list;
  1668. wmi_ssid_list *ssid_list;
  1669. wmi_ie_data *ie_data;
  1670. A_UINT32 *tmp_ptr;
  1671. int i, len = sizeof(wmi_start_scan_cmd);
  1672. #ifdef TEST_CODE
  1673. len += sizeof(wmi_chan_list) + 3 * sizeof(A_UINT32);
  1674. #else
  1675. if (param->chan_list.num_chan) {
  1676. len += sizeof(wmi_chan_list) + (param->chan_list.num_chan - 1)
  1677. * sizeof(A_UINT32);
  1678. }
  1679. #endif
  1680. if (param->num_ssids) {
  1681. len += sizeof(wmi_ssid_list) + (param->num_ssids - 1)
  1682. * sizeof(wmi_ssid);
  1683. }
  1684. if (param->num_bssid) {
  1685. len += sizeof(wmi_bssid_list) + (param->num_bssid - 1)
  1686. * sizeof(wmi_mac_addr);
  1687. }
  1688. if (param->extraie.len) {
  1689. i = param->extraie.len % sizeof(A_UINT32);
  1690. if (i)
  1691. len += sizeof(A_UINT32) - i;
  1692. len += 2 * sizeof(A_UINT32) + param->extraie.len;
  1693. }
  1694. buf = wmi_buf_alloc(wmi_handle, len);
  1695. if (!buf) {
  1696. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  1697. return QDF_STATUS_E_NOMEM;
  1698. }
  1699. cmd = (wmi_start_scan_cmd *)wmi_buf_data(buf);
  1700. OS_MEMZERO(cmd, len);
  1701. cmd->vdev_id = param->vdev_id;
  1702. cmd->scan_priority = param->scan_priority;
  1703. cmd->scan_id = param->scan_id;
  1704. cmd->scan_req_id = param->scan_req_id;
  1705. /* Scan events subscription */
  1706. if (param->scan_ev_started)
  1707. cmd->notify_scan_events |= WMI_SCAN_EVENT_STARTED;
  1708. if (param->scan_ev_completed)
  1709. cmd->notify_scan_events |= WMI_SCAN_EVENT_COMPLETED;
  1710. if (param->scan_ev_bss_chan)
  1711. cmd->notify_scan_events |= WMI_SCAN_EVENT_BSS_CHANNEL;
  1712. if (param->scan_ev_foreign_chan)
  1713. cmd->notify_scan_events |= WMI_SCAN_EVENT_FOREIGN_CHANNEL;
  1714. if (param->scan_ev_dequeued)
  1715. cmd->notify_scan_events |= WMI_SCAN_EVENT_DEQUEUED;
  1716. if (param->scan_ev_preempted)
  1717. cmd->notify_scan_events |= WMI_SCAN_EVENT_PREEMPTED;
  1718. if (param->scan_ev_start_failed)
  1719. cmd->notify_scan_events |= WMI_SCAN_EVENT_START_FAILED;
  1720. if (param->scan_ev_restarted)
  1721. cmd->notify_scan_events |= WMI_SCAN_EVENT_RESTARTED;
  1722. if (param->scan_ev_foreign_chn_exit)
  1723. cmd->notify_scan_events |= WMI_SCAN_EVENT_FOREIGN_CHANNEL_EXIT;
  1724. if (param->scan_ev_invalid)
  1725. cmd->notify_scan_events |= WMI_SCAN_EVENT_INVALID;
  1726. if (param->scan_ev_gpio_timeout)
  1727. cmd->notify_scan_events |= WMI_SCAN_EVENT_GPIO_TIMEOUT;
  1728. /** Max. active channel dwell time */
  1729. cmd->dwell_time_active = param->dwell_time_active;
  1730. /** Passive channel dwell time */
  1731. cmd->dwell_time_passive = param->dwell_time_passive;
  1732. /** Scan control flags */
  1733. cmd->scan_ctrl_flags = 0;
  1734. if (param->scan_f_passive)
  1735. cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
  1736. if (param->scan_f_strict_passive_pch)
  1737. cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN;
  1738. if (param->scan_f_promisc_mode)
  1739. cmd->scan_ctrl_flags |= WMI_SCAN_PROMISCOUS_MODE;
  1740. if (param->scan_f_capture_phy_err)
  1741. cmd->scan_ctrl_flags |= WMI_SCAN_CAPTURE_PHY_ERROR;
  1742. if (param->scan_f_half_rate)
  1743. cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_HALF_RATE_SUPPORT;
  1744. if (param->scan_f_quarter_rate)
  1745. cmd->scan_ctrl_flags |= WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT;
  1746. if (param->scan_f_cck_rates)
  1747. cmd->scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
  1748. if (param->scan_f_chan_stat_evnt)
  1749. cmd->scan_ctrl_flags |= WMI_SCAN_CHAN_STAT_EVENT;
  1750. if (param->scan_f_bcast_probe)
  1751. cmd->scan_ctrl_flags |= WMI_SCAN_ADD_BCAST_PROBE_REQ;
  1752. if (param->scan_f_offchan_mgmt_tx)
  1753. cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_MGMT_TX;
  1754. if (param->scan_f_offchan_data_tx)
  1755. cmd->scan_ctrl_flags |= WMI_SCAN_OFFCHAN_DATA_TX;
  1756. /* Always enable ofdm rates */
  1757. cmd->scan_ctrl_flags |= WMI_SCAN_ADD_OFDM_RATES;
  1758. /** send multiple braodcast probe req with this delay in between */
  1759. cmd->repeat_probe_time = param->repeat_probe_time;
  1760. cmd->probe_spacing_time = param->probe_spacing_time;
  1761. /** delay between channel change and first probe request */
  1762. cmd->probe_delay = param->probe_delay;
  1763. /** idle time on channel for which if no traffic is seen
  1764. then scanner can switch to off channel */
  1765. cmd->idle_time = param->idle_time;
  1766. cmd->min_rest_time = param->min_rest_time;
  1767. /** maximum rest time allowed on bss channel, overwrites
  1768. * other conditions and changes channel to off channel
  1769. * even if min beacon count, idle time requirements are not met.
  1770. */
  1771. cmd->max_rest_time = param->max_rest_time;
  1772. /** maxmimum scan time allowed */
  1773. #if IPQ4019_EMU
  1774. cmd->max_scan_time = 0xffffffff;
  1775. #else
  1776. cmd->max_scan_time = param->max_scan_time;
  1777. #endif
  1778. tmp_ptr = (A_UINT32 *) (cmd + 1);
  1779. #ifdef TEST_CODE
  1780. #define DEFAULT_TIME 150
  1781. cmd->min_rest_time = DEFAULT_TIME;
  1782. cmd->idle_time = 10*DEFAULT_TIME;
  1783. cmd->max_rest_time = 30*DEFAULT_TIME;
  1784. chan_list = (wmi_chan_list *) tmp_ptr;
  1785. chan_list->tag = WMI_CHAN_LIST_TAG;
  1786. chan_list->num_chan = 4;
  1787. chan_list->channel_list[0] = 2412; /* 1 */
  1788. chan_list->channel_list[1] = 2437; /* 6 */
  1789. chan_list->channel_list[2] = 5180; /* 36 */-
  1790. chan_list->channel_list[3] = 5680; /* 136 */
  1791. tmp_ptr += (2 + chan_list->num_chan); /* increase by words */-
  1792. #else
  1793. #define FREQUENCY_THRESH 1000
  1794. if (param->chan_list.num_chan) {
  1795. chan_list = (wmi_chan_list *) tmp_ptr;
  1796. chan_list->tag = WMI_CHAN_LIST_TAG;
  1797. chan_list->num_chan = param->chan_list.num_chan;
  1798. for (i = 0; i < param->chan_list.num_chan; ++i)
  1799. chan_list->channel_list[i] =
  1800. param->chan_list.chan[i].freq;
  1801. tmp_ptr += (2 + param->chan_list.num_chan);
  1802. }
  1803. #endif
  1804. if (param->num_ssids) {
  1805. ssid_list = (wmi_ssid_list *) tmp_ptr;
  1806. ssid_list->tag = WMI_SSID_LIST_TAG;
  1807. ssid_list->num_ssids = param->num_ssids;
  1808. for (i = 0; i < param->num_ssids; ++i) {
  1809. ssid_list->ssids[i].ssid_len = param->ssid[i].length;
  1810. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(
  1811. ssid_list->ssids[i].ssid,
  1812. param->ssid[i].ssid,
  1813. param->ssid[i].length);
  1814. }
  1815. tmp_ptr += (2 + (sizeof(wmi_ssid) *
  1816. param->num_ssids)/sizeof(A_UINT32));
  1817. }
  1818. if (param->num_bssid) {
  1819. bssid_list = (wmi_bssid_list *) tmp_ptr;
  1820. bssid_list->tag = WMI_BSSID_LIST_TAG;
  1821. bssid_list->num_bssid = param->num_bssid;
  1822. for (i = 0; i < param->num_bssid; ++i) {
  1823. WMI_CHAR_ARRAY_TO_MAC_ADDR(
  1824. &(param->bssid_list[i].bytes[0]),
  1825. &bssid_list->bssid_list[i]);
  1826. }
  1827. tmp_ptr += (2 + (sizeof(wmi_mac_addr) *
  1828. param->num_bssid)/sizeof(A_UINT32));
  1829. }
  1830. if (param->extraie.len) {
  1831. ie_data = (wmi_ie_data *) tmp_ptr;
  1832. ie_data->tag = WMI_IE_TAG;
  1833. ie_data->ie_len = param->extraie.len;
  1834. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(ie_data->ie_data,
  1835. param->extraie.ptr, param->extraie.len);
  1836. }
  1837. qdf_print("Sending SCAN START cmd\n");
  1838. return wmi_unified_cmd_send(wmi_handle, buf, len, WMI_START_SCAN_CMDID);
  1839. }
  1840. /**
  1841. * send_scan_stop_cmd_non_tlv() - WMI scan stop function
  1842. *
  1843. * @param wmi_handle : handle to WMI.
  1844. * @param param : pointer to hold scan start cmd parameter
  1845. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1846. */
  1847. static QDF_STATUS send_scan_stop_cmd_non_tlv(wmi_unified_t wmi_handle,
  1848. struct scan_cancel_param *param)
  1849. {
  1850. wmi_stop_scan_cmd *cmd = NULL;
  1851. wmi_buf_t buf;
  1852. u_int32_t len = sizeof(wmi_stop_scan_cmd);
  1853. buf = wmi_buf_alloc(wmi_handle, len);
  1854. if (!buf) {
  1855. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  1856. return QDF_STATUS_E_NOMEM;
  1857. }
  1858. cmd = (wmi_stop_scan_cmd *)wmi_buf_data(buf);
  1859. OS_MEMZERO(cmd, len);
  1860. /* scan scheduler is not supportd yet */
  1861. cmd->scan_id = param->scan_id;
  1862. cmd->requestor = param->requester;
  1863. cmd->vdev_id = param->vdev_id;
  1864. if (param->req_type == WLAN_SCAN_CANCEL_PDEV_ALL) {
  1865. /* Cancelling all scans - always match scan id */
  1866. cmd->req_type = WMI_SCAN_STOP_ALL;
  1867. } else if (param->req_type == WLAN_SCAN_CANCEL_VDEV_ALL) {
  1868. /*-
  1869. * Cancelling VAP scans - report a match if scan was requested
  1870. * by the same VAP trying to cancel it.
  1871. */
  1872. cmd->req_type = WMI_SCN_STOP_VAP_ALL;
  1873. } else if (param->req_type == WLAN_SCAN_CANCEL_SINGLE) {
  1874. /*-
  1875. * Cancelling specific scan - report a match if specified scan
  1876. * id matches the request's scan id.
  1877. */
  1878. cmd->req_type = WMI_SCAN_STOP_ONE;
  1879. }
  1880. wmi_unified_cmd_send(wmi_handle, buf, len, WMI_STOP_SCAN_CMDID);
  1881. return QDF_STATUS_SUCCESS;
  1882. }
  1883. /**
  1884. * send_scan_chan_list_cmd_non_tlv() - WMI scan channel list function
  1885. *
  1886. * @param wmi_handle : handle to WMI.
  1887. * @param param : pointer to hold scan channel list parameter
  1888. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1889. */
  1890. static QDF_STATUS send_scan_chan_list_cmd_non_tlv(wmi_unified_t wmi_handle,
  1891. struct scan_chan_list_params *param)
  1892. {
  1893. uint32_t i;
  1894. wmi_buf_t buf;
  1895. wmi_scan_chan_list_cmd *cmd;
  1896. int len = sizeof(wmi_scan_chan_list_cmd);
  1897. len = sizeof(wmi_scan_chan_list_cmd) +
  1898. sizeof(wmi_channel)*param->nallchans;
  1899. buf = wmi_buf_alloc(wmi_handle, len);
  1900. if (!buf) {
  1901. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  1902. return QDF_STATUS_E_NOMEM;
  1903. }
  1904. cmd = (wmi_scan_chan_list_cmd *)wmi_buf_data(buf);
  1905. cmd->num_scan_chans = param->nallchans;
  1906. OS_MEMZERO(cmd->chan_info, sizeof(wmi_channel)*cmd->num_scan_chans);
  1907. for (i = 0; i < param->nallchans; ++i) {
  1908. cmd->chan_info[i].mhz = param->ch_param[i].mhz;
  1909. if (param->ch_param[i].is_chan_passive)
  1910. WMI_SET_CHANNEL_FLAG(&(cmd->chan_info[i]),
  1911. WMI_CHAN_FLAG_PASSIVE);
  1912. if (param->ch_param[i].allow_vht)
  1913. WMI_SET_CHANNEL_FLAG(&(cmd->chan_info[i]),
  1914. WMI_CHAN_FLAG_ALLOW_VHT);
  1915. else if (param->ch_param[i].allow_ht)
  1916. WMI_SET_CHANNEL_FLAG(&(cmd->chan_info[i]),
  1917. WMI_CHAN_FLAG_ALLOW_HT);
  1918. cmd->chan_info[i].band_center_freq1 =
  1919. param->ch_param[i].cfreq1;
  1920. cmd->chan_info[i].band_center_freq2 =
  1921. param->ch_param[i].cfreq2;
  1922. WMI_SET_CHANNEL_MODE(&cmd->chan_info[i],
  1923. param->ch_param[i].phy_mode);
  1924. if (param->ch_param[i].half_rate)
  1925. WMI_SET_CHANNEL_FLAG(&(cmd->chan_info[i]),
  1926. WMI_CHAN_FLAG_HALF);
  1927. if (param->ch_param[i].quarter_rate)
  1928. WMI_SET_CHANNEL_FLAG(&(cmd->chan_info[i]),
  1929. WMI_CHAN_FLAG_QUARTER);
  1930. /* also fill in power information */
  1931. WMI_SET_CHANNEL_MIN_POWER(&cmd->chan_info[i],
  1932. param->ch_param[i].minpower);
  1933. WMI_SET_CHANNEL_MAX_POWER(&cmd->chan_info[i],
  1934. param->ch_param[i].maxpower);
  1935. WMI_SET_CHANNEL_REG_POWER(&cmd->chan_info[i],
  1936. param->ch_param[i].maxregpower);
  1937. WMI_SET_CHANNEL_ANTENNA_MAX(&cmd->chan_info[i],
  1938. param->ch_param[i].antennamax);
  1939. WMI_SET_CHANNEL_REG_CLASSID(&cmd->chan_info[i],
  1940. param->ch_param[i].reg_class_id);
  1941. }
  1942. wmi_unified_cmd_send(wmi_handle, buf, len, WMI_SCAN_CHAN_LIST_CMDID);
  1943. return QDF_STATUS_SUCCESS;
  1944. }
  1945. /**
  1946. * send_thermal_mitigation_param_cmd_non_tlv() - WMI scan channel list function
  1947. *
  1948. * @param wmi_handle : handle to WMI.
  1949. * @param param : pointer to hold thermal mitigation param
  1950. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1951. */
  1952. static QDF_STATUS send_thermal_mitigation_param_cmd_non_tlv(wmi_unified_t wmi_handle,
  1953. struct thermal_mitigation_params *param)
  1954. {
  1955. wmi_buf_t buf = NULL;
  1956. tt_config_t *cmd = NULL;
  1957. int error = 0;
  1958. int32_t len = 0;
  1959. int i = 0;
  1960. len = sizeof(tt_config_t);
  1961. buf = wmi_buf_alloc(wmi_handle, len);
  1962. if (!buf) {
  1963. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  1964. return QDF_STATUS_E_NOMEM;
  1965. }
  1966. cmd = (tt_config_t *) wmi_buf_data(buf);
  1967. cmd->enable = param->enable;
  1968. cmd->dc = param->dc;
  1969. cmd->dc_per_event = param->dc_per_event;
  1970. for (i = 0; i < THERMAL_LEVELS; i++) {
  1971. cmd->levelconf[i].tmplwm = param->levelconf[i].tmplwm;
  1972. cmd->levelconf[i].tmphwm = param->levelconf[i].tmphwm;
  1973. cmd->levelconf[i].dcoffpercent =
  1974. param->levelconf[i].dcoffpercent;
  1975. cmd->levelconf[i].prio = param->levelconf[i].priority;
  1976. }
  1977. error = wmi_unified_cmd_send(wmi_handle, buf, len,
  1978. WMI_TT_SET_CONF_CMDID);
  1979. return error;
  1980. }
  1981. /**
  1982. * send_phyerr_enable_cmd_non_tlv() - WMI phyerr enable function
  1983. *
  1984. * @param wmi_handle : handle to WMI.
  1985. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  1986. */
  1987. static QDF_STATUS send_phyerr_enable_cmd_non_tlv(wmi_unified_t wmi_handle)
  1988. {
  1989. wmi_buf_t buf;
  1990. /*
  1991. * Passing a NULL pointer to wmi_unified_cmd_send() panics it,
  1992. * so let's just use a 32 byte fake array for now.
  1993. */
  1994. buf = wmi_buf_alloc(wmi_handle, 32);
  1995. if (buf == NULL) {
  1996. /* XXX error? */
  1997. return QDF_STATUS_E_NOMEM;
  1998. }
  1999. qdf_print("%s: about to send\n", __func__);
  2000. if (wmi_unified_cmd_send(wmi_handle, buf, 32,
  2001. WMI_PDEV_DFS_ENABLE_CMDID) != QDF_STATUS_SUCCESS) {
  2002. qdf_print("%s: send failed\n", __func__);
  2003. return QDF_STATUS_E_FAILURE;
  2004. }
  2005. return QDF_STATUS_SUCCESS;
  2006. }
  2007. /**
  2008. * send_phyerr_disable_cmd_non_tlv() - WMI phyerr disable function
  2009. *
  2010. * @param wmi_handle : handle to WMI.
  2011. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  2012. */
  2013. static QDF_STATUS send_phyerr_disable_cmd_non_tlv(wmi_unified_t wmi_handle)
  2014. {
  2015. wmi_buf_t buf;
  2016. /*
  2017. * Passing a NULL pointer to wmi_unified_cmd_send() panics it,
  2018. * so let's just use a 32 byte fake array for now.
  2019. */
  2020. buf = wmi_buf_alloc(wmi_handle, 32);
  2021. if (buf == NULL) {
  2022. /* XXX error? */
  2023. return QDF_STATUS_E_NOMEM;
  2024. }
  2025. qdf_print("%s: about to send\n", __func__);
  2026. if (wmi_unified_cmd_send(wmi_handle, buf, 32,
  2027. WMI_PDEV_DFS_DISABLE_CMDID) != QDF_STATUS_SUCCESS) {
  2028. qdf_print("%s: send failed\n", __func__);
  2029. return QDF_STATUS_E_FAILURE;
  2030. }
  2031. return QDF_STATUS_SUCCESS;
  2032. }
  2033. /**
  2034. * send_smart_ant_enable_cmd_non_tlv() - WMI smart ant enable function
  2035. *
  2036. * @param wmi_handle : handle to WMI.
  2037. * @param param : pointer to antenna param
  2038. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  2039. */
  2040. static QDF_STATUS send_smart_ant_enable_cmd_non_tlv(wmi_unified_t wmi_handle,
  2041. struct smart_ant_enable_params *param)
  2042. {
  2043. /* Send WMI COMMAND to Enable */
  2044. wmi_pdev_smart_ant_enable_cmd *cmd;
  2045. wmi_buf_t buf;
  2046. int len = 0;
  2047. int ret;
  2048. len = sizeof(wmi_pdev_smart_ant_enable_cmd);
  2049. buf = wmi_buf_alloc(wmi_handle, len);
  2050. if (!buf) {
  2051. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2052. return QDF_STATUS_E_NOMEM;
  2053. }
  2054. cmd = (wmi_pdev_smart_ant_enable_cmd *)wmi_buf_data(buf);
  2055. cmd->enable = param->enable;
  2056. cmd->mode = param->mode;
  2057. cmd->rx_antenna = param->rx_antenna;
  2058. cmd->tx_default_antenna = param->rx_antenna;
  2059. if (param->mode == SMART_ANT_MODE_SERIAL) {
  2060. cmd->gpio_pin[0] = param->gpio_pin[0];
  2061. cmd->gpio_pin[1] = param->gpio_pin[1];
  2062. cmd->gpio_pin[2] = 0;
  2063. cmd->gpio_pin[3] = 0;
  2064. cmd->gpio_func[0] = param->gpio_func[0];
  2065. cmd->gpio_func[1] = param->gpio_func[1];
  2066. cmd->gpio_func[2] = 0;
  2067. cmd->gpio_func[3] = 0;
  2068. } else if (param->mode == SMART_ANT_MODE_PARALLEL) {
  2069. cmd->gpio_pin[0] = param->gpio_pin[0];
  2070. cmd->gpio_pin[1] = param->gpio_pin[1];
  2071. cmd->gpio_pin[2] = param->gpio_pin[2];
  2072. cmd->gpio_pin[3] = param->gpio_pin[3];
  2073. cmd->gpio_func[0] = param->gpio_func[0];
  2074. cmd->gpio_func[1] = param->gpio_func[1];
  2075. cmd->gpio_func[2] = param->gpio_func[2];
  2076. cmd->gpio_func[3] = param->gpio_func[3];
  2077. }
  2078. ret = wmi_unified_cmd_send(wmi_handle,
  2079. buf,
  2080. len,
  2081. WMI_PDEV_SMART_ANT_ENABLE_CMDID);
  2082. if (ret != 0) {
  2083. qdf_print(" %s :WMI Failed\n", __func__);
  2084. qdf_print("%s: Failed to send WMI_PDEV_SMART_ANT_ENABLE_CMDID.\n"
  2085. "enable:%d mode:%d rx_antenna: 0x%08x PINS: "
  2086. "[%d %d %d %d] Func[%d %d %d %d] cmdstatus=%d\n",
  2087. __func__,
  2088. cmd->enable,
  2089. cmd->mode,
  2090. cmd->rx_antenna,
  2091. cmd->gpio_pin[0],
  2092. cmd->gpio_pin[1],
  2093. cmd->gpio_pin[2],
  2094. cmd->gpio_pin[3],
  2095. cmd->gpio_func[0],
  2096. cmd->gpio_func[1],
  2097. cmd->gpio_func[2],
  2098. cmd->gpio_func[3],
  2099. ret);
  2100. wmi_buf_free(buf);
  2101. }
  2102. return ret;
  2103. }
  2104. /**
  2105. * send_smart_ant_set_rx_ant_cmd_non_tlv() - WMI set rx antenna function
  2106. *
  2107. * @param wmi_handle : handle to WMI.
  2108. * @param param : pointer to rx antenna param
  2109. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  2110. */
  2111. static QDF_STATUS send_smart_ant_set_rx_ant_cmd_non_tlv(wmi_unified_t wmi_handle,
  2112. struct smart_ant_rx_ant_params *param)
  2113. {
  2114. wmi_pdev_smart_ant_set_rx_antenna_cmd *cmd;
  2115. wmi_buf_t buf;
  2116. int len = 0;
  2117. int ret;
  2118. len = sizeof(wmi_pdev_smart_ant_set_rx_antenna_cmd);
  2119. buf = wmi_buf_alloc(wmi_handle, len);
  2120. if (!buf) {
  2121. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2122. return QDF_STATUS_E_NOMEM;
  2123. }
  2124. cmd = (wmi_pdev_smart_ant_set_rx_antenna_cmd *)wmi_buf_data(buf);
  2125. cmd->rx_antenna = param->antenna;
  2126. ret = wmi_unified_cmd_send(wmi_handle,
  2127. buf,
  2128. len,
  2129. WMI_PDEV_SMART_ANT_SET_RX_ANTENNA_CMDID);
  2130. if (ret != 0) {
  2131. qdf_print(" %s :WMI Failed\n", __func__);
  2132. qdf_print("%s: Failed to send WMI_PDEV_SMART_ANT_SET_RX_ANTENNA_CMDID.\n"
  2133. " rx_antenna: 0x%08x cmdstatus=%d\n",
  2134. __func__,
  2135. cmd->rx_antenna,
  2136. ret);
  2137. wmi_buf_free(buf);
  2138. }
  2139. return ret;
  2140. }
  2141. /**
  2142. * send_smart_ant_set_tx_ant_cmd_non_tlv() - WMI set tx antenna function
  2143. * @param wmi_handle : handle to WMI.
  2144. * @param macaddr : vdev mac address
  2145. * @param param : pointer to tx antenna param
  2146. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  2147. */
  2148. static QDF_STATUS send_smart_ant_set_tx_ant_cmd_non_tlv(wmi_unified_t wmi_handle,
  2149. uint8_t macaddr[IEEE80211_ADDR_LEN],
  2150. struct smart_ant_tx_ant_params *param)
  2151. {
  2152. wmi_peer_sant_set_tx_antenna_cmd *cmd;
  2153. wmi_buf_t buf;
  2154. int len = 0;
  2155. int ret;
  2156. len = sizeof(wmi_peer_sant_set_tx_antenna_cmd);
  2157. buf = wmi_buf_alloc(wmi_handle, len);
  2158. if (!buf) {
  2159. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2160. return QDF_STATUS_E_NOMEM;
  2161. }
  2162. cmd = (wmi_peer_sant_set_tx_antenna_cmd *)wmi_buf_data(buf);
  2163. cmd->vdev_id = param->vdev_id;
  2164. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
  2165. cmd->antenna_series[0] = param->antenna_array[0];
  2166. cmd->antenna_series[1] = param->antenna_array[1];
  2167. ret = wmi_unified_cmd_send(wmi_handle,
  2168. buf,
  2169. len,
  2170. WMI_PEER_SMART_ANT_SET_TX_ANTENNA_CMDID);
  2171. if (ret != 0) {
  2172. qdf_print(" %s :WMI Failed\n", __func__);
  2173. qdf_print("%s: Failed to send WMI_PEER_SMART_ANT_SET_TX_ANTENNA_CMDID.\n"
  2174. " Node: %s tx_antennas: [0x%08x 0x%08x] cmdstatus=%d\n",
  2175. __func__,
  2176. ether_sprintf(macaddr),
  2177. cmd->antenna_series[0],
  2178. cmd->antenna_series[1],
  2179. ret);
  2180. wmi_buf_free(buf);
  2181. }
  2182. return ret;
  2183. }
  2184. /**
  2185. * send_smart_ant_set_training_info_cmd_non_tlv() - WMI set smart antenna
  2186. * training information function
  2187. * @param wmi_handle : handle to WMI.
  2188. * @macaddr : vdev mac address
  2189. * @param param : pointer to tx antenna param
  2190. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  2191. */
  2192. static QDF_STATUS send_smart_ant_set_training_info_cmd_non_tlv(
  2193. wmi_unified_t wmi_handle,
  2194. uint8_t macaddr[IEEE80211_ADDR_LEN],
  2195. struct smart_ant_training_info_params *param)
  2196. {
  2197. wmi_peer_sant_set_train_antenna_cmd *cmd;
  2198. wmi_buf_t buf;
  2199. int len = 0;
  2200. int ret;
  2201. len = sizeof(wmi_peer_sant_set_train_antenna_cmd);
  2202. buf = wmi_buf_alloc(wmi_handle, len);
  2203. if (!buf) {
  2204. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2205. return QDF_STATUS_E_NOMEM;
  2206. }
  2207. cmd = (wmi_peer_sant_set_train_antenna_cmd *)wmi_buf_data(buf);
  2208. cmd->vdev_id = param->vdev_id;
  2209. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
  2210. qdf_mem_copy(&cmd->train_rate_series[0], &param->rate_array[0],
  2211. (sizeof(uint32_t)*SMART_ANT_MAX_RATE_SERIES));
  2212. qdf_mem_copy(&cmd->train_antenna_series[0], &param->antenna_array[0],
  2213. (sizeof(uint32_t)*SMART_ANT_MAX_RATE_SERIES));
  2214. cmd->num_pkts = param->numpkts;
  2215. ret = wmi_unified_cmd_send(wmi_handle,
  2216. buf,
  2217. len,
  2218. WMI_PEER_SMART_ANT_SET_TRAIN_INFO_CMDID);
  2219. if (ret != 0) {
  2220. qdf_print(" %s :WMI Failed\n", __func__);
  2221. qdf_print("%s: Failed to Send WMI_PEER_SMART_ANT_SET_TRAIN_INFO_CMDID.\n"
  2222. " Train Node: %s rate_array[0x%02x 0x%02x] "
  2223. "tx_antennas: [0x%08x 0x%08x] cmdstatus=%d\n",
  2224. __func__,
  2225. ether_sprintf(macaddr),
  2226. cmd->train_rate_series[0],
  2227. cmd->train_rate_series[1],
  2228. cmd->train_antenna_series[0],
  2229. cmd->train_antenna_series[1],
  2230. ret);
  2231. wmi_buf_free(buf);
  2232. }
  2233. return ret;
  2234. }
  2235. /**
  2236. * send_smart_ant_set_node_config_cmd_non_tlv() - WMI set node
  2237. * configuration function
  2238. * @param wmi_handle : handle to WMI.
  2239. * @macaddr : vdev mad address
  2240. * @param param : pointer to tx antenna param
  2241. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  2242. */
  2243. static QDF_STATUS send_smart_ant_set_node_config_cmd_non_tlv(wmi_unified_t wmi_handle,
  2244. uint8_t macaddr[IEEE80211_ADDR_LEN],
  2245. struct smart_ant_node_config_params *param)
  2246. {
  2247. wmi_peer_sant_set_node_config_ops_cmd *cmd;
  2248. wmi_buf_t buf;
  2249. int len = 0;
  2250. int ret;
  2251. int i = 0;
  2252. len = sizeof(wmi_peer_sant_set_node_config_ops_cmd);
  2253. if ((param->args_count == 0) || (param->args_count >
  2254. (sizeof(cmd->args) / sizeof(cmd->args[0])))) {
  2255. qdf_print("%s: Can't send a command with %d arguments\n",
  2256. __func__, param->args_count);
  2257. return QDF_STATUS_E_FAILURE;
  2258. }
  2259. buf = wmi_buf_alloc(wmi_handle, len);
  2260. if (!buf) {
  2261. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2262. return QDF_STATUS_E_NOMEM;
  2263. }
  2264. cmd = (wmi_peer_sant_set_node_config_ops_cmd *)wmi_buf_data(buf);
  2265. cmd->vdev_id = param->vdev_id;
  2266. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
  2267. cmd->cmd_id = param->cmd_id;
  2268. cmd->args_count = param->args_count;
  2269. for (i = 0; i < param->args_count; i++)
  2270. cmd->args[i] = param->args_arr[i];
  2271. ret = wmi_unified_cmd_send(wmi_handle,
  2272. buf,
  2273. len,
  2274. WMI_PEER_SMART_ANT_SET_NODE_CONFIG_OPS_CMDID);
  2275. if (ret != 0) {
  2276. qdf_print(" %s :WMI Failed\n", __func__);
  2277. qdf_print("%s: Sent "
  2278. "WMI_PEER_SMART_ANT_SET_NODE_CONFIG_OPS_CMDID, cmd_id:"
  2279. " 0x%x\n Node: %s cmdstatus=%d\n",
  2280. __func__, param->cmd_id, ether_sprintf(macaddr), ret);
  2281. }
  2282. return ret;
  2283. }
  2284. /**
  2285. * send_smart_ant_enable_tx_feedback_cmd_non_tlv() - WMI enable smart antenna
  2286. * tx feedback function
  2287. * @param wmi_handle : handle to WMI.
  2288. * @param param : pointer to hold enable param
  2289. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  2290. */
  2291. static QDF_STATUS send_smart_ant_enable_tx_feedback_cmd_non_tlv(
  2292. wmi_unified_t wmi_handle,
  2293. struct smart_ant_enable_tx_feedback_params *param)
  2294. {
  2295. uint32_t types = 0;
  2296. int len = 0;
  2297. wmi_buf_t buf;
  2298. wmi_pdev_pktlog_enable_cmd *cmd;
  2299. if (param->enable == 1) {
  2300. types |= WMI_PKTLOG_EVENT_TX;
  2301. types |= WMI_PKTLOG_EVENT_SMART_ANTENNA;
  2302. len = sizeof(wmi_pdev_pktlog_enable_cmd);
  2303. buf = wmi_buf_alloc(wmi_handle, len);
  2304. if (!buf) {
  2305. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2306. return QDF_STATUS_E_FAILURE;
  2307. }
  2308. cmd = (wmi_pdev_pktlog_enable_cmd *)wmi_buf_data(buf);
  2309. cmd->evlist = types;
  2310. /*enabling the pktlog for smart antenna tx feedback*/
  2311. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  2312. WMI_PDEV_PKTLOG_ENABLE_CMDID))
  2313. return QDF_STATUS_E_FAILURE;
  2314. return QDF_STATUS_SUCCESS;
  2315. } else if (param->enable == 0) {
  2316. buf = wmi_buf_alloc(wmi_handle, 0);
  2317. if (!buf) {
  2318. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2319. return QDF_STATUS_E_FAILURE;
  2320. }
  2321. if (!wmi_unified_cmd_send(wmi_handle, buf, len,
  2322. WMI_PDEV_PKTLOG_DISABLE_CMDID))
  2323. return QDF_STATUS_E_FAILURE;
  2324. return QDF_STATUS_SUCCESS;
  2325. } else
  2326. return QDF_STATUS_E_FAILURE;
  2327. }
  2328. /**
  2329. * send_vdev_spectral_configure_cmd_non_tlv() - send VDEV spectral configure
  2330. * command to fw
  2331. * @wmi_handle: wmi handle
  2332. * @param: pointer to hold spectral config parameter
  2333. *
  2334. * Return: 0 for success or error code
  2335. */
  2336. static QDF_STATUS send_vdev_spectral_configure_cmd_non_tlv(wmi_unified_t wmi_handle,
  2337. struct vdev_spectral_configure_params *param)
  2338. {
  2339. wmi_vdev_spectral_configure_cmd *cmd;
  2340. wmi_buf_t buf;
  2341. int len = 0;
  2342. int ret;
  2343. len = sizeof(wmi_vdev_spectral_configure_cmd);
  2344. buf = wmi_buf_alloc(wmi_handle, len);
  2345. if (!buf) {
  2346. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2347. return QDF_STATUS_E_NOMEM;
  2348. }
  2349. cmd = (wmi_vdev_spectral_configure_cmd *)wmi_buf_data(buf);
  2350. cmd->vdev_id = param->vdev_id;
  2351. cmd->spectral_scan_count = param->count;
  2352. cmd->spectral_scan_period = param->period;
  2353. cmd->spectral_scan_priority = param->spectral_pri;
  2354. cmd->spectral_scan_fft_size = param->fft_size;
  2355. cmd->spectral_scan_gc_ena = param->gc_enable;
  2356. cmd->spectral_scan_restart_ena = param->restart_enable;
  2357. cmd->spectral_scan_noise_floor_ref = param->noise_floor_ref;
  2358. cmd->spectral_scan_init_delay = param->init_delay;
  2359. cmd->spectral_scan_nb_tone_thr = param->nb_tone_thr;
  2360. cmd->spectral_scan_str_bin_thr = param->str_bin_thr;
  2361. cmd->spectral_scan_wb_rpt_mode = param->wb_rpt_mode;
  2362. cmd->spectral_scan_rssi_rpt_mode = param->rssi_rpt_mode;
  2363. cmd->spectral_scan_rssi_thr = param->rssi_thr;
  2364. cmd->spectral_scan_pwr_format = param->pwr_format;
  2365. cmd->spectral_scan_rpt_mode = param->rpt_mode;
  2366. cmd->spectral_scan_bin_scale = param->bin_scale;
  2367. cmd->spectral_scan_dBm_adj = param->dBm_adj;
  2368. cmd->spectral_scan_chn_mask = param->chn_mask;
  2369. ret = wmi_unified_cmd_send(wmi_handle,
  2370. buf,
  2371. len,
  2372. WMI_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID);
  2373. #ifdef OL_SPECTRAL_DEBUG_CONFIG_INTERACTIONS
  2374. qdf_print("%s: Sent "
  2375. "WMI_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID\n", __func__);
  2376. qdf_print("vdev_id = %u\n"
  2377. "spectral_scan_count = %u\n"
  2378. "spectral_scan_period = %u\n"
  2379. "spectral_scan_priority = %u\n"
  2380. "spectral_scan_fft_size = %u\n"
  2381. "spectral_scan_gc_ena = %u\n"
  2382. "spectral_scan_restart_ena = %u\n"
  2383. "spectral_scan_noise_floor_ref = %u\n"
  2384. "spectral_scan_init_delay = %u\n"
  2385. "spectral_scan_nb_tone_thr = %u\n"
  2386. "spectral_scan_str_bin_thr = %u\n"
  2387. "spectral_scan_wb_rpt_mode = %u\n"
  2388. "spectral_scan_rssi_rpt_mode = %u\n"
  2389. "spectral_scan_rssi_thr = %u\n"
  2390. "spectral_scan_pwr_format = %u\n"
  2391. "spectral_scan_rpt_mode = %u\n"
  2392. "spectral_scan_bin_scale = %u\n"
  2393. "spectral_scan_dBm_adj = %u\n"
  2394. "spectral_scan_chn_mask = %u\n",
  2395. param->vdev_id,
  2396. param->count,
  2397. param->period,
  2398. param->spectral_pri,
  2399. param->fft_size,
  2400. param->gc_enable,
  2401. param->restart_enable,
  2402. param->noise_floor_ref,
  2403. param->init_delay,
  2404. param->nb_tone_thr,
  2405. param->str_bin_thr,
  2406. param->wb_rpt_mode,
  2407. param->rssi_rpt_mode,
  2408. param->rssi_thr,
  2409. param->pwr_format,
  2410. param->rpt_mode,
  2411. param->bin_scale,
  2412. param->dBm_adj,
  2413. param->chn_mask);
  2414. qdf_print("%s: Status: %d\n\n", __func__, ret);
  2415. #endif /* OL_SPECTRAL_DEBUG_CONFIG_INTERACTIONS */
  2416. return ret;
  2417. }
  2418. #ifdef WLAN_SUPPORT_FILS
  2419. /**
  2420. * send_fils_discovery_send_cmd_non_tlv() - WMI FILS Discovery send function
  2421. * @wmi_handle: handle to WMI
  2422. * @param: pointer to hold FD send cmd parameter
  2423. *
  2424. * Return: QDF_STATUS_SUCCESS on success and QDF_STATUS error code on failure.
  2425. */
  2426. static QDF_STATUS
  2427. send_fils_discovery_send_cmd_non_tlv(wmi_unified_t wmi_handle,
  2428. struct fd_params *param)
  2429. {
  2430. wmi_fd_send_from_host_cmd_t *cmd;
  2431. wmi_buf_t wmi_buf;
  2432. QDF_STATUS status;
  2433. int fd_len = qdf_nbuf_len(param->wbuf);
  2434. int len = sizeof(wmi_fd_send_from_host_cmd_t);
  2435. wmi_buf = wmi_buf_alloc(wmi_handle, roundup(len, sizeof(u_int32_t)));
  2436. if (!wmi_buf) {
  2437. WMI_LOGE("wmi_buf_alloc failed\n");
  2438. return QDF_STATUS_E_NOMEM;
  2439. }
  2440. cmd = (wmi_fd_send_from_host_cmd_t *)wmi_buf_data(wmi_buf);
  2441. cmd->vdev_id = param->vdev_id;
  2442. cmd->data_len = fd_len;
  2443. cmd->frag_ptr = qdf_nbuf_get_frag_paddr(param->wbuf, 0);
  2444. cmd->frame_ctrl = param->frame_ctrl;
  2445. status = wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  2446. WMI_PDEV_SEND_FD_CMDID);
  2447. if (status != QDF_STATUS_SUCCESS) {
  2448. wmi_buf_free(wmi_buf);
  2449. return QDF_STATUS_E_FAILURE;
  2450. }
  2451. return QDF_STATUS_SUCCESS;
  2452. }
  2453. /**
  2454. * send_vdev_fils_enable_cmd_non_tlv() - enable/Disable FD Frame command to fw
  2455. * @wmi_handle: wmi handle
  2456. * @param: pointer to hold FILS discovery enable param
  2457. *
  2458. * Return: QDF_STATUS_SUCCESS on success or QDF_STATUS error code on failure
  2459. */
  2460. static QDF_STATUS
  2461. send_vdev_fils_enable_cmd_non_tlv(wmi_unified_t wmi_handle,
  2462. struct config_fils_params *param)
  2463. {
  2464. wmi_enable_fils_cmd *cmd;
  2465. wmi_buf_t buf;
  2466. QDF_STATUS status;
  2467. int len = sizeof(wmi_enable_fils_cmd);
  2468. buf = wmi_buf_alloc(wmi_handle, len);
  2469. if (!buf) {
  2470. WMI_LOGE("wmi_buf_alloc failed\n");
  2471. return QDF_STATUS_E_FAILURE;
  2472. }
  2473. cmd = (wmi_enable_fils_cmd *)wmi_buf_data(buf);
  2474. cmd->vdev_id = param->vdev_id;
  2475. cmd->fd_period = param->fd_period;
  2476. WMI_LOGI("Setting FD period to %d vdev id : %d\n",
  2477. param->fd_period, param->vdev_id);
  2478. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  2479. WMI_ENABLE_FILS_CMDID);
  2480. if (status != QDF_STATUS_SUCCESS) {
  2481. wmi_buf_free(buf);
  2482. return QDF_STATUS_E_FAILURE;
  2483. }
  2484. return QDF_STATUS_SUCCESS;
  2485. }
  2486. /**
  2487. * extract_swfda_vdev_id_non_tlv() - extract swfda vdev id from event
  2488. * @wmi_handle: wmi handle
  2489. * @evt_buf: pointer to event buffer
  2490. * @vdev_id: pointer to hold vdev id
  2491. *
  2492. * Return: QDF_STATUS_SUCCESS
  2493. */
  2494. static QDF_STATUS
  2495. extract_swfda_vdev_id_non_tlv(wmi_unified_t wmi_handle,
  2496. void *evt_buf, uint32_t *vdev_id)
  2497. {
  2498. wmi_host_swfda_event *swfda_event = (wmi_host_swfda_event *)evt_buf;
  2499. *vdev_id = swfda_event->vdev_id;
  2500. return QDF_STATUS_SUCCESS;
  2501. }
  2502. #endif /* WLAN_SUPPORT_FILS */
  2503. /**
  2504. * send_vdev_spectral_enable_cmd_non_tlv() - send VDEV spectral configure
  2505. * command to fw
  2506. * @wmi_handle: wmi handle
  2507. * @param: pointer to hold spectral enable parameter
  2508. *
  2509. * Return: 0 for success or error code
  2510. */
  2511. static QDF_STATUS send_vdev_spectral_enable_cmd_non_tlv(wmi_unified_t wmi_handle,
  2512. struct vdev_spectral_enable_params *param)
  2513. {
  2514. wmi_vdev_spectral_enable_cmd *cmd;
  2515. wmi_buf_t buf;
  2516. int len = 0;
  2517. int ret;
  2518. len = sizeof(wmi_vdev_spectral_enable_cmd);
  2519. buf = wmi_buf_alloc(wmi_handle, len);
  2520. if (!buf) {
  2521. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2522. return QDF_STATUS_E_NOMEM;
  2523. }
  2524. cmd = (wmi_vdev_spectral_enable_cmd *)wmi_buf_data(buf);
  2525. cmd->vdev_id = param->vdev_id;
  2526. if (param->active_valid) {
  2527. cmd->trigger_cmd = param->active ? 1 : 2;
  2528. /* 1: Trigger, 2: Clear Trigger */
  2529. } else {
  2530. cmd->trigger_cmd = 0; /* 0: Ignore */
  2531. }
  2532. if (param->enabled_valid) {
  2533. cmd->enable_cmd = param->enabled ? 1 : 2;
  2534. /* 1: Enable 2: Disable */
  2535. } else {
  2536. cmd->enable_cmd = 0; /* 0: Ignore */
  2537. }
  2538. #ifdef OL_SPECTRAL_DEBUG_CONFIG_INTERACTIONS
  2539. qdf_print
  2540. ("%s: Sent WMI_VDEV_SPECTRAL_SCAN_ENABLE_CMDID\n", __func__);
  2541. qdf_print("vdev_id = %u\n"
  2542. "trigger_cmd = %u\n"
  2543. "enable_cmd = %u\n",
  2544. cmd->vdev_id,
  2545. cmd->trigger_cmd,
  2546. cmd->enable_cmd);
  2547. qdf_print("%s: Status: %d\n\n", __func__, ret);
  2548. #endif /* OL_SPECTRAL_DEBUG_CONFIG_INTERACTIONS */
  2549. ret = wmi_unified_cmd_send(wmi_handle,
  2550. buf,
  2551. len,
  2552. WMI_VDEV_SPECTRAL_SCAN_ENABLE_CMDID);
  2553. return ret;
  2554. }
  2555. /**
  2556. * send_pdev_set_regdomain_cmd_non_tlv() - send set regdomain command to fw
  2557. * @wmi_handle: wmi handle
  2558. * @param: pointer to pdev regdomain params
  2559. *
  2560. * Return: 0 for success or error code
  2561. */
  2562. static QDF_STATUS
  2563. send_pdev_set_regdomain_cmd_non_tlv(wmi_unified_t wmi_handle,
  2564. struct pdev_set_regdomain_params *param)
  2565. {
  2566. wmi_pdev_set_regdomain_cmd *cmd;
  2567. wmi_buf_t buf;
  2568. int len = sizeof(wmi_pdev_set_regdomain_cmd);
  2569. buf = wmi_buf_alloc(wmi_handle, len);
  2570. if (!buf) {
  2571. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2572. return QDF_STATUS_E_FAILURE;
  2573. }
  2574. cmd = (wmi_pdev_set_regdomain_cmd *)wmi_buf_data(buf);
  2575. cmd->reg_domain = param->currentRDinuse;
  2576. cmd->reg_domain_2G = param->currentRD2G;
  2577. cmd->reg_domain_5G = param->currentRD5G;
  2578. cmd->conformance_test_limit_2G = param->ctl_2G;
  2579. cmd->conformance_test_limit_5G = param->ctl_5G;
  2580. cmd->dfs_domain = param->dfsDomain;
  2581. return wmi_unified_cmd_send(wmi_handle, buf, len,
  2582. WMI_PDEV_SET_REGDOMAIN_CMDID);
  2583. }
  2584. /**
  2585. * send_set_quiet_mode_cmd_non_tlv() - send set quiet mode command to fw
  2586. * @wmi_handle: wmi handle
  2587. * @param: pointer to quiet mode params
  2588. *
  2589. * Return: 0 for success or error code
  2590. */
  2591. static QDF_STATUS
  2592. send_set_quiet_mode_cmd_non_tlv(wmi_unified_t wmi_handle,
  2593. struct set_quiet_mode_params *param)
  2594. {
  2595. wmi_buf_t buf;
  2596. wmi_pdev_set_quiet_cmd *quiet_cmd;
  2597. int len = sizeof(wmi_pdev_set_quiet_cmd);
  2598. buf = wmi_buf_alloc(wmi_handle, len);
  2599. if (!buf) {
  2600. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2601. return QDF_STATUS_E_NOMEM;
  2602. }
  2603. quiet_cmd = (wmi_pdev_set_quiet_cmd *)wmi_buf_data(buf);
  2604. quiet_cmd->enabled = param->enabled;
  2605. quiet_cmd->period = (param->period)*(param->intval);
  2606. quiet_cmd->duration = param->duration;
  2607. quiet_cmd->next_start = param->offset;
  2608. wmi_unified_cmd_send(wmi_handle, buf, len,
  2609. WMI_PDEV_SET_QUIET_MODE_CMDID);
  2610. return QDF_STATUS_SUCCESS;
  2611. }
  2612. /**
  2613. * send_set_beacon_filter_cmd_non_tlv() - send beacon filter command to fw
  2614. * @wmi_handle: wmi handle
  2615. * @param: pointer to beacon filter params
  2616. *
  2617. * Return: 0 for success or error code
  2618. */
  2619. static QDF_STATUS
  2620. send_set_beacon_filter_cmd_non_tlv(wmi_unified_t wmi_handle,
  2621. struct set_beacon_filter_params *param)
  2622. {
  2623. /* Issue WMI command to set beacon filter */
  2624. int i;
  2625. wmi_add_bcn_filter_cmd_t *cmd;
  2626. QDF_STATUS res;
  2627. wmi_buf_t buf = NULL;
  2628. int len = sizeof(wmi_add_bcn_filter_cmd_t);
  2629. buf = wmi_buf_alloc(wmi_handle, len);
  2630. if (!buf) {
  2631. qdf_print("buf alloc failed\n");
  2632. return QDF_STATUS_E_NOMEM;
  2633. }
  2634. cmd = (wmi_add_bcn_filter_cmd_t *)wmi_buf_data(buf);
  2635. cmd->vdev_id = param->vdev_id;
  2636. qdf_print("vdev_id: %d\n", cmd->vdev_id);
  2637. for (i = 0; i < BCN_FLT_MAX_ELEMS_IE_LIST; i++)
  2638. cmd->ie_map[i] = 0;
  2639. if (param->ie) {
  2640. for (i = 0; i < BCN_FLT_MAX_ELEMS_IE_LIST; i++)
  2641. cmd->ie_map[i] = param->ie[i];
  2642. }
  2643. res = wmi_unified_cmd_send(wmi_handle, buf, len,
  2644. WMI_ADD_BCN_FILTER_CMDID);
  2645. return (res == QDF_STATUS_SUCCESS) ?
  2646. QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
  2647. }
  2648. /**
  2649. * send_remove_beacon_filter_cmd_non_tlv() - send remove beacon filter command
  2650. * to fw
  2651. * @wmi_handle: wmi handle
  2652. * @param: pointer to remove beacon filter params
  2653. *
  2654. * Return: 0 for success or error code
  2655. */
  2656. static QDF_STATUS
  2657. send_remove_beacon_filter_cmd_non_tlv(wmi_unified_t wmi_handle,
  2658. struct remove_beacon_filter_params *param)
  2659. {
  2660. wmi_rmv_bcn_filter_cmd_t *cmd;
  2661. QDF_STATUS res;
  2662. wmi_buf_t buf = NULL;
  2663. int len = sizeof(wmi_rmv_bcn_filter_cmd_t);
  2664. buf = wmi_buf_alloc(wmi_handle, len);
  2665. if (!buf) {
  2666. qdf_print("buf alloc failed\n");
  2667. return QDF_STATUS_E_NOMEM;
  2668. }
  2669. cmd = (wmi_rmv_bcn_filter_cmd_t *)wmi_buf_data(buf);
  2670. cmd->vdev_id = param->vdev_id;
  2671. res = wmi_unified_cmd_send(wmi_handle, buf, len,
  2672. WMI_RMV_BCN_FILTER_CMDID);
  2673. return (res == QDF_STATUS_SUCCESS) ?
  2674. QDF_STATUS_SUCCESS : QDF_STATUS_E_FAILURE;
  2675. }
  2676. /**
  2677. * send_mgmt_cmd_non_tlv() - send mgmt command to fw
  2678. * @wmi_handle: wmi handle
  2679. * @param: pointer to mgmt params
  2680. * Return: 0 for success or error code
  2681. */
  2682. static QDF_STATUS
  2683. send_mgmt_cmd_non_tlv(wmi_unified_t wmi_handle,
  2684. struct wmi_mgmt_params *param)
  2685. {
  2686. wmi_mgmt_tx_cmd *cmd;
  2687. wmi_buf_t wmi_buf;
  2688. int len = sizeof(wmi_mgmt_tx_hdr) + param->frm_len;
  2689. wmi_buf = wmi_buf_alloc(wmi_handle, roundup(len, sizeof(u_int32_t)));
  2690. if (!wmi_buf) {
  2691. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  2692. return QDF_STATUS_E_FAILURE;
  2693. }
  2694. cmd = (wmi_mgmt_tx_cmd *)wmi_buf_data(wmi_buf);
  2695. cmd->hdr.vdev_id = param->vdev_id;
  2696. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->macaddr, &cmd->hdr.peer_macaddr);
  2697. cmd->hdr.buf_len = param->frm_len;
  2698. #ifdef BIG_ENDIAN_HOST
  2699. {
  2700. /* for big endian host, copy engine byte_swap is enabled
  2701. * But the mgmt frame buffer content is in network byte order
  2702. * Need to byte swap the mgmt frame buffer content - so when
  2703. * copy engine does byte_swap - target gets buffer content in
  2704. * the correct order
  2705. */
  2706. int i;
  2707. u_int32_t *destp, *srcp;
  2708. destp = (u_int32_t *)cmd->bufp;
  2709. srcp = (u_int32_t *)wmi_buf_data(param->tx_frame);
  2710. for (i = 0; i < (roundup(param->frm_len,
  2711. sizeof(u_int32_t))/4); i++) {
  2712. *destp = qdf_le32_to_cpu(*srcp);
  2713. destp++; srcp++;
  2714. }
  2715. }
  2716. #else
  2717. qdf_mem_copy(cmd->bufp, wmi_buf_data(param->tx_frame), param->frm_len);
  2718. #endif
  2719. /* Send the management frame buffer to the target */
  2720. wmi_unified_cmd_send(wmi_handle, wmi_buf, roundup(len,
  2721. sizeof(u_int32_t)), WMI_MGMT_TX_CMDID);
  2722. return QDF_STATUS_SUCCESS;
  2723. }
  2724. /**
  2725. * send_addba_clearresponse_cmd_non_tlv() - send addba clear response command
  2726. * to fw
  2727. * @wmi_handle: wmi handle
  2728. * @param: pointer to addba clearresp params
  2729. * @macaddr: vdev mac address
  2730. * Return: 0 for success or error code
  2731. */
  2732. static QDF_STATUS
  2733. send_addba_clearresponse_cmd_non_tlv(wmi_unified_t wmi_handle,
  2734. uint8_t macaddr[IEEE80211_ADDR_LEN],
  2735. struct addba_clearresponse_params *param)
  2736. {
  2737. wmi_addba_clear_resp_cmd *cmd;
  2738. wmi_buf_t buf;
  2739. int len = sizeof(wmi_addba_clear_resp_cmd);
  2740. buf = wmi_buf_alloc(wmi_handle, len);
  2741. if (!buf) {
  2742. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  2743. return QDF_STATUS_E_FAILURE;
  2744. }
  2745. cmd = (wmi_addba_clear_resp_cmd *)wmi_buf_data(buf);
  2746. cmd->vdev_id = param->vdev_id;
  2747. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
  2748. /* Send the management frame buffer to the target */
  2749. wmi_unified_cmd_send(wmi_handle, buf, len, WMI_ADDBA_CLEAR_RESP_CMDID);
  2750. return QDF_STATUS_SUCCESS;
  2751. }
  2752. /**
  2753. * send_addba_send_cmd_non_tlv() - send addba send command to fw
  2754. * @wmi_handle: wmi handle
  2755. * @param: pointer to addba send params
  2756. * @macaddr: vdev mac address
  2757. * Return: 0 for success or error code
  2758. */
  2759. static QDF_STATUS
  2760. send_addba_send_cmd_non_tlv(wmi_unified_t wmi_handle,
  2761. uint8_t macaddr[IEEE80211_ADDR_LEN],
  2762. struct addba_send_params *param)
  2763. {
  2764. wmi_addba_send_cmd *cmd;
  2765. wmi_buf_t buf;
  2766. int len = sizeof(wmi_addba_send_cmd);
  2767. buf = wmi_buf_alloc(wmi_handle, len);
  2768. if (!buf) {
  2769. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  2770. return QDF_STATUS_E_FAILURE;
  2771. }
  2772. cmd = (wmi_addba_send_cmd *)wmi_buf_data(buf);
  2773. cmd->vdev_id = param->vdev_id;
  2774. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
  2775. cmd->tid = param->tidno;
  2776. cmd->buffersize = param->buffersize;
  2777. /* Send the management frame buffer to the target */
  2778. wmi_unified_cmd_send(wmi_handle, buf, len, WMI_ADDBA_SEND_CMDID);
  2779. return QDF_STATUS_SUCCESS;
  2780. }
  2781. /**
  2782. * send_delba_send_cmd_non_tlv() - send delba send command to fw
  2783. * @wmi_handle: wmi handle
  2784. * @param: pointer to delba send params
  2785. * @macaddr: vdev mac address
  2786. * Return: 0 for success or error code
  2787. */
  2788. static QDF_STATUS
  2789. send_delba_send_cmd_non_tlv(wmi_unified_t wmi_handle,
  2790. uint8_t macaddr[IEEE80211_ADDR_LEN],
  2791. struct delba_send_params *param)
  2792. {
  2793. wmi_delba_send_cmd *cmd;
  2794. wmi_buf_t buf;
  2795. int len = sizeof(wmi_delba_send_cmd);
  2796. buf = wmi_buf_alloc(wmi_handle, len);
  2797. if (!buf) {
  2798. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  2799. return QDF_STATUS_E_NOMEM;
  2800. }
  2801. cmd = (wmi_delba_send_cmd *)wmi_buf_data(buf);
  2802. cmd->vdev_id = param->vdev_id;
  2803. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
  2804. cmd->tid = param->tidno;
  2805. cmd->initiator = param->initiator;
  2806. cmd->reasoncode = param->reasoncode;
  2807. /* send the management frame buffer to the target */
  2808. wmi_unified_cmd_send(wmi_handle, buf, len, WMI_DELBA_SEND_CMDID);
  2809. return QDF_STATUS_SUCCESS;
  2810. }
  2811. /**
  2812. * send_addba_setresponse_cmd_non_tlv() - send addba set response command to fw
  2813. * @wmi_handle: wmi handle
  2814. * @param: pointer to addba setresp params
  2815. * @macaddr: vdev mac address
  2816. * Return: 0 for success or error code
  2817. */
  2818. static QDF_STATUS
  2819. send_addba_setresponse_cmd_non_tlv(wmi_unified_t wmi_handle,
  2820. uint8_t macaddr[IEEE80211_ADDR_LEN],
  2821. struct addba_setresponse_params *param)
  2822. {
  2823. wmi_addba_setresponse_cmd *cmd;
  2824. wmi_buf_t buf;
  2825. int len = sizeof(wmi_addba_setresponse_cmd);
  2826. buf = wmi_buf_alloc(wmi_handle, len);
  2827. if (!buf) {
  2828. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  2829. return QDF_STATUS_E_NOMEM;
  2830. }
  2831. cmd = (wmi_addba_setresponse_cmd *)wmi_buf_data(buf);
  2832. cmd->vdev_id = param->vdev_id;
  2833. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
  2834. cmd->tid = param->tidno;
  2835. cmd->statuscode = param->statuscode;
  2836. /* send the management frame buffer to the target */
  2837. wmi_unified_cmd_send(wmi_handle, buf, len, WMI_ADDBA_SET_RESP_CMDID);
  2838. return QDF_STATUS_SUCCESS;
  2839. }
  2840. /**
  2841. * send_singleamsdu_cmd_non_tlv() - send single amsdu command to fw
  2842. * @wmi_handle: wmi handle
  2843. * @param: pointer to single amsdu params
  2844. * @macaddr: vdev mac address
  2845. * Return: 0 for success or error code
  2846. */
  2847. static QDF_STATUS
  2848. send_singleamsdu_cmd_non_tlv(wmi_unified_t wmi_handle,
  2849. uint8_t macaddr[IEEE80211_ADDR_LEN],
  2850. struct singleamsdu_params *param)
  2851. {
  2852. wmi_send_singleamsdu_cmd *cmd;
  2853. wmi_buf_t buf;
  2854. int len = sizeof(wmi_send_singleamsdu_cmd);
  2855. buf = wmi_buf_alloc(wmi_handle, len);
  2856. if (!buf) {
  2857. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  2858. return QDF_STATUS_E_NOMEM;
  2859. }
  2860. cmd = (wmi_send_singleamsdu_cmd *)wmi_buf_data(buf);
  2861. cmd->vdev_id = param->vdev_id;
  2862. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
  2863. cmd->tid = param->tidno;
  2864. /* send the management frame buffer to the target */
  2865. wmi_unified_cmd_send(wmi_handle, buf, len, WMI_SEND_SINGLEAMSDU_CMDID);
  2866. return QDF_STATUS_SUCCESS;
  2867. }
  2868. /**
  2869. * send_set_qboost_param_cmd_non_tlv() - send set qboost command to fw
  2870. * @wmi_handle: wmi handle
  2871. * @param: pointer to qboost params
  2872. * @macaddr: vdev mac address
  2873. * Return: 0 for success or error code
  2874. */
  2875. static QDF_STATUS
  2876. send_set_qboost_param_cmd_non_tlv(wmi_unified_t wmi_handle,
  2877. uint8_t macaddr[IEEE80211_ADDR_LEN],
  2878. struct set_qboost_params *param)
  2879. {
  2880. WMI_QBOOST_CFG_CMD *cmd;
  2881. wmi_buf_t buf;
  2882. int ret;
  2883. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  2884. if (!buf) {
  2885. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  2886. return QDF_STATUS_E_FAILURE;
  2887. }
  2888. cmd = (WMI_QBOOST_CFG_CMD *)wmi_buf_data(buf);
  2889. cmd->vdev_id = param->vdev_id;
  2890. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->peer_macaddr);
  2891. cmd->qb_enable = param->value;
  2892. ret = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
  2893. WMI_QBOOST_CFG_CMDID);
  2894. return ret;
  2895. }
  2896. /**
  2897. * send_mu_scan_cmd_non_tlv() - send mu scan command to fw
  2898. * @wmi_handle: wmi handle
  2899. * @param: pointer to mu scan params
  2900. * Return: 0 for success or error code
  2901. */
  2902. static QDF_STATUS
  2903. send_mu_scan_cmd_non_tlv(wmi_unified_t wmi_handle,
  2904. struct mu_scan_params *param)
  2905. {
  2906. wmi_mu_start_cmd *cmd;
  2907. wmi_buf_t buf;
  2908. buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_mu_start_cmd));
  2909. if (!buf) {
  2910. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  2911. return QDF_STATUS_E_FAILURE;
  2912. }
  2913. cmd = (wmi_mu_start_cmd *)wmi_buf_data(buf);
  2914. cmd->mu_request_id = param->id;
  2915. cmd->mu_duration = param->duration;
  2916. cmd->mu_type = param->type;
  2917. cmd->lteu_tx_power = param->lteu_tx_power;
  2918. cmd->rssi_thr_bssid = param->rssi_thr_bssid;
  2919. cmd->rssi_thr_sta = param->rssi_thr_sta;
  2920. cmd->rssi_thr_sc = param->rssi_thr_sc;
  2921. cmd->plmn_id = param->plmn_id;
  2922. cmd->alpha_num_bssid = param->alpha_num_bssid;
  2923. return wmi_unified_cmd_send(wmi_handle, buf,
  2924. sizeof(wmi_mu_start_cmd),
  2925. WMI_MU_CAL_START_CMDID);
  2926. }
  2927. /**
  2928. * send_lteu_config_cmd_non_tlv() - send lteu config command to fw
  2929. * @wmi_handle: wmi handle
  2930. * @param: pointer to lteu config params
  2931. * Return: 0 for success or error code
  2932. */
  2933. static QDF_STATUS
  2934. send_lteu_config_cmd_non_tlv(wmi_unified_t wmi_handle,
  2935. struct lteu_config_params *param)
  2936. {
  2937. wmi_set_lteu_config *cmd;
  2938. wmi_buf_t buf;
  2939. int i;
  2940. buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_set_lteu_config));
  2941. if (!buf) {
  2942. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  2943. return QDF_STATUS_E_FAILURE;
  2944. }
  2945. cmd = (wmi_set_lteu_config *)wmi_buf_data(buf);
  2946. cmd->gpio_enable = param->lteu_gpio_start;
  2947. cmd->num_lteu_bins = param->lteu_num_bins;
  2948. for (i = 0; i < cmd->num_lteu_bins; i++) {
  2949. cmd->mu_rssi_threshold[i] = param->lteu_thresh[i];
  2950. cmd->mu_weight[i] = param->lteu_weight[i];
  2951. cmd->mu_gamma[i] = param->lteu_gamma[i];
  2952. }
  2953. cmd->mu_scan_timeout = param->lteu_scan_timeout;
  2954. cmd->alpha_num_bssid = param->alpha_num_bssid;
  2955. cmd->use_actual_nf = param->use_actual_nf;
  2956. cmd->wifi_tx_power = param->wifi_tx_power;
  2957. cmd->allow_err_packets = param->allow_err_packets;
  2958. return wmi_unified_cmd_send(wmi_handle, buf,
  2959. sizeof(wmi_set_lteu_config),
  2960. WMI_SET_LTEU_CONFIG_CMDID);
  2961. }
  2962. /**
  2963. * send_pdev_get_tpc_config_cmd_non_tlv() - send get tpc config command to fw
  2964. * @wmi_handle: wmi handle
  2965. * @param: pointer to get tpc config params
  2966. *
  2967. * Return: 0 for success or error code
  2968. */
  2969. static QDF_STATUS
  2970. send_pdev_get_tpc_config_cmd_non_tlv(wmi_unified_t wmi_handle,
  2971. uint32_t param)
  2972. {
  2973. wmi_pdev_get_tpc_config_cmd *cmd;
  2974. wmi_buf_t buf;
  2975. int32_t len = sizeof(wmi_pdev_get_tpc_config_cmd);
  2976. buf = wmi_buf_alloc(wmi_handle, len);
  2977. if (!buf) {
  2978. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  2979. return QDF_STATUS_E_FAILURE;
  2980. }
  2981. cmd = (wmi_pdev_get_tpc_config_cmd *)wmi_buf_data(buf);
  2982. cmd->param = param;
  2983. return wmi_unified_cmd_send(wmi_handle, buf, len,
  2984. WMI_PDEV_GET_TPC_CONFIG_CMDID);
  2985. }
  2986. /**
  2987. * send_set_bwf_cmd_non_tlv() - send set bwf command to fw
  2988. * @wmi_handle: wmi handle
  2989. * @param: pointer to set bwf param
  2990. *
  2991. * Return: 0 for success or error code
  2992. */
  2993. static QDF_STATUS
  2994. send_set_bwf_cmd_non_tlv(wmi_unified_t wmi_handle,
  2995. struct set_bwf_params *param)
  2996. {
  2997. struct wmi_bwf_peer_info *peer_info;
  2998. wmi_peer_bwf_request *cmd;
  2999. wmi_buf_t buf;
  3000. int len = sizeof(wmi_peer_bwf_request);
  3001. int i, retval = 0;
  3002. len += param->num_peers * sizeof(struct wmi_bwf_peer_info);
  3003. buf = wmi_buf_alloc(wmi_handle, len);
  3004. if (!buf) {
  3005. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3006. return QDF_STATUS_E_FAILURE;
  3007. }
  3008. cmd = (wmi_peer_bwf_request *)wmi_buf_data(buf);
  3009. qdf_mem_copy(&(cmd->num_peers), &(param->num_peers), sizeof(uint32_t));
  3010. peer_info = (struct wmi_bwf_peer_info *)&(cmd->peer_info[0]);
  3011. for (i = 0; i < param->num_peers; i++) {
  3012. qdf_mem_copy(&(peer_info[i].peer_macaddr),
  3013. &(param->peer_info[i].peer_macaddr),
  3014. sizeof(wmi_mac_addr));
  3015. peer_info[i].bwf_guaranteed_bandwidth =
  3016. param->peer_info[i].throughput;
  3017. peer_info[i].bwf_max_airtime = param->peer_info[i].max_airtime;
  3018. peer_info[i].bwf_peer_priority = param->peer_info[i].priority;
  3019. }
  3020. retval = wmi_unified_cmd_send(wmi_handle, buf, len,
  3021. WMI_PEER_BWF_REQUEST_CMDID);
  3022. if (retval)
  3023. wmi_buf_free(buf);
  3024. return retval;
  3025. }
  3026. /**
  3027. * send_set_atf_cmd_non_tlv() - send set atf command to fw
  3028. * @wmi_handle: wmi handle
  3029. * @param: pointer to set atf param
  3030. *
  3031. * Return: 0 for success or error code
  3032. */
  3033. static QDF_STATUS
  3034. send_set_atf_cmd_non_tlv(wmi_unified_t wmi_handle,
  3035. struct set_atf_params *param)
  3036. {
  3037. struct wmi_atf_peer_info *peer_info;
  3038. wmi_peer_atf_request *cmd;
  3039. wmi_buf_t buf;
  3040. int len = sizeof(wmi_peer_atf_request);
  3041. int i, retval = 0;
  3042. len += param->num_peers * sizeof(struct wmi_atf_peer_info);
  3043. buf = wmi_buf_alloc(wmi_handle, len);
  3044. if (!buf) {
  3045. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3046. return QDF_STATUS_E_FAILURE;
  3047. }
  3048. cmd = (wmi_peer_atf_request *)wmi_buf_data(buf);
  3049. qdf_mem_copy(&(cmd->num_peers), &(param->num_peers), sizeof(uint32_t));
  3050. peer_info = (struct wmi_atf_peer_info *)&(cmd->peer_info[0]);
  3051. for (i = 0; i < param->num_peers; i++) {
  3052. qdf_mem_copy(&(peer_info[i].peer_macaddr),
  3053. &(param->peer_info[i].peer_macaddr),
  3054. sizeof(wmi_mac_addr));
  3055. peer_info[i].atf_units = param->peer_info[i].percentage_peer;
  3056. }
  3057. /* qdf_print("wmi_unified_pdev_set_atf peer_num=%d\n", cmd->num_peers); */
  3058. retval = wmi_unified_cmd_send(wmi_handle, buf, len,
  3059. WMI_PEER_ATF_REQUEST_CMDID);
  3060. return retval;
  3061. }
  3062. /**
  3063. * send_atf_peer_request_cmd_non_tlv() - send atf peer request command to fw
  3064. * @wmi_handle: wmi handle
  3065. * @param: pointer to atf peer request param
  3066. *
  3067. * Return: 0 for success or error code
  3068. */
  3069. static QDF_STATUS
  3070. send_atf_peer_request_cmd_non_tlv(wmi_unified_t wmi_handle,
  3071. struct atf_peer_request_params *param)
  3072. {
  3073. struct wmi_atf_peer_ext_info *peer_ext_info;
  3074. wmi_peer_atf_ext_request *cmd;
  3075. wmi_buf_t buf;
  3076. int len = sizeof(wmi_peer_atf_ext_request);
  3077. int i, retval = 0;
  3078. len += param->num_peers * sizeof(struct wmi_atf_peer_ext_info);
  3079. buf = wmi_buf_alloc(wmi_handle, len);
  3080. if (!buf) {
  3081. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3082. return QDF_STATUS_E_FAILURE;
  3083. }
  3084. cmd = (wmi_peer_atf_ext_request *)wmi_buf_data(buf);
  3085. qdf_mem_copy(&(cmd->num_peers), &(param->num_peers), sizeof(uint32_t));
  3086. peer_ext_info =
  3087. (struct wmi_atf_peer_ext_info *)&(cmd->peer_ext_info[0]);
  3088. for (i = 0; i < param->num_peers; i++) {
  3089. qdf_mem_copy(&(peer_ext_info[i].peer_macaddr),
  3090. &(param->peer_ext_info[i].peer_macaddr),
  3091. sizeof(wmi_mac_addr));
  3092. peer_ext_info[i].atf_groupid =
  3093. param->peer_ext_info[i].group_index;
  3094. peer_ext_info[i].atf_units_reserved =
  3095. param->peer_ext_info[i].atf_index_reserved;
  3096. }
  3097. retval = wmi_unified_cmd_send(wmi_handle, buf, len,
  3098. WMI_PEER_ATF_EXT_REQUEST_CMDID);
  3099. return retval;
  3100. }
  3101. /**
  3102. * send_set_atf_grouping_cmd_non_tlv() - send set atf grouping command to fw
  3103. * @wmi_handle: wmi handle
  3104. * @param: pointer to set atf grouping param
  3105. *
  3106. * Return: 0 for success or error code
  3107. */
  3108. static QDF_STATUS
  3109. send_set_atf_grouping_cmd_non_tlv(wmi_unified_t wmi_handle,
  3110. struct atf_grouping_params *param)
  3111. {
  3112. struct wmi_atf_group_info *group_info;
  3113. wmi_atf_ssid_grp_request *cmd;
  3114. wmi_buf_t buf;
  3115. int len = sizeof(wmi_atf_ssid_grp_request);
  3116. int i, retval = 0;
  3117. len += param->num_groups * sizeof(struct wmi_atf_group_info);
  3118. buf = wmi_buf_alloc(wmi_handle, len);
  3119. if (!buf) {
  3120. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3121. return QDF_STATUS_E_FAILURE;
  3122. }
  3123. cmd = (wmi_atf_ssid_grp_request *)wmi_buf_data(buf);
  3124. qdf_mem_copy(&(cmd->num_groups), &(param->num_groups),
  3125. sizeof(uint32_t));
  3126. group_info = (struct wmi_atf_group_info *)&(cmd->group_info[0]);
  3127. for (i = 0; i < param->num_groups; i++) {
  3128. group_info[i].atf_group_units =
  3129. param->group_info[i].percentage_group;
  3130. group_info[i].atf_group_units_reserved =
  3131. param->group_info[i].atf_group_units_reserved;
  3132. }
  3133. retval = wmi_unified_cmd_send(wmi_handle, buf, len,
  3134. WMI_ATF_SSID_GROUPING_REQUEST_CMDID);
  3135. return retval;
  3136. }
  3137. /**
  3138. * send_wlan_profile_enable_cmd_non_tlv() - send wlan profile enable command
  3139. * to fw
  3140. * @wmi_handle: wmi handle
  3141. * @param: pointer to wlan profile param
  3142. *
  3143. * Return: 0 for success or error code
  3144. */
  3145. static QDF_STATUS
  3146. send_wlan_profile_enable_cmd_non_tlv(wmi_unified_t wmi_handle,
  3147. struct wlan_profile_params *param)
  3148. {
  3149. wmi_buf_t buf;
  3150. uint16_t len;
  3151. wmi_wlan_profile_enable_profile_id_cmd *cmd;
  3152. len = sizeof(wmi_wlan_profile_enable_profile_id_cmd);
  3153. buf = wmi_buf_alloc(wmi_handle, len);
  3154. if (!buf) {
  3155. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3156. return QDF_STATUS_E_FAILURE;
  3157. }
  3158. cmd = (wmi_wlan_profile_enable_profile_id_cmd *)wmi_buf_data(buf);
  3159. cmd->profile_id = param->profile_id;
  3160. cmd->enable = param->enable;
  3161. return wmi_unified_cmd_send(wmi_handle, buf, len,
  3162. WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID);
  3163. }
  3164. /**
  3165. * send_wlan_profile_trigger_cmd_non_tlv() - send wlan profile trigger command
  3166. * to fw
  3167. * @wmi_handle: wmi handle
  3168. * @param: pointer to wlan profile param
  3169. *
  3170. * Return: 0 for success or error code
  3171. */
  3172. static QDF_STATUS
  3173. send_wlan_profile_trigger_cmd_non_tlv(wmi_unified_t wmi_handle,
  3174. struct wlan_profile_params *param)
  3175. {
  3176. wmi_buf_t buf;
  3177. uint16_t len;
  3178. wmi_wlan_profile_trigger_cmd *cmd;
  3179. len = sizeof(wmi_wlan_profile_trigger_cmd);
  3180. buf = wmi_buf_alloc(wmi_handle, len);
  3181. if (!buf) {
  3182. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3183. return QDF_STATUS_E_FAILURE;
  3184. }
  3185. cmd = (wmi_wlan_profile_trigger_cmd *)wmi_buf_data(buf);
  3186. cmd->enable = param->enable;
  3187. return wmi_unified_cmd_send(wmi_handle, buf, len,
  3188. WMI_WLAN_PROFILE_TRIGGER_CMDID);
  3189. }
  3190. #ifdef BIG_ENDIAN_HOST
  3191. void wmi_host_swap_bytes(void *pv, size_t n)
  3192. {
  3193. int noWords;
  3194. int i;
  3195. A_UINT32 *wordPtr;
  3196. noWords = n/sizeof(u_int32_t);
  3197. wordPtr = (u_int32_t *)pv;
  3198. for (i = 0; i < noWords; i++)
  3199. *(wordPtr + i) = __cpu_to_le32(*(wordPtr + i));
  3200. }
  3201. #define WMI_HOST_SWAPME(x, len) wmi_host_swap_bytes(&x, len);
  3202. #endif
  3203. /**
  3204. * send_set_ht_ie_cmd_non_tlv() - send ht ie command to fw
  3205. * @wmi_handle: wmi handle
  3206. * @param: pointer to ht ie param
  3207. *
  3208. * Return: 0 for success or error code
  3209. */
  3210. static QDF_STATUS
  3211. send_set_ht_ie_cmd_non_tlv(wmi_unified_t wmi_handle,
  3212. struct ht_ie_params *param)
  3213. {
  3214. wmi_pdev_set_ht_ie_cmd *cmd;
  3215. wmi_buf_t buf;
  3216. /* adjust length to be next multiple of four */
  3217. int len = (param->ie_len + (sizeof(uint32_t) - 1)) &
  3218. (~(sizeof(uint32_t) - 1));
  3219. /* to account for extra four bytes of ie data in the struct */
  3220. len += (sizeof(wmi_pdev_set_ht_ie_cmd) - 4);
  3221. buf = wmi_buf_alloc(wmi_handle, len);
  3222. if (!buf) {
  3223. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3224. return QDF_STATUS_E_FAILURE;
  3225. }
  3226. cmd = (wmi_pdev_set_ht_ie_cmd *)wmi_buf_data(buf);
  3227. cmd->ie_len = param->ie_len;
  3228. qdf_mem_copy(cmd->ie_data, param->ie_data, param->ie_len);
  3229. #ifdef BIG_ENDIAN_HOST
  3230. WMI_HOST_SWAPME(cmd->ie_data, len-(offsetof(wmi_pdev_set_ht_ie_cmd,
  3231. ie_data)));
  3232. #endif
  3233. return wmi_unified_cmd_send(wmi_handle, buf, len,
  3234. WMI_PDEV_SET_HT_CAP_IE_CMDID);
  3235. }
  3236. /**
  3237. * send_set_vht_ie_cmd_non_tlv() - send vht ie command to fw
  3238. * @wmi_handle: wmi handle
  3239. * @param: pointer to vht ie param
  3240. *
  3241. * Return: 0 for success or error code
  3242. */
  3243. static QDF_STATUS
  3244. send_set_vht_ie_cmd_non_tlv(wmi_unified_t wmi_handle,
  3245. struct vht_ie_params *param)
  3246. {
  3247. wmi_pdev_set_vht_ie_cmd *cmd;
  3248. wmi_buf_t buf;
  3249. /* adjust length to be next multiple of four */
  3250. int len = (param->ie_len + (sizeof(u_int32_t) - 1)) &
  3251. (~(sizeof(u_int32_t) - 1));
  3252. /* to account for extra four bytes of ie data in the struct */
  3253. len += (sizeof(wmi_pdev_set_vht_ie_cmd) - 4);
  3254. buf = wmi_buf_alloc(wmi_handle, len);
  3255. if (!buf) {
  3256. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3257. return QDF_STATUS_E_FAILURE;
  3258. }
  3259. cmd = (wmi_pdev_set_vht_ie_cmd *)wmi_buf_data(buf);
  3260. cmd->ie_len = param->ie_len;
  3261. qdf_mem_copy(cmd->ie_data, param->ie_data, param->ie_len);
  3262. #ifdef BIG_ENDIAN_HOST
  3263. WMI_HOST_SWAPME(cmd->ie_data, len-(offsetof(wmi_pdev_set_vht_ie_cmd,
  3264. ie_data)));
  3265. #endif
  3266. return wmi_unified_cmd_send(wmi_handle, buf, len,
  3267. WMI_PDEV_SET_VHT_CAP_IE_CMDID);
  3268. }
  3269. /**
  3270. * send_wmm_update_cmd_non_tlv() - send wmm update command to fw
  3271. * @wmi_handle: wmi handle
  3272. * @param: pointer to wmm update param
  3273. *
  3274. * Return: 0 for success or error code
  3275. */
  3276. static QDF_STATUS
  3277. send_wmm_update_cmd_non_tlv(wmi_unified_t wmi_handle,
  3278. struct wmm_update_params *param)
  3279. {
  3280. wmi_buf_t buf;
  3281. wmi_pdev_set_wmm_params_cmd *cmd;
  3282. wmi_wmm_params *wmi_param = 0;
  3283. int ac;
  3284. int len = sizeof(wmi_pdev_set_wmm_params_cmd);
  3285. struct wmi_host_wmeParams *wmep;
  3286. buf = wmi_buf_alloc(wmi_handle, len);
  3287. if (!buf) {
  3288. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3289. return QDF_STATUS_SUCCESS;
  3290. }
  3291. cmd = (wmi_pdev_set_wmm_params_cmd *)wmi_buf_data(buf);
  3292. for (ac = 0; ac < WME_NUM_AC; ac++) {
  3293. wmep = &param->wmep_array[ac];
  3294. switch (ac) {
  3295. case WMI_HOST_AC_BE:
  3296. wmi_param = &cmd->wmm_params_ac_be;
  3297. break;
  3298. case WMI_HOST_AC_BK:
  3299. wmi_param = &cmd->wmm_params_ac_bk;
  3300. break;
  3301. case WMI_HOST_AC_VI:
  3302. wmi_param = &cmd->wmm_params_ac_vi;
  3303. break;
  3304. case WMI_HOST_AC_VO:
  3305. wmi_param = &cmd->wmm_params_ac_vo;
  3306. break;
  3307. default:
  3308. break;
  3309. }
  3310. wmi_param->aifs = wmep->wmep_aifsn;
  3311. wmi_param->cwmin = ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmin);
  3312. wmi_param->cwmax = ATH_EXPONENT_TO_VALUE(wmep->wmep_logcwmax);
  3313. wmi_param->txoplimit = ATH_TXOP_TO_US(wmep->wmep_txopLimit);
  3314. wmi_param->acm = wmep->wmep_acm;
  3315. wmi_param->no_ack = wmep->wmep_noackPolicy;
  3316. }
  3317. wmi_unified_cmd_send(wmi_handle, buf, len,
  3318. WMI_PDEV_SET_WMM_PARAMS_CMDID);
  3319. return QDF_STATUS_SUCCESS;
  3320. }
  3321. /**
  3322. * send_set_ant_switch_tbl_cmd_non_tlv() - send ant switch tbl cmd to fw
  3323. * @wmi_handle: wmi handle
  3324. * @param: pointer to hold ant switch tbl param
  3325. *
  3326. * Return: 0 for success or error code
  3327. */
  3328. static QDF_STATUS
  3329. send_set_ant_switch_tbl_cmd_non_tlv(wmi_unified_t wmi_handle,
  3330. struct ant_switch_tbl_params *param)
  3331. {
  3332. uint8_t len;
  3333. wmi_buf_t buf;
  3334. wmi_pdev_set_ant_switch_tbl_cmd *cmd;
  3335. len = sizeof(wmi_pdev_set_ant_switch_tbl_cmd);
  3336. buf = wmi_buf_alloc(wmi_handle, len);
  3337. if (!buf) {
  3338. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3339. return QDF_STATUS_E_NOMEM;
  3340. }
  3341. cmd = (wmi_pdev_set_ant_switch_tbl_cmd *)wmi_buf_data(buf);
  3342. cmd->antCtrlCommon1 = param->ant_ctrl_common1;
  3343. cmd->antCtrlCommon2 = param->ant_ctrl_common2;
  3344. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  3345. WMI_PDEV_SET_ANTENNA_SWITCH_TABLE_CMDID)) {
  3346. return QDF_STATUS_E_FAILURE;
  3347. }
  3348. return QDF_STATUS_SUCCESS;
  3349. }
  3350. /**
  3351. * send_set_ratepwr_table_cmd_non_tlv() - send rate power table cmd to fw
  3352. * @wmi_handle: wmi handle
  3353. * @param: pointer to hold rate power table param
  3354. *
  3355. * Return: 0 for success or error code
  3356. */
  3357. static QDF_STATUS
  3358. send_set_ratepwr_table_cmd_non_tlv(wmi_unified_t wmi_handle,
  3359. struct ratepwr_table_params *param)
  3360. {
  3361. uint16_t len;
  3362. wmi_buf_t buf;
  3363. wmi_pdev_ratepwr_table_cmd *cmd;
  3364. if (!param->ratepwr_tbl)
  3365. return QDF_STATUS_E_FAILURE;
  3366. len = sizeof(wmi_pdev_ratepwr_table_cmd);
  3367. len += roundup(param->ratepwr_len, sizeof(A_UINT32)) - sizeof(A_UINT32);
  3368. /* already 4 bytes in cmd structure */
  3369. qdf_print("wmi buf len = %d\n", len);
  3370. buf = wmi_buf_alloc(wmi_handle, len);
  3371. if (!buf) {
  3372. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3373. return QDF_STATUS_E_NOMEM;
  3374. }
  3375. cmd = (wmi_pdev_ratepwr_table_cmd *)wmi_buf_data(buf);
  3376. cmd->op = RATEPWR_TABLE_OPS_SET;
  3377. cmd->ratepwr_len = param->ratepwr_len;
  3378. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(&cmd->ratepwr_tbl[0],
  3379. param->ratepwr_tbl, param->ratepwr_len);
  3380. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  3381. WMI_PDEV_RATEPWR_TABLE_CMDID)) {
  3382. return QDF_STATUS_E_FAILURE;
  3383. }
  3384. return QDF_STATUS_SUCCESS;
  3385. }
  3386. /**
  3387. * send_get_ratepwr_table_cmd_non_tlv() - send rate power table cmd to fw
  3388. * @wmi_handle: wmi handle
  3389. *
  3390. * Return: 0 for success or error code
  3391. */
  3392. static QDF_STATUS
  3393. send_get_ratepwr_table_cmd_non_tlv(wmi_unified_t wmi_handle)
  3394. {
  3395. uint16_t len;
  3396. wmi_buf_t buf;
  3397. wmi_pdev_ratepwr_table_cmd *cmd;
  3398. len = sizeof(wmi_pdev_ratepwr_table_cmd);
  3399. qdf_print("wmi buf len = %d\n", len);
  3400. buf = wmi_buf_alloc(wmi_handle, len);
  3401. if (!buf) {
  3402. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3403. return QDF_STATUS_E_NOMEM;
  3404. }
  3405. cmd = (wmi_pdev_ratepwr_table_cmd *)wmi_buf_data(buf);
  3406. cmd->op = RATEPWR_TABLE_OPS_GET;
  3407. cmd->ratepwr_len = 0;
  3408. cmd->ratepwr_tbl[0] = 0;
  3409. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  3410. WMI_PDEV_RATEPWR_TABLE_CMDID)) {
  3411. return QDF_STATUS_E_FAILURE;
  3412. }
  3413. return QDF_STATUS_SUCCESS;
  3414. }
  3415. /**
  3416. * send_set_ctl_table_cmd_non_tlv() - send ctl table cmd to fw
  3417. * @wmi_handle: wmi handle
  3418. * @param: pointer to hold ctl table param
  3419. *
  3420. * Return: 0 for success or error code
  3421. */
  3422. static QDF_STATUS
  3423. send_set_ctl_table_cmd_non_tlv(wmi_unified_t wmi_handle,
  3424. struct ctl_table_params *param)
  3425. {
  3426. uint16_t len;
  3427. wmi_buf_t buf;
  3428. wmi_pdev_set_ctl_table_cmd *cmd;
  3429. if (!param->ctl_array)
  3430. return QDF_STATUS_E_FAILURE;
  3431. /* CTL array length check for Beeliner family */
  3432. if (param->target_type == TARGET_TYPE_AR900B ||
  3433. param->target_type == TARGET_TYPE_QCA9984 ||
  3434. param->target_type == TARGET_TYPE_IPQ4019 ||
  3435. param->target_type == TARGET_TYPE_QCA9888) {
  3436. if (param->is_2g) {
  3437. /* For 2G, CTL array length should be 688*/
  3438. if (param->ctl_cmd_len !=
  3439. (4 + (WMI_HOST_NUM_CTLS_2G_11B * 2) +
  3440. (WMI_HOST_NUM_BAND_EDGES_2G_11B * 3) +
  3441. 1 + (WMI_HOST_NUM_CTLS_2G_11B *
  3442. WMI_HOST_NUM_BAND_EDGES_2G_11B) +
  3443. (WMI_HOST_NUM_CTLS_2G_20MHZ * 2) +
  3444. (WMI_HOST_NUM_BAND_EDGES_2G_20MHZ * 3) +
  3445. 1 + (WMI_HOST_NUM_CTLS_2G_20MHZ *
  3446. WMI_HOST_NUM_BAND_EDGES_2G_20MHZ) +
  3447. (WMI_HOST_NUM_CTLS_2G_40MHZ * 2) +
  3448. (WMI_HOST_NUM_BAND_EDGES_2G_40MHZ * 3) +
  3449. (WMI_HOST_NUM_CTLS_2G_40MHZ *
  3450. WMI_HOST_NUM_BAND_EDGES_2G_40MHZ) + 4)) {
  3451. qdf_print("CTL array len not correct\n");
  3452. return QDF_STATUS_E_FAILURE;
  3453. }
  3454. } else {
  3455. /* For 5G, CTL array length should be 1540 */
  3456. if (param->ctl_cmd_len !=
  3457. (4 + (WMI_HOST_NUM_CTLS_5G_11A * 2) +
  3458. (WMI_HOST_NUM_BAND_EDGES_5G_11A * 3) +
  3459. 1 + (WMI_HOST_NUM_CTLS_5G_11A *
  3460. WMI_HOST_NUM_BAND_EDGES_5G_11A) + 1
  3461. + (WMI_HOST_NUM_CTLS_5G_HT20 * 2) +
  3462. (WMI_HOST_NUM_BAND_EDGES_5G_HT20 * 3) +
  3463. 1 + (WMI_HOST_NUM_CTLS_5G_HT20 *
  3464. WMI_HOST_NUM_BAND_EDGES_5G_HT20) +
  3465. (WMI_HOST_NUM_CTLS_5G_HT40 * 2) +
  3466. (WMI_HOST_NUM_BAND_EDGES_5G_HT40 * 3) +
  3467. (WMI_HOST_NUM_CTLS_5G_HT40 *
  3468. WMI_HOST_NUM_BAND_EDGES_5G_HT40) +
  3469. (WMI_HOST_NUM_CTLS_5G_HT80 * 2) +
  3470. (WMI_HOST_NUM_BAND_EDGES_5G_HT80 * 3) +
  3471. (WMI_HOST_NUM_CTLS_5G_HT80 *
  3472. WMI_HOST_NUM_BAND_EDGES_5G_HT80) +
  3473. (WMI_HOST_NUM_CTLS_5G_HT160 * 2) +
  3474. (WMI_HOST_NUM_BAND_EDGES_5G_HT160 * 3) +
  3475. (WMI_HOST_NUM_CTLS_5G_HT160 *
  3476. WMI_HOST_NUM_BAND_EDGES_5G_HT160))) {
  3477. qdf_print("CTL array len not correct\n");
  3478. return QDF_STATUS_E_FAILURE;
  3479. }
  3480. }
  3481. } else {
  3482. if (param->ctl_cmd_len !=
  3483. WMI_HOST_NUM_CTLS_2G * WMI_HOST_NUM_BAND_EDGES_2G * 2 +
  3484. WMI_HOST_NUM_CTLS_5G * WMI_HOST_NUM_BAND_EDGES_5G * 2) {
  3485. qdf_print("CTL array len not correct\n");
  3486. return QDF_STATUS_E_FAILURE;
  3487. }
  3488. }
  3489. len = sizeof(wmi_pdev_set_ctl_table_cmd);
  3490. len += roundup(param->ctl_cmd_len, sizeof(A_UINT32)) - sizeof(A_UINT32);
  3491. qdf_print("wmi buf len = %d\n", len);
  3492. buf = wmi_buf_alloc(wmi_handle, len);
  3493. if (!buf) {
  3494. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3495. return QDF_STATUS_E_FAILURE;
  3496. }
  3497. cmd = (wmi_pdev_set_ctl_table_cmd *)wmi_buf_data(buf);
  3498. cmd->ctl_len = param->ctl_cmd_len;
  3499. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(&cmd->ctl_info[0], &param->ctl_band,
  3500. sizeof(param->ctl_band));
  3501. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(&cmd->ctl_info[1], param->ctl_array,
  3502. param->ctl_cmd_len - sizeof(param->ctl_band));
  3503. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  3504. WMI_PDEV_SET_CTL_TABLE_CMDID)) {
  3505. qdf_print("%s:Failed to send command\n", __func__);
  3506. return QDF_STATUS_E_FAILURE;
  3507. }
  3508. return QDF_STATUS_SUCCESS;
  3509. }
  3510. /**
  3511. * send_set_mimogain_table_cmd_non_tlv() - send mimogain table cmd to fw
  3512. * @wmi_handle: wmi handle
  3513. * @param: pointer to hold mimogain table param
  3514. *
  3515. * Return: 0 for success or error code
  3516. */
  3517. static QDF_STATUS
  3518. send_set_mimogain_table_cmd_non_tlv(wmi_unified_t wmi_handle,
  3519. struct mimogain_table_params *param)
  3520. {
  3521. uint16_t len;
  3522. wmi_buf_t buf;
  3523. wmi_pdev_set_mimogain_table_cmd *cmd;
  3524. if (!param->array_gain)
  3525. return QDF_STATUS_E_FAILURE;
  3526. /* len must be multiple of a single array gain table */
  3527. if (param->tbl_len %
  3528. ((WMI_HOST_TX_NUM_CHAIN-1) * WMI_HOST_TPC_REGINDEX_MAX *
  3529. WMI_HOST_ARRAY_GAIN_NUM_STREAMS) != 0) {
  3530. qdf_print("Array gain table len not correct\n");
  3531. return QDF_STATUS_E_FAILURE;
  3532. }
  3533. len = sizeof(wmi_pdev_set_mimogain_table_cmd);
  3534. len += roundup(param->tbl_len, sizeof(A_UINT32)) - sizeof(A_UINT32);
  3535. buf = wmi_buf_alloc(wmi_handle, len);
  3536. if (!buf) {
  3537. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3538. return QDF_STATUS_E_FAILURE;
  3539. }
  3540. cmd = (wmi_pdev_set_mimogain_table_cmd *)wmi_buf_data(buf);
  3541. WMI_MIMOGAIN_ARRAY_GAIN_LEN_SET(cmd->mimogain_info, param->tbl_len);
  3542. WMI_MIMOGAIN_MULTI_CHAIN_BYPASS_SET(cmd->mimogain_info,
  3543. param->multichain_gain_bypass);
  3544. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(&cmd->arraygain_tbl[0],
  3545. param->array_gain,
  3546. param->tbl_len);
  3547. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  3548. WMI_PDEV_SET_MIMOGAIN_TABLE_CMDID)) {
  3549. return QDF_STATUS_E_FAILURE;
  3550. }
  3551. return QDF_STATUS_SUCCESS;
  3552. }
  3553. /**
  3554. * send_set_ratepwr_chainmsk_cmd_non_tlv() - send ratepwr chainmask cmd to fw
  3555. * @wmi_handle: wmi handle
  3556. * @param: pointer to hold ratepwr chainmask param
  3557. *
  3558. * Return: 0 for success or error code
  3559. */
  3560. static QDF_STATUS
  3561. send_set_ratepwr_chainmsk_cmd_non_tlv(wmi_unified_t wmi_handle,
  3562. struct ratepwr_chainmsk_params *param)
  3563. {
  3564. #define RC_CCK_OFDM_RATES 0
  3565. #define RC_HT_RATES 1
  3566. #define RC_VHT_RATES 2
  3567. uint16_t len;
  3568. wmi_buf_t buf;
  3569. wmi_pdev_ratepwr_chainmsk_tbl_cmd *cmd;
  3570. if (!param->ratepwr_chain_tbl)
  3571. return QDF_STATUS_E_FAILURE;
  3572. len = sizeof(wmi_pdev_ratepwr_chainmsk_tbl_cmd);
  3573. len += roundup(param->num_rate*sizeof(uint32_t), sizeof(A_UINT32));
  3574. buf = wmi_buf_alloc(wmi_handle, len);
  3575. if (!buf) {
  3576. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3577. return QDF_STATUS_E_NOMEM;
  3578. }
  3579. cmd = (wmi_pdev_ratepwr_chainmsk_tbl_cmd *)wmi_buf_data(buf);
  3580. cmd->op = param->ops;
  3581. cmd->pream_type = param->pream_type;
  3582. cmd->rate_len = param->num_rate;
  3583. if (param->ops == RATEPWR_CHAINMSK_TABLE_OPS_EN) {
  3584. qdf_mem_copy(&cmd->ratepwr_chaintbl[0],
  3585. param->ratepwr_chain_tbl,
  3586. param->num_rate*sizeof(u_int32_t));
  3587. }
  3588. wmi_unified_cmd_send(wmi_handle, buf, len,
  3589. WMI_PDEV_RATEPWR_CHAINMSK_TABLE_CMDID);
  3590. return QDF_STATUS_SUCCESS;
  3591. }
  3592. /**
  3593. * send_set_macaddr_cmd_non_tlv() - send set macaddr cmd to fw
  3594. * @wmi_handle: wmi handle
  3595. * @param: pointer to hold macaddr param
  3596. *
  3597. * Return: 0 for success or error code
  3598. */
  3599. static QDF_STATUS
  3600. send_set_macaddr_cmd_non_tlv(wmi_unified_t wmi_handle,
  3601. struct macaddr_params *param)
  3602. {
  3603. uint8_t len;
  3604. wmi_buf_t buf;
  3605. wmi_pdev_set_base_macaddr_cmd *cmd;
  3606. len = sizeof(wmi_pdev_set_base_macaddr_cmd);
  3607. buf = wmi_buf_alloc(wmi_handle, len);
  3608. if (!buf) {
  3609. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3610. return QDF_STATUS_E_FAILURE;
  3611. }
  3612. cmd = (wmi_pdev_set_base_macaddr_cmd *)wmi_buf_data(buf);
  3613. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->macaddr, &cmd->base_macaddr);
  3614. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  3615. WMI_PDEV_SET_BASE_MACADDR_CMDID)) {
  3616. return QDF_STATUS_E_FAILURE;
  3617. }
  3618. return QDF_STATUS_SUCCESS;
  3619. }
  3620. /**
  3621. * send_pdev_scan_start_cmd_non_tlv() - send pdev scan start cmd to fw
  3622. * @wmi_handle: wmi handle
  3623. *
  3624. * Return: 0 for success or error code
  3625. */
  3626. static QDF_STATUS
  3627. send_pdev_scan_start_cmd_non_tlv(wmi_unified_t wmi_handle)
  3628. {
  3629. /*
  3630. * this command was added to support host scan egine which is
  3631. * deprecated. now the scan engine is in FW and host directly
  3632. * isssues a scan request to perform scan and provide results back
  3633. * to host
  3634. */
  3635. wmi_buf_t buf;
  3636. wmi_pdev_scan_cmd *cmd;
  3637. int len = sizeof(wmi_pdev_scan_cmd);
  3638. buf = wmi_buf_alloc(wmi_handle, len);
  3639. qdf_print("%s:\n", __func__);
  3640. if (!buf) {
  3641. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3642. return QDF_STATUS_E_NOMEM;
  3643. }
  3644. cmd = (wmi_pdev_scan_cmd *)wmi_buf_data(buf);
  3645. cmd->scan_start = TRUE;
  3646. #if DEPRECATE_WMI
  3647. wmi_unified_cmd_send(wmi_handle, buf, len, WMI_PDEV_SCAN_CMDID);
  3648. #endif
  3649. return QDF_STATUS_SUCCESS;
  3650. }
  3651. /**
  3652. * send_pdev_scan_end_cmd_non_tlv() - send pdev scan end cmd to fw
  3653. * @wmi_handle: wmi handle
  3654. *
  3655. * Return: 0 for success or error code
  3656. */
  3657. static QDF_STATUS
  3658. send_pdev_scan_end_cmd_non_tlv(wmi_unified_t wmi_handle)
  3659. {
  3660. /*
  3661. * this command was added to support host scan egine which is
  3662. * deprecated. now the scan engine is in FW and host directly isssues
  3663. * a scan request to perform scan and provide results back to host
  3664. */
  3665. wmi_pdev_scan_cmd *cmd;
  3666. wmi_buf_t buf;
  3667. int len = sizeof(wmi_pdev_scan_cmd);
  3668. buf = wmi_buf_alloc(wmi_handle, len);
  3669. qdf_print("%s:\n", __func__);
  3670. if (!buf) {
  3671. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3672. return QDF_STATUS_E_NOMEM;
  3673. }
  3674. cmd = (wmi_pdev_scan_cmd *)wmi_buf_data(buf);
  3675. cmd->scan_start = FALSE;
  3676. #if DEPRECATE_WMI
  3677. wmi_unified_cmd_send(wmi_handle, buf, len, WMI_PDEV_SCAN_CMDID);
  3678. #endif
  3679. return QDF_STATUS_SUCCESS;
  3680. }
  3681. /**
  3682. * send_set_acparams_cmd_non_tlv() - send acparams cmd to fw
  3683. * @wmi_handle: wmi handle
  3684. * @param: pointer to hold acparams
  3685. *
  3686. * Return: 0 for success or error code
  3687. */
  3688. static QDF_STATUS
  3689. send_set_acparams_cmd_non_tlv(wmi_unified_t wmi_handle,
  3690. struct acparams_params *param)
  3691. {
  3692. wmi_pdev_set_param_cmd *cmd;
  3693. wmi_buf_t buf;
  3694. uint32_t param_value = 0;
  3695. int len = sizeof(wmi_pdev_set_param_cmd);
  3696. buf = wmi_buf_alloc(wmi_handle, len);
  3697. if (!buf) {
  3698. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3699. return QDF_STATUS_E_NOMEM;
  3700. }
  3701. cmd = (wmi_pdev_set_param_cmd *)wmi_buf_data(buf);
  3702. cmd->param_id = WMI_PDEV_PARAM_AC_AGGRSIZE_SCALING;
  3703. param_value = param->ac;
  3704. param_value |= (param->aggrsize_scaling << 8);
  3705. cmd->param_value = param_value;
  3706. wmi_unified_cmd_send(wmi_handle, buf, len, WMI_PDEV_SET_PARAM_CMDID);
  3707. return QDF_STATUS_SUCCESS;
  3708. }
  3709. /**
  3710. * send_set_vap_dscp_tid_map_cmd_non_tlv() - send vap dscp tid map cmd to fw
  3711. * @wmi_handle: wmi handle
  3712. * @param: pointer to hold vap dscp tid map param
  3713. *
  3714. * Return: 0 for success or error code
  3715. */
  3716. static QDF_STATUS
  3717. send_set_vap_dscp_tid_map_cmd_non_tlv(wmi_unified_t wmi_handle,
  3718. struct vap_dscp_tid_map_params *param)
  3719. {
  3720. wmi_buf_t buf;
  3721. wmi_vdev_set_dscp_tid_map_cmd *cmd_vdev;
  3722. int len_vdev = sizeof(wmi_vdev_set_dscp_tid_map_cmd);
  3723. buf = wmi_buf_alloc(wmi_handle, len_vdev);
  3724. if (!buf) {
  3725. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3726. return QDF_STATUS_E_FAILURE;
  3727. }
  3728. cmd_vdev = (wmi_vdev_set_dscp_tid_map_cmd *)wmi_buf_data(buf);
  3729. qdf_mem_copy(cmd_vdev->dscp_to_tid_map, param->dscp_to_tid_map,
  3730. sizeof(A_UINT32) * WMI_DSCP_MAP_MAX);
  3731. cmd_vdev->vdev_id = param->vdev_id;
  3732. qdf_print("Setting dscp for vap id: %d\n", cmd_vdev->vdev_id);
  3733. return wmi_unified_cmd_send(wmi_handle, buf, len_vdev,
  3734. WMI_VDEV_SET_DSCP_TID_MAP_CMDID);
  3735. }
  3736. /**
  3737. * send_proxy_ast_reserve_cmd_non_tlv() - send proxy ast reserve cmd to fw
  3738. * @wmi_handle: wmi handle
  3739. * @param: pointer to hold proxy ast reserve param
  3740. *
  3741. * Return: 0 for success or error code
  3742. */
  3743. static QDF_STATUS
  3744. send_proxy_ast_reserve_cmd_non_tlv(wmi_unified_t wmi_handle,
  3745. struct proxy_ast_reserve_params *param)
  3746. {
  3747. wmi_pdev_reserve_ast_entry_cmd *cmd;
  3748. wmi_buf_t buf;
  3749. int len = sizeof(wmi_pdev_reserve_ast_entry_cmd);
  3750. buf = wmi_buf_alloc(wmi_handle, len);
  3751. if (!buf) {
  3752. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3753. return QDF_STATUS_E_FAILURE;
  3754. }
  3755. cmd = (wmi_pdev_reserve_ast_entry_cmd *)wmi_buf_data(buf);
  3756. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->macaddr, &cmd->mac_addr);
  3757. cmd->key_id = 0;
  3758. cmd->mcast = 0;
  3759. qdf_print("%s macaddr=%s key_id=%d mcast=%d\n", __func__,
  3760. ether_sprintf(param->macaddr), cmd->key_id, cmd->mcast);
  3761. return wmi_unified_cmd_send(wmi_handle, buf, len,
  3762. WMI_PDEV_RESERVE_AST_ENTRY_CMDID);
  3763. }
  3764. /**
  3765. * send_pdev_fips_cmd_non_tlv() - send pdev fips cmd to fw
  3766. * @wmi_handle: wmi handle
  3767. * @param: pointer to hold pdev fips param
  3768. *
  3769. * Return: 0 for success or error code
  3770. */
  3771. static QDF_STATUS
  3772. send_pdev_fips_cmd_non_tlv(wmi_unified_t wmi_handle,
  3773. struct fips_params *param)
  3774. {
  3775. wmi_pdev_fips_cmd *cmd;
  3776. wmi_buf_t buf;
  3777. int len = sizeof(wmi_pdev_fips_cmd) + param->data_len;
  3778. int retval = 0;
  3779. /* Data length must be multiples of 16 bytes - checked against 0xF -
  3780. * and must be less than WMI_SVC_MSG_SIZE - static size of
  3781. * wmi_pdev_fips_cmd structure
  3782. */
  3783. /* do sanity on the input */
  3784. if (!(((param->data_len & 0xF) == 0) &&
  3785. ((param->data_len > 0) &&
  3786. (param->data_len < (WMI_HOST_MAX_BUFFER_SIZE -
  3787. sizeof(wmi_pdev_fips_cmd)))))) {
  3788. return QDF_STATUS_E_INVAL;
  3789. }
  3790. buf = wmi_buf_alloc(wmi_handle, len);
  3791. if (!buf) {
  3792. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3793. return QDF_STATUS_E_FAILURE;
  3794. }
  3795. cmd = (wmi_pdev_fips_cmd *)wmi_buf_data(buf);
  3796. if (param->key != NULL && param->data != NULL) {
  3797. cmd->key_len = param->key_len;
  3798. cmd->data_len = param->data_len;
  3799. cmd->fips_cmd = !!(param->op);
  3800. #ifdef BIG_ENDIAN_HOST
  3801. {
  3802. /****************BE to LE conversion*****************/
  3803. /* Assigning unaligned space to copy the key */
  3804. unsigned char *key_unaligned = qdf_mem_malloc(
  3805. sizeof(u_int8_t)*param->key_len + FIPS_ALIGN);
  3806. u_int8_t *key_aligned = NULL;
  3807. unsigned char *data_unaligned = qdf_mem_malloc(
  3808. sizeof(u_int8_t)*param->data_len + FIPS_ALIGN);
  3809. u_int8_t *data_aligned = NULL;
  3810. int c;
  3811. /* Checking if kmalloc is succesful to allocate space */
  3812. if (key_unaligned == NULL)
  3813. return QDF_STATUS_SUCCESS;
  3814. /* Checking if space is aligned */
  3815. if (!FIPS_IS_ALIGNED(key_unaligned, FIPS_ALIGN)) {
  3816. /* align to 4 */
  3817. key_aligned =
  3818. (u_int8_t *)FIPS_ALIGNTO(key_unaligned,
  3819. FIPS_ALIGN);
  3820. } else {
  3821. key_aligned = (u_int8_t *)key_unaligned;
  3822. }
  3823. /* memset and copy content from key to key aligned */
  3824. OS_MEMSET(key_aligned, 0, param->key_len);
  3825. OS_MEMCPY(key_aligned, param->key, param->key_len);
  3826. /* print a hexdump for host debug */
  3827. print_hex_dump(KERN_DEBUG,
  3828. "\t Aligned and Copied Key:@@@@ ",
  3829. DUMP_PREFIX_NONE,
  3830. 16, 1, key_aligned, param->key_len, true);
  3831. /* Checking if kmalloc is succesful to allocate space */
  3832. if (data_unaligned == NULL)
  3833. return QDF_STATUS_SUCCESS;
  3834. /* Checking of space is aligned */
  3835. if (!FIPS_IS_ALIGNED(data_unaligned, FIPS_ALIGN)) {
  3836. /* align to 4 */
  3837. data_aligned =
  3838. (u_int8_t *)FIPS_ALIGNTO(data_unaligned,
  3839. FIPS_ALIGN);
  3840. } else {
  3841. data_aligned = (u_int8_t *)data_unaligned;
  3842. }
  3843. /* memset and copy content from data to data aligned */
  3844. OS_MEMSET(data_aligned, 0, param->data_len);
  3845. OS_MEMCPY(data_aligned, param->data, param->data_len);
  3846. /* print a hexdump for host debug */
  3847. print_hex_dump(KERN_DEBUG,
  3848. "\t Properly Aligned and Copied Data:@@@@ ",
  3849. DUMP_PREFIX_NONE,
  3850. 16, 1, data_aligned, param->data_len, true);
  3851. /* converting to little Endian both key_aligned and
  3852. * data_aligned*/
  3853. for (c = 0; c < param->key_len/4; c++) {
  3854. *((u_int32_t *)key_aligned+c) =
  3855. qdf_cpu_to_le32(*((u_int32_t *)key_aligned+c));
  3856. }
  3857. for (c = 0; c < param->data_len/4; c++) {
  3858. *((u_int32_t *)data_aligned+c) =
  3859. qdf_cpu_to_le32(*((u_int32_t *)data_aligned+c));
  3860. }
  3861. /* update endian data to key and data vectors */
  3862. OS_MEMCPY(param->key, key_aligned, param->key_len);
  3863. OS_MEMCPY(param->data, data_aligned, param->data_len);
  3864. /* clean up allocated spaces */
  3865. qdf_mem_free(key_unaligned);
  3866. key_unaligned = NULL;
  3867. key_aligned = NULL;
  3868. qdf_mem_free(data_unaligned);
  3869. data_unaligned = NULL;
  3870. data_aligned = NULL;
  3871. /*****************************************************/
  3872. }
  3873. #endif
  3874. qdf_mem_copy(cmd->key, param->key, param->key_len);
  3875. qdf_mem_copy(cmd->data, param->data, param->data_len);
  3876. if (param->mode == FIPS_ENGINE_AES_CTR ||
  3877. param->mode == FIPS_ENGINE_AES_MIC) {
  3878. cmd->mode = param->mode;
  3879. } else {
  3880. cmd->mode = FIPS_ENGINE_AES_CTR;
  3881. }
  3882. qdf_print(KERN_ERR "Key len = %d, Data len = %d\n",
  3883. cmd->key_len, cmd->data_len);
  3884. print_hex_dump(KERN_DEBUG, "Key: ", DUMP_PREFIX_NONE, 16, 1,
  3885. cmd->key, cmd->key_len, true);
  3886. print_hex_dump(KERN_DEBUG, "Plain text: ", DUMP_PREFIX_NONE,
  3887. 16, 1, cmd->data, cmd->data_len, true);
  3888. retval = wmi_unified_cmd_send(wmi_handle, buf, len,
  3889. WMI_PDEV_FIPS_CMDID);
  3890. qdf_print("%s return value %d\n", __func__, retval);
  3891. } else {
  3892. qdf_print("\n%s:%d Key or Data is NULL\n", __func__, __LINE__);
  3893. retval = -EFAULT;
  3894. }
  3895. return retval;
  3896. }
  3897. /**
  3898. * send_pdev_set_chan_cmd_non_tlv() - send pdev set chan cmd to fw
  3899. * @wmi_handle: wmi handle
  3900. * @param: pointer to hold set chan param
  3901. *
  3902. * Return: 0 for success or error code
  3903. */
  3904. static QDF_STATUS
  3905. send_pdev_set_chan_cmd_non_tlv(wmi_unified_t wmi_handle,
  3906. struct channel_param *param)
  3907. {
  3908. wmi_set_channel_cmd *cmd;
  3909. wmi_buf_t buf;
  3910. int len = sizeof(wmi_set_channel_cmd);
  3911. buf = wmi_buf_alloc(wmi_handle, len);
  3912. if (!buf) {
  3913. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  3914. return QDF_STATUS_E_FAILURE;
  3915. }
  3916. cmd = (wmi_set_channel_cmd *)wmi_buf_data(buf);
  3917. cmd->chan.mhz = param->mhz;
  3918. WMI_SET_CHANNEL_MODE(&cmd->chan, param->phy_mode);
  3919. cmd->chan.band_center_freq1 = param->cfreq1;
  3920. cmd->chan.band_center_freq2 = param->cfreq2;
  3921. WMI_SET_CHANNEL_MIN_POWER(&cmd->chan, param->minpower);
  3922. WMI_SET_CHANNEL_MAX_POWER(&cmd->chan, param->maxpower);
  3923. WMI_SET_CHANNEL_REG_POWER(&cmd->chan, param->maxregpower);
  3924. WMI_SET_CHANNEL_ANTENNA_MAX(&cmd->chan, param->antennamax);
  3925. WMI_SET_CHANNEL_REG_CLASSID(&cmd->chan, param->reg_class_id);
  3926. if (param->dfs_set)
  3927. WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_DFS);
  3928. if (param->dfs_set_cfreq2)
  3929. WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_DFS_CFREQ2);
  3930. if (param->half_rate)
  3931. WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_HALF);
  3932. if (param->quarter_rate)
  3933. WMI_SET_CHANNEL_FLAG(&cmd->chan, WMI_CHAN_FLAG_QUARTER);
  3934. if ((param->phy_mode == MODE_11AC_VHT80_80) ||
  3935. (param->phy_mode == MODE_11AC_VHT160)) {
  3936. qdf_print(
  3937. "WMI channel freq=%d, mode=%x band_center_freq1=%d band_center_freq2=%d\n",
  3938. cmd->chan.mhz,
  3939. WMI_GET_CHANNEL_MODE(&cmd->chan), cmd->chan.band_center_freq1,
  3940. cmd->chan.band_center_freq2);
  3941. } else {
  3942. qdf_print("WMI channel freq=%d, mode=%x band_center_freq1=%d\n"
  3943. , cmd->chan.mhz,
  3944. WMI_GET_CHANNEL_MODE(&cmd->chan),
  3945. cmd->chan.band_center_freq1);
  3946. }
  3947. return wmi_unified_cmd_send(wmi_handle, buf, len,
  3948. WMI_PDEV_SET_CHANNEL_CMDID);
  3949. }
  3950. /**
  3951. * send_mcast_group_update_cmd_non_tlv() - send mcast group update cmd to fw
  3952. * @wmi_handle: wmi handle
  3953. * @param: pointer to hold mcast update param
  3954. *
  3955. * Return: 0 for success or error code
  3956. */
  3957. static QDF_STATUS
  3958. send_mcast_group_update_cmd_non_tlv(wmi_unified_t wmi_handle,
  3959. struct mcast_group_update_params *param)
  3960. {
  3961. wmi_peer_mcast_group_cmd *cmd;
  3962. wmi_buf_t buf;
  3963. int len;
  3964. int offset = 0;
  3965. static char dummymask[4] = { 0xFF, 0xFF, 0xFF, 0xFF};
  3966. len = sizeof(wmi_peer_mcast_group_cmd);
  3967. buf = wmi_buf_alloc(wmi_handle, len);
  3968. if (!buf) {
  3969. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  3970. return QDF_STATUS_E_NOMEM;
  3971. }
  3972. cmd = (wmi_peer_mcast_group_cmd *) wmi_buf_data(buf);
  3973. /* confirm the buffer is 4-byte aligned */
  3974. ASSERT((((size_t) cmd) & 0x3) == 0);
  3975. OS_MEMZERO(cmd, sizeof(wmi_peer_mcast_group_cmd));
  3976. cmd->vdev_id = param->vap_id;
  3977. /* construct the message assuming our endianness matches the target */
  3978. cmd->flags |= WMI_PEER_MCAST_GROUP_FLAG_ACTION_M &
  3979. (param->action << WMI_PEER_MCAST_GROUP_FLAG_ACTION_S);
  3980. cmd->flags |= WMI_PEER_MCAST_GROUP_FLAG_WILDCARD_M &
  3981. (param->wildcard << WMI_PEER_MCAST_GROUP_FLAG_WILDCARD_S);
  3982. if (param->is_action_delete)
  3983. cmd->flags |= WMI_PEER_MCAST_GROUP_FLAG_DELETEALL_M;
  3984. if (param->is_mcast_addr_len)
  3985. cmd->flags |= WMI_PEER_MCAST_GROUP_FLAG_IPV6_M;
  3986. if (param->is_filter_mode_snoop)
  3987. cmd->flags |= WMI_PEER_MCAST_GROUP_FLAG_SRC_FILTER_EXCLUDE_M;
  3988. /* unicast address spec only applies for non-wildcard cases */
  3989. if (!param->wildcard && param->ucast_mac_addr) {
  3990. qdf_mem_copy(
  3991. &cmd->ucast_mac_addr,
  3992. param->ucast_mac_addr,
  3993. sizeof(cmd->ucast_mac_addr));
  3994. }
  3995. if (param->mcast_ip_addr) {
  3996. ASSERT(param->mcast_ip_addr_bytes <=
  3997. sizeof(cmd->mcast_ip_addr));
  3998. offset = sizeof(cmd->mcast_ip_addr) -
  3999. param->mcast_ip_addr_bytes;
  4000. qdf_mem_copy(((u_int8_t *) &cmd->mcast_ip_addr) + offset,
  4001. param->mcast_ip_addr,
  4002. param->mcast_ip_addr_bytes);
  4003. }
  4004. if (!param->mask)
  4005. param->mask = &dummymask[0];
  4006. qdf_mem_copy(((u_int8_t *) &cmd->mcast_ip_mask) + offset, param->mask,
  4007. param->mcast_ip_addr_bytes);
  4008. if (param->srcs && param->nsrcs) {
  4009. cmd->num_filter_addr = param->nsrcs;
  4010. ASSERT((param->nsrcs * param->mcast_ip_addr_bytes) <=
  4011. sizeof(cmd->srcs));
  4012. qdf_mem_copy(((u_int8_t *) &cmd->filter_addr), param->srcs,
  4013. param->nsrcs * param->mcast_ip_addr_bytes);
  4014. }
  4015. /* now correct for endianness, if necessary */
  4016. /*
  4017. * For Little Endian, N/w Stack gives packets in Network byte order and
  4018. * issue occurs if both Host and Target happens to be in Little Endian.
  4019. * Target when compares IP addresses in packet with MCAST_GROUP_CMDID
  4020. * given IP addresses, it fails. Hence swap only mcast_ip_addr
  4021. * (16 bytes) for now.
  4022. * TODO : filter
  4023. */
  4024. /* TBD in OL Layer
  4025. #ifdef BIG_ENDIAN_HOST
  4026. ol_bytestream_endian_fix(
  4027. (u_int32_t *)&cmd->ucast_mac_addr,
  4028. (sizeof(*cmd)-4) / sizeof(u_int32_t));
  4029. #else
  4030. ol_bytestream_endian_fix(
  4031. (u_int32_t *)&cmd->mcast_ip_addr,
  4032. (sizeof(cmd->mcast_ip_addr)) / sizeof(u_int32_t));
  4033. #endif Little Endian */
  4034. wmi_unified_cmd_send(
  4035. wmi_handle, buf, len, WMI_PEER_MCAST_GROUP_CMDID);
  4036. return QDF_STATUS_SUCCESS;
  4037. }
  4038. /**
  4039. * send_periodic_chan_stats_config_cmd_non_tlv() - send periodic chan stats cmd
  4040. * to fw
  4041. * @wmi_handle: wmi handle
  4042. * @param: pointer to hold periodic chan stats param
  4043. *
  4044. * Return: 0 for success or error code
  4045. */
  4046. static QDF_STATUS
  4047. send_periodic_chan_stats_config_cmd_non_tlv(wmi_unified_t wmi_handle,
  4048. struct periodic_chan_stats_params *param)
  4049. {
  4050. wmi_buf_t buf = NULL;
  4051. wmi_set_periodic_channel_stats_config *cmd = NULL;
  4052. QDF_STATUS error = 0;
  4053. int32_t len = 0;
  4054. len = sizeof(wmi_set_periodic_channel_stats_config);
  4055. buf = wmi_buf_alloc(wmi_handle, len);
  4056. if (!buf) {
  4057. qdf_print("%s: Unable to allocate merory\n", __func__);
  4058. return QDF_STATUS_E_NOMEM;
  4059. }
  4060. cmd = (wmi_set_periodic_channel_stats_config *) wmi_buf_data(buf);
  4061. cmd->enable = param->enable;
  4062. cmd->stats_period = param->stats_period;
  4063. error = wmi_unified_cmd_send(wmi_handle, buf, len,
  4064. WMI_SET_PERIODIC_CHANNEL_STATS_CONFIG);
  4065. if (error)
  4066. qdf_print(" %s :WMI Failed\n", __func__);
  4067. return error;
  4068. }
  4069. /**
  4070. * send_nf_dbr_dbm_info_get_cmd_non_tlv() - send request to get nf to fw
  4071. * @wmi_handle: wmi handle
  4072. *
  4073. * Return: 0 for success or error code
  4074. */
  4075. static QDF_STATUS
  4076. send_nf_dbr_dbm_info_get_cmd_non_tlv(wmi_unified_t wmi_handle)
  4077. {
  4078. wmi_buf_t wmibuf;
  4079. wmibuf = wmi_buf_alloc(wmi_handle, 0);
  4080. if (wmibuf == NULL)
  4081. return QDF_STATUS_E_NOMEM;
  4082. return wmi_unified_cmd_send(wmi_handle, wmibuf, 0,
  4083. WMI_PDEV_GET_NFCAL_POWER_CMDID);
  4084. }
  4085. /**
  4086. * enum packet_power_non_tlv_flags: Target defined
  4087. * packet power rate flags
  4088. * @WMI_NON_TLV_FLAG_ONE_CHAIN: one chain
  4089. * @WMI_NON_TLV_FLAG_TWO_CHAIN: two chain
  4090. * @WMI_NON_TLV_FLAG_THREE_CHAIN: three chain
  4091. * @WMI_NON_TLV_FLAG_FOUR_CHAIN: four chain
  4092. * @WMI_NON_TLV_FLAG_STBC: STBC is set
  4093. * @WMI_NON_TLV_FLAG_40MHZ: 40MHz channel width
  4094. * @WMI_NON_TLV_FLAG_80MHZ: 80MHz channel width
  4095. * @WMI_NON_TLV_FLAG_1600MHZ: 1600MHz channel width
  4096. * @WMI_NON_TLV_FLAG_TXBF: Tx Bf enabled
  4097. * @WMI_NON_TLV_FLAG_RTSENA: RTS enabled
  4098. * @WMI_NON_TLV_FLAG_CTSENA: CTS enabled
  4099. * @WMI_NON_TLV_FLAG_LDPC: LDPC is set
  4100. * @WMI_NON_TLV_FLAG_SERIES1: Rate series 1
  4101. * @WMI_NON_TLV_FLAG_SGI: Short gaurd interval
  4102. * @WMI_NON_TLV_FLAG_MU2: MU2 data
  4103. * @WMI_NON_TLV_FLAG_MU3: MU3 data
  4104. */
  4105. enum packet_power_non_tlv_flags {
  4106. WMI_NON_TLV_FLAG_ONE_CHAIN = 0x0001,
  4107. WMI_NON_TLV_FLAG_TWO_CHAIN = 0x0005,
  4108. WMI_NON_TLV_FLAG_THREE_CHAIN = 0x0007,
  4109. WMI_NON_TLV_FLAG_FOUR_CHAIN = 0x000F,
  4110. WMI_NON_TLV_FLAG_STBC = 0x0010,
  4111. WMI_NON_TLV_FLAG_40MHZ = 0x0020,
  4112. WMI_NON_TLV_FLAG_80MHZ = 0x0040,
  4113. WMI_NON_TLV_FLAG_160MHZ = 0x0080,
  4114. WMI_NON_TLV_FLAG_TXBF = 0x0100,
  4115. WMI_NON_TLV_FLAG_RTSENA = 0x0200,
  4116. WMI_NON_TLV_FLAG_CTSENA = 0x0400,
  4117. WMI_NON_TLV_FLAG_LDPC = 0x0800,
  4118. WMI_NON_TLV_FLAG_SERIES1 = 0x1000,
  4119. WMI_NON_TLV_FLAG_SGI = 0x2000,
  4120. WMI_NON_TLV_FLAG_MU2 = 0x4000,
  4121. WMI_NON_TLV_FLAG_MU3 = 0x8000,
  4122. };
  4123. /**
  4124. * convert_to_power_info_rate_flags() - convert packet_power_info_params
  4125. * to FW understandable format
  4126. * @param: pointer to hold packet power info param
  4127. *
  4128. * @return FW understandable 16 bit rate flags
  4129. */
  4130. static uint16_t
  4131. convert_to_power_info_rate_flags(struct packet_power_info_params *param)
  4132. {
  4133. uint16_t rateflags = 0;
  4134. if (param->chainmask)
  4135. rateflags |= (param->chainmask & 0xf);
  4136. if (param->chan_width == WMI_HOST_CHAN_WIDTH_40)
  4137. rateflags |= WMI_NON_TLV_FLAG_40MHZ;
  4138. if (param->chan_width == WMI_HOST_CHAN_WIDTH_80)
  4139. rateflags |= WMI_NON_TLV_FLAG_80MHZ;
  4140. if (param->chan_width == WMI_HOST_CHAN_WIDTH_160)
  4141. rateflags |= WMI_NON_TLV_FLAG_160MHZ;
  4142. if (param->rate_flags & WMI_HOST_FLAG_STBC)
  4143. rateflags |= WMI_NON_TLV_FLAG_STBC;
  4144. if (param->rate_flags & WMI_HOST_FLAG_LDPC)
  4145. rateflags |= WMI_NON_TLV_FLAG_LDPC;
  4146. if (param->rate_flags & WMI_HOST_FLAG_TXBF)
  4147. rateflags |= WMI_NON_TLV_FLAG_TXBF;
  4148. if (param->rate_flags & WMI_HOST_FLAG_RTSENA)
  4149. rateflags |= WMI_NON_TLV_FLAG_RTSENA;
  4150. if (param->rate_flags & WMI_HOST_FLAG_CTSENA)
  4151. rateflags |= WMI_NON_TLV_FLAG_CTSENA;
  4152. if (param->rate_flags & WMI_HOST_FLAG_SGI)
  4153. rateflags |= WMI_NON_TLV_FLAG_SGI;
  4154. if (param->rate_flags & WMI_HOST_FLAG_SERIES1)
  4155. rateflags |= WMI_NON_TLV_FLAG_SERIES1;
  4156. if (param->rate_flags & WMI_HOST_FLAG_MU2)
  4157. rateflags |= WMI_NON_TLV_FLAG_MU2;
  4158. if (param->rate_flags & WMI_HOST_FLAG_MU3)
  4159. rateflags |= WMI_NON_TLV_FLAG_MU3;
  4160. return rateflags;
  4161. }
  4162. /**
  4163. * send_packet_power_info_get_cmd_non_tlv() - send request to get packet power
  4164. * info to fw
  4165. * @wmi_handle: wmi handle
  4166. * @param: pointer to hold packet power info param
  4167. *
  4168. * Return: 0 for success or error code
  4169. */
  4170. static QDF_STATUS
  4171. send_packet_power_info_get_cmd_non_tlv(wmi_unified_t wmi_handle,
  4172. struct packet_power_info_params *param)
  4173. {
  4174. wmi_pdev_get_tpc_cmd *cmd;
  4175. wmi_buf_t wmibuf;
  4176. u_int32_t len = sizeof(wmi_pdev_get_tpc_cmd);
  4177. wmibuf = wmi_buf_alloc(wmi_handle, len);
  4178. if (wmibuf == NULL)
  4179. return QDF_STATUS_E_NOMEM;
  4180. cmd = (wmi_pdev_get_tpc_cmd *)wmi_buf_data(wmibuf);
  4181. cmd->rate_flags = convert_to_power_info_rate_flags(param);
  4182. cmd->nss = param->nss;
  4183. cmd->preamble = param->preamble;
  4184. cmd->hw_rate = param->hw_rate;
  4185. cmd->rsvd = 0x0;
  4186. WMI_LOGD("%s[%d] commandID %d, wmi_pdev_get_tpc_cmd=0x%x,"
  4187. "rate_flags: 0x%x, nss: %d, preamble: %d, hw_rate: %d\n",
  4188. __func__, __LINE__, WMI_PDEV_GET_TPC_CMDID, *((u_int32_t *)cmd),
  4189. cmd->rate_flags, cmd->nss, cmd->preamble, cmd->hw_rate);
  4190. return wmi_unified_cmd_send(wmi_handle, wmibuf, len,
  4191. WMI_PDEV_GET_TPC_CMDID);
  4192. }
  4193. /**
  4194. * send_gpio_config_cmd_non_tlv() - send gpio config to fw
  4195. * @wmi_handle: wmi handle
  4196. * @param: pointer to hold gpio config param
  4197. *
  4198. * Return: 0 for success or error code
  4199. */
  4200. static QDF_STATUS
  4201. send_gpio_config_cmd_non_tlv(wmi_unified_t wmi_handle,
  4202. struct gpio_config_params *param)
  4203. {
  4204. wmi_gpio_config_cmd *cmd;
  4205. wmi_buf_t wmibuf;
  4206. u_int32_t len = sizeof(wmi_gpio_config_cmd);
  4207. /* Sanity Checks */
  4208. if (param->pull_type > WMI_GPIO_PULL_DOWN ||
  4209. param->intr_mode > WMI_GPIO_INTTYPE_LEVEL_HIGH) {
  4210. return QDF_STATUS_E_FAILURE;
  4211. }
  4212. wmibuf = wmi_buf_alloc(wmi_handle, len);
  4213. if (wmibuf == NULL)
  4214. return QDF_STATUS_E_FAILURE;
  4215. cmd = (wmi_gpio_config_cmd *)wmi_buf_data(wmibuf);
  4216. cmd->gpio_num = param->gpio_num;
  4217. cmd->input = param->input;
  4218. cmd->pull_type = param->pull_type;
  4219. cmd->intr_mode = param->intr_mode;
  4220. return wmi_unified_cmd_send(wmi_handle, wmibuf, len,
  4221. WMI_GPIO_CONFIG_CMDID);
  4222. }
  4223. /**
  4224. * send_gpio_output_cmd_non_tlv() - send gpio output to fw
  4225. * @wmi_handle: wmi handle
  4226. * @param: pointer to hold gpio output param
  4227. *
  4228. * Return: 0 for success or error code
  4229. */
  4230. static QDF_STATUS
  4231. send_gpio_output_cmd_non_tlv(wmi_unified_t wmi_handle,
  4232. struct gpio_output_params *param)
  4233. {
  4234. wmi_gpio_output_cmd *cmd;
  4235. wmi_buf_t wmibuf;
  4236. u_int32_t len = sizeof(wmi_gpio_output_cmd);
  4237. wmibuf = wmi_buf_alloc(wmi_handle, len);
  4238. if (wmibuf == NULL)
  4239. return QDF_STATUS_E_FAILURE;
  4240. cmd = (wmi_gpio_output_cmd *)wmi_buf_data(wmibuf);
  4241. cmd->gpio_num = param->gpio_num;
  4242. cmd->set = param->set;
  4243. return wmi_unified_cmd_send(wmi_handle, wmibuf, len,
  4244. WMI_GPIO_OUTPUT_CMDID);
  4245. }
  4246. /*
  4247. * send_rtt_meas_req_test_cmd_non_tlv() - send rtt meas req test cmd to fw
  4248. * @wmi_handle: wmi handle
  4249. * @param: pointer to hold rtt meas req test param
  4250. *
  4251. * Return: 0 for success or error code
  4252. */
  4253. static QDF_STATUS
  4254. send_rtt_meas_req_test_cmd_non_tlv(wmi_unified_t wmi_handle,
  4255. struct rtt_meas_req_test_params *param)
  4256. {
  4257. wmi_buf_t buf;
  4258. u_int8_t *p;
  4259. int ret;
  4260. u_int16_t len;
  4261. wmi_rtt_measreq_head *head;
  4262. wmi_rtt_measreq_body *body;
  4263. wmi_channel *w_chan;
  4264. qdf_print("%s: The request ID is: %d\n", __func__, param->req_id);
  4265. len = sizeof(wmi_rtt_measreq_head) + param->req_num_req *
  4266. sizeof(wmi_rtt_measreq_body);
  4267. buf = wmi_buf_alloc(wmi_handle, len);
  4268. if (!buf) {
  4269. qdf_print("No WMI resource!");
  4270. return QDF_STATUS_E_NOMEM;
  4271. }
  4272. p = (u_int8_t *) wmi_buf_data(buf);
  4273. qdf_mem_set(p, len, 0);
  4274. head = (wmi_rtt_measreq_head *) p;
  4275. WMI_RTT_REQ_ID_SET(head->req_id, param->req_id);
  4276. WMI_RTT_SPS_SET(head->req_id, 1);
  4277. WMI_RTT_NUM_STA_SET(head->sta_num, param->req_num_req);
  4278. body = &(head->body[0]);
  4279. WMI_RTT_VDEV_ID_SET(body->measure_info, 0);
  4280. WMI_RTT_TIMEOUT_SET(body->measure_info, 100);
  4281. WMI_RTT_REPORT_TYPE_SET(body->measure_info, param->req_report_type);
  4282. WMI_RTT_FRAME_TYPE_SET(body->control_flag, param->req_frame_type);
  4283. WMI_RTT_TX_CHAIN_SET(body->control_flag, 001);
  4284. WMI_RTT_QCA_PEER_SET(body->control_flag, 1);
  4285. if (param->req_preamble == WMI_RTT_PREAM_LEGACY)
  4286. WMI_RTT_MCS_SET(body->control_flag, 3);
  4287. else
  4288. WMI_RTT_MCS_SET(body->control_flag, 0);
  4289. WMI_RTT_RETRIES_SET(body->control_flag, 1);
  4290. /*
  4291. qdf_mem_copy(peer, param->mac_addr, 6);
  4292. qdf_print("The mac_addr is"
  4293. " %.2x:%.2x:%.2x:%.2x:%.2x:%.2x extra=%d\n",
  4294. peer[0], peer[1], peer[2],
  4295. peer[3], peer[4], peer[5], param->extra);
  4296. */
  4297. /* start from here, embed the first req in each RTT measurement
  4298. * Command */
  4299. /*peer[5] = 0x12;
  4300. peer[4] = 0x90;
  4301. peer[3] = 0x78;
  4302. peer[2] = 0x56;
  4303. peer[1] = 0x34;
  4304. peer[0] = 0x12;
  4305. >---*/
  4306. head->channel.mhz = param->channel.mhz;
  4307. head->channel.band_center_freq1 = param->channel.cfreq1;
  4308. head->channel.band_center_freq2 = param->channel.cfreq2;
  4309. w_chan = (wmi_channel *)&head->channel;
  4310. WMI_SET_CHANNEL_MODE(w_chan, param->channel.phy_mode);
  4311. WMI_SET_CHANNEL_MIN_POWER(w_chan, param->channel.minpower);
  4312. WMI_SET_CHANNEL_MAX_POWER(w_chan, param->channel.maxpower);
  4313. WMI_SET_CHANNEL_REG_POWER(w_chan, param->channel.maxregpower);
  4314. WMI_SET_CHANNEL_ANTENNA_MAX(w_chan, param->channel.antennamax);
  4315. WMI_SET_CHANNEL_REG_CLASSID(w_chan, param->channel.reg_class_id);
  4316. WMI_CHAR_ARRAY_TO_MAC_ADDR(((u_int8_t *)param->peer), &body->dest_mac);
  4317. WMI_CHAR_ARRAY_TO_MAC_ADDR(((u_int8_t *)param->peer),
  4318. &body->spoof_bssid);
  4319. WMI_RTT_BW_SET(body->control_flag, param->req_bw);
  4320. WMI_RTT_PREAMBLE_SET(body->control_flag, param->req_preamble);
  4321. WMI_RTT_MEAS_NUM_SET(body->measure_info, param->num_measurements);
  4322. body->measure_params_1 = 0;
  4323. body->measure_params_2 = 0;
  4324. WMI_RTT_ASAP_MODE_SET(body->measure_params_1, param->asap_mode);
  4325. WMI_RTT_LCI_REQ_SET(body->measure_params_1, param->lci_requested);
  4326. WMI_RTT_LOC_CIV_REQ_SET(body->measure_params_1,
  4327. param->loc_civ_requested);
  4328. WMI_RTT_NUM_BURST_EXP_SET(body->measure_params_1, 0);
  4329. WMI_RTT_BURST_DUR_SET(body->measure_params_1, 15);
  4330. WMI_RTT_BURST_PERIOD_SET(body->measure_params_1, 0);
  4331. WMI_RTT_TSF_DELTA_VALID_SET(body->measure_params_1, 1);
  4332. WMI_RTT_TSF_DELTA_SET(body->measure_params_2, 0);
  4333. /** other requests are same with first request */
  4334. p = (u_int8_t *) body;
  4335. while (--param->req_num_req) {
  4336. body++;
  4337. qdf_mem_copy(body, p, sizeof(wmi_rtt_measreq_body));
  4338. }
  4339. ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_RTT_MEASREQ_CMDID);
  4340. qdf_print("send rtt cmd to FW with length %d and return %d\n",
  4341. len, ret);
  4342. return QDF_STATUS_SUCCESS;
  4343. }
  4344. /**
  4345. * send_rtt_meas_req_cmd_non_tlv() - send rtt meas req cmd to fw
  4346. * @wmi_handle: wmi handle
  4347. * @param: pointer to hold rtt meas req param
  4348. *
  4349. * Return: 0 for success or error code
  4350. */
  4351. static QDF_STATUS
  4352. send_rtt_meas_req_cmd_non_tlv(wmi_unified_t wmi_handle,
  4353. struct rtt_meas_req_params *param)
  4354. {
  4355. wmi_buf_t buf;
  4356. uint8_t *p;
  4357. int ret;
  4358. uint16_t len;
  4359. uint8_t peer[6];
  4360. uint8_t spoof[6];
  4361. wmi_rtt_measreq_head *head;
  4362. wmi_rtt_measreq_body *body;
  4363. int req_frame_type, req_preamble;
  4364. wmi_channel *w_chan;
  4365. /* Temporarily, hardcoding peer mac address for test purpose will be
  4366. * removed once RTT host has been developed for even req_id, like
  4367. * 0, 2, 4, there is no channel_swicth for odd req_id, like 1, 3 , 5,
  4368. * there is channel switch currently, for both cases, we have 3 req in
  4369. * each command please change here if you only have one (or just let
  4370. * it be). Even == HC, odd == OC.
  4371. */
  4372. if (!(param->req_id & 0x1)) {
  4373. len = sizeof(wmi_rtt_measreq_head);
  4374. /* + 2 * sizeof(wmi_rtt_measreq_body);*/
  4375. } else {
  4376. len = sizeof(wmi_rtt_measreq_head);
  4377. /* + 2 * sizeof(wmi_rtt_measreq_body);*/
  4378. }
  4379. buf = wmi_buf_alloc(wmi_handle, len);
  4380. if (!buf) {
  4381. qdf_print("No WMI resource!");
  4382. return QDF_STATUS_E_FAILURE;
  4383. }
  4384. p = (uint8_t *) wmi_buf_data(buf);
  4385. qdf_mem_set(p, len, 0);
  4386. /* encode header */
  4387. head = (wmi_rtt_measreq_head *) p;
  4388. /* head->req_id = req_id;*/
  4389. WMI_RTT_REQ_ID_SET(head->req_id, param->req_id);
  4390. /* WMI_RTT_SPS_SET(head->req_id, 1);*/
  4391. if (!(param->req_id & 0x1)) { /*even req id */
  4392. #ifndef RTT_TEST
  4393. /* we actually only have 3 sta to measure
  4394. this is used to test over limit request protection
  4395. XIN:WMI_RTT_NUM_STA_SET(head->sta_num, 5);*/
  4396. #else
  4397. /* XIN:WMI_RTT_NUM_STA_SET(head->sta_num, 2);*/
  4398. WMI_RTT_NUM_STA_SET(head->sta_num, 1);
  4399. #endif
  4400. WMI_RTT_NUM_STA_SET(head->sta_num, 1);
  4401. } else { /* odd req id */
  4402. /* XIN:WMI_RTT_NUM_STA_SET(head->sta_num, 3); */
  4403. WMI_RTT_NUM_STA_SET(head->sta_num, 1);
  4404. }
  4405. req_frame_type = RTT_MEAS_FRAME_NULL;
  4406. /* MS(extra, RTT_REQ_FRAME_TYPE);*/
  4407. /* req_bw = //MS(extra, RTT_REQ_BW);*/
  4408. req_preamble = WMI_RTT_PREAM_LEGACY;/*MS(extra, RTT_REQ_PREAMBLE);*/
  4409. /*encode common parts for each RTT measurement command body
  4410. The value here can be overwrite in following each req hardcoding */
  4411. body = &(head->body[0]);
  4412. WMI_RTT_VDEV_ID_SET(body->measure_info, param->vdev_id);
  4413. WMI_RTT_TIMEOUT_SET(body->measure_info, RTT_TIMEOUT_MS);
  4414. WMI_RTT_REPORT_TYPE_SET(body->measure_info, 1);
  4415. WMI_RTT_FRAME_TYPE_SET(body->control_flag, req_frame_type);
  4416. WMI_RTT_TX_CHAIN_SET(body->control_flag, 001);
  4417. WMI_RTT_QCA_PEER_SET(body->control_flag, 1);
  4418. if (req_preamble == WMI_RTT_PREAM_LEGACY)
  4419. WMI_RTT_MCS_SET(body->control_flag, 3);
  4420. else
  4421. WMI_RTT_MCS_SET(body->control_flag, 0);
  4422. WMI_RTT_RETRIES_SET(body->control_flag, 1);
  4423. if (!(param->req_id & 0x1)) { /* even time */
  4424. qdf_mem_copy(peer, param->sta_mac_addr, 6);
  4425. } else { /* odd time */
  4426. qdf_mem_copy(peer, param->sta_mac_addr, 6);
  4427. }
  4428. head->channel.mhz = param->channel.mhz;
  4429. head->channel.band_center_freq1 = param->channel.cfreq1;
  4430. head->channel.band_center_freq2 = param->channel.cfreq2;
  4431. w_chan = (wmi_channel *)&head->channel;
  4432. WMI_SET_CHANNEL_MAX_POWER(w_chan, param->channel.phy_mode);
  4433. WMI_SET_CHANNEL_MIN_POWER(w_chan, param->channel.minpower);
  4434. WMI_SET_CHANNEL_MAX_POWER(w_chan, param->channel.maxpower);
  4435. WMI_SET_CHANNEL_REG_POWER(w_chan, param->channel.maxregpower);
  4436. WMI_SET_CHANNEL_ANTENNA_MAX(w_chan, param->channel.antennamax);
  4437. WMI_SET_CHANNEL_REG_CLASSID(w_chan, param->channel.reg_class_id);
  4438. if (param->is_mode_na)
  4439. WMI_SET_CHANNEL_MODE(w_chan, MODE_11NG_HT20);
  4440. else if (param->is_mode_ac)
  4441. WMI_SET_CHANNEL_MODE(w_chan, MODE_11NA_HT20);
  4442. if (param->channel.dfs_set)
  4443. WMI_SET_CHANNEL_FLAG(w_chan, WMI_CHAN_FLAG_DFS);
  4444. WMI_CHAR_ARRAY_TO_MAC_ADDR(((uint8_t *)peer), &body->dest_mac);
  4445. qdf_mem_set(spoof, IEEE80211_ADDR_LEN, 0);
  4446. WMI_CHAR_ARRAY_TO_MAC_ADDR(((uint8_t *)param->spoof_mac_addr),
  4447. &body->spoof_bssid);
  4448. /** embedded varing part of each request
  4449. set Preamble, BW, measurement times */
  4450. if (param->is_bw_20)
  4451. WMI_RTT_BW_SET(body->control_flag, WMI_RTT_BW_20);
  4452. else if (param->is_bw_40)
  4453. WMI_RTT_BW_SET(body->control_flag, WMI_RTT_BW_40);
  4454. else if (param->is_bw_80)
  4455. WMI_RTT_BW_SET(body->control_flag, WMI_RTT_BW_80);
  4456. else
  4457. WMI_RTT_BW_SET(body->control_flag, WMI_RTT_BW_20);
  4458. WMI_RTT_PREAMBLE_SET(body->control_flag, req_preamble);
  4459. WMI_RTT_MEAS_NUM_SET(body->measure_info, param->num_probe_rqst);
  4460. ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_RTT_MEASREQ_CMDID);
  4461. qdf_print("send rtt cmd to FW with length %d and return %d\n",
  4462. len, ret);
  4463. return ret;
  4464. }
  4465. /**
  4466. * send_rtt_keepalive_req_cmd_non_tlv() - send rtt keepalive req cmd to fw
  4467. * @wmi_handle: wmi handle
  4468. * @param: pointer to hold rtt keepalive req param
  4469. *
  4470. * Return: 0 for success or error code
  4471. */
  4472. static QDF_STATUS
  4473. send_rtt_keepalive_req_cmd_non_tlv(wmi_unified_t wmi_handle,
  4474. struct rtt_keepalive_req_params *param)
  4475. {
  4476. wmi_buf_t buf;
  4477. wmi_rtt_keepalive_cmd *cmd;
  4478. int ret;
  4479. uint16_t len;
  4480. uint8_t *ptr;
  4481. len = sizeof(wmi_rtt_keepalive_cmd);
  4482. buf = wmi_buf_alloc(wmi_handle, len);
  4483. if (!buf) {
  4484. qdf_print("No WMI resource\n");
  4485. return QDF_STATUS_E_FAILURE;
  4486. }
  4487. ptr = (uint8_t *)wmi_buf_data(buf);
  4488. OS_MEMSET(ptr, 0, len);
  4489. cmd = (wmi_rtt_keepalive_cmd *)wmi_buf_data(buf);
  4490. WMI_RTT_REQ_ID_SET(cmd->req_id, param->req_id);
  4491. WMI_RTT_KEEPALIVE_ACTION_SET(cmd->req_id, param->stop);
  4492. WMI_RTT_VDEV_ID_SET(cmd->probe_info, param->vdev_id);
  4493. /* 3ms probe interval by default */
  4494. WMI_RTT_KEEPALIVE_PERIOD_SET(cmd->probe_info, 3);
  4495. /* max retry of 50 by default */
  4496. WMI_RTT_TIMEOUT_SET(cmd->probe_info, 20);
  4497. /* set frame type */
  4498. WMI_RTT_FRAME_TYPE_SET(cmd->control_flag, RTT_MEAS_FRAME_KEEPALIVE);
  4499. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->macaddr, &cmd->sta_mac);
  4500. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4501. WMI_RTT_KEEPALIVE_CMDID);
  4502. qdf_print("send rtt keepalive cmd to FW with length %d and return %d\n"
  4503. , len, ret);
  4504. param->req_id++;
  4505. return QDF_STATUS_SUCCESS;
  4506. }
  4507. /**
  4508. * send_lci_set_cmd_non_tlv() - send lci cmd to fw
  4509. * @wmi_handle: wmi handle
  4510. * @param: pointer to hold lci param
  4511. *
  4512. * Return: 0 for success or error code
  4513. */
  4514. static QDF_STATUS
  4515. send_lci_set_cmd_non_tlv(wmi_unified_t wmi_handle,
  4516. struct lci_set_params *param)
  4517. {
  4518. wmi_buf_t buf;
  4519. uint8_t *p;
  4520. wmi_oem_measreq_head *head;
  4521. int len;
  4522. int colocated_bss_len = 0;
  4523. wmi_rtt_lci_cfg_head *rtt_req;
  4524. rtt_req = (wmi_rtt_lci_cfg_head *) param->lci_data;
  4525. len = param->msg_len;
  4526. /* colocated_bss[1] contains num of vaps */
  4527. /* Provide colocated bssid subIE only when there are 2 vaps or more */
  4528. if (param->colocated_bss[1] > 1) {
  4529. qdf_print("%s: Adding %d co-located BSSIDs to LCI data\n",
  4530. __func__, param->colocated_bss[1]);
  4531. /* Convert num_vaps to octets:
  4532. 6*Num_of_vap + 1 (Max BSSID Indicator field) */
  4533. param->colocated_bss[1] =
  4534. (param->colocated_bss[1]*IEEE80211_ADDR_LEN)+1;
  4535. colocated_bss_len = param->colocated_bss[1]+2;
  4536. qdf_mem_copy(rtt_req->colocated_bssids_info,
  4537. param->colocated_bss,
  4538. colocated_bss_len);
  4539. rtt_req->co_located_bssid_len = colocated_bss_len;
  4540. qdf_print("%s: co_located_bssid_len: %d\n", __func__,
  4541. param->colocated_bss[1]+2);
  4542. } else {
  4543. qdf_print("No co-located BSSID was added to LCI data\n");
  4544. }
  4545. buf = wmi_buf_alloc(wmi_handle, len);
  4546. if (!buf) {
  4547. qdf_print("No WMI resource!");
  4548. return QDF_STATUS_E_FAILURE;
  4549. }
  4550. p = (uint8_t *) wmi_buf_data(buf);
  4551. qdf_mem_set(p, len, 0);
  4552. head = (wmi_oem_measreq_head *)p;
  4553. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(head, param->lci_data, len);
  4554. if (wmi_unified_cmd_send(wmi_handle, buf, len, WMI_OEM_REQ_CMDID))
  4555. return QDF_STATUS_E_FAILURE;
  4556. /* Save LCI data in host buffer */
  4557. {
  4558. param->latitude_unc = WMI_RTT_LCI_LAT_UNC_GET(
  4559. rtt_req->lci_cfg_param_info);
  4560. param->latitude_0_1 = ((uint32_t)(rtt_req->latitude & 0x3));
  4561. param->latitude_2_33 = (uint32_t)
  4562. (((uint64_t)(rtt_req->latitude)) >> 2);
  4563. param->longitude_unc =
  4564. WMI_RTT_LCI_LON_UNC_GET(rtt_req->lci_cfg_param_info);
  4565. param->longitude_0_1 = ((uint32_t)(rtt_req->longitude & 0x3));
  4566. param->longitude_2_33 =
  4567. (uint32_t)(((uint64_t)(rtt_req->longitude)) >> 2);
  4568. param->altitude_type =
  4569. WMI_RTT_LCI_ALT_TYPE_GET(rtt_req->altitude_info);
  4570. param->altitude_unc_0_3 =
  4571. (WMI_RTT_LCI_ALT_UNC_GET(rtt_req->altitude_info) & 0xF);
  4572. param->altitude_unc_4_5 =
  4573. ((WMI_RTT_LCI_ALT_UNC_GET(rtt_req->altitude_info) >> 4) &
  4574. 0x3);
  4575. param->altitude = (rtt_req->altitude & RTT_LCI_ALTITUDE_MASK);
  4576. param->datum =
  4577. WMI_RTT_LCI_DATUM_GET(rtt_req->lci_cfg_param_info);
  4578. param->reg_loc_agmt =
  4579. WMI_RTT_LCI_REG_LOC_AGMT_GET(rtt_req->lci_cfg_param_info);
  4580. param->reg_loc_dse =
  4581. WMI_RTT_LCI_REG_LOC_DSE_GET(rtt_req->lci_cfg_param_info);
  4582. param->dep_sta =
  4583. WMI_RTT_LCI_DEP_STA_GET(rtt_req->lci_cfg_param_info);
  4584. param->version =
  4585. WMI_RTT_LCI_VERSION_GET(rtt_req->lci_cfg_param_info);
  4586. }
  4587. return QDF_STATUS_SUCCESS;
  4588. }
  4589. /**
  4590. * send_lcr_set_cmd_non_tlv() - send lcr cmd to fw
  4591. * @wmi_handle: wmi handle
  4592. * @param: pointer to hold lcr param
  4593. *
  4594. * Return: 0 for success or error code
  4595. */
  4596. static QDF_STATUS
  4597. send_lcr_set_cmd_non_tlv(wmi_unified_t wmi_handle,
  4598. struct lcr_set_params *param)
  4599. {
  4600. wmi_buf_t buf;
  4601. uint8_t *p;
  4602. wmi_oem_measreq_head *head;
  4603. int len;
  4604. len = param->msg_len;
  4605. buf = wmi_buf_alloc(wmi_handle, len);
  4606. if (!buf) {
  4607. qdf_print("No WMI resource!");
  4608. return QDF_STATUS_E_FAILURE;
  4609. }
  4610. p = (uint8_t *) wmi_buf_data(buf);
  4611. qdf_mem_set(p, len, 0);
  4612. head = (wmi_oem_measreq_head *)p;
  4613. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(head, param->lcr_data, len);
  4614. if (wmi_unified_cmd_send(wmi_handle, buf, len, WMI_OEM_REQ_CMDID))
  4615. return QDF_STATUS_E_FAILURE;
  4616. return QDF_STATUS_SUCCESS;
  4617. }
  4618. /**
  4619. * send_start_oem_data_cmd_non_tlv() - send oem req cmd to fw
  4620. * @wmi_handle: wmi handle
  4621. * @param: pointer to hold oem req param
  4622. */
  4623. static QDF_STATUS
  4624. send_start_oem_data_cmd_non_tlv(wmi_unified_t wmi_handle,
  4625. uint32_t data_len,
  4626. uint8_t *data)
  4627. {
  4628. wmi_buf_t buf;
  4629. uint8_t *p;
  4630. wmi_oem_measreq_head *head;
  4631. buf = wmi_buf_alloc(wmi_handle, data_len);
  4632. if (!buf) {
  4633. qdf_print("%s: No WMI resource!\n", __func__);
  4634. return QDF_STATUS_E_FAILURE;
  4635. }
  4636. p = (uint8_t *) wmi_buf_data(buf);
  4637. qdf_mem_set(p, data_len, 0);
  4638. head = (wmi_oem_measreq_head *)p;
  4639. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(head, data, data_len);
  4640. if (wmi_unified_cmd_send(wmi_handle, buf,
  4641. data_len, WMI_OEM_REQ_CMDID)) {
  4642. qdf_print("%s: ERROR: Host unable to send LOWI request to FW\n",
  4643. __func__);
  4644. wmi_buf_free(buf);
  4645. return QDF_STATUS_E_FAILURE;
  4646. }
  4647. return QDF_STATUS_SUCCESS;
  4648. }
  4649. /**
  4650. * send_get_user_position_cmd_non_tlv() - send cmd get user position from fw
  4651. * @wmi_handle: wmi handle
  4652. * @value: user pos value
  4653. *
  4654. * Return: 0 for success or error code
  4655. */
  4656. static QDF_STATUS
  4657. send_get_user_position_cmd_non_tlv(wmi_unified_t wmi_handle, uint32_t value)
  4658. {
  4659. wmi_buf_t buf;
  4660. wmi_peer_gid_userpos_list_cmd *cmd;
  4661. buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_peer_gid_userpos_list_cmd));
  4662. if (!buf) {
  4663. qdf_print("No WMI resource!");
  4664. return QDF_STATUS_E_FAILURE;
  4665. }
  4666. qdf_nbuf_put_tail(buf, sizeof(wmi_peer_gid_userpos_list_cmd));
  4667. cmd = (wmi_peer_gid_userpos_list_cmd *)(wmi_buf_data(buf));
  4668. cmd->aid = value;
  4669. if (wmi_unified_cmd_send(wmi_handle, buf,
  4670. sizeof(wmi_peer_gid_userpos_list_cmd),
  4671. WMI_PEER_GID_USERPOS_LIST_CMDID)) {
  4672. wmi_buf_free(buf);
  4673. return QDF_STATUS_E_FAILURE;
  4674. }
  4675. return QDF_STATUS_SUCCESS;
  4676. }
  4677. /**
  4678. * send_reset_peer_mumimo_tx_count_cmd_non_tlv() - send mumimo reset tx count fw
  4679. * @wmi_handle: wmi handle
  4680. * @value: reset tx count
  4681. *
  4682. * Return: 0 for success or error code
  4683. */
  4684. static QDF_STATUS
  4685. send_reset_peer_mumimo_tx_count_cmd_non_tlv(wmi_unified_t wmi_handle,
  4686. uint32_t value)
  4687. {
  4688. wmi_buf_t buf;
  4689. wmi_peer_txmu_rstcnt_cmd *cmd;
  4690. buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_peer_txmu_rstcnt_cmd));
  4691. if (!buf) {
  4692. qdf_print("No WMI resource!");
  4693. return QDF_STATUS_E_FAILURE;
  4694. }
  4695. qdf_nbuf_put_tail(buf, sizeof(wmi_peer_txmu_rstcnt_cmd));
  4696. cmd = (wmi_peer_txmu_rstcnt_cmd *)(wmi_buf_data(buf));
  4697. cmd->aid = value;
  4698. if (wmi_unified_cmd_send(wmi_handle, buf,
  4699. sizeof(wmi_peer_txmu_rstcnt_cmd),
  4700. WMI_PEER_TX_MU_TXMIT_RSTCNT_CMDID)) {
  4701. wmi_buf_free(buf);
  4702. return QDF_STATUS_E_FAILURE;
  4703. }
  4704. return QDF_STATUS_SUCCESS;
  4705. }
  4706. /**
  4707. * send_get_peer_mumimo_tx_count_cmd_non_tlv() - send cmd to get mumimo tx count from fw
  4708. * @wmi_handle: wmi handle
  4709. *
  4710. * Return: 0 for success or error code
  4711. */
  4712. static QDF_STATUS
  4713. send_get_peer_mumimo_tx_count_cmd_non_tlv(wmi_unified_t wmi_handle,
  4714. uint32_t value)
  4715. {
  4716. wmi_buf_t buf;
  4717. wmi_peer_txmu_cnt_cmd *cmd;
  4718. buf = wmi_buf_alloc(wmi_handle, sizeof(wmi_peer_txmu_cnt_cmd));
  4719. if (!buf) {
  4720. qdf_print("No WMI resource!");
  4721. return QDF_STATUS_E_FAILURE;
  4722. }
  4723. qdf_nbuf_put_tail(buf, sizeof(wmi_peer_txmu_cnt_cmd));
  4724. cmd = (wmi_peer_txmu_cnt_cmd *)(wmi_buf_data(buf));
  4725. cmd->aid = value;
  4726. if (wmi_unified_cmd_send(wmi_handle, buf,
  4727. sizeof(wmi_peer_txmu_cnt_cmd),
  4728. WMI_PEER_TX_MU_TXMIT_COUNT_CMDID)) {
  4729. wmi_buf_free(buf);
  4730. return QDF_STATUS_E_FAILURE;
  4731. }
  4732. return QDF_STATUS_SUCCESS;
  4733. }
  4734. /**
  4735. * send_pdev_caldata_version_check_cmd_non_tlv() - send caldata check cmd to fw
  4736. * @wmi_handle: wmi handle
  4737. * @param: reserved param
  4738. *
  4739. * Return: 0 for success or error code
  4740. */
  4741. static QDF_STATUS
  4742. send_pdev_caldata_version_check_cmd_non_tlv(wmi_unified_t wmi_handle,
  4743. uint32_t param)
  4744. {
  4745. wmi_pdev_check_cal_version_cmd *cmd;
  4746. wmi_buf_t buf;
  4747. int32_t len = sizeof(wmi_pdev_check_cal_version_cmd);
  4748. buf = wmi_buf_alloc(wmi_handle, len);
  4749. if (!buf) {
  4750. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  4751. return QDF_STATUS_E_FAILURE;
  4752. }
  4753. cmd = (wmi_pdev_check_cal_version_cmd *)wmi_buf_data(buf);
  4754. cmd->reserved = param; /* set to 0x0 as expected from FW */
  4755. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  4756. WMI_PDEV_CHECK_CAL_VERSION_CMDID)) {
  4757. wmi_buf_free(buf);
  4758. return QDF_STATUS_E_FAILURE;
  4759. }
  4760. return QDF_STATUS_SUCCESS;
  4761. }
  4762. /**
  4763. * send_btcoex_wlan_priority_cmd_non_tlv() - send btcoex wlan priority fw
  4764. * @wmi_handle: wmi handle
  4765. * @param: btcoex config params
  4766. *
  4767. * Return: 0 for success or error code
  4768. */
  4769. static QDF_STATUS
  4770. send_btcoex_wlan_priority_cmd_non_tlv(wmi_unified_t wmi_handle,
  4771. struct btcoex_cfg_params *param)
  4772. {
  4773. wmi_buf_t buf;
  4774. wmi_btcoex_cfg_cmd *cmd;
  4775. int len = sizeof(wmi_btcoex_cfg_cmd);
  4776. buf = wmi_buf_alloc(wmi_handle, len);
  4777. if (!buf) {
  4778. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  4779. return QDF_STATUS_E_FAILURE;
  4780. }
  4781. cmd = (wmi_btcoex_cfg_cmd *) wmi_buf_data(buf);
  4782. cmd->btcoex_wlan_priority_bitmap = param->btcoex_wlan_priority_bitmap;
  4783. cmd->btcoex_param_flags = param->btcoex_param_flags;
  4784. if (wmi_unified_cmd_send(wmi_handle, buf, len, WMI_BTCOEX_CFG_CMDID)) {
  4785. wmi_buf_free(buf);
  4786. return QDF_STATUS_E_FAILURE;
  4787. }
  4788. return QDF_STATUS_SUCCESS;
  4789. }
  4790. /**
  4791. * send_btcoex_duty_cycle_cmd_non_tlv() - send btcoex wlan priority fw
  4792. * @wmi_handle: wmi handle
  4793. * @param: period and duration
  4794. *
  4795. * Return: 0 for success or error code
  4796. */
  4797. static QDF_STATUS
  4798. send_btcoex_duty_cycle_cmd_non_tlv(wmi_unified_t wmi_handle,
  4799. struct btcoex_cfg_params *param)
  4800. {
  4801. wmi_buf_t buf;
  4802. wmi_btcoex_cfg_cmd *cmd;
  4803. int len = sizeof(wmi_btcoex_cfg_cmd);
  4804. buf = wmi_buf_alloc(wmi_handle, len);
  4805. if (!buf) {
  4806. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  4807. return QDF_STATUS_E_FAILURE;
  4808. }
  4809. cmd = (wmi_btcoex_cfg_cmd *) wmi_buf_data(buf);
  4810. cmd->wlan_duration = param->wlan_duration;
  4811. cmd->period = param->period;
  4812. cmd->btcoex_param_flags = param->btcoex_param_flags;
  4813. if (wmi_unified_cmd_send(wmi_handle, buf, len, WMI_BTCOEX_CFG_CMDID)) {
  4814. wmi_buf_free(buf);
  4815. return QDF_STATUS_E_FAILURE;
  4816. }
  4817. return QDF_STATUS_SUCCESS;
  4818. }
  4819. /**
  4820. * send_coex_ver_cfg_cmd_non_tlv() - send coex ver cfg
  4821. * @wmi_handle: wmi handle
  4822. * @param: coex ver and configuration
  4823. *
  4824. * Return: 0 for success or error code
  4825. */
  4826. static QDF_STATUS
  4827. send_coex_ver_cfg_cmd_non_tlv(wmi_unified_t wmi_handle, coex_ver_cfg_t *param)
  4828. {
  4829. wmi_buf_t buf;
  4830. coex_ver_cfg_t *cmd;
  4831. int len = sizeof(wmi_coex_ver_cfg_cmd);
  4832. buf = wmi_buf_alloc(wmi_handle, len);
  4833. if (!buf) {
  4834. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  4835. return QDF_STATUS_E_FAILURE;
  4836. }
  4837. cmd = (coex_ver_cfg_t *)wmi_buf_data(buf);
  4838. cmd->coex_version = param->coex_version;
  4839. cmd->length = param->length;
  4840. qdf_mem_copy(cmd->config_buf, param->config_buf,
  4841. sizeof(cmd->config_buf));
  4842. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  4843. WMI_COEX_VERSION_CFG_CMID)) {
  4844. wmi_buf_free(buf);
  4845. return QDF_STATUS_E_FAILURE;
  4846. }
  4847. return QDF_STATUS_SUCCESS;
  4848. }
  4849. /**
  4850. * wmi_copy_resource_config_non_tlv() - copy resource configuration function
  4851. * @param resource_cfg: pointer to resource configuration
  4852. * @param tgt_res_cfg: pointer to target resource configuration
  4853. *
  4854. * Return: None
  4855. */
  4856. static void wmi_copy_resource_config_non_tlv(wmi_resource_config *resource_cfg,
  4857. target_resource_config *tgt_res_cfg)
  4858. {
  4859. resource_cfg->num_vdevs = tgt_res_cfg->num_vdevs;
  4860. resource_cfg->num_peers = tgt_res_cfg->num_peers;
  4861. resource_cfg->num_active_peers = tgt_res_cfg->num_active_peers;
  4862. resource_cfg->num_offload_peers = tgt_res_cfg->num_offload_peers;
  4863. resource_cfg->num_offload_reorder_buffs =
  4864. tgt_res_cfg->num_offload_reorder_buffs;
  4865. resource_cfg->num_peer_keys = tgt_res_cfg->num_peer_keys;
  4866. resource_cfg->num_tids = tgt_res_cfg->num_tids;
  4867. resource_cfg->ast_skid_limit = tgt_res_cfg->ast_skid_limit;
  4868. resource_cfg->tx_chain_mask = tgt_res_cfg->tx_chain_mask;
  4869. resource_cfg->rx_chain_mask = tgt_res_cfg->rx_chain_mask;
  4870. resource_cfg->rx_timeout_pri[0] = tgt_res_cfg->rx_timeout_pri[0];
  4871. resource_cfg->rx_timeout_pri[1] = tgt_res_cfg->rx_timeout_pri[1];
  4872. resource_cfg->rx_timeout_pri[2] = tgt_res_cfg->rx_timeout_pri[2];
  4873. resource_cfg->rx_timeout_pri[3] = tgt_res_cfg->rx_timeout_pri[3];
  4874. resource_cfg->rx_decap_mode = tgt_res_cfg->rx_decap_mode;
  4875. resource_cfg->scan_max_pending_req = tgt_res_cfg->scan_max_pending_req;
  4876. resource_cfg->bmiss_offload_max_vdev =
  4877. tgt_res_cfg->bmiss_offload_max_vdev;
  4878. resource_cfg->roam_offload_max_vdev =
  4879. tgt_res_cfg->roam_offload_max_vdev;
  4880. resource_cfg->roam_offload_max_ap_profiles =
  4881. tgt_res_cfg->roam_offload_max_ap_profiles;
  4882. resource_cfg->num_mcast_groups = tgt_res_cfg->num_mcast_groups;
  4883. resource_cfg->num_mcast_table_elems =
  4884. tgt_res_cfg->num_mcast_table_elems;
  4885. resource_cfg->mcast2ucast_mode = tgt_res_cfg->mcast2ucast_mode;
  4886. resource_cfg->tx_dbg_log_size = tgt_res_cfg->tx_dbg_log_size;
  4887. resource_cfg->num_wds_entries = tgt_res_cfg->num_wds_entries;
  4888. resource_cfg->dma_burst_size = tgt_res_cfg->dma_burst_size;
  4889. resource_cfg->mac_aggr_delim = tgt_res_cfg->mac_aggr_delim;
  4890. resource_cfg->rx_skip_defrag_timeout_dup_detection_check =
  4891. tgt_res_cfg->rx_skip_defrag_timeout_dup_detection_check;
  4892. resource_cfg->vow_config = tgt_res_cfg->vow_config;
  4893. resource_cfg->gtk_offload_max_vdev = tgt_res_cfg->gtk_offload_max_vdev;
  4894. resource_cfg->num_msdu_desc = tgt_res_cfg->num_msdu_desc;
  4895. resource_cfg->max_frag_entries = tgt_res_cfg->max_frag_entries;
  4896. resource_cfg->max_peer_ext_stats = tgt_res_cfg->max_peer_ext_stats;
  4897. resource_cfg->smart_ant_cap = tgt_res_cfg->smart_ant_cap;
  4898. resource_cfg->BK_Minfree = tgt_res_cfg->BK_Minfree;
  4899. resource_cfg->BE_Minfree = tgt_res_cfg->BE_Minfree;
  4900. resource_cfg->VI_Minfree = tgt_res_cfg->VI_Minfree;
  4901. resource_cfg->VO_Minfree = tgt_res_cfg->VO_Minfree;
  4902. resource_cfg->rx_batchmode = tgt_res_cfg->rx_batchmode;
  4903. resource_cfg->tt_support = tgt_res_cfg->tt_support;
  4904. resource_cfg->atf_config = tgt_res_cfg->atf_config;
  4905. resource_cfg->iphdr_pad_config = tgt_res_cfg->iphdr_pad_config;
  4906. WMI_SET_QWRAP(resource_cfg, tgt_res_cfg->qwrap_config);
  4907. WMI_SET_ALLOC_FRAG(resource_cfg,
  4908. tgt_res_cfg->alloc_frag_desc_for_data_pkt);
  4909. }
  4910. /**
  4911. * init_cmd_send_non_tlv() - send initialization cmd to fw
  4912. * @wmi_handle: wmi handle
  4913. * @param param: pointer to wmi init param
  4914. *
  4915. * Return: 0 for success or error code
  4916. */
  4917. static QDF_STATUS init_cmd_send_non_tlv(wmi_unified_t wmi_handle,
  4918. struct wmi_init_cmd_param *param)
  4919. {
  4920. wmi_buf_t buf;
  4921. wmi_init_cmd *cmd;
  4922. wlan_host_memory_chunk *host_mem_chunks;
  4923. uint32_t mem_chunk_len = 0;
  4924. uint16_t idx;
  4925. int len;
  4926. len = sizeof(*cmd);
  4927. mem_chunk_len = (sizeof(wlan_host_memory_chunk) * MAX_MEM_CHUNKS);
  4928. buf = wmi_buf_alloc(wmi_handle, len + mem_chunk_len);
  4929. if (!buf) {
  4930. qdf_print("%s: wmi_buf_alloc failed\n", __func__);
  4931. return QDF_STATUS_E_FAILURE;
  4932. }
  4933. cmd = (wmi_init_cmd *) wmi_buf_data(buf);
  4934. wmi_copy_resource_config_non_tlv(&cmd->resource_config, param->res_cfg);
  4935. host_mem_chunks = cmd->host_mem_chunks;
  4936. for (idx = 0; idx < param->num_mem_chunks; ++idx) {
  4937. host_mem_chunks[idx].ptr = param->mem_chunks[idx].paddr;
  4938. host_mem_chunks[idx].size = param->mem_chunks[idx].len;
  4939. host_mem_chunks[idx].req_id = param->mem_chunks[idx].req_id;
  4940. qdf_print("chunk %d len %d requested , ptr 0x%x\n",
  4941. idx, cmd->host_mem_chunks[idx].size,
  4942. cmd->host_mem_chunks[idx].ptr);
  4943. }
  4944. cmd->num_host_mem_chunks = param->num_mem_chunks;
  4945. if (param->num_mem_chunks > 1)
  4946. len += ((param->num_mem_chunks-1) *
  4947. sizeof(wlan_host_memory_chunk));
  4948. if (wmi_unified_cmd_send(wmi_handle, buf, len, WMI_INIT_CMDID) < 0) {
  4949. wmi_buf_free(buf);
  4950. return QDF_STATUS_E_FAILURE;
  4951. }
  4952. return QDF_STATUS_SUCCESS;
  4953. }
  4954. /**
  4955. * send_ext_resource_config_non_tlv() - send extended resource configuration
  4956. * @wmi_handle: wmi handle
  4957. * @param ext_cfg: pointer to extended resource configuration
  4958. *
  4959. * Return: 0 for success or error code
  4960. */
  4961. static QDF_STATUS send_ext_resource_config_non_tlv(wmi_unified_t wmi_handle,
  4962. wmi_host_ext_resource_config *ext_cfg)
  4963. {
  4964. wmi_buf_t buf;
  4965. int len = 0;
  4966. wmi_ext_resource_config *cmd_cfg;
  4967. #define PAD_LENGTH 100
  4968. buf = wmi_buf_alloc(wmi_handle,
  4969. len + (sizeof(wmi_ext_resource_config) + PAD_LENGTH));
  4970. if (!buf) {
  4971. qdf_print("%s:wmi_buf_alloc failed\n", __func__);
  4972. return QDF_STATUS_E_FAILURE;
  4973. }
  4974. cmd_cfg = (wmi_ext_resource_config *)wmi_buf_data(buf);
  4975. qdf_mem_copy(cmd_cfg, ext_cfg, sizeof(wmi_ext_resource_config));
  4976. qdf_print("\nSending Ext resource cfg: HOST PLATFORM as %d\n"
  4977. "fw_feature_bitmap as %x to TGT\n",
  4978. cmd_cfg->host_platform_config,
  4979. cmd_cfg->fw_feature_bitmap);
  4980. if (wmi_unified_cmd_send(wmi_handle, buf,
  4981. sizeof(wmi_ext_resource_config),
  4982. WMI_EXT_RESOURCE_CFG_CMDID) < 0) {
  4983. wmi_buf_free(buf);
  4984. return QDF_STATUS_E_FAILURE;
  4985. }
  4986. return QDF_STATUS_SUCCESS;
  4987. }
  4988. /**
  4989. * save_service_bitmap_non_tlv() - save service bitmap
  4990. * @wmi_handle: wmi handle
  4991. * @param evt_buf: pointer to event buffer
  4992. * @param bitmap_buf: bitmap buffer for converged legacy support
  4993. *
  4994. * Return: QDF_STATUS
  4995. */
  4996. static QDF_STATUS save_service_bitmap_non_tlv(wmi_unified_t wmi_handle,
  4997. void *evt_buf, void *bitmap_buf)
  4998. {
  4999. wmi_service_ready_event *ev;
  5000. struct wmi_soc *soc = wmi_handle->soc;
  5001. ev = (wmi_service_ready_event *) evt_buf;
  5002. /* If it is already allocated, use that buffer. This can happen
  5003. * during target stop/start scenarios where host allocation is skipped.
  5004. */
  5005. if (!soc->wmi_service_bitmap) {
  5006. soc->wmi_service_bitmap =
  5007. qdf_mem_malloc(WMI_SERVICE_BM_SIZE * sizeof(uint32_t));
  5008. if (!soc->wmi_service_bitmap) {
  5009. WMI_LOGE("Failed memory alloc for service bitmap\n");
  5010. return QDF_STATUS_E_NOMEM;
  5011. }
  5012. }
  5013. qdf_mem_copy(soc->wmi_service_bitmap, ev->wmi_service_bitmap,
  5014. (WMI_SERVICE_BM_SIZE * sizeof(uint32_t)));
  5015. if (bitmap_buf)
  5016. qdf_mem_copy(bitmap_buf, ev->wmi_service_bitmap,
  5017. (WMI_SERVICE_BM_SIZE * sizeof(uint32_t)));
  5018. return QDF_STATUS_SUCCESS;
  5019. }
  5020. /**
  5021. * is_service_enabled_non_tlv() - Check if service enabled
  5022. * @param wmi_handle: wmi handle
  5023. * @param service_id: service identifier
  5024. *
  5025. * Return: 1 enabled, 0 disabled
  5026. */
  5027. static bool is_service_enabled_non_tlv(wmi_unified_t wmi_handle,
  5028. uint32_t service_id)
  5029. {
  5030. struct wmi_soc *soc = wmi_handle->soc;
  5031. if (!soc->wmi_service_bitmap) {
  5032. WMI_LOGE("WMI service bit map is not saved yet\n");
  5033. return false;
  5034. }
  5035. return WMI_SERVICE_IS_ENABLED(soc->wmi_service_bitmap,
  5036. service_id);
  5037. }
  5038. static inline void copy_ht_cap_info(uint32_t ev_target_cap,
  5039. struct wlan_psoc_target_capability_info *cap)
  5040. {
  5041. cap->ht_cap_info |= ev_target_cap & (
  5042. WMI_HT_CAP_ENABLED
  5043. | WMI_HT_CAP_HT20_SGI
  5044. | WMI_HT_CAP_DYNAMIC_SMPS
  5045. | WMI_HT_CAP_TX_STBC
  5046. | WMI_HT_CAP_TX_STBC_MASK_SHIFT
  5047. | WMI_HT_CAP_RX_STBC
  5048. | WMI_HT_CAP_RX_STBC_MASK_SHIFT
  5049. | WMI_HT_CAP_LDPC
  5050. | WMI_HT_CAP_L_SIG_TXOP_PROT
  5051. | WMI_HT_CAP_MPDU_DENSITY
  5052. | WMI_HT_CAP_MPDU_DENSITY_MASK_SHIFT
  5053. | WMI_HT_CAP_HT40_SGI
  5054. | WMI_HT_CAP_IBF_BFER);
  5055. if (ev_target_cap & WMI_HT_CAP_IBF_BFER)
  5056. cap->ht_cap_info |= WMI_HOST_HT_CAP_IBF_BFER;
  5057. }
  5058. /**
  5059. * extract_service_ready_non_tlv() - extract service ready event
  5060. * @wmi_handle: wmi handle
  5061. * @param evt_buf: pointer to received event buffer
  5062. * @param cap: pointer to hold target capability information extracted from even
  5063. *
  5064. * Return: 0 for success or error code
  5065. */
  5066. static QDF_STATUS extract_service_ready_non_tlv(wmi_unified_t wmi_handle,
  5067. void *evt_buf,
  5068. struct wlan_psoc_target_capability_info *cap)
  5069. {
  5070. wmi_service_ready_event *ev;
  5071. ev = (wmi_service_ready_event *) evt_buf;
  5072. cap->phy_capability = ev->phy_capability;
  5073. cap->max_frag_entry = ev->max_frag_entry;
  5074. cap->num_rf_chains = ev->num_rf_chains;
  5075. copy_ht_cap_info(ev->ht_cap_info, cap);
  5076. cap->vht_cap_info = ev->vht_cap_info;
  5077. cap->vht_supp_mcs = ev->vht_supp_mcs;
  5078. cap->hw_min_tx_power = ev->hw_min_tx_power;
  5079. cap->hw_max_tx_power = ev->hw_max_tx_power;
  5080. cap->sys_cap_info = ev->sys_cap_info;
  5081. cap->min_pkt_size_enable = ev->min_pkt_size_enable;
  5082. cap->max_bcn_ie_size = ev->max_bcn_ie_size;
  5083. cap->fw_version = ev->sw_version;
  5084. cap->fw_version_1 = ev->sw_version_1;
  5085. /* Following caps not recieved in older fw/hw
  5086. * Initialize it as zero(default). */
  5087. cap->max_num_scan_channels = 0;
  5088. cap->max_supported_macs = 0;
  5089. cap->wmi_fw_sub_feat_caps = 0;
  5090. cap->txrx_chainmask = 0;
  5091. cap->default_dbs_hw_mode_index = 0;
  5092. cap->num_msdu_desc = 0;
  5093. return QDF_STATUS_SUCCESS;
  5094. }
  5095. /**
  5096. * extract_fw_version_non_tlv() - extract fw version
  5097. * @wmi_handle: wmi handle
  5098. * @param evt_buf: pointer to event buffer
  5099. * @param fw_ver: Pointer to hold fw version
  5100. *
  5101. * Return: 0 for success or error code
  5102. */
  5103. static QDF_STATUS extract_fw_version_non_tlv(wmi_unified_t wmi_handle,
  5104. void *evt_buf, struct wmi_host_fw_ver *fw_ver)
  5105. {
  5106. wmi_service_ready_event *ev;
  5107. ev = (wmi_service_ready_event *) evt_buf;
  5108. fw_ver->sw_version = ev->sw_version;
  5109. fw_ver->sw_version_1 = ev->sw_version_1;
  5110. return QDF_STATUS_SUCCESS;
  5111. }
  5112. /**
  5113. * extract_fw_abi_version_non_tlv() - extract fw abi version
  5114. * @wmi_handle: wmi handle
  5115. * @param evt_buf: Pointer to event buffer
  5116. * @param fw_ver: Pointer to hold fw abi version
  5117. *
  5118. * Return: 0 for success or error code
  5119. */
  5120. static QDF_STATUS extract_fw_abi_version_non_tlv(wmi_unified_t wmi_handle,
  5121. void *evt_buf, struct wmi_host_fw_abi_ver *fw_ver)
  5122. {
  5123. wmi_ready_event *ev;
  5124. ev = (wmi_ready_event *) evt_buf;
  5125. fw_ver->sw_version = ev->sw_version;
  5126. fw_ver->abi_version = ev->abi_version;
  5127. return QDF_STATUS_SUCCESS;
  5128. }
  5129. /**
  5130. * extract_hal_reg_cap_non_tlv() - extract HAL registered capabilities
  5131. * @wmi_handle: wmi handle
  5132. * @param evt_buf: Pointer to event buffer
  5133. * @param cap: pointer to hold HAL reg capabilities
  5134. *
  5135. * Return: 0 for success or error code
  5136. */
  5137. static QDF_STATUS extract_hal_reg_cap_non_tlv(wmi_unified_t wmi_handle,
  5138. void *evt_buf,
  5139. struct wlan_psoc_hal_reg_capability *cap)
  5140. {
  5141. wmi_service_ready_event *ev;
  5142. u_int32_t wireless_modes_orig = 0;
  5143. ev = (wmi_service_ready_event *) evt_buf;
  5144. qdf_mem_copy(cap, &ev->hal_reg_capabilities,
  5145. sizeof(struct wlan_psoc_hal_reg_capability));
  5146. /* Convert REGDMN_MODE values sent by target to host internal
  5147. * WMI_HOST_REGDMN_MODE values.
  5148. *
  5149. * REGULATORY TODO :
  5150. * REGDMN_MODE_11AC_VHT*_2G values are not used by the
  5151. * host currently. Add this in the future if required.
  5152. */
  5153. wireless_modes_orig = ev->hal_reg_capabilities.wireless_modes;
  5154. cap->wireless_modes = 0;
  5155. if (wireless_modes_orig & REGDMN_MODE_11A)
  5156. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11A;
  5157. if (wireless_modes_orig & REGDMN_MODE_TURBO)
  5158. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_TURBO;
  5159. if (wireless_modes_orig & REGDMN_MODE_11B)
  5160. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11B;
  5161. if (wireless_modes_orig & REGDMN_MODE_PUREG)
  5162. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_PUREG;
  5163. if (wireless_modes_orig & REGDMN_MODE_11G)
  5164. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11G;
  5165. if (wireless_modes_orig & REGDMN_MODE_108G)
  5166. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_108G;
  5167. if (wireless_modes_orig & REGDMN_MODE_108A)
  5168. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_108A;
  5169. if (wireless_modes_orig & REGDMN_MODE_XR)
  5170. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_XR;
  5171. if (wireless_modes_orig & REGDMN_MODE_11A_HALF_RATE)
  5172. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11A_HALF_RATE;
  5173. if (wireless_modes_orig & REGDMN_MODE_11A_QUARTER_RATE)
  5174. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11A_QUARTER_RATE;
  5175. if (wireless_modes_orig & REGDMN_MODE_11NG_HT20)
  5176. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11NG_HT20;
  5177. if (wireless_modes_orig & REGDMN_MODE_11NA_HT20)
  5178. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11NA_HT20;
  5179. if (wireless_modes_orig & REGDMN_MODE_11NG_HT40PLUS)
  5180. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11NG_HT40PLUS;
  5181. if (wireless_modes_orig & REGDMN_MODE_11NG_HT40MINUS)
  5182. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11NG_HT40MINUS;
  5183. if (wireless_modes_orig & REGDMN_MODE_11NA_HT40PLUS)
  5184. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11NA_HT40PLUS;
  5185. if (wireless_modes_orig & REGDMN_MODE_11NA_HT40MINUS)
  5186. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11NA_HT40MINUS;
  5187. if (wireless_modes_orig & REGDMN_MODE_11AC_VHT20)
  5188. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT20;
  5189. if (wireless_modes_orig & REGDMN_MODE_11AC_VHT40PLUS)
  5190. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT40PLUS;
  5191. if (wireless_modes_orig & REGDMN_MODE_11AC_VHT40MINUS)
  5192. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT40MINUS;
  5193. if (wireless_modes_orig & REGDMN_MODE_11AC_VHT80)
  5194. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT80;
  5195. if (wireless_modes_orig & REGDMN_MODE_11AC_VHT160)
  5196. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT160;
  5197. if (wireless_modes_orig & REGDMN_MODE_11AC_VHT80_80)
  5198. cap->wireless_modes |= WMI_HOST_REGDMN_MODE_11AC_VHT80_80;
  5199. return QDF_STATUS_SUCCESS;
  5200. }
  5201. /**
  5202. * extract_host_mem_req_non_tlv() - Extract host memory request event
  5203. * @wmi_handle: wmi handle
  5204. * @param evt_buf: pointer to event buffer
  5205. * @param num_entries: pointer to hold number of entries requested
  5206. *
  5207. * Return: Number of entries requested
  5208. */
  5209. static host_mem_req *extract_host_mem_req_non_tlv(wmi_unified_t wmi_handle,
  5210. void *evt_buf, uint8_t *num_entries)
  5211. {
  5212. wmi_service_ready_event *ev;
  5213. ev = (wmi_service_ready_event *) evt_buf;
  5214. *num_entries = ev->num_mem_reqs;
  5215. return (host_mem_req *)ev->mem_reqs;
  5216. }
  5217. /**
  5218. * save_fw_version_in_service_ready_non_tlv() - Save fw version in service
  5219. * ready function
  5220. * @wmi_handle: wmi handle
  5221. * @param evt_buf: pointer to event buffer
  5222. *
  5223. * Return: 0 for success or error code
  5224. */
  5225. static QDF_STATUS save_fw_version_in_service_ready_non_tlv(
  5226. wmi_unified_t wmi_handle,
  5227. void *evt_buf)
  5228. {
  5229. /* Version check and exchange is not present in non-tlv implementation*/
  5230. return QDF_STATUS_SUCCESS;
  5231. }
  5232. /**
  5233. * ready_check_and_update_fw_version_non_tlv() - Ready and fw version check
  5234. * function
  5235. * @wmi_handle: wmi handle
  5236. * @param evt_buf: pointer to event buffer
  5237. *
  5238. * Return: 0 for success or error code
  5239. */
  5240. static QDF_STATUS ready_check_and_update_fw_version_non_tlv(
  5241. wmi_unified_t wmi_handle,
  5242. void *evt_buf)
  5243. {
  5244. /* Version check and exchange is not present in non-tlv implementation*/
  5245. return QDF_STATUS_SUCCESS;
  5246. }
  5247. /**
  5248. * ready_extract_init_status_non_tlv() - Extract init status from ready event
  5249. * @wmi_handle: wmi handle
  5250. * @param evt_buf: Pointer to event buffer
  5251. *
  5252. * Return: ready status
  5253. */
  5254. static uint32_t ready_extract_init_status_non_tlv(wmi_unified_t wmi_hdl,
  5255. void *evt_buf)
  5256. {
  5257. wmi_ready_event *ev = (wmi_ready_event *) evt_buf;
  5258. qdf_print("Version = %d %d status = %d\n", ev->sw_version,
  5259. ev->abi_version, ev->status);
  5260. return ev->status;
  5261. }
  5262. /**
  5263. * ready_extract_mac_addr_non_tlv() - extract mac address from ready event
  5264. * @wmi_handle: wmi handle
  5265. * @param evt_buf: pointer to event buffer
  5266. * @param macaddr: Pointer to hold MAC address
  5267. *
  5268. * Return: 0 for success or error code
  5269. */
  5270. static QDF_STATUS ready_extract_mac_addr_non_tlv(wmi_unified_t wmi_hdl,
  5271. void *evt_buf,
  5272. uint8_t *macaddr)
  5273. {
  5274. wmi_ready_event *ev = (wmi_ready_event *) evt_buf;
  5275. WMI_MAC_ADDR_TO_CHAR_ARRAY(&ev->mac_addr, macaddr);
  5276. return QDF_STATUS_SUCCESS;
  5277. }
  5278. /**
  5279. * extract_ready_params_non_tlv() - Extract data from ready event apart from
  5280. * status, macaddr and version.
  5281. * @wmi_handle: Pointer to WMI handle.
  5282. * @evt_buf: Pointer to Ready event buffer.
  5283. * @ev_param: Pointer to host defined struct to copy the data from event.
  5284. *
  5285. * Return: QDF_STATUS_SUCCESS on success.
  5286. */
  5287. static QDF_STATUS extract_ready_event_params_non_tlv(wmi_unified_t wmi_handle,
  5288. void *evt_buf, struct wmi_host_ready_ev_param *ev_param)
  5289. {
  5290. wmi_ready_event *ev = (wmi_ready_event *) evt_buf;
  5291. ev_param->status = ev->status;
  5292. ev_param->num_dscp_table = ev->num_dscp_table;
  5293. if (ev->agile_capability)
  5294. ev_param->agile_capability = true;
  5295. else
  5296. ev_param->agile_capability = false;
  5297. /* Following params not present in non-TLV target. Set Defaults */
  5298. ev_param->num_extra_mac_addr = 0;
  5299. ev_param->num_total_peer = 0;
  5300. ev_param->num_extra_peer = 0;
  5301. return QDF_STATUS_SUCCESS;
  5302. }
  5303. /**
  5304. * extract_dbglog_data_len_non_tlv() - extract debuglog data length
  5305. * @wmi_handle: wmi handle
  5306. * @param evt_buf: pointer to event buffer
  5307. *
  5308. * Return: length
  5309. */
  5310. static uint8_t *extract_dbglog_data_len_non_tlv(wmi_unified_t wmi_handle,
  5311. void *evt_buf,
  5312. uint32_t *len)
  5313. {
  5314. /*Len is already valid from event. No need to change it */
  5315. return evt_buf;
  5316. }
  5317. /**
  5318. * extract_wds_addr_event_non_tlv() - extract wds address from event
  5319. * @wmi_handle: wmi handle
  5320. * @param evt_buf: pointer to event buffer
  5321. * @param wds_ev: Pointer to hold wds address
  5322. *
  5323. * Return: 0 for success or error code
  5324. */
  5325. static QDF_STATUS extract_wds_addr_event_non_tlv(wmi_unified_t wmi_handle,
  5326. void *evt_buf,
  5327. uint16_t len, wds_addr_event_t *wds_ev)
  5328. {
  5329. wmi_wds_addr_event_t *ev = (wmi_wds_addr_event_t *) evt_buf;
  5330. int i;
  5331. #ifdef BIG_ENDIAN_HOST
  5332. {
  5333. uint8_t *datap = (uint8_t *) ev;
  5334. /*Skip swapping the first long word*/
  5335. datap += sizeof(uint32_t);
  5336. for (i = 0; i < ((len / sizeof(uint32_t))-1);
  5337. i++, datap += sizeof(uint32_t))
  5338. *(uint32_t *)datap =
  5339. qdf_le32_to_cpu(*(uint32_t *)datap);
  5340. }
  5341. #endif
  5342. qdf_mem_copy(wds_ev->event_type, ev->event_type,
  5343. sizeof(wds_ev->event_type));
  5344. for (i = 0; i < 4; i++) {
  5345. wds_ev->peer_mac[i] =
  5346. ((u_int8_t *)&(ev->peer_mac.mac_addr31to0))[i];
  5347. wds_ev->dest_mac[i] =
  5348. ((u_int8_t *)&(ev->dest_mac.mac_addr31to0))[i];
  5349. }
  5350. for (i = 0; i < 2; i++) {
  5351. wds_ev->peer_mac[4+i] =
  5352. ((u_int8_t *)&(ev->peer_mac.mac_addr47to32))[i];
  5353. wds_ev->dest_mac[4+i] =
  5354. ((u_int8_t *)&(ev->dest_mac.mac_addr47to32))[i];
  5355. }
  5356. /* vdev_id is not available in legacy. It is required only to get
  5357. * pdev, hence setting it to zero as legacy as only one pdev.
  5358. */
  5359. wds_ev->vdev_id = 0;
  5360. return QDF_STATUS_SUCCESS;
  5361. }
  5362. /**
  5363. * extract_dcs_interference_type_non_tlv() - extract dcs interference type
  5364. * from event
  5365. * @wmi_handle: wmi handle
  5366. * @param evt_buf: pointer to event buffer
  5367. * @param param: Pointer to hold dcs interference param
  5368. *
  5369. * Return: 0 for success or error code
  5370. */
  5371. static QDF_STATUS extract_dcs_interference_type_non_tlv(
  5372. wmi_unified_t wmi_handle,
  5373. void *evt_buf, struct wmi_host_dcs_interference_param *param)
  5374. {
  5375. wmi_dcs_interference_event_t *ev =
  5376. (wmi_dcs_interference_event_t *) evt_buf;
  5377. param->interference_type = ev->interference_type;
  5378. param->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  5379. return QDF_STATUS_SUCCESS;
  5380. }
  5381. /*
  5382. * extract_dcs_cw_int_non_tlv() - extract dcs cw interference from event
  5383. * @wmi_handle: wmi handle
  5384. * @param evt_buf: pointer to event buffer
  5385. * @param cw_int: Pointer to hold cw interference
  5386. *
  5387. * Return: 0 for success or error code
  5388. */
  5389. static QDF_STATUS extract_dcs_cw_int_non_tlv(wmi_unified_t wmi_handle,
  5390. void *evt_buf,
  5391. wmi_host_ath_dcs_cw_int *cw_int)
  5392. {
  5393. wmi_dcs_interference_event_t *ev =
  5394. (wmi_dcs_interference_event_t *) evt_buf;
  5395. qdf_mem_copy(cw_int, &ev->int_event.cw_int, sizeof(*cw_int));
  5396. return QDF_STATUS_SUCCESS;
  5397. }
  5398. /**
  5399. * extract_dcs_im_tgt_stats_non_tlv() - extract dcs im target stats from event
  5400. * @wmi_handle: wmi handle
  5401. * @param evt_buf: pointer to event buffer
  5402. * @param wlan_stat: Pointer to hold wlan stats
  5403. *
  5404. * Return: 0 for success or error code
  5405. */
  5406. static QDF_STATUS extract_dcs_im_tgt_stats_non_tlv(wmi_unified_t wmi_handle,
  5407. void *evt_buf,
  5408. wmi_host_dcs_im_tgt_stats_t *wlan_stat)
  5409. {
  5410. wmi_dcs_interference_event_t *ev =
  5411. (wmi_dcs_interference_event_t *) evt_buf;
  5412. qdf_mem_copy(wlan_stat, &ev->int_event.wlan_stat,
  5413. sizeof(wmi_host_dcs_im_tgt_stats_t));
  5414. return QDF_STATUS_SUCCESS;
  5415. }
  5416. /**
  5417. * extract_fips_event_data_non_tlv() - extract fips event data
  5418. * @wmi_handle: wmi handle
  5419. * @param evt_buf: pointer to event buffer
  5420. * @param param: pointer FIPS event params
  5421. *
  5422. * Return: 0 for success or error code
  5423. */
  5424. static QDF_STATUS extract_fips_event_data_non_tlv(wmi_unified_t wmi_handle,
  5425. void *evt_buf,
  5426. struct wmi_host_fips_event_param *param)
  5427. {
  5428. wmi_pdev_fips_event *event = (wmi_pdev_fips_event *)evt_buf;
  5429. param->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  5430. #ifdef BIG_ENDIAN_HOST
  5431. {
  5432. /*****************LE to BE conversion*************************/
  5433. /* Assigning unaligned space to copy the data */
  5434. unsigned char *data_unaligned = qdf_mem_malloc(
  5435. (sizeof(u_int8_t)*event->data_len + FIPS_ALIGN));
  5436. u_int8_t *data_aligned = NULL;
  5437. int c;
  5438. /* Checking if kmalloc does succesful allocation */
  5439. if (data_unaligned == NULL)
  5440. return QDF_STATUS_E_FAILURE;
  5441. /* Checking if space is alligned */
  5442. if (!FIPS_IS_ALIGNED(data_unaligned, FIPS_ALIGN)) {
  5443. /* align the data space */
  5444. data_aligned =
  5445. (u_int8_t *)FIPS_ALIGNTO(data_unaligned, FIPS_ALIGN);
  5446. } else {
  5447. data_aligned = (u_int8_t *)data_unaligned;
  5448. }
  5449. /* memset and copy content from data to data aligned */
  5450. OS_MEMSET(data_aligned, 0, event->data_len);
  5451. OS_MEMCPY(data_aligned, event->data, event->data_len);
  5452. /* Endianness to LE */
  5453. for (c = 0; c < event->data_len/4; c++) {
  5454. *((u_int32_t *)data_aligned+c) =
  5455. qdf_le32_to_cpu(*((u_int32_t *)data_aligned+c));
  5456. }
  5457. /* Copy content to event->data */
  5458. OS_MEMCPY(event->data, data_aligned, event->data_len);
  5459. /* clean up allocated space */
  5460. qdf_mem_free(data_unaligned);
  5461. data_aligned = NULL;
  5462. data_unaligned = NULL;
  5463. /*************************************************************/
  5464. }
  5465. #endif
  5466. param->data = event->data;
  5467. param->data_len = event->data_len;
  5468. param->error_status = event->error_status;
  5469. return QDF_STATUS_SUCCESS;
  5470. }
  5471. /**
  5472. * extract_vdev_start_resp_non_tlv() - extract vdev start response
  5473. * @wmi_handle: wmi handle
  5474. * @param evt_buf: pointer to event buffer
  5475. * @param vdev_rsp: Pointer to hold vdev response
  5476. *
  5477. * Return: 0 for success or error code
  5478. */
  5479. static QDF_STATUS extract_vdev_start_resp_non_tlv(wmi_unified_t wmi_handle,
  5480. void *evt_buf,
  5481. wmi_host_vdev_start_resp *vdev_rsp)
  5482. {
  5483. wmi_vdev_start_response_event *ev =
  5484. (wmi_vdev_start_response_event *) evt_buf;
  5485. qdf_mem_zero(vdev_rsp, sizeof(*vdev_rsp));
  5486. vdev_rsp->vdev_id = ev->vdev_id;
  5487. vdev_rsp->requestor_id = ev->requestor_id;
  5488. vdev_rsp->resp_type = ev->resp_type;
  5489. vdev_rsp->status = ev->status;
  5490. return QDF_STATUS_SUCCESS;
  5491. }
  5492. /**
  5493. * extract_tbttoffset_num_vdevs_non_tlv() - extract tbtt offset num vdevs
  5494. * @wmi_handle: wmi handle
  5495. * @param evt_buf: pointer to event buffer
  5496. * @param num_vdev: Pointer to hold num vdev
  5497. *
  5498. * Return: 0 for success or error code
  5499. */
  5500. static QDF_STATUS extract_tbttoffset_num_vdevs_non_tlv(void *wmi_hdl,
  5501. void *evt_buf,
  5502. uint32_t *num_vdevs)
  5503. {
  5504. wmi_tbtt_offset_event *tbtt_offset_event =
  5505. (wmi_tbtt_offset_event *)evt_buf;
  5506. uint32_t vdev_map;
  5507. vdev_map = tbtt_offset_event->vdev_map;
  5508. *num_vdevs = wmi_vdev_map_to_num_vdevs(vdev_map);
  5509. return QDF_STATUS_SUCCESS;
  5510. }
  5511. /**
  5512. * extract_tbttoffset_update_params_non_tlv() - extract tbtt offset update param
  5513. * @wmi_handle: wmi handle
  5514. * @param evt_buf: pointer to event buffer
  5515. * @param idx: Index refering to a vdev
  5516. * @param tbtt_param: Pointer to tbttoffset event param
  5517. *
  5518. * Return: 0 for success or error code
  5519. */
  5520. static QDF_STATUS extract_tbttoffset_update_params_non_tlv(void *wmi_hdl,
  5521. void *evt_buf, uint8_t idx,
  5522. struct tbttoffset_params *tbtt_param)
  5523. {
  5524. wmi_tbtt_offset_event *tbtt_offset_event =
  5525. (wmi_tbtt_offset_event *)evt_buf;
  5526. uint32_t vdev_map;
  5527. vdev_map = tbtt_offset_event->vdev_map;
  5528. tbtt_param->vdev_id = wmi_vdev_map_to_vdev_id(vdev_map, idx);
  5529. if (tbtt_param->vdev_id == WLAN_INVALID_VDEV_ID)
  5530. return QDF_STATUS_E_INVAL;
  5531. tbtt_param->tbttoffset =
  5532. tbtt_offset_event->tbttoffset_list[tbtt_param->vdev_id];
  5533. return QDF_STATUS_SUCCESS;
  5534. }
  5535. /**
  5536. * extract_mgmt_rx_params_non_tlv() - extract management rx params from event
  5537. * @wmi_handle: wmi handle
  5538. * @param evt_buf: pointer to event buffer
  5539. * @param hdr: Pointer to hold header
  5540. * @param bufp: Pointer to hold pointer to rx param buffer
  5541. *
  5542. * Return: 0 for success or error code
  5543. */
  5544. static QDF_STATUS extract_mgmt_rx_params_non_tlv(wmi_unified_t wmi_handle,
  5545. void *evt_buf,
  5546. struct mgmt_rx_event_params *hdr, uint8_t **bufp)
  5547. {
  5548. wmi_mgmt_rx_event *ev = (wmi_mgmt_rx_event *)evt_buf;
  5549. hdr->channel = ev->hdr.channel;
  5550. hdr->snr = ev->hdr.snr;
  5551. hdr->rssi = ev->hdr.snr;
  5552. hdr->rate = ev->hdr.rate;
  5553. hdr->phy_mode = ev->hdr.phy_mode;
  5554. hdr->buf_len = ev->hdr.buf_len;
  5555. hdr->status = ev->hdr.status;
  5556. hdr->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  5557. qdf_mem_copy(hdr->rssi_ctl, ev->hdr.rssi_ctl, sizeof(hdr->rssi_ctl));
  5558. *bufp = ev->bufp;
  5559. return QDF_STATUS_SUCCESS;
  5560. }
  5561. /**
  5562. * extract_vdev_stopped_param_non_tlv() - extract vdev stop param from event
  5563. * @wmi_handle: wmi handle
  5564. * @param evt_buf: pointer to event buffer
  5565. * @param vdev_id: Pointer to hold vdev identifier
  5566. *
  5567. * Return: 0 for success or error code
  5568. */
  5569. static QDF_STATUS extract_vdev_stopped_param_non_tlv(wmi_unified_t wmi_handle,
  5570. void *evt_buf,
  5571. uint32_t *vdev_id)
  5572. {
  5573. wmi_vdev_stopped_event *event = (wmi_vdev_stopped_event *)evt_buf;
  5574. *vdev_id = event->vdev_id;
  5575. return QDF_STATUS_SUCCESS;
  5576. }
  5577. /**
  5578. * extract_vdev_roam_param_non_tlv() - extract vdev roam param from event
  5579. * @wmi_handle: wmi handle
  5580. * @param evt_buf: pointer to event buffer
  5581. * @param param: Pointer to hold roam param
  5582. *
  5583. * Return: 0 for success or error code
  5584. */
  5585. static QDF_STATUS extract_vdev_roam_param_non_tlv(wmi_unified_t wmi_handle,
  5586. void *evt_buf,
  5587. wmi_host_roam_event *param)
  5588. {
  5589. wmi_roam_event *evt = (wmi_roam_event *)evt_buf;
  5590. qdf_mem_zero(param, sizeof(*param));
  5591. param->vdev_id = evt->vdev_id;
  5592. param->reason = evt->reason;
  5593. return QDF_STATUS_SUCCESS;
  5594. }
  5595. /**
  5596. * extract_vdev_scan_ev_param_non_tlv() - extract vdev scan param from event
  5597. * @wmi_handle: wmi handle
  5598. * @param evt_buf: pointer to event buffer
  5599. * @param param: Pointer to hold vdev scan param
  5600. *
  5601. * Return: 0 for success or error code
  5602. */
  5603. static QDF_STATUS extract_vdev_scan_ev_param_non_tlv(wmi_unified_t wmi_handle,
  5604. void *evt_buf,
  5605. struct scan_event *param)
  5606. {
  5607. wmi_scan_event *evt = (wmi_scan_event *)evt_buf;
  5608. qdf_mem_zero(param, sizeof(*param));
  5609. switch (evt->event) {
  5610. case WMI_SCAN_EVENT_STARTED:
  5611. param->type = SCAN_EVENT_TYPE_STARTED;
  5612. break;
  5613. case WMI_SCAN_EVENT_COMPLETED:
  5614. param->type = SCAN_EVENT_TYPE_COMPLETED;
  5615. break;
  5616. case WMI_SCAN_EVENT_BSS_CHANNEL:
  5617. param->type = SCAN_EVENT_TYPE_BSS_CHANNEL;
  5618. break;
  5619. case WMI_SCAN_EVENT_FOREIGN_CHANNEL:
  5620. param->type = SCAN_EVENT_TYPE_FOREIGN_CHANNEL;
  5621. break;
  5622. case WMI_SCAN_EVENT_DEQUEUED:
  5623. param->type = SCAN_EVENT_TYPE_DEQUEUED;
  5624. break;
  5625. case WMI_SCAN_EVENT_PREEMPTED:
  5626. param->type = SCAN_EVENT_TYPE_PREEMPTED;
  5627. break;
  5628. case WMI_SCAN_EVENT_START_FAILED:
  5629. param->type = SCAN_EVENT_TYPE_START_FAILED;
  5630. break;
  5631. case WMI_SCAN_EVENT_RESTARTED:
  5632. param->type = SCAN_EVENT_TYPE_RESTARTED;
  5633. break;
  5634. case WMI_HOST_SCAN_EVENT_FOREIGN_CHANNEL_EXIT:
  5635. param->type = SCAN_EVENT_TYPE_FOREIGN_CHANNEL_EXIT;
  5636. break;
  5637. case WMI_SCAN_EVENT_INVALID:
  5638. param->type = SCAN_EVENT_TYPE_INVALID;
  5639. break;
  5640. case WMI_SCAN_EVENT_MAX:
  5641. default:
  5642. param->type = SCAN_EVENT_TYPE_MAX;
  5643. break;
  5644. };
  5645. switch (evt->reason) {
  5646. case WMI_SCAN_REASON_NONE:
  5647. param->reason = SCAN_REASON_NONE;
  5648. break;
  5649. case WMI_SCAN_REASON_COMPLETED:
  5650. param->reason = SCAN_REASON_COMPLETED;
  5651. break;
  5652. case WMI_SCAN_REASON_CANCELLED:
  5653. param->reason = SCAN_REASON_CANCELLED;
  5654. break;
  5655. case WMI_SCAN_REASON_PREEMPTED:
  5656. param->reason = SCAN_REASON_PREEMPTED;
  5657. break;
  5658. case WMI_SCAN_REASON_TIMEDOUT:
  5659. param->reason = SCAN_REASON_TIMEDOUT;
  5660. break;
  5661. case WMI_SCAN_REASON_INTERNAL_FAILURE:
  5662. param->reason = SCAN_REASON_INTERNAL_FAILURE;
  5663. break;
  5664. case WMI_SCAN_REASON_MAX:
  5665. default:
  5666. param->reason = SCAN_REASON_MAX;
  5667. break;
  5668. };
  5669. param->chan_freq = evt->channel_freq;
  5670. param->requester = evt->requestor;
  5671. param->scan_id = evt->scan_id;
  5672. param->vdev_id = evt->vdev_id;
  5673. return QDF_STATUS_SUCCESS;
  5674. }
  5675. /**
  5676. * extract_mu_ev_param_non_tlv() - extract mu param from event
  5677. * @wmi_handle: wmi handle
  5678. * @param evt_buf: pointer to event buffer
  5679. * @param param: Pointer to hold mu report
  5680. *
  5681. * Return: 0 for success or error code
  5682. */
  5683. static QDF_STATUS extract_mu_ev_param_non_tlv(wmi_unified_t wmi_handle, void *evt_buf,
  5684. wmi_host_mu_report_event *param)
  5685. {
  5686. wmi_mu_report_event *event = (wmi_mu_report_event *)evt_buf;
  5687. param->mu_request_id = event->mu_request_id;
  5688. param->status_reason = event->status_reason;
  5689. qdf_mem_copy(param->total_mu, event->total_mu, sizeof(param->total_mu));
  5690. param->num_active_bssid = event->num_active_bssid;
  5691. qdf_mem_copy(param->hidden_node_mu, event->hidden_node_mu,
  5692. sizeof(param->hidden_node_mu));
  5693. param->num_TA_entries = event->num_TA_entries;
  5694. return QDF_STATUS_SUCCESS;
  5695. }
  5696. /**
  5697. * extract_mu_db_entry_non_tlv() - extract mu db entry from event
  5698. * @wmi_handle: wmi handle
  5699. * @param evt_buf: pointer to event buffer
  5700. * @param profile_data: Pointer to hold mu_db_entry
  5701. *
  5702. * Return: 0 for success or error code
  5703. */
  5704. static QDF_STATUS extract_mu_db_entry_non_tlv(wmi_unified_t wmi_handle,
  5705. void *evt_buf, uint8_t idx,
  5706. wmi_host_mu_db_entry *db_entry)
  5707. {
  5708. wmi_mu_report_event *event = (wmi_mu_report_event *)evt_buf;
  5709. if (idx > event->num_TA_entries)
  5710. return QDF_STATUS_E_INVAL;
  5711. qdf_mem_copy(db_entry, &event->mu_entry[idx],
  5712. sizeof(wmi_host_mu_db_entry));
  5713. return QDF_STATUS_SUCCESS;
  5714. }
  5715. /**
  5716. * extract_mumimo_tx_count_ev_param_non_tlv() - extract mumimo tx count from event
  5717. * @wmi_handle: wmi handle
  5718. * @param evt_buf: pointer to event buffer
  5719. * @param param: Pointer to hold mu report
  5720. *
  5721. * Return: 0 for success or error code
  5722. */
  5723. static QDF_STATUS extract_mumimo_tx_count_ev_param_non_tlv(wmi_unified_t wmi_handle,
  5724. void *evt_buf, wmi_host_peer_txmu_cnt_event *param)
  5725. {
  5726. wmi_peer_txmu_cnt_event *event = (wmi_peer_txmu_cnt_event *)evt_buf;
  5727. param->tx_mu_transmitted = event->tx_mu_transmitted;
  5728. return QDF_STATUS_SUCCESS;
  5729. }
  5730. /**
  5731. * extract_peer_gid_userpos_list_ev_param_non_tlv() - extract gid user position
  5732. * from event
  5733. * @wmi_handle: wmi handle
  5734. * @param evt_buf: pointer to event buffer
  5735. * @param param: Pointer to hold peer user position list
  5736. *
  5737. * Return: 0 for success or error code
  5738. */
  5739. static QDF_STATUS extract_peer_gid_userpos_list_ev_param_non_tlv(
  5740. wmi_unified_t wmi_handle,
  5741. void *evt_buf,
  5742. wmi_host_peer_gid_userpos_list_event *param)
  5743. {
  5744. wmi_peer_gid_userpos_list_event *event =
  5745. (wmi_peer_gid_userpos_list_event *)evt_buf;
  5746. qdf_mem_copy(param->usr_list, event->usr_list, sizeof(param->usr_list));
  5747. return QDF_STATUS_SUCCESS;
  5748. }
  5749. /**
  5750. * extract_pdev_caldata_version_check_ev_param_non_tlv() - extract caldata from event
  5751. * @wmi_handle: wmi handle
  5752. * @param evt_buf: pointer to event buffer
  5753. * @param param: Pointer to hold peer caldata version data
  5754. *
  5755. * Return: 0 for success or error code
  5756. */
  5757. static QDF_STATUS extract_pdev_caldata_version_check_ev_param_non_tlv(
  5758. wmi_unified_t wmi_handle,
  5759. void *evt_buf,
  5760. wmi_host_pdev_check_cal_version_event *param)
  5761. {
  5762. wmi_pdev_check_cal_version_event *event =
  5763. (wmi_pdev_check_cal_version_event *)evt_buf;
  5764. param->software_cal_version = event->software_cal_version;
  5765. param->board_cal_version = event->board_cal_version;
  5766. param->cal_ok = event->cal_ok;
  5767. if (event->board_mcn_detail[WMI_BOARD_MCN_STRING_MAX_SIZE] != '\0')
  5768. event->board_mcn_detail[WMI_BOARD_MCN_STRING_MAX_SIZE] = '\0';
  5769. WMI_HOST_IF_MSG_COPY_CHAR_ARRAY(param->board_mcn_detail,
  5770. event->board_mcn_detail, WMI_BOARD_MCN_STRING_BUF_SIZE);
  5771. return QDF_STATUS_SUCCESS;
  5772. }
  5773. /**
  5774. * extract_pdev_tpc_config_ev_param_non_tlv() - extract pdev tpc configuration
  5775. * param from event
  5776. * @wmi_handle: wmi handle
  5777. * @param evt_buf: pointer to event buffer
  5778. * @param param: Pointer to hold tpc configuration
  5779. *
  5780. * Return: 0 for success or error code
  5781. */
  5782. static QDF_STATUS extract_pdev_tpc_config_ev_param_non_tlv(wmi_unified_t wmi_handle,
  5783. void *evt_buf,
  5784. wmi_host_pdev_tpc_config_event *param)
  5785. {
  5786. wmi_pdev_tpc_config_event *event = (wmi_pdev_tpc_config_event *)evt_buf;
  5787. param->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  5788. param->regDomain = event->regDomain;
  5789. param->chanFreq = event->chanFreq;
  5790. param->phyMode = event->phyMode;
  5791. param->twiceAntennaReduction = event->twiceAntennaReduction;
  5792. param->twiceMaxRDPower = event->twiceMaxRDPower;
  5793. param->powerLimit = event->powerLimit;
  5794. param->rateMax = event->rateMax;
  5795. param->numTxChain = event->numTxChain;
  5796. param->ctl = event->ctl;
  5797. param->flags = event->flags;
  5798. qdf_mem_copy(param->maxRegAllowedPower, event->maxRegAllowedPower,
  5799. sizeof(param->maxRegAllowedPower));
  5800. qdf_mem_copy(param->maxRegAllowedPowerAGCDD,
  5801. event->maxRegAllowedPowerAGCDD,
  5802. sizeof(param->maxRegAllowedPowerAGCDD));
  5803. qdf_mem_copy(param->maxRegAllowedPowerAGSTBC,
  5804. event->maxRegAllowedPowerAGSTBC,
  5805. sizeof(param->maxRegAllowedPowerAGSTBC));
  5806. qdf_mem_copy(param->maxRegAllowedPowerAGTXBF,
  5807. event->maxRegAllowedPowerAGTXBF,
  5808. sizeof(param->maxRegAllowedPowerAGTXBF));
  5809. qdf_mem_copy(param->ratesArray, event->ratesArray,
  5810. sizeof(param->ratesArray));
  5811. return QDF_STATUS_SUCCESS;
  5812. }
  5813. /**
  5814. * extract_nfcal_power_ev_param_non_tlv() - extract noise floor calibration
  5815. * power param from event
  5816. * @wmi_handle: wmi handle
  5817. * @param evt_buf: pointer to event buffer
  5818. * @param param: Pointer to hold nf cal power param
  5819. *
  5820. * Return: 0 for success or error code
  5821. */
  5822. static QDF_STATUS extract_nfcal_power_ev_param_non_tlv(wmi_unified_t wmi_handle,
  5823. void *evt_buf,
  5824. wmi_host_pdev_nfcal_power_all_channels_event *param)
  5825. {
  5826. wmi_pdev_nfcal_power_all_channels_event *event =
  5827. (wmi_pdev_nfcal_power_all_channels_event *)evt_buf;
  5828. qdf_mem_copy(param->nfdBr, event->nfdBr, sizeof(param->nfdBr));
  5829. qdf_mem_copy(param->nfdBm, event->nfdBm, sizeof(param->nfdBm));
  5830. qdf_mem_copy(param->freqNum, event->freqNum, sizeof(param->freqNum));
  5831. param->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  5832. return QDF_STATUS_SUCCESS;
  5833. }
  5834. /**
  5835. * extract_pdev_tpc_ev_param_non_tlv() - extract tpc param from event
  5836. * @wmi_handle: wmi handle
  5837. * @param evt_buf: pointer to event buffer
  5838. * @param param: Pointer to hold tpc param
  5839. *
  5840. * Return: 0 for success or error code
  5841. */
  5842. static QDF_STATUS extract_pdev_tpc_ev_param_non_tlv(wmi_unified_t wmi_handle,
  5843. void *evt_buf,
  5844. wmi_host_pdev_tpc_event *param)
  5845. {
  5846. wmi_pdev_tpc_event *event = (wmi_pdev_tpc_event *)evt_buf;
  5847. qdf_mem_copy(param->tpc, event->tpc, sizeof(param->tpc));
  5848. param->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  5849. return QDF_STATUS_SUCCESS;
  5850. }
  5851. /**
  5852. * extract_pdev_generic_buffer_ev_param_non_tlv() - extract pdev generic buffer
  5853. * from event
  5854. * @wmi_handle: wmi handle
  5855. * @param evt_buf: pointer to event buffer
  5856. * @param param: Pointer to generic buffer param
  5857. *
  5858. * Return: 0 for success or error code
  5859. */
  5860. static QDF_STATUS extract_pdev_generic_buffer_ev_param_non_tlv(
  5861. wmi_unified_t wmi_handle, void *evt_buf,
  5862. wmi_host_pdev_generic_buffer_event *param)
  5863. {
  5864. wmi_pdev_generic_buffer_event *event =
  5865. (wmi_pdev_generic_buffer_event *)evt_buf;
  5866. param->buf_type = event->buf_type;
  5867. param->frag_id = event->frag_id;
  5868. param->more_frag = event->more_frag;
  5869. param->buf_len = event->buf_len;
  5870. qdf_mem_copy(param->buf_info, event->buf_info, event->buf_len);
  5871. return QDF_STATUS_SUCCESS;
  5872. }
  5873. /**
  5874. * extract_gpio_input_ev_param_non_tlv() - extract gpio input param from event
  5875. * @wmi_handle: wmi handle
  5876. * @param evt_buf: pointer to event buffer
  5877. * @param gpio_num: Pointer to hold gpio number
  5878. *
  5879. * Return: 0 for success or error code
  5880. */
  5881. static QDF_STATUS extract_gpio_input_ev_param_non_tlv(wmi_unified_t wmi_handle,
  5882. void *evt_buf, uint32_t *gpio_num)
  5883. {
  5884. wmi_gpio_input_event *ev = (wmi_gpio_input_event *) evt_buf;
  5885. *gpio_num = ev->gpio_num;
  5886. return QDF_STATUS_SUCCESS;
  5887. }
  5888. /**
  5889. * extract_pdev_reserve_ast_ev_param_non_tlv() - extract reserve ast entry
  5890. * param from event
  5891. * @wmi_handle: wmi handle
  5892. * @param evt_buf: pointer to event buffer
  5893. * @param result: Pointer to hold reserve ast entry param
  5894. *
  5895. * Return: 0 for success or error code
  5896. */
  5897. static QDF_STATUS extract_pdev_reserve_ast_ev_param_non_tlv(
  5898. wmi_unified_t wmi_handle,
  5899. void *evt_buf, struct wmi_host_proxy_ast_reserve_param *param)
  5900. {
  5901. wmi_pdev_reserve_ast_entry_event *ev =
  5902. (wmi_pdev_reserve_ast_entry_event *) evt_buf;
  5903. param->result = ev->result;
  5904. param->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  5905. return QDF_STATUS_SUCCESS;
  5906. }
  5907. /**
  5908. * extract_swba_num_vdevs_non_tlv() - extract swba num vdevs from event
  5909. * @wmi_handle: wmi handle
  5910. * @param evt_buf: pointer to event buffer
  5911. * @param num_vdevs: Pointer to hold num vdevs
  5912. *
  5913. * Return: 0 for success or error code
  5914. */
  5915. static QDF_STATUS extract_swba_num_vdevs_non_tlv(wmi_unified_t wmi_handle,
  5916. void *evt_buf,
  5917. uint32_t *num_vdevs)
  5918. {
  5919. wmi_host_swba_event *swba_event = (wmi_host_swba_event *)evt_buf;
  5920. uint32_t vdev_map;
  5921. vdev_map = swba_event->vdev_map;
  5922. *num_vdevs = wmi_vdev_map_to_num_vdevs(vdev_map);
  5923. return QDF_STATUS_SUCCESS;
  5924. }
  5925. /**
  5926. * extract_swba_tim_info_non_tlv() - extract swba tim info from event
  5927. * @wmi_handle: wmi handle
  5928. * @param evt_buf: pointer to event buffer
  5929. * @param idx: Index to bcn info
  5930. * @param tim_info: Pointer to hold tim info
  5931. *
  5932. * Return: 0 for success or error code
  5933. */
  5934. static QDF_STATUS extract_swba_tim_info_non_tlv(wmi_unified_t wmi_handle,
  5935. void *evt_buf,
  5936. uint32_t idx, wmi_host_tim_info *tim_info)
  5937. {
  5938. wmi_host_swba_event *swba_event = (wmi_host_swba_event *)evt_buf;
  5939. wmi_bcn_info *bcn_info;
  5940. uint32_t vdev_map;
  5941. bcn_info = &swba_event->bcn_info[idx];
  5942. vdev_map = swba_event->vdev_map;
  5943. tim_info->vdev_id = wmi_vdev_map_to_vdev_id(vdev_map, idx);
  5944. if (tim_info->vdev_id == WLAN_INVALID_VDEV_ID)
  5945. return QDF_STATUS_E_INVAL;
  5946. tim_info->tim_len = bcn_info->tim_info.tim_len;
  5947. tim_info->tim_mcast = bcn_info->tim_info.tim_mcast;
  5948. qdf_mem_copy(tim_info->tim_bitmap, bcn_info->tim_info.tim_bitmap,
  5949. (sizeof(uint32_t) * WMI_TIM_BITMAP_ARRAY_SIZE));
  5950. tim_info->tim_changed = bcn_info->tim_info.tim_changed;
  5951. tim_info->tim_num_ps_pending = bcn_info->tim_info.tim_num_ps_pending;
  5952. return QDF_STATUS_SUCCESS;
  5953. }
  5954. /**
  5955. * extract_swba_noa_info_non_tlv() - extract swba NoA information from event
  5956. * @wmi_handle: wmi handle
  5957. * @param evt_buf: pointer to event buffer
  5958. * @param idx: Index to bcn info
  5959. * @param p2p_desc: Pointer to hold p2p NoA info
  5960. *
  5961. * Return: 0 for success or error code
  5962. */
  5963. static QDF_STATUS extract_swba_noa_info_non_tlv(wmi_unified_t wmi_handle,
  5964. void *evt_buf,
  5965. uint32_t idx, wmi_host_p2p_noa_info *p2p_desc)
  5966. {
  5967. wmi_host_swba_event *swba_event = (wmi_host_swba_event *)evt_buf;
  5968. wmi_p2p_noa_info *p2p_noa_info;
  5969. wmi_bcn_info *bcn_info;
  5970. uint8_t i = 0;
  5971. uint32_t vdev_map;
  5972. bcn_info = &swba_event->bcn_info[idx];
  5973. vdev_map = swba_event->vdev_map;
  5974. p2p_noa_info = &bcn_info->p2p_noa_info;
  5975. p2p_desc->vdev_id = wmi_vdev_map_to_vdev_id(vdev_map, idx);
  5976. if (p2p_desc->vdev_id == WLAN_INVALID_VDEV_ID)
  5977. return QDF_STATUS_E_INVAL;
  5978. p2p_desc->modified = false;
  5979. p2p_desc->num_descriptors = 0;
  5980. if (WMI_UNIFIED_NOA_ATTR_IS_MODIFIED(p2p_noa_info)) {
  5981. p2p_desc->modified = true;
  5982. p2p_desc->index =
  5983. (uint8_t) WMI_UNIFIED_NOA_ATTR_INDEX_GET(p2p_noa_info);
  5984. p2p_desc->oppPS =
  5985. (uint8_t) WMI_UNIFIED_NOA_ATTR_OPP_PS_GET(p2p_noa_info);
  5986. p2p_desc->ctwindow =
  5987. (uint8_t) WMI_UNIFIED_NOA_ATTR_CTWIN_GET(p2p_noa_info);
  5988. p2p_desc->num_descriptors =
  5989. (uint8_t) WMI_UNIFIED_NOA_ATTR_NUM_DESC_GET(p2p_noa_info);
  5990. for (i = 0; i < p2p_desc->num_descriptors; i++) {
  5991. p2p_desc->noa_descriptors[i].type_count =
  5992. (uint8_t) p2p_noa_info->noa_descriptors[i].
  5993. type_count;
  5994. p2p_desc->noa_descriptors[i].duration =
  5995. p2p_noa_info->noa_descriptors[i].duration;
  5996. p2p_desc->noa_descriptors[i].interval =
  5997. p2p_noa_info->noa_descriptors[i].interval;
  5998. p2p_desc->noa_descriptors[i].start_time =
  5999. p2p_noa_info->noa_descriptors[i].start_time;
  6000. }
  6001. }
  6002. return QDF_STATUS_SUCCESS;
  6003. }
  6004. /**
  6005. * extract_peer_sta_ps_statechange_ev_non_tlv() - extract peer sta ps state
  6006. * from event
  6007. * @wmi_handle: wmi handle
  6008. * @param evt_buf: pointer to event buffer
  6009. * @param ev: Pointer to hold peer param and ps state
  6010. *
  6011. * Return: 0 for success or error code
  6012. */
  6013. static QDF_STATUS extract_peer_sta_ps_statechange_ev_non_tlv(wmi_unified_t wmi_handle,
  6014. void *evt_buf, wmi_host_peer_sta_ps_statechange_event *ev)
  6015. {
  6016. wmi_peer_sta_ps_statechange_event *event =
  6017. (wmi_peer_sta_ps_statechange_event *)evt_buf;
  6018. WMI_MAC_ADDR_TO_CHAR_ARRAY(&event->peer_macaddr, ev->peer_macaddr);
  6019. ev->peer_ps_state = event->peer_ps_state;
  6020. return QDF_STATUS_SUCCESS;
  6021. }
  6022. /**
  6023. * extract_peer_sta_kickout_ev_non_tlv() - extract peer sta kickout event
  6024. * @wmi_handle: wmi handle
  6025. * @param evt_buf: pointer to event buffer
  6026. * @param ev: Pointer to hold peer param
  6027. *
  6028. * Return: 0 for success or error code
  6029. */
  6030. static QDF_STATUS extract_peer_sta_kickout_ev_non_tlv(wmi_unified_t wmi_handle,
  6031. void *evt_buf,
  6032. wmi_host_peer_sta_kickout_event *ev)
  6033. {
  6034. wmi_peer_sta_kickout_event *kickout_event =
  6035. (wmi_peer_sta_kickout_event *)evt_buf;
  6036. WMI_MAC_ADDR_TO_CHAR_ARRAY(&kickout_event->peer_macaddr,
  6037. ev->peer_macaddr);
  6038. /**Following not available in legacy wmi*/
  6039. ev->reason = 0;
  6040. ev->rssi = 0;
  6041. return QDF_STATUS_SUCCESS;
  6042. }
  6043. /**
  6044. * extract_peer_ratecode_list_ev_non_tlv() - extract peer ratecode from event
  6045. * @wmi_handle: wmi handle
  6046. * @param evt_buf: pointer to event buffer
  6047. * @param peer_mac: Pointer to hold peer mac address
  6048. * @param rate_cap: Pointer to hold ratecode
  6049. *
  6050. * Return: 0 for success or error code
  6051. */
  6052. static QDF_STATUS extract_peer_ratecode_list_ev_non_tlv(wmi_unified_t wmi_handle,
  6053. void *evt_buf,
  6054. uint8_t *peer_mac, wmi_sa_rate_cap *rate_cap)
  6055. {
  6056. wmi_peer_ratecode_list_event_t *rate_event =
  6057. (wmi_peer_ratecode_list_event_t *)evt_buf;
  6058. int i, htindex, j;
  6059. uint8_t shift = 0;
  6060. WMI_MAC_ADDR_TO_CHAR_ARRAY(&rate_event->peer_macaddr, peer_mac);
  6061. htindex = 0;
  6062. rate_cap->ratecount[0] =
  6063. ((rate_event->peer_rate_info.ratecount) & SA_MASK_BYTE);
  6064. rate_cap->ratecount[1] =
  6065. ((rate_event->peer_rate_info.ratecount >> 8) & SA_MASK_BYTE);
  6066. rate_cap->ratecount[2] =
  6067. ((rate_event->peer_rate_info.ratecount >> 16) & SA_MASK_BYTE);
  6068. rate_cap->ratecount[3] =
  6069. ((rate_event->peer_rate_info.ratecount >> 24) & SA_MASK_BYTE);
  6070. if (rate_cap->ratecount[0]) {
  6071. for (i = 0; i < SA_MAX_LEGACY_RATE_DWORDS; i++) {
  6072. for (j = 0; j < SA_BYTES_IN_DWORD; j++) {
  6073. rate_cap->ratecode_legacy[htindex] =
  6074. ((rate_event->peer_rate_info.ratecode_legacy[i]
  6075. >> (8*j)) & SA_MASK_BYTE);
  6076. htindex++;
  6077. }
  6078. }
  6079. }
  6080. htindex = 0;
  6081. for (i = 0; i < SA_MAX_HT_RATE_DWORDS; i++) {
  6082. for (j = 0; j < SA_BYTES_IN_DWORD; j++) {
  6083. shift = (8*j);
  6084. rate_cap->ratecode_20[htindex] =
  6085. ((rate_event->peer_rate_info.ratecode_20[i]
  6086. >> (shift)) & SA_MASK_BYTE);
  6087. rate_cap->ratecode_40[htindex] =
  6088. ((rate_event->peer_rate_info.ratecode_40[i]
  6089. >> (shift)) & SA_MASK_BYTE);
  6090. rate_cap->ratecode_80[htindex] =
  6091. ((rate_event->peer_rate_info.ratecode_80[i]
  6092. >> (shift)) & SA_MASK_BYTE);
  6093. htindex++;
  6094. }
  6095. }
  6096. return QDF_STATUS_SUCCESS;
  6097. }
  6098. /**
  6099. * extract_rtt_header_internal_non_tlv() - extract internal rtt header from
  6100. * event
  6101. * @param ev: pointer to internal rtt event header
  6102. * @param hdr: Pointer to received rtt event header
  6103. *
  6104. * Return: None
  6105. */
  6106. static void extract_rtt_header_internal_non_tlv(wmi_host_rtt_event_hdr *ev,
  6107. wmi_rtt_event_hdr *hdr)
  6108. {
  6109. ev->req_id = WMI_RTT_REQ_ID_GET(hdr->req_id);
  6110. ev->result = (hdr->req_id & 0xffff0000) >> 16;
  6111. ev->meas_type = WMI_RTT_REPORT_MEAS_TYPE_GET(hdr->req_id);
  6112. ev->report_type = WMI_RTT_REPORT_REPORT_TYPE_GET(hdr->req_id);
  6113. ev->v3_status = WMI_RTT_REPORT_V3_STATUS_GET(hdr->req_id);
  6114. ev->v3_finish = WMI_RTT_REPORT_V3_FINISH_GET(hdr->req_id);
  6115. ev->v3_tm_start = WMI_RTT_REPORT_V3_TM_START_GET(hdr->req_id);
  6116. ev->num_ap = WMI_RTT_REPORT_NUM_AP_GET(hdr->req_id);
  6117. WMI_MAC_ADDR_TO_CHAR_ARRAY(&hdr->dest_mac, ev->dest_mac);
  6118. }
  6119. /**
  6120. * extract_rtt_error_report_ev_non_tlv() - extract rtt error report from event
  6121. * @wmi_handle: wmi handle
  6122. * @param evt_buf: pointer to event buffer
  6123. * @param wds_ev: Pointer to hold rtt error report
  6124. *
  6125. * Return: 0 for success or error code
  6126. */
  6127. static QDF_STATUS extract_rtt_error_report_ev_non_tlv(wmi_unified_t wmi_handle,
  6128. void *evt_buf,
  6129. wmi_host_rtt_error_report_event *ev)
  6130. {
  6131. wmi_rtt_error_report_event *error_report =
  6132. (wmi_rtt_error_report_event *) evt_buf;
  6133. extract_rtt_header_internal_non_tlv(&ev->hdr, &error_report->header);
  6134. ev->reject_reason = error_report->reject_reason;
  6135. return QDF_STATUS_SUCCESS;
  6136. }
  6137. /**
  6138. * extract_rtt_hdr_non_tlv() - extract rtt header from event
  6139. * @wmi_handle: wmi handle
  6140. * @param evt_buf: pointer to event buffer
  6141. * @param ev: Pointer to hold rtt header
  6142. *
  6143. * Return: 0 for success or error code
  6144. */
  6145. static QDF_STATUS extract_rtt_hdr_non_tlv(wmi_unified_t wmi_handle, void *evt_buf,
  6146. wmi_host_rtt_event_hdr *ev)
  6147. {
  6148. wmi_rtt_event_hdr *hdr = (wmi_rtt_event_hdr *) evt_buf;
  6149. extract_rtt_header_internal_non_tlv(ev, hdr);
  6150. return QDF_STATUS_SUCCESS;
  6151. }
  6152. /**
  6153. * copy_rtt_report_cfr
  6154. * @ev: pointer to destination event pointer
  6155. * @report_type: report type recieved in event
  6156. * @p: pointer to event data
  6157. * @hdump: pointer to destination buffer
  6158. * @hdump_len: length of dest buffer
  6159. *
  6160. * Return: Pointer to current offset in p
  6161. */
  6162. static uint8_t *copy_rtt_report_cfr(wmi_host_rtt_meas_event *ev,
  6163. uint8_t report_type, uint8_t *p,
  6164. uint8_t *hdump, int16_t hdump_len)
  6165. {
  6166. uint8_t index, i;
  6167. uint8_t *tmp, *temp1, *temp2;
  6168. #define TONE_LEGACY_20M 53
  6169. #define TONE_VHT_20M 56
  6170. #define TONE_VHT_40M 117
  6171. #define TONE_VHT_80M 242
  6172. int tone_number[4] = {
  6173. TONE_LEGACY_20M, TONE_VHT_20M, TONE_VHT_40M, TONE_VHT_80M};
  6174. #define MEM_ALIGN(x) ((((x)<<1)+3) & 0xFFFC)
  6175. /* the buffer size of 1 chain for each BW 0-3 */
  6176. u_int16_t bw_size[4] = {
  6177. MEM_ALIGN(TONE_LEGACY_20M),
  6178. MEM_ALIGN(TONE_VHT_20M),
  6179. MEM_ALIGN(TONE_VHT_40M),
  6180. MEM_ALIGN(TONE_VHT_80M)
  6181. };
  6182. if (hdump == NULL) {
  6183. qdf_print("Destination buffer is NULL\n");
  6184. return p;
  6185. }
  6186. temp1 = temp2 = hdump;
  6187. for (index = 0; index < 4; index++) {
  6188. if (ev->chain_mask & (1 << index)) {
  6189. if (index == 0)
  6190. ev->rssi0 = *((u_int32_t *)p);
  6191. if (index == 1)
  6192. ev->rssi1 = *((u_int32_t *)p);
  6193. if (index == 2)
  6194. ev->rssi2 = *((u_int32_t *)p);
  6195. if (index == 3)
  6196. ev->rssi3 = *((u_int32_t *)p);
  6197. p += sizeof(u_int32_t);
  6198. if (report_type == WMI_RTT_REPORT_CFR) {
  6199. tmp = p + bw_size[ev->bw];
  6200. ev->txrxchain_mask = tone_number[ev->bw];
  6201. temp2 = temp2 + bw_size[ev->bw];
  6202. for (i = 0; (i < tone_number[ev->bw]); i++) {
  6203. qdf_mem_copy(temp1, p, 2);
  6204. temp1 += 2;
  6205. p += 2;
  6206. hdump_len -= 2;
  6207. if (hdump_len <= 0)
  6208. break;
  6209. }
  6210. temp1 = temp2;
  6211. p = tmp;
  6212. }
  6213. }
  6214. }
  6215. return p;
  6216. }
  6217. /**
  6218. * extract_rtt_ev_non_tlv() - extract rtt event
  6219. * @wmi_handle: wmi handle
  6220. * @param evt_buf: Pointer to event buffer
  6221. * @param ev: Pointer to hold rtt event
  6222. * @param hdump: Pointer to hold hex dump
  6223. * @param hdump_len: hex dump length
  6224. *
  6225. * Return: 0 for success or error code
  6226. */
  6227. static QDF_STATUS extract_rtt_ev_non_tlv(wmi_unified_t wmi_handle, void *evt_buf,
  6228. wmi_host_rtt_meas_event *ev, uint8_t *hdump, uint16_t h_len)
  6229. {
  6230. wmi_rtt_meas_event *body = (wmi_rtt_meas_event *) evt_buf;
  6231. uint8_t meas_type, report_type;
  6232. uint8_t *p;
  6233. int16_t hdump_len = h_len;
  6234. A_TIME64 *time;
  6235. if (body) {
  6236. meas_type = WMI_RTT_REPORT_MEAS_TYPE_GET(body->header.req_id);
  6237. report_type =
  6238. WMI_RTT_REPORT_REPORT_TYPE_GET(body->header.req_id);
  6239. ev->chain_mask = WMI_RTT_REPORT_RX_CHAIN_GET(body->rx_chain);
  6240. ev->bw = WMI_RTT_REPORT_RX_BW_GET(body->rx_chain);
  6241. /* If report type is not WMI_RTT_REPORT_CFR */
  6242. ev->txrxchain_mask = 0;
  6243. ev->tod = ((u_int64_t) body->tod.time32) << 32;
  6244. ev->tod |= body->tod.time0; /*tmp1 is the 64 bit tod*/
  6245. ev->toa = ((u_int64_t) body->toa.time32) << 32;
  6246. ev->toa |= body->toa.time0;
  6247. p = (u_int8_t *) (++body);
  6248. /* if the measurement is TMR, we should have T3 and T4 */
  6249. if (meas_type == RTT_MEAS_FRAME_TMR) {
  6250. time = (A_TIME64 *) body;
  6251. ev->t3 = (u_int64_t) (time->time32) << 32;
  6252. ev->t3 |= time->time0;
  6253. time++;
  6254. ev->t4 = (u_int64_t)(time->time32) << 32;
  6255. ev->t4 |= time->time0;
  6256. p = (u_int8_t *) (++time);
  6257. } else {
  6258. ev->t3 = 0;
  6259. ev->t4 = 0;
  6260. }
  6261. ev->rssi0 = 0;
  6262. ev->rssi1 = 0;
  6263. ev->rssi2 = 0;
  6264. ev->rssi3 = 0;
  6265. p = copy_rtt_report_cfr(ev, report_type, p, hdump, hdump_len);
  6266. } else {
  6267. qdf_print("Error!body is NULL\n");
  6268. return QDF_STATUS_E_FAILURE;
  6269. }
  6270. return QDF_STATUS_SUCCESS;
  6271. }
  6272. /**
  6273. * extract_thermal_stats_non_tlv() - extract thermal stats from event
  6274. * @wmi_handle: wmi handle
  6275. * @param evt_buf: Pointer to event buffer
  6276. * @param temp: Pointer to hold extracted temperature
  6277. * @param level: Pointer to hold extracted level
  6278. *
  6279. * Return: 0 for success or error code
  6280. */
  6281. static QDF_STATUS extract_thermal_stats_non_tlv(wmi_unified_t wmi_handle,
  6282. void *evt_buf,
  6283. uint32_t *temp, uint32_t *level, uint32_t *pdev_id)
  6284. {
  6285. tt_stats_t *tt_stats_event = NULL;
  6286. tt_stats_event = (tt_stats_t *) evt_buf;
  6287. *pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  6288. *temp = tt_stats_event->temp;
  6289. *level = tt_stats_event->level;
  6290. return QDF_STATUS_SUCCESS;
  6291. }
  6292. /**
  6293. * extract_thermal_level_stats_non_tlv() - extract thermal level stats from
  6294. * event
  6295. * @wmi_handle: wmi handle
  6296. * @param evt_buf: pointer to event buffer
  6297. * @param idx: Index to level stats
  6298. * @param levelcount: Pointer to hold levelcount
  6299. * @param dccount: Pointer to hold dccount
  6300. *
  6301. * Return: 0 for success or error code
  6302. */
  6303. static QDF_STATUS extract_thermal_level_stats_non_tlv(wmi_unified_t wmi_handle,
  6304. void *evt_buf,
  6305. uint8_t idx, uint32_t *levelcount, uint32_t *dccount)
  6306. {
  6307. tt_stats_t *tt_stats_event = NULL;
  6308. tt_stats_event = (tt_stats_t *) evt_buf;
  6309. if (idx < TT_LEVELS) {
  6310. *levelcount = tt_stats_event->levstats[idx].levelcount;
  6311. *dccount = tt_stats_event->levstats[idx].dccount;
  6312. return QDF_STATUS_SUCCESS;
  6313. }
  6314. return QDF_STATUS_E_FAILURE;
  6315. }
  6316. /**
  6317. * extract_comb_phyerr_non_tlv() - extract comb phy error from event
  6318. * @wmi_handle: wmi handle
  6319. * @param evt_buf: pointer to event buffer
  6320. * @param datalen: data length of event buffer
  6321. * @param buf_offset: Pointer to hold value of current event buffer offset
  6322. * post extraction
  6323. * @param phyer: Pointer to hold phyerr
  6324. *
  6325. * Return: 0 for success or error code
  6326. */
  6327. static QDF_STATUS extract_comb_phyerr_non_tlv(wmi_unified_t wmi_handle, void *evt_buf,
  6328. uint16_t datalen, uint16_t *buf_offset,
  6329. wmi_host_phyerr_t *phyerr)
  6330. {
  6331. wmi_comb_phyerr_rx_event *pe;
  6332. #if ATH_PHYERR_DEBUG
  6333. int i;
  6334. #endif /* ATH_PHYERR_DEBUG */
  6335. uint8_t *data;
  6336. data = (uint8_t *) evt_buf;
  6337. #if ATH_PHYERR_DEBUG
  6338. qdf_print("%s: data=%pK, datalen=%d\n", __func__, data, datalen);
  6339. /* XXX for now */
  6340. for (i = 0; i < datalen; i++) {
  6341. qdf_print("%02X ", data[i]);
  6342. if (i % 32 == 31)
  6343. qdf_print("\n");
  6344. }
  6345. qdf_print("\n");
  6346. #endif /* ATH_PHYERR_DEBUG */
  6347. /* Ensure it's at least the size of the header */
  6348. if (datalen < sizeof(*pe)) {
  6349. return QDF_STATUS_E_FAILURE;
  6350. /* XXX what should errors be? */
  6351. }
  6352. pe = (wmi_comb_phyerr_rx_event *) data;
  6353. #if ATH_PHYERR_DEBUG
  6354. qdf_print("%s: pe->hdr.num_phyerr_events=%d\n",
  6355. __func__,
  6356. pe->hdr.num_phyerr_events);
  6357. #endif /* ATH_PHYERR_DEBUG */
  6358. /*
  6359. * Reconstruct the 64 bit event TSF. This isn't from the MAC, it's
  6360. * at the time the event was sent to us, the TSF value will be
  6361. * in the future.
  6362. */
  6363. phyerr->tsf64 = pe->hdr.tsf_l32;
  6364. phyerr->tsf64 |= (((uint64_t) pe->hdr.tsf_u32) << 32);
  6365. *buf_offset = sizeof(pe->hdr);
  6366. phyerr->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  6367. return QDF_STATUS_SUCCESS;
  6368. }
  6369. /**
  6370. * extract_single_phyerr_non_tlv() - extract single phy error from event
  6371. * @wmi_handle: wmi handle
  6372. * @param evt_buf: pointer to event buffer
  6373. * @param datalen: data length of event buffer
  6374. * @param buf_offset: Pointer to hold value of current event buffer offset
  6375. * post extraction
  6376. * @param phyerr: Pointer to hold phyerr
  6377. *
  6378. * Return: 0 for success or error code
  6379. */
  6380. static QDF_STATUS extract_single_phyerr_non_tlv(wmi_unified_t wmi_handle,
  6381. void *evt_buf,
  6382. uint16_t datalen, uint16_t *buf_offset,
  6383. wmi_host_phyerr_t *phyerr)
  6384. {
  6385. wmi_single_phyerr_rx_event *ev;
  6386. #if ATH_PHYERR_DEBUG
  6387. int i;
  6388. #endif /* ATH_PHYERR_DEBUG */
  6389. int n = 0;
  6390. uint8_t *data;
  6391. phyerr->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  6392. n = (int) *buf_offset;
  6393. data = (uint8_t *) evt_buf;
  6394. /* Loop over the bufp, extracting out phyerrors */
  6395. /*
  6396. * XXX wmi_unified_comb_phyerr_rx_event.bufp is a char pointer,
  6397. * which isn't correct here - what we have received here
  6398. * is an array of TLV-style PHY errors.
  6399. */
  6400. if (n < datalen) {
  6401. /* ensure there's at least space for the header */
  6402. if ((datalen - n) < sizeof(ev->hdr)) {
  6403. qdf_print(
  6404. "%s: not enough space? (datalen=%d, n=%d, hdr=%zd bytes\n",
  6405. __func__,
  6406. datalen,
  6407. n,
  6408. sizeof(ev->hdr));
  6409. return QDF_STATUS_SUCCESS;
  6410. }
  6411. /*
  6412. * Obtain a pointer to the beginning of the current event.
  6413. * data[0] is the beginning of the WMI payload.
  6414. */
  6415. ev = (wmi_single_phyerr_rx_event *) &data[n];
  6416. /*
  6417. * Sanity check the buffer length of the event against
  6418. * what we currently have.
  6419. *
  6420. * Since buf_len is 32 bits, we check if it overflows
  6421. * a large 32 bit value. It's not 0x7fffffff because
  6422. * we increase n by (buf_len + sizeof(hdr)), which would
  6423. * in itself cause n to overflow.
  6424. *
  6425. * If "int" is 64 bits then this becomes a moot point.
  6426. */
  6427. if (ev->hdr.buf_len > 0x7f000000) {
  6428. qdf_print("%s: buf_len is garbage? (0x%x\n)\n",
  6429. __func__,
  6430. ev->hdr.buf_len);
  6431. return QDF_STATUS_SUCCESS;
  6432. }
  6433. if (n + ev->hdr.buf_len > datalen) {
  6434. qdf_print("%s: buf_len exceeds available space "
  6435. "(n=%d, buf_len=%d, datalen=%d\n",
  6436. __func__,
  6437. n,
  6438. ev->hdr.buf_len,
  6439. datalen);
  6440. return QDF_STATUS_SUCCESS;
  6441. }
  6442. phyerr->phy_err_code = WMI_UNIFIED_PHYERRCODE_GET(&ev->hdr);
  6443. #if ATH_PHYERR_DEBUG
  6444. qdf_print("%s: len=%d, tsf=0x%08x, rssi = 0x%x/0x%x/0x%x/0x%x, "
  6445. "comb rssi = 0x%x, phycode=%d\n",
  6446. __func__,
  6447. ev->hdr.buf_len,
  6448. ev->hdr.tsf_timestamp,
  6449. ev->hdr.rssi_chain0,
  6450. ev->hdr.rssi_chain1,
  6451. ev->hdr.rssi_chain2,
  6452. ev->hdr.rssi_chain3,
  6453. WMI_UNIFIED_RSSI_COMB_GET(&ev->hdr),
  6454. phyerr->phy_err_code);
  6455. /*
  6456. * For now, unroll this loop - the chain 'value' field isn't
  6457. * a variable but glued together into a macro field definition.
  6458. * Grr. :-)
  6459. */
  6460. qdf_print(
  6461. "%s: chain 0: raw=0x%08x; pri20=%d sec20=%d sec40=%d sec80=%d\n",
  6462. __func__,
  6463. ev->hdr.rssi_chain0,
  6464. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, PRI20),
  6465. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC20),
  6466. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC40),
  6467. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC80));
  6468. qdf_print(
  6469. "%s: chain 1: raw=0x%08x: pri20=%d sec20=%d sec40=%d sec80=%d\n",
  6470. __func__,
  6471. ev->hdr.rssi_chain1,
  6472. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, PRI20),
  6473. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC20),
  6474. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC40),
  6475. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC80));
  6476. qdf_print(
  6477. "%s: chain 2: raw=0x%08x: pri20=%d sec20=%d sec40=%d sec80=%d\n",
  6478. __func__,
  6479. ev->hdr.rssi_chain2,
  6480. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, PRI20),
  6481. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC20),
  6482. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC40),
  6483. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC80));
  6484. qdf_print(
  6485. "%s: chain 3: raw=0x%08x: pri20=%d sec20=%d sec40=%d sec80=%d\n",
  6486. __func__,
  6487. ev->hdr.rssi_chain3,
  6488. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, PRI20),
  6489. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC20),
  6490. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC40),
  6491. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC80));
  6492. qdf_print(
  6493. "%s: freq_info_1=0x%08x, freq_info_2=0x%08x\n",
  6494. __func__, ev->hdr.freq_info_1, ev->hdr.freq_info_2);
  6495. /*
  6496. * The NF chain values are signed and are negative - hence
  6497. * the cast evilness.
  6498. */
  6499. qdf_print(
  6500. "%s: nfval[1]=0x%08x, nfval[2]=0x%08x, nf=%d/%d/%d/%d, "
  6501. "freq1=%d, freq2=%d, cw=%d\n",
  6502. __func__,
  6503. ev->hdr.nf_list_1,
  6504. ev->hdr.nf_list_2,
  6505. (int) WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 0),
  6506. (int) WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 1),
  6507. (int) WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 2),
  6508. (int) WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 3),
  6509. WMI_UNIFIED_FREQ_INFO_GET(&ev->hdr, 1),
  6510. WMI_UNIFIED_FREQ_INFO_GET(&ev->hdr, 2),
  6511. WMI_UNIFIED_CHWIDTH_GET(&ev->hdr));
  6512. #endif /* ATH_PHYERR_DEBUG */
  6513. #if ATH_SUPPORT_DFS
  6514. /*
  6515. * If required, pass radar events to the dfs pattern matching
  6516. * code.
  6517. *
  6518. * Don't pass radar events with no buffer payload.
  6519. */
  6520. phyerr->tsf_timestamp = ev->hdr.tsf_timestamp;
  6521. phyerr->bufp = &ev->bufp[0];
  6522. phyerr->buf_len = ev->hdr.buf_len;
  6523. #endif /* ATH_SUPPORT_DFS */
  6524. /* populate the rf info */
  6525. phyerr->rf_info.rssi_comb =
  6526. WMI_UNIFIED_RSSI_COMB_GET(&ev->hdr);
  6527. #ifdef WLAN_CONV_SPECTRAL_ENABLE
  6528. /*
  6529. * If required, pass spectral events to the spectral module
  6530. *
  6531. */
  6532. if (phyerr->phy_err_code == WMI_HOST_PHY_ERROR_FALSE_RADAR_EXT
  6533. || phyerr->phy_err_code == WMI_HOST_PHY_ERROR_SPECTRAL_SCAN) {
  6534. if (ev->hdr.buf_len > 0) {
  6535. /* Initialize the NF values to Zero. */
  6536. phyerr->rf_info.noise_floor[0] =
  6537. WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 0);
  6538. phyerr->rf_info.noise_floor[1] =
  6539. WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 1);
  6540. phyerr->rf_info.noise_floor[2] =
  6541. WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 2);
  6542. phyerr->rf_info.noise_floor[3] =
  6543. WMI_UNIFIED_NF_CHAIN_GET(&ev->hdr, 3);
  6544. /* Need to unroll loop due to macro
  6545. * constraints
  6546. * chain 0 */
  6547. phyerr->rf_info.pc_rssi_info[0].rssi_pri20 =
  6548. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, PRI20);
  6549. phyerr->rf_info.pc_rssi_info[0].rssi_sec20 =
  6550. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC20);
  6551. phyerr->rf_info.pc_rssi_info[0].rssi_sec40 =
  6552. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC40);
  6553. phyerr->rf_info.pc_rssi_info[0].rssi_sec80 =
  6554. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 0, SEC80);
  6555. /* chain 1 */
  6556. phyerr->rf_info.pc_rssi_info[1].rssi_pri20 =
  6557. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, PRI20);
  6558. phyerr->rf_info.pc_rssi_info[1].rssi_sec20 =
  6559. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC20);
  6560. phyerr->rf_info.pc_rssi_info[1].rssi_sec40 =
  6561. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC40);
  6562. phyerr->rf_info.pc_rssi_info[1].rssi_sec80 =
  6563. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 1, SEC80);
  6564. /* chain 2 */
  6565. phyerr->rf_info.pc_rssi_info[2].rssi_pri20 =
  6566. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, PRI20);
  6567. phyerr->rf_info.pc_rssi_info[2].rssi_sec20 =
  6568. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC20);
  6569. phyerr->rf_info.pc_rssi_info[2].rssi_sec40 =
  6570. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC40);
  6571. phyerr->rf_info.pc_rssi_info[2].rssi_sec80 =
  6572. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 2, SEC80);
  6573. /* chain 3 */
  6574. phyerr->rf_info.pc_rssi_info[3].rssi_pri20 =
  6575. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, PRI20);
  6576. phyerr->rf_info.pc_rssi_info[3].rssi_sec20 =
  6577. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC20);
  6578. phyerr->rf_info.pc_rssi_info[3].rssi_sec40 =
  6579. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC40);
  6580. phyerr->rf_info.pc_rssi_info[3].rssi_sec80 =
  6581. WMI_UNIFIED_RSSI_CHAN_GET(&ev->hdr, 3, SEC80);
  6582. phyerr->chan_info.center_freq1 =
  6583. WMI_UNIFIED_FREQ_INFO_GET(&ev->hdr, 1);
  6584. phyerr->chan_info.center_freq2 =
  6585. WMI_UNIFIED_FREQ_INFO_GET(&ev->hdr, 2);
  6586. }
  6587. }
  6588. #endif /* WLAN_CONV_SPECTRAL_ENABLE */
  6589. /*
  6590. * Advance the buffer pointer to the next PHY error.
  6591. * buflen is the length of this payload, so we need to
  6592. * advance past the current header _AND_ the payload.
  6593. */
  6594. n += sizeof(*ev) + ev->hdr.buf_len;
  6595. }
  6596. *buf_offset = n;
  6597. return QDF_STATUS_SUCCESS;
  6598. }
  6599. /**
  6600. * extract_composite_phyerr_non_tlv() - extract composite phy error from event
  6601. * @wmi_handle: wmi handle
  6602. * @param evt_buf: pointer to event buffer
  6603. * @param datalen: Length of event buffer
  6604. * @param phyerr: Pointer to hold phy error
  6605. *
  6606. * Return: 0 for success or error code
  6607. */
  6608. static QDF_STATUS extract_composite_phyerr_non_tlv(wmi_unified_t wmi_handle,
  6609. void *evt_buf,
  6610. uint16_t datalen, wmi_host_phyerr_t *phyerr)
  6611. {
  6612. wmi_composite_phyerr_rx_event *pe;
  6613. wmi_composite_phyerr_rx_hdr *ph;
  6614. /* Ensure it's at least the size of the header */
  6615. if (datalen < sizeof(*pe)) {
  6616. return QDF_STATUS_E_FAILURE;
  6617. /* XXX what should errors be? */
  6618. }
  6619. phyerr->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  6620. pe = (wmi_composite_phyerr_rx_event *) evt_buf;
  6621. ph = &pe->hdr;
  6622. /*
  6623. * Reconstruct the 64 bit event TSF. This isn't from the MAC, it's
  6624. * at the time the event was sent to us, the TSF value will be
  6625. * in the future.
  6626. */
  6627. phyerr->tsf64 = ph->tsf_l32;
  6628. phyerr->tsf64 |= (((uint64_t) ph->tsf_u32) << 32);
  6629. phyerr->tsf_timestamp = ph->tsf_timestamp;
  6630. phyerr->bufp = &pe->bufp[0];
  6631. phyerr->buf_len = ph->buf_len;
  6632. phyerr->phy_err_mask0 = ph->phy_err_mask0;
  6633. phyerr->phy_err_mask1 = ph->phy_err_mask1;
  6634. phyerr->rf_info.rssi_comb =
  6635. WMI_UNIFIED_RSSI_COMB_GET(ph);
  6636. /* Handle Spectral PHY Error */
  6637. if ((ph->phy_err_mask0 & WMI_HOST_AR900B_SPECTRAL_PHYERR_MASK)) {
  6638. #ifdef WLAN_CONV_SPECTRAL_ENABLE
  6639. if (ph->buf_len > 0) {
  6640. /* Initialize the NF values to Zero. */
  6641. phyerr->rf_info.noise_floor[0] =
  6642. WMI_UNIFIED_NF_CHAIN_GET(ph, 0);
  6643. phyerr->rf_info.noise_floor[1] =
  6644. WMI_UNIFIED_NF_CHAIN_GET(ph, 1);
  6645. phyerr->rf_info.noise_floor[2] =
  6646. WMI_UNIFIED_NF_CHAIN_GET(ph, 2);
  6647. phyerr->rf_info.noise_floor[3] =
  6648. WMI_UNIFIED_NF_CHAIN_GET(ph, 3);
  6649. /* populate the rf info */
  6650. /* Need to unroll loop due to macro constraints */
  6651. /* chain 0 */
  6652. phyerr->rf_info.pc_rssi_info[0].rssi_pri20 =
  6653. WMI_UNIFIED_RSSI_CHAN_GET(ph, 0, PRI20);
  6654. phyerr->rf_info.pc_rssi_info[0].rssi_sec20 =
  6655. WMI_UNIFIED_RSSI_CHAN_GET(ph, 0, SEC20);
  6656. phyerr->rf_info.pc_rssi_info[0].rssi_sec40 =
  6657. WMI_UNIFIED_RSSI_CHAN_GET(ph, 0, SEC40);
  6658. phyerr->rf_info.pc_rssi_info[0].rssi_sec80 =
  6659. WMI_UNIFIED_RSSI_CHAN_GET(ph, 0, SEC80);
  6660. /* chain 1 */
  6661. phyerr->rf_info.pc_rssi_info[1].rssi_pri20 =
  6662. WMI_UNIFIED_RSSI_CHAN_GET(ph, 1, PRI20);
  6663. phyerr->rf_info.pc_rssi_info[1].rssi_sec20 =
  6664. WMI_UNIFIED_RSSI_CHAN_GET(ph, 1, SEC20);
  6665. phyerr->rf_info.pc_rssi_info[1].rssi_sec40 =
  6666. WMI_UNIFIED_RSSI_CHAN_GET(ph, 1, SEC40);
  6667. phyerr->rf_info.pc_rssi_info[1].rssi_sec80 =
  6668. WMI_UNIFIED_RSSI_CHAN_GET(ph, 1, SEC80);
  6669. /* chain 2 */
  6670. phyerr->rf_info.pc_rssi_info[2].rssi_pri20 =
  6671. WMI_UNIFIED_RSSI_CHAN_GET(ph, 2, PRI20);
  6672. phyerr->rf_info.pc_rssi_info[2].rssi_sec20 =
  6673. WMI_UNIFIED_RSSI_CHAN_GET(ph, 2, SEC20);
  6674. phyerr->rf_info.pc_rssi_info[2].rssi_sec40 =
  6675. WMI_UNIFIED_RSSI_CHAN_GET(ph, 2, SEC40);
  6676. phyerr->rf_info.pc_rssi_info[2].rssi_sec80 =
  6677. WMI_UNIFIED_RSSI_CHAN_GET(ph, 2, SEC80);
  6678. /* chain 3 */
  6679. phyerr->rf_info.pc_rssi_info[3].rssi_pri20 =
  6680. WMI_UNIFIED_RSSI_CHAN_GET(ph, 3, PRI20);
  6681. phyerr->rf_info.pc_rssi_info[3].rssi_sec20 =
  6682. WMI_UNIFIED_RSSI_CHAN_GET(ph, 3, SEC20);
  6683. phyerr->rf_info.pc_rssi_info[3].rssi_sec40 =
  6684. WMI_UNIFIED_RSSI_CHAN_GET(ph, 3, SEC40);
  6685. phyerr->rf_info.pc_rssi_info[3].rssi_sec80 =
  6686. WMI_UNIFIED_RSSI_CHAN_GET(ph, 3, SEC80);
  6687. phyerr->chan_info.center_freq1 =
  6688. WMI_UNIFIED_FREQ_INFO_GET(ph, 1);
  6689. phyerr->chan_info.center_freq2 =
  6690. WMI_UNIFIED_FREQ_INFO_GET(ph, 2);
  6691. }
  6692. #endif /* WLAN_CONV_SPECTRAL_ENABLE */
  6693. }
  6694. return QDF_STATUS_SUCCESS;
  6695. }
  6696. /**
  6697. * extract_all_stats_counts_non_tlv() - extract all stats count from event
  6698. * @wmi_handle: wmi handle
  6699. * @param evt_buf: pointer to event buffer
  6700. * @param stats_param: Pointer to hold stats count
  6701. *
  6702. * Return: 0 for success or error code
  6703. */
  6704. static QDF_STATUS extract_all_stats_counts_non_tlv(wmi_unified_t wmi_handle,
  6705. void *evt_buf,
  6706. wmi_host_stats_event *stats_param)
  6707. {
  6708. wmi_stats_event *ev = (wmi_stats_event *) evt_buf;
  6709. switch (ev->stats_id) {
  6710. case WMI_REQUEST_PEER_STAT:
  6711. stats_param->stats_id |= WMI_HOST_REQUEST_PEER_STAT;
  6712. break;
  6713. case WMI_REQUEST_AP_STAT:
  6714. stats_param->stats_id |= WMI_HOST_REQUEST_AP_STAT;
  6715. break;
  6716. case WMI_REQUEST_INST_STAT:
  6717. stats_param->stats_id |= WMI_HOST_REQUEST_INST_STAT;
  6718. break;
  6719. case WMI_REQUEST_PEER_EXTD_STAT:
  6720. stats_param->stats_id |= WMI_HOST_REQUEST_PEER_EXTD_STAT;
  6721. break;
  6722. case WMI_REQUEST_VDEV_EXTD_STAT:
  6723. stats_param->stats_id |= WMI_HOST_REQUEST_VDEV_EXTD_STAT;
  6724. break;
  6725. default:
  6726. stats_param->stats_id = 0;
  6727. break;
  6728. }
  6729. stats_param->num_pdev_stats = ev->num_pdev_stats;
  6730. stats_param->num_pdev_ext_stats = ev->num_pdev_ext_stats;
  6731. stats_param->num_vdev_stats = ev->num_vdev_stats;
  6732. stats_param->num_peer_stats = ev->num_peer_stats;
  6733. stats_param->num_bcnflt_stats = ev->num_bcnflt_stats;
  6734. stats_param->num_chan_stats = 0;
  6735. stats_param->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  6736. return QDF_STATUS_SUCCESS;
  6737. }
  6738. /**
  6739. * extract_pdev_stats_non_tlv() - extract pdev stats from event
  6740. * @wmi_handle: wmi handle
  6741. * @param evt_buf: pointer to event buffer
  6742. * @param index: Index into pdev stats
  6743. * @param pdev_stats: Pointer to hold pdev stats
  6744. *
  6745. * Return: 0 for success or error code
  6746. */
  6747. static QDF_STATUS extract_pdev_stats_non_tlv(wmi_unified_t wmi_handle,
  6748. void *evt_buf,
  6749. uint32_t index, wmi_host_pdev_stats *pdev_stats)
  6750. {
  6751. if (index < ((wmi_stats_event *)evt_buf)->num_pdev_stats) {
  6752. wmi_pdev_stats *ev =
  6753. (wmi_pdev_stats *) ((((wmi_stats_event *)evt_buf)->data) +
  6754. (index * sizeof(wmi_pdev_stats)));
  6755. /* direct copy possible since wmi_host_pdev_stats is same as
  6756. * wmi_pdev_stats for non-tlv */
  6757. /* qdf_mem_copy(pdev_stats, ev, sizeof(wmi_pdev_stats));*/
  6758. pdev_stats->chan_nf = ev->chan_nf;
  6759. pdev_stats->tx_frame_count = ev->tx_frame_count;
  6760. pdev_stats->rx_frame_count = ev->rx_frame_count;
  6761. pdev_stats->rx_clear_count = ev->rx_clear_count;
  6762. pdev_stats->cycle_count = ev->cycle_count;
  6763. pdev_stats->phy_err_count = ev->phy_err_count;
  6764. pdev_stats->chan_tx_pwr = ev->chan_tx_pwr;
  6765. #define tx_stats (pdev_stats->pdev_stats.tx)
  6766. #define ev_tx_stats (ev->pdev_stats.tx)
  6767. /* Tx Stats */
  6768. tx_stats.comp_queued = ev_tx_stats.comp_queued;
  6769. tx_stats.comp_delivered = ev_tx_stats.comp_delivered;
  6770. tx_stats.msdu_enqued = ev_tx_stats.msdu_enqued;
  6771. tx_stats.mpdu_enqued = ev_tx_stats.mpdu_enqued;
  6772. tx_stats.wmm_drop = ev_tx_stats.wmm_drop;
  6773. tx_stats.local_enqued = ev_tx_stats.local_enqued;
  6774. tx_stats.local_freed = ev_tx_stats.local_freed;
  6775. tx_stats.hw_queued = ev_tx_stats.hw_queued;
  6776. tx_stats.hw_reaped = ev_tx_stats.hw_reaped;
  6777. tx_stats.underrun = ev_tx_stats.underrun;
  6778. tx_stats.hw_paused = ev_tx_stats.hw_paused;
  6779. tx_stats.tx_abort = ev_tx_stats.tx_abort;
  6780. tx_stats.mpdus_requed = ev_tx_stats.mpdus_requed;
  6781. tx_stats.tx_xretry = ev_tx_stats.tx_xretry;
  6782. tx_stats.data_rc = ev_tx_stats.data_rc;
  6783. tx_stats.self_triggers = ev_tx_stats.self_triggers;
  6784. tx_stats.sw_retry_failure = ev_tx_stats.sw_retry_failure;
  6785. tx_stats.illgl_rate_phy_err = ev_tx_stats.illgl_rate_phy_err;
  6786. tx_stats.pdev_cont_xretry = ev_tx_stats.pdev_cont_xretry;
  6787. tx_stats.pdev_tx_timeout = ev_tx_stats.pdev_tx_timeout;
  6788. tx_stats.pdev_resets = ev_tx_stats.pdev_resets;
  6789. tx_stats.stateless_tid_alloc_failure =
  6790. ev_tx_stats.stateless_tid_alloc_failure;
  6791. tx_stats.phy_underrun = ev_tx_stats.phy_underrun;
  6792. tx_stats.txop_ovf = ev_tx_stats.txop_ovf;
  6793. tx_stats.seq_posted = ev_tx_stats.seq_posted;
  6794. tx_stats.seq_failed_queueing = ev_tx_stats.seq_failed_queueing;
  6795. tx_stats.seq_completed = ev_tx_stats.seq_completed;
  6796. tx_stats.seq_restarted = ev_tx_stats.seq_restarted;
  6797. tx_stats.mu_seq_posted = ev_tx_stats.mu_seq_posted;
  6798. tx_stats.mpdus_sw_flush = ev_tx_stats.mpdus_sw_flush;
  6799. tx_stats.mpdus_hw_filter = ev_tx_stats.mpdus_hw_filter;
  6800. tx_stats.mpdus_truncated = ev_tx_stats.mpdus_truncated;
  6801. tx_stats.mpdus_ack_failed = ev_tx_stats.mpdus_ack_failed;
  6802. tx_stats.mpdus_expired = ev_tx_stats.mpdus_expired;
  6803. /* Only NON-TLV */
  6804. tx_stats.mc_drop = ev_tx_stats.mc_drop;
  6805. /* Only TLV */
  6806. tx_stats.tx_ko = 0;
  6807. #define rx_stats (pdev_stats->pdev_stats.rx)
  6808. #define ev_rx_stats (ev->pdev_stats.rx)
  6809. /* Rx Stats */
  6810. rx_stats.mid_ppdu_route_change =
  6811. ev_rx_stats.mid_ppdu_route_change;
  6812. rx_stats.status_rcvd = ev_rx_stats.status_rcvd;
  6813. rx_stats.r0_frags = ev_rx_stats.r0_frags;
  6814. rx_stats.r1_frags = ev_rx_stats.r1_frags;
  6815. rx_stats.r2_frags = ev_rx_stats.r2_frags;
  6816. /* Only TLV */
  6817. rx_stats.r3_frags = 0;
  6818. rx_stats.htt_msdus = ev_rx_stats.htt_msdus;
  6819. rx_stats.htt_mpdus = ev_rx_stats.htt_mpdus;
  6820. rx_stats.loc_msdus = ev_rx_stats.loc_msdus;
  6821. rx_stats.loc_mpdus = ev_rx_stats.loc_mpdus;
  6822. rx_stats.oversize_amsdu = ev_rx_stats.oversize_amsdu;
  6823. rx_stats.phy_errs = ev_rx_stats.phy_errs;
  6824. rx_stats.phy_err_drop = ev_rx_stats.phy_err_drop;
  6825. rx_stats.mpdu_errs = ev_rx_stats.mpdu_errs;
  6826. rx_stats.pdev_rx_timeout = ev_rx_stats.pdev_rx_timeout;
  6827. rx_stats.rx_ovfl_errs = ev_rx_stats.rx_ovfl_errs;
  6828. /* mem stats */
  6829. pdev_stats->pdev_stats.mem.iram_free_size =
  6830. ev->pdev_stats.mem.iram_free_size;
  6831. pdev_stats->pdev_stats.mem.dram_free_size =
  6832. ev->pdev_stats.mem.dram_free_size;
  6833. /* Only Non-TLV */
  6834. pdev_stats->pdev_stats.mem.sram_free_size =
  6835. ev->pdev_stats.mem.sram_free_size;
  6836. /* Peer stats */
  6837. /* Only TLV */
  6838. pdev_stats->pdev_stats.peer.dummy = 0;
  6839. /* Only NON-TLV */
  6840. pdev_stats->ackRcvBad = ev->ackRcvBad;
  6841. pdev_stats->rtsBad = ev->rtsBad;
  6842. pdev_stats->rtsGood = ev->rtsGood;
  6843. pdev_stats->fcsBad = ev->fcsBad;
  6844. pdev_stats->noBeacons = ev->noBeacons;
  6845. pdev_stats->mib_int_count = ev->mib_int_count;
  6846. }
  6847. return QDF_STATUS_SUCCESS;
  6848. }
  6849. /**
  6850. * extract_pdev_ext_stats_non_tlv() - extract extended pdev stats from event
  6851. * @wmi_handle: wmi handle
  6852. * @param evt_buf: pointer to event buffer
  6853. * @param index: Index into extended pdev stats
  6854. * @param pdev_ext_stats: Pointer to hold extended pdev stats
  6855. *
  6856. * Return: 0 for success or error code
  6857. */
  6858. static QDF_STATUS extract_pdev_ext_stats_non_tlv(wmi_unified_t wmi_handle,
  6859. void *evt_buf,
  6860. uint32_t index, wmi_host_pdev_ext_stats *pdev_ext_stats)
  6861. {
  6862. if (index < ((wmi_stats_event *)evt_buf)->num_pdev_ext_stats) {
  6863. wmi_pdev_ext_stats *ev =
  6864. (wmi_pdev_ext_stats *) ((((wmi_stats_event *)evt_buf)->data) +
  6865. ((((wmi_stats_event *)evt_buf)->num_pdev_stats) *
  6866. sizeof(wmi_pdev_stats)) +
  6867. (index * sizeof(wmi_pdev_ext_stats)));
  6868. /* Copy content to event->data */
  6869. OS_MEMCPY(pdev_ext_stats, ev, sizeof(wmi_pdev_ext_stats));
  6870. }
  6871. return QDF_STATUS_SUCCESS;
  6872. }
  6873. /**
  6874. * extract_vdev_stats_non_tlv() - extract vdev stats from event
  6875. * @wmi_handle: wmi handle
  6876. * @param evt_buf: pointer to event buffer
  6877. * @param index: Index into vdev stats
  6878. * @param vdev_stats: Pointer to hold vdev stats
  6879. *
  6880. * Return: 0 for success or error code
  6881. */
  6882. static QDF_STATUS extract_vdev_stats_non_tlv(wmi_unified_t wmi_handle,
  6883. void *evt_buf, uint32_t index, wmi_host_vdev_stats *vdev_stats)
  6884. {
  6885. if (index < ((wmi_stats_event *)evt_buf)->num_vdev_stats) {
  6886. wmi_vdev_stats *ev =
  6887. (wmi_vdev_stats *) ((((wmi_stats_event *)evt_buf)->data) +
  6888. ((((wmi_stats_event *)evt_buf)->num_pdev_stats) *
  6889. sizeof(wmi_pdev_stats)) +
  6890. ((((wmi_stats_event *)evt_buf)->num_pdev_ext_stats) *
  6891. sizeof(wmi_pdev_ext_stats)) +
  6892. (index * sizeof(wmi_vdev_stats)));
  6893. OS_MEMSET(vdev_stats, 0, sizeof(wmi_host_vdev_stats));
  6894. vdev_stats->vdev_id = ev->vdev_id;
  6895. }
  6896. return QDF_STATUS_SUCCESS;
  6897. }
  6898. /**
  6899. * extract_peer_stats_non_tlv() - extract peer stats from event
  6900. * @wmi_handle: wmi handle
  6901. * @param evt_buf: pointer to event buffer
  6902. * @param index: Index into peer stats
  6903. * @param peer_stats: Pointer to hold peer stats
  6904. *
  6905. * Return: 0 for success or error code
  6906. */
  6907. static QDF_STATUS extract_peer_stats_non_tlv(wmi_unified_t wmi_handle,
  6908. void *evt_buf, uint32_t index, wmi_host_peer_stats *peer_stats)
  6909. {
  6910. if (index < ((wmi_stats_event *)evt_buf)->num_peer_stats) {
  6911. wmi_peer_stats *ev =
  6912. (wmi_peer_stats *) ((((wmi_stats_event *)evt_buf)->data) +
  6913. ((((wmi_stats_event *)evt_buf)->num_pdev_stats) *
  6914. sizeof(wmi_pdev_stats)) +
  6915. ((((wmi_stats_event *)evt_buf)->num_pdev_ext_stats) *
  6916. sizeof(wmi_pdev_ext_stats)) +
  6917. ((((wmi_stats_event *)evt_buf)->num_vdev_stats) *
  6918. sizeof(wmi_vdev_stats)) +
  6919. (index * sizeof(wmi_peer_stats)));
  6920. OS_MEMCPY(&(peer_stats->peer_macaddr), &(ev->peer_macaddr),
  6921. sizeof(wmi_mac_addr));
  6922. peer_stats->peer_rssi = ev->peer_rssi;
  6923. peer_stats->peer_rssi_seq_num = ev->peer_rssi_seq_num;
  6924. peer_stats->peer_tx_rate = ev->peer_tx_rate;
  6925. peer_stats->peer_rx_rate = ev->peer_rx_rate;
  6926. peer_stats->currentper = ev->currentper;
  6927. peer_stats->retries = ev->retries;
  6928. peer_stats->txratecount = ev->txratecount;
  6929. peer_stats->max4msframelen = ev->max4msframelen;
  6930. peer_stats->totalsubframes = ev->totalsubframes;
  6931. peer_stats->txbytes = ev->txbytes;
  6932. OS_MEMCPY(peer_stats->nobuffs, ev->nobuffs,
  6933. sizeof(peer_stats->nobuffs));
  6934. OS_MEMCPY(peer_stats->excretries, ev->excretries,
  6935. sizeof(peer_stats->excretries));
  6936. peer_stats->peer_rssi_changed = ev->peer_rssi_changed;
  6937. }
  6938. return QDF_STATUS_SUCCESS;
  6939. }
  6940. /**
  6941. * extract_bcnflt_stats_non_tlv() - extract bcn fault stats from event
  6942. * @wmi_handle: wmi handle
  6943. * @param evt_buf: pointer to event buffer
  6944. * @param index: Index into bcn fault stats
  6945. * @param bcnflt_stats: Pointer to hold bcn fault stats
  6946. *
  6947. * Return: 0 for success or error code
  6948. */
  6949. static QDF_STATUS extract_bcnflt_stats_non_tlv(wmi_unified_t wmi_handle,
  6950. void *evt_buf, uint32_t index, wmi_host_bcnflt_stats *bcnflt_stats)
  6951. {
  6952. return QDF_STATUS_SUCCESS;
  6953. }
  6954. /**
  6955. * extract_peer_extd_stats_non_tlv() - extract extended peer stats from event
  6956. * @wmi_handle: wmi handle
  6957. * @param evt_buf: pointer to event buffer
  6958. * @param index: Index into extended peer stats
  6959. * @param peer_extd_stats: Pointer to hold extended peer stats
  6960. *
  6961. * Return: 0 for success or error code
  6962. */
  6963. static QDF_STATUS extract_peer_extd_stats_non_tlv(wmi_unified_t wmi_handle,
  6964. void *evt_buf, uint32_t index,
  6965. wmi_host_peer_extd_stats *peer_extd_stats)
  6966. {
  6967. uint8_t *pdata = ((wmi_stats_event *)evt_buf)->data;
  6968. if (WMI_REQUEST_PEER_EXTD_STAT &
  6969. ((wmi_stats_event *)evt_buf)->stats_id) {
  6970. if (index < ((wmi_stats_event *)evt_buf)->num_peer_stats) {
  6971. wmi_peer_extd_stats *ev = (wmi_peer_extd_stats *)
  6972. ((pdata) +
  6973. ((((wmi_stats_event *)evt_buf)->num_pdev_stats) *
  6974. sizeof(wmi_pdev_stats)) +
  6975. ((((wmi_stats_event *)evt_buf)->num_pdev_ext_stats) *
  6976. sizeof(wmi_pdev_ext_stats)) +
  6977. ((((wmi_stats_event *)evt_buf)->num_vdev_stats) *
  6978. sizeof(wmi_vdev_stats)) +
  6979. ((((wmi_stats_event *)evt_buf)->num_peer_stats) *
  6980. sizeof(wmi_peer_stats)) +
  6981. (index * sizeof(wmi_peer_extd_stats)));
  6982. OS_MEMCPY(peer_extd_stats, ev,
  6983. sizeof(wmi_host_peer_extd_stats));
  6984. }
  6985. }
  6986. return QDF_STATUS_SUCCESS;
  6987. }
  6988. /**
  6989. * extract_vdev_extd_stats_non_tlv() - extract extended vdev stats from event
  6990. * @wmi_handle: wmi handle
  6991. * @param evt_buf: pointer to event buffer
  6992. * @param index: Index into extended vdev stats
  6993. * @param vdev_extd_stats: Pointer to hold extended vdev stats
  6994. *
  6995. * Return: 0 for success or error code
  6996. */
  6997. static QDF_STATUS extract_vdev_extd_stats_non_tlv(wmi_unified_t wmi_handle,
  6998. void *evt_buf, uint32_t index,
  6999. wmi_host_vdev_extd_stats *vdev_extd_stats)
  7000. {
  7001. uint8_t *pdata = ((wmi_stats_event *)evt_buf)->data;
  7002. if (WMI_REQUEST_PEER_EXTD_STAT &
  7003. ((wmi_stats_event *)evt_buf)->stats_id) {
  7004. if (index < ((wmi_stats_event *)evt_buf)->num_vdev_stats) {
  7005. wmi_vdev_extd_stats *ev = (wmi_vdev_extd_stats *)
  7006. ((pdata) +
  7007. ((((wmi_stats_event *)evt_buf)->num_pdev_stats) *
  7008. sizeof(wmi_pdev_stats)) +
  7009. ((((wmi_stats_event *)evt_buf)->num_pdev_ext_stats) *
  7010. sizeof(wmi_pdev_ext_stats)) +
  7011. ((((wmi_stats_event *)evt_buf)->num_vdev_stats) *
  7012. sizeof(wmi_vdev_stats)) +
  7013. ((((wmi_stats_event *)evt_buf)->num_peer_stats) *
  7014. sizeof(wmi_peer_stats)) +
  7015. ((((wmi_stats_event *)evt_buf)->num_peer_stats) *
  7016. sizeof(wmi_peer_extd_stats)) +
  7017. (index * sizeof(wmi_vdev_extd_stats)));
  7018. OS_MEMCPY(vdev_extd_stats, ev,
  7019. sizeof(wmi_host_vdev_extd_stats));
  7020. }
  7021. }
  7022. return QDF_STATUS_SUCCESS;
  7023. }
  7024. /**
  7025. * extract_chan_stats_non_tlv() - extract chan stats from event
  7026. * @wmi_handle: wmi handle
  7027. * @param evt_buf: pointer to event buffer
  7028. * @param index: Index into chan stats
  7029. * @param vdev_extd_stats: Pointer to hold chan stats
  7030. *
  7031. * Return: 0 for success or error code
  7032. */
  7033. static QDF_STATUS extract_chan_stats_non_tlv(wmi_unified_t wmi_handle,
  7034. void *evt_buf,
  7035. uint32_t index, wmi_host_chan_stats *chan_stats)
  7036. {
  7037. /* Non-TLV doesnt have num_chan_stats */
  7038. return QDF_STATUS_SUCCESS;
  7039. }
  7040. /**
  7041. * extract_profile_ctx_non_tlv() - extract profile context from event
  7042. * @wmi_handle: wmi handle
  7043. * @param evt_buf: pointer to event buffer
  7044. * @param profile_ctx: Pointer to hold profile context
  7045. *
  7046. * Return: 0 for success or error code
  7047. */
  7048. static QDF_STATUS extract_profile_ctx_non_tlv(wmi_unified_t wmi_handle,
  7049. void *evt_buf,
  7050. wmi_host_wlan_profile_ctx_t *profile_ctx)
  7051. {
  7052. wmi_profile_stats_event *profile_ev =
  7053. (wmi_profile_stats_event *)evt_buf;
  7054. qdf_mem_copy(profile_ctx, &(profile_ev->profile_ctx),
  7055. sizeof(wmi_host_wlan_profile_ctx_t));
  7056. return QDF_STATUS_SUCCESS;
  7057. }
  7058. /**
  7059. * extract_profile_data_non_tlv() - extract profile data from event
  7060. * @wmi_handle: wmi handle
  7061. * @param evt_buf: pointer to event buffer
  7062. * @param profile_data: Pointer to hold profile data
  7063. *
  7064. * Return: 0 for success or error code
  7065. */
  7066. static QDF_STATUS extract_profile_data_non_tlv(wmi_unified_t wmi_handle,
  7067. void *evt_buf, uint8_t idx,
  7068. wmi_host_wlan_profile_t *profile_data)
  7069. {
  7070. wmi_profile_stats_event *profile_ev =
  7071. (wmi_profile_stats_event *)evt_buf;
  7072. if (idx > profile_ev->profile_ctx.bin_count)
  7073. return QDF_STATUS_E_INVAL;
  7074. qdf_mem_copy(profile_data, &profile_ev->profile_data[idx],
  7075. sizeof(wmi_host_wlan_profile_t));
  7076. return QDF_STATUS_SUCCESS;
  7077. }
  7078. /**
  7079. * extract_chan_info_event_non_tlv() - extract chan information from event
  7080. * @wmi_handle: wmi handle
  7081. * @param evt_buf: pointer to event buffer
  7082. * @param chan_info: Pointer to hold chan information
  7083. *
  7084. * Return: 0 for success or error code
  7085. */
  7086. static QDF_STATUS extract_chan_info_event_non_tlv(wmi_unified_t wmi_handle,
  7087. void *evt_buf,
  7088. wmi_host_chan_info_event *chan_info)
  7089. {
  7090. wmi_chan_info_event *chan_info_ev = (wmi_chan_info_event *)evt_buf;
  7091. chan_info->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  7092. chan_info->err_code = chan_info_ev->err_code;
  7093. chan_info->freq = chan_info_ev->freq;
  7094. chan_info->cmd_flags = chan_info_ev->cmd_flags;
  7095. chan_info->noise_floor = chan_info_ev->noise_floor;
  7096. chan_info->rx_clear_count = chan_info_ev->rx_clear_count;
  7097. chan_info->cycle_count = chan_info_ev->cycle_count;
  7098. chan_info->rx_11b_mode_data_duration =
  7099. chan_info_ev->rx_11b_mode_data_duration;
  7100. /* ONLY NON-TLV */
  7101. chan_info->chan_tx_pwr_range = chan_info_ev->chan_tx_pwr_range;
  7102. chan_info->chan_tx_pwr_tp = chan_info_ev->chan_tx_pwr_tp;
  7103. chan_info->rx_frame_count = chan_info_ev->rx_frame_count;
  7104. return QDF_STATUS_SUCCESS;
  7105. }
  7106. /**
  7107. * extract_channel_hopping_event_non_tlv() - extract channel hopping param
  7108. * from event
  7109. * @wmi_handle: wmi handle
  7110. * @param evt_buf: pointer to event buffer
  7111. * @param ch_hopping: Pointer to hold channel hopping param
  7112. *
  7113. * Return: 0 for success or error code
  7114. */
  7115. static QDF_STATUS extract_channel_hopping_event_non_tlv(
  7116. wmi_unified_t wmi_handle, void *evt_buf,
  7117. wmi_host_pdev_channel_hopping_event *ch_hopping)
  7118. {
  7119. wmi_pdev_channel_hopping_event *event =
  7120. (wmi_pdev_channel_hopping_event *)evt_buf;
  7121. ch_hopping->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  7122. ch_hopping->noise_floor_report_iter = event->noise_floor_report_iter;
  7123. ch_hopping->noise_floor_total_iter = event->noise_floor_total_iter;
  7124. return QDF_STATUS_SUCCESS;
  7125. }
  7126. /**
  7127. * extract_bss_chan_info_event_non_tlv() - extract bss channel information
  7128. * from event
  7129. * @wmi_handle: wmi handle
  7130. * @param evt_buf: pointer to event buffer
  7131. * @param bss_chan_info: Pointer to hold bss channel information
  7132. *
  7133. * Return: 0 for success or error code
  7134. */
  7135. static QDF_STATUS extract_bss_chan_info_event_non_tlv(wmi_unified_t wmi_handle,
  7136. void *evt_buf, wmi_host_pdev_bss_chan_info_event *bss_chan_info)
  7137. {
  7138. wmi_pdev_bss_chan_info_event *event =
  7139. (wmi_pdev_bss_chan_info_event *)evt_buf;
  7140. bss_chan_info->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  7141. bss_chan_info->freq = event->freq;
  7142. bss_chan_info->noise_floor = event->noise_floor;
  7143. bss_chan_info->rx_clear_count_low = event->rx_clear_count_low;
  7144. bss_chan_info->rx_clear_count_high = event->rx_clear_count_high;
  7145. bss_chan_info->cycle_count_low = event->cycle_count_low;
  7146. bss_chan_info->cycle_count_high = event->cycle_count_high;
  7147. bss_chan_info->tx_cycle_count_low = event->tx_cycle_count_low;
  7148. bss_chan_info->tx_cycle_count_high = event->tx_cycle_count_high;
  7149. bss_chan_info->rx_cycle_count_low = event->rx_cycle_count_low;
  7150. bss_chan_info->rx_cycle_count_high = event->rx_cycle_count_high;
  7151. bss_chan_info->rx_bss_cycle_count_low = event->rx_bss_cycle_count_low;
  7152. bss_chan_info->rx_bss_cycle_count_high = event->rx_bss_cycle_count_high;
  7153. bss_chan_info->reserved = event->reserved;
  7154. return QDF_STATUS_SUCCESS;
  7155. }
  7156. /**
  7157. * extract_inst_rssi_stats_event_non_tlv() - extract inst rssi stats from event
  7158. * @wmi_handle: wmi handle
  7159. * @param evt_buf: pointer to event buffer
  7160. * @param inst_rssi_resp: Pointer to hold inst rssi response
  7161. *
  7162. * Return: 0 for success or error code
  7163. */
  7164. static QDF_STATUS extract_inst_rssi_stats_event_non_tlv(
  7165. wmi_unified_t wmi_handle, void *evt_buf,
  7166. wmi_host_inst_stats_resp *inst_rssi_resp)
  7167. {
  7168. wmi_inst_stats_resp *event = (wmi_inst_stats_resp *)evt_buf;
  7169. inst_rssi_resp->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  7170. qdf_mem_copy(inst_rssi_resp, event, sizeof(wmi_inst_stats_resp));
  7171. return QDF_STATUS_SUCCESS;
  7172. }
  7173. /**
  7174. * extract_tx_data_traffic_ctrl_ev_non_tlv() - extract tx data traffic control
  7175. * from event
  7176. * @wmi_handle: wmi handle
  7177. * @param evt_buf: pointer to event buffer
  7178. * @param ev: Pointer to hold data traffic control
  7179. *
  7180. * Return: 0 for success or error code
  7181. */
  7182. static QDF_STATUS extract_tx_data_traffic_ctrl_ev_non_tlv(
  7183. wmi_unified_t wmi_handle, void *evt_buf,
  7184. wmi_host_tx_data_traffic_ctrl_event *ev)
  7185. {
  7186. wmi_tx_data_traffic_ctrl_event *evt =
  7187. (wmi_tx_data_traffic_ctrl_event *)evt_buf;
  7188. ev->peer_ast_idx = evt->peer_ast_idx;
  7189. ev->vdev_id = evt->vdev_id;
  7190. ev->ctrl_cmd = evt->ctrl_cmd;
  7191. return QDF_STATUS_SUCCESS;
  7192. }
  7193. /**
  7194. * extract_atf_peer_stats_ev_non_tlv() - extract atf peer stats
  7195. * from event
  7196. * @wmi_handle: wmi handle
  7197. * @param evt_buf: pointer to event buffer
  7198. * @param ev: Pointer to hold atf stats event data
  7199. *
  7200. * Return: 0 for success or error code
  7201. */
  7202. static QDF_STATUS extract_atf_peer_stats_ev_non_tlv(
  7203. wmi_unified_t wmi_handle, void *evt_buf,
  7204. wmi_host_atf_peer_stats_event *ev)
  7205. {
  7206. wmi_atf_peer_stats_event *evt =
  7207. (wmi_atf_peer_stats_event *)evt_buf;
  7208. ev->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  7209. ev->num_atf_peers = evt->num_atf_peers;
  7210. ev->comp_usable_airtime = evt->comp_usable_airtime;
  7211. qdf_mem_copy(&ev->reserved[0], &evt->reserved[0],
  7212. sizeof(evt->reserved));
  7213. return QDF_STATUS_SUCCESS;
  7214. }
  7215. /**
  7216. * extract_atf_token_info_ev_non_tlv() - extract atf token info
  7217. * from event
  7218. * @wmi_handle: wmi handle
  7219. * @param evt_buf: pointer to event buffer
  7220. * @idx: Index indicating the peer number
  7221. * @param atf_token_info: Pointer to hold atf token info
  7222. *
  7223. * Return: 0 for success or error code
  7224. */
  7225. static QDF_STATUS extract_atf_token_info_ev_non_tlv(
  7226. wmi_unified_t wmi_handle, void *evt_buf,
  7227. uint8_t idx, wmi_host_atf_peer_stats_info *atf_token_info)
  7228. {
  7229. wmi_atf_peer_stats_event *evt =
  7230. (wmi_atf_peer_stats_event *)evt_buf;
  7231. if (idx > evt->num_atf_peers)
  7232. return QDF_STATUS_E_INVAL;
  7233. atf_token_info->field1 = evt->token_info_list[idx].field1;
  7234. atf_token_info->field2 = evt->token_info_list[idx].field2;
  7235. atf_token_info->field3 = evt->token_info_list[idx].field3;
  7236. return QDF_STATUS_SUCCESS;
  7237. }
  7238. /**
  7239. * extract_pdev_utf_event_non_tlv() - extract UTF data info from event
  7240. * @wmi_handle: WMI handle
  7241. * @param evt_buf: Pointer to event buffer
  7242. * @param param: Pointer to hold data
  7243. *
  7244. * Return : QDF_STATUS_SUCCESS for success or error code
  7245. */
  7246. static QDF_STATUS extract_pdev_utf_event_non_tlv(
  7247. wmi_unified_t wmi_handle,
  7248. uint8_t *evt_buf,
  7249. struct wmi_host_pdev_utf_event *event)
  7250. {
  7251. event->data = evt_buf;
  7252. event->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  7253. return QDF_STATUS_SUCCESS;
  7254. }
  7255. /**
  7256. * extract_pdev_qvit_event_non_tlv() - extract QVIT data info from event
  7257. * @wmi_handle: WMI handle
  7258. * @param evt_buf: Pointer to event buffer
  7259. * @param param: Pointer to hold data
  7260. *
  7261. * Return : QDF_STATUS_SUCCESS for success or error code
  7262. */
  7263. static QDF_STATUS extract_pdev_qvit_event_non_tlv(
  7264. wmi_unified_t wmi_handle,
  7265. uint8_t *evt_buf,
  7266. struct wmi_host_pdev_qvit_event *event)
  7267. {
  7268. event->data = evt_buf;
  7269. event->pdev_id = WMI_NON_TLV_DEFAULT_PDEV_ID;
  7270. return QDF_STATUS_SUCCESS;
  7271. }
  7272. /**
  7273. * extract_wds_entry_non_tlv() - extract wds entry from event
  7274. * @wmi_handle: wmi handle
  7275. * @evt_buf: pointer to event buffer
  7276. * @wds_entry: wds entry
  7277. * @idx: index to point wds entry in event buffer
  7278. *
  7279. * Return: 0 for success or error code
  7280. */
  7281. static QDF_STATUS extract_wds_entry_non_tlv(wmi_unified_t wmi_handle,
  7282. u_int8_t *evt_buf,
  7283. struct wdsentry *wds_entry,
  7284. u_int32_t idx)
  7285. {
  7286. wmi_pdev_wds_entry_dump_event *wds_entry_dump_event =
  7287. (wmi_pdev_wds_entry_dump_event *)evt_buf;
  7288. if (idx >= wds_entry_dump_event->num_entries)
  7289. return QDF_STATUS_E_INVAL;
  7290. qdf_mem_zero(wds_entry, sizeof(struct wdsentry));
  7291. WMI_MAC_ADDR_TO_CHAR_ARRAY(
  7292. &(wds_entry_dump_event->wds_entry[idx].peer_macaddr),
  7293. wds_entry->peer_mac);
  7294. WMI_MAC_ADDR_TO_CHAR_ARRAY(
  7295. &(wds_entry_dump_event->wds_entry[idx].wds_macaddr),
  7296. wds_entry->wds_mac);
  7297. wds_entry->flags = wds_entry_dump_event->wds_entry[idx].flags;
  7298. return QDF_STATUS_SUCCESS;
  7299. }
  7300. static bool is_management_record_non_tlv(uint32_t cmd_id)
  7301. {
  7302. if ((cmd_id == WMI_BCN_TX_CMDID) ||
  7303. (cmd_id == WMI_PDEV_SEND_BCN_CMDID) ||
  7304. (cmd_id == WMI_MGMT_TX_CMDID) ||
  7305. (cmd_id == WMI_GPIO_OUTPUT_CMDID) ||
  7306. (cmd_id == WMI_HOST_SWBA_EVENTID)) {
  7307. return true;
  7308. }
  7309. return false;
  7310. }
  7311. /**
  7312. * wmi_set_htc_tx_tag_non_tlv() - set HTC TX tag for WMI commands
  7313. * @wmi_handle: WMI handle
  7314. * @buf: WMI buffer
  7315. * @cmd_id: WMI command Id
  7316. *
  7317. * Return htc_tx_tag
  7318. */
  7319. static uint16_t wmi_set_htc_tx_tag_non_tlv(wmi_unified_t wmi_handle,
  7320. wmi_buf_t buf, uint32_t cmd_id)
  7321. {
  7322. return 0;
  7323. }
  7324. /**
  7325. * send_dfs_phyerr_offload_en_cmd_non_tlv() - send dfs phyerr offload en cmd
  7326. * @wmi_handle: wmi handle
  7327. * @pdev_id: pdev id
  7328. *
  7329. * Send WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMDID command to firmware.
  7330. *
  7331. * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
  7332. */
  7333. static QDF_STATUS send_dfs_phyerr_offload_en_cmd_non_tlv(
  7334. wmi_unified_t wmi_handle,
  7335. uint32_t pdev_id)
  7336. {
  7337. return QDF_STATUS_SUCCESS;
  7338. }
  7339. /**
  7340. * send_dfs_phyerr_offload_dis_cmd_non_tlv() - send dfs phyerr offload dis cmd
  7341. * @wmi_handle: wmi handle
  7342. * @pdev_id: pdev id
  7343. *
  7344. * Send WMI_PDEV_DFS_PHYERR_OFFLOAD_DISABLE_CMDID command to firmware.
  7345. *
  7346. * Return: QDF_STATUS_SUCCESS on success, QDF_STATUS_E_** on error
  7347. */
  7348. static QDF_STATUS send_dfs_phyerr_offload_dis_cmd_non_tlv(
  7349. wmi_unified_t wmi_handle,
  7350. uint32_t pdev_id)
  7351. {
  7352. return QDF_STATUS_SUCCESS;
  7353. }
  7354. /**
  7355. * send_wds_entry_list_cmd_non_tlv() - WMI function to get list of
  7356. * wds entries from FW
  7357. *
  7358. * @param wmi_handle : handle to WMI.
  7359. * @return QDF_STATUS_SUCCESS on success and -ve on failure.
  7360. */
  7361. QDF_STATUS send_wds_entry_list_cmd_non_tlv(wmi_unified_t wmi_handle)
  7362. {
  7363. wmi_buf_t buf;
  7364. /*
  7365. * Passing a NULL pointer to wmi_unified_cmd_send() panics it,
  7366. * so let's just use a 32 byte fake array for now.
  7367. */
  7368. buf = wmi_buf_alloc(wmi_handle, 32);
  7369. if (buf == NULL)
  7370. return QDF_STATUS_E_NOMEM;
  7371. if (wmi_unified_cmd_send(wmi_handle, buf, 32,
  7372. WMI_PDEV_WDS_ENTRY_LIST_CMDID) != QDF_STATUS_SUCCESS) {
  7373. qdf_print("%s: send failed\n", __func__);
  7374. wmi_buf_free(buf);
  7375. return QDF_STATUS_E_FAILURE;
  7376. }
  7377. return QDF_STATUS_SUCCESS;
  7378. }
  7379. struct wmi_ops non_tlv_ops = {
  7380. .send_vdev_create_cmd = send_vdev_create_cmd_non_tlv,
  7381. .send_vdev_delete_cmd = send_vdev_delete_cmd_non_tlv,
  7382. .send_vdev_down_cmd = send_vdev_down_cmd_non_tlv,
  7383. .send_peer_flush_tids_cmd = send_peer_flush_tids_cmd_non_tlv,
  7384. .send_peer_param_cmd = send_peer_param_cmd_non_tlv,
  7385. .send_vdev_up_cmd = send_vdev_up_cmd_non_tlv,
  7386. .send_peer_create_cmd = send_peer_create_cmd_non_tlv,
  7387. .send_peer_delete_cmd = send_peer_delete_cmd_non_tlv,
  7388. #ifdef WLAN_SUPPORT_GREEN_AP
  7389. .send_green_ap_ps_cmd = send_green_ap_ps_cmd_non_tlv,
  7390. #endif
  7391. .send_pdev_utf_cmd = send_pdev_utf_cmd_non_tlv,
  7392. .send_pdev_param_cmd = send_pdev_param_cmd_non_tlv,
  7393. .send_suspend_cmd = send_suspend_cmd_non_tlv,
  7394. .send_resume_cmd = send_resume_cmd_non_tlv,
  7395. .send_wow_enable_cmd = send_wow_enable_cmd_non_tlv,
  7396. .send_set_ap_ps_param_cmd = send_set_ap_ps_param_cmd_non_tlv,
  7397. .send_set_sta_ps_param_cmd = send_set_sta_ps_param_cmd_non_tlv,
  7398. .send_crash_inject_cmd = send_crash_inject_cmd_non_tlv,
  7399. .send_dbglog_cmd = send_dbglog_cmd_non_tlv,
  7400. .send_vdev_set_param_cmd = send_vdev_set_param_cmd_non_tlv,
  7401. .send_stats_request_cmd = send_stats_request_cmd_non_tlv,
  7402. .send_packet_log_enable_cmd = send_packet_log_enable_cmd_non_tlv,
  7403. .send_packet_log_disable_cmd = send_packet_log_disable_cmd_non_tlv,
  7404. .send_beacon_send_cmd = send_beacon_send_cmd_non_tlv,
  7405. .send_peer_assoc_cmd = send_peer_assoc_cmd_non_tlv,
  7406. .send_scan_start_cmd = send_scan_start_cmd_non_tlv,
  7407. .send_scan_stop_cmd = send_scan_stop_cmd_non_tlv,
  7408. .send_scan_chan_list_cmd = send_scan_chan_list_cmd_non_tlv,
  7409. .send_pdev_get_tpc_config_cmd = send_pdev_get_tpc_config_cmd_non_tlv,
  7410. .send_set_atf_cmd = send_set_atf_cmd_non_tlv,
  7411. .send_atf_peer_request_cmd = send_atf_peer_request_cmd_non_tlv,
  7412. .send_set_atf_grouping_cmd = send_set_atf_grouping_cmd_non_tlv,
  7413. .send_set_bwf_cmd = send_set_bwf_cmd_non_tlv,
  7414. .send_pdev_fips_cmd = send_pdev_fips_cmd_non_tlv,
  7415. .send_wlan_profile_enable_cmd = send_wlan_profile_enable_cmd_non_tlv,
  7416. .send_wlan_profile_trigger_cmd = send_wlan_profile_trigger_cmd_non_tlv,
  7417. .send_pdev_set_chan_cmd = send_pdev_set_chan_cmd_non_tlv,
  7418. .send_set_ht_ie_cmd = send_set_ht_ie_cmd_non_tlv,
  7419. .send_set_vht_ie_cmd = send_set_vht_ie_cmd_non_tlv,
  7420. .send_wmm_update_cmd = send_wmm_update_cmd_non_tlv,
  7421. .send_set_ant_switch_tbl_cmd = send_set_ant_switch_tbl_cmd_non_tlv,
  7422. .send_set_ratepwr_table_cmd = send_set_ratepwr_table_cmd_non_tlv,
  7423. .send_get_ratepwr_table_cmd = send_get_ratepwr_table_cmd_non_tlv,
  7424. .send_set_ctl_table_cmd = send_set_ctl_table_cmd_non_tlv,
  7425. .send_set_mimogain_table_cmd = send_set_mimogain_table_cmd_non_tlv,
  7426. .send_set_ratepwr_chainmsk_cmd = send_set_ratepwr_chainmsk_cmd_non_tlv,
  7427. .send_set_macaddr_cmd = send_set_macaddr_cmd_non_tlv,
  7428. .send_pdev_scan_start_cmd = send_pdev_scan_start_cmd_non_tlv,
  7429. .send_pdev_scan_end_cmd = send_pdev_scan_end_cmd_non_tlv,
  7430. .send_set_acparams_cmd = send_set_acparams_cmd_non_tlv,
  7431. .send_set_vap_dscp_tid_map_cmd = send_set_vap_dscp_tid_map_cmd_non_tlv,
  7432. .send_proxy_ast_reserve_cmd = send_proxy_ast_reserve_cmd_non_tlv,
  7433. .send_pdev_qvit_cmd = send_pdev_qvit_cmd_non_tlv,
  7434. .send_mcast_group_update_cmd = send_mcast_group_update_cmd_non_tlv,
  7435. .send_peer_add_wds_entry_cmd = send_peer_add_wds_entry_cmd_non_tlv,
  7436. .send_peer_del_wds_entry_cmd = send_peer_del_wds_entry_cmd_non_tlv,
  7437. .send_set_bridge_mac_addr_cmd = send_set_bridge_mac_addr_cmd_non_tlv,
  7438. .send_peer_update_wds_entry_cmd =
  7439. send_peer_update_wds_entry_cmd_non_tlv,
  7440. .send_phyerr_enable_cmd = send_phyerr_enable_cmd_non_tlv,
  7441. .send_phyerr_disable_cmd = send_phyerr_disable_cmd_non_tlv,
  7442. .send_smart_ant_enable_cmd = send_smart_ant_enable_cmd_non_tlv,
  7443. .send_smart_ant_set_rx_ant_cmd = send_smart_ant_set_rx_ant_cmd_non_tlv,
  7444. .send_smart_ant_set_tx_ant_cmd = send_smart_ant_set_tx_ant_cmd_non_tlv,
  7445. .send_smart_ant_set_training_info_cmd =
  7446. send_smart_ant_set_training_info_cmd_non_tlv,
  7447. .send_smart_ant_set_node_config_cmd =
  7448. send_smart_ant_set_node_config_cmd_non_tlv,
  7449. .send_smart_ant_enable_tx_feedback_cmd =
  7450. send_smart_ant_enable_tx_feedback_cmd_non_tlv,
  7451. .send_vdev_spectral_configure_cmd =
  7452. send_vdev_spectral_configure_cmd_non_tlv,
  7453. .send_vdev_spectral_enable_cmd =
  7454. send_vdev_spectral_enable_cmd_non_tlv,
  7455. .send_bss_chan_info_request_cmd =
  7456. send_bss_chan_info_request_cmd_non_tlv,
  7457. .send_thermal_mitigation_param_cmd =
  7458. send_thermal_mitigation_param_cmd_non_tlv,
  7459. .send_vdev_start_cmd = send_vdev_start_cmd_non_tlv,
  7460. .send_vdev_stop_cmd = send_vdev_stop_cmd_non_tlv,
  7461. .send_vdev_set_neighbour_rx_cmd =
  7462. send_vdev_set_neighbour_rx_cmd_non_tlv,
  7463. .send_vdev_set_fwtest_param_cmd =
  7464. send_vdev_set_fwtest_param_cmd_non_tlv,
  7465. .send_vdev_config_ratemask_cmd = send_vdev_config_ratemask_cmd_non_tlv,
  7466. .send_setup_install_key_cmd =
  7467. send_setup_install_key_cmd_non_tlv,
  7468. .send_wow_wakeup_cmd = send_wow_wakeup_cmd_non_tlv,
  7469. .send_wow_add_wakeup_event_cmd = send_wow_add_wakeup_event_cmd_non_tlv,
  7470. .send_wow_add_wakeup_pattern_cmd =
  7471. send_wow_add_wakeup_pattern_cmd_non_tlv,
  7472. .send_wow_remove_wakeup_pattern_cmd =
  7473. send_wow_remove_wakeup_pattern_cmd_non_tlv,
  7474. .send_pdev_set_regdomain_cmd =
  7475. send_pdev_set_regdomain_cmd_non_tlv,
  7476. .send_set_quiet_mode_cmd = send_set_quiet_mode_cmd_non_tlv,
  7477. .send_set_beacon_filter_cmd = send_set_beacon_filter_cmd_non_tlv,
  7478. .send_remove_beacon_filter_cmd = send_remove_beacon_filter_cmd_non_tlv,
  7479. .send_mgmt_cmd = send_mgmt_cmd_non_tlv,
  7480. .send_addba_clearresponse_cmd = send_addba_clearresponse_cmd_non_tlv,
  7481. .send_addba_send_cmd = send_addba_send_cmd_non_tlv,
  7482. .send_delba_send_cmd = send_delba_send_cmd_non_tlv,
  7483. .send_addba_setresponse_cmd = send_addba_setresponse_cmd_non_tlv,
  7484. .send_singleamsdu_cmd = send_singleamsdu_cmd_non_tlv,
  7485. .send_set_qboost_param_cmd = send_set_qboost_param_cmd_non_tlv,
  7486. .send_mu_scan_cmd = send_mu_scan_cmd_non_tlv,
  7487. .send_lteu_config_cmd = send_lteu_config_cmd_non_tlv,
  7488. .send_set_ps_mode_cmd = send_set_ps_mode_cmd_non_tlv,
  7489. .init_cmd_send = init_cmd_send_non_tlv,
  7490. .send_ext_resource_config = send_ext_resource_config_non_tlv,
  7491. #if 0
  7492. .send_bcn_prb_template_cmd = send_bcn_prb_template_cmd_non_tlv,
  7493. #endif
  7494. .send_nf_dbr_dbm_info_get_cmd = send_nf_dbr_dbm_info_get_cmd_non_tlv,
  7495. .send_packet_power_info_get_cmd =
  7496. send_packet_power_info_get_cmd_non_tlv,
  7497. .send_gpio_config_cmd = send_gpio_config_cmd_non_tlv,
  7498. .send_gpio_output_cmd = send_gpio_output_cmd_non_tlv,
  7499. .send_rtt_meas_req_test_cmd = send_rtt_meas_req_test_cmd_non_tlv,
  7500. .send_rtt_meas_req_cmd = send_rtt_meas_req_cmd_non_tlv,
  7501. .send_lci_set_cmd = send_lci_set_cmd_non_tlv,
  7502. .send_lcr_set_cmd = send_lcr_set_cmd_non_tlv,
  7503. .send_start_oem_data_cmd = send_start_oem_data_cmd_non_tlv,
  7504. .send_rtt_keepalive_req_cmd = send_rtt_keepalive_req_cmd_non_tlv,
  7505. .send_periodic_chan_stats_config_cmd =
  7506. send_periodic_chan_stats_config_cmd_non_tlv,
  7507. .send_get_user_position_cmd = send_get_user_position_cmd_non_tlv,
  7508. .send_reset_peer_mumimo_tx_count_cmd =
  7509. send_reset_peer_mumimo_tx_count_cmd_non_tlv,
  7510. .send_get_peer_mumimo_tx_count_cmd =
  7511. send_get_peer_mumimo_tx_count_cmd_non_tlv,
  7512. .send_pdev_caldata_version_check_cmd =
  7513. send_pdev_caldata_version_check_cmd_non_tlv,
  7514. .send_btcoex_wlan_priority_cmd = send_btcoex_wlan_priority_cmd_non_tlv,
  7515. .send_btcoex_duty_cycle_cmd = send_btcoex_duty_cycle_cmd_non_tlv,
  7516. .send_coex_ver_cfg_cmd = send_coex_ver_cfg_cmd_non_tlv,
  7517. .get_target_cap_from_service_ready = extract_service_ready_non_tlv,
  7518. .extract_fw_version = extract_fw_version_non_tlv,
  7519. .extract_fw_abi_version = extract_fw_abi_version_non_tlv,
  7520. .extract_hal_reg_cap = extract_hal_reg_cap_non_tlv,
  7521. .extract_host_mem_req = extract_host_mem_req_non_tlv,
  7522. .save_service_bitmap = save_service_bitmap_non_tlv,
  7523. .is_service_enabled = is_service_enabled_non_tlv,
  7524. .save_fw_version = save_fw_version_in_service_ready_non_tlv,
  7525. .check_and_update_fw_version =
  7526. ready_check_and_update_fw_version_non_tlv,
  7527. .extract_dbglog_data_len = extract_dbglog_data_len_non_tlv,
  7528. .ready_extract_init_status = ready_extract_init_status_non_tlv,
  7529. .ready_extract_mac_addr = ready_extract_mac_addr_non_tlv,
  7530. .extract_ready_event_params = extract_ready_event_params_non_tlv,
  7531. .extract_wds_addr_event = extract_wds_addr_event_non_tlv,
  7532. .extract_dcs_interference_type = extract_dcs_interference_type_non_tlv,
  7533. .extract_dcs_cw_int = extract_dcs_cw_int_non_tlv,
  7534. .extract_dcs_im_tgt_stats = extract_dcs_im_tgt_stats_non_tlv,
  7535. .extract_vdev_start_resp = extract_vdev_start_resp_non_tlv,
  7536. .extract_tbttoffset_update_params =
  7537. extract_tbttoffset_update_params_non_tlv,
  7538. .extract_tbttoffset_num_vdevs =
  7539. extract_tbttoffset_num_vdevs_non_tlv,
  7540. .extract_mgmt_rx_params = extract_mgmt_rx_params_non_tlv,
  7541. .extract_vdev_stopped_param = extract_vdev_stopped_param_non_tlv,
  7542. .extract_vdev_roam_param = extract_vdev_roam_param_non_tlv,
  7543. .extract_vdev_scan_ev_param = extract_vdev_scan_ev_param_non_tlv,
  7544. .extract_mu_ev_param = extract_mu_ev_param_non_tlv,
  7545. .extract_pdev_tpc_config_ev_param =
  7546. extract_pdev_tpc_config_ev_param_non_tlv,
  7547. .extract_nfcal_power_ev_param = extract_nfcal_power_ev_param_non_tlv,
  7548. .extract_pdev_tpc_ev_param = extract_pdev_tpc_ev_param_non_tlv,
  7549. .extract_pdev_generic_buffer_ev_param =
  7550. extract_pdev_generic_buffer_ev_param_non_tlv,
  7551. .extract_gpio_input_ev_param = extract_gpio_input_ev_param_non_tlv,
  7552. .extract_pdev_reserve_ast_ev_param =
  7553. extract_pdev_reserve_ast_ev_param_non_tlv,
  7554. .extract_swba_num_vdevs = extract_swba_num_vdevs_non_tlv,
  7555. .extract_swba_tim_info = extract_swba_tim_info_non_tlv,
  7556. .extract_swba_noa_info = extract_swba_noa_info_non_tlv,
  7557. .extract_peer_sta_ps_statechange_ev =
  7558. extract_peer_sta_ps_statechange_ev_non_tlv,
  7559. .extract_peer_sta_kickout_ev = extract_peer_sta_kickout_ev_non_tlv,
  7560. .extract_peer_ratecode_list_ev = extract_peer_ratecode_list_ev_non_tlv,
  7561. .extract_comb_phyerr = extract_comb_phyerr_non_tlv,
  7562. .extract_single_phyerr = extract_single_phyerr_non_tlv,
  7563. .extract_composite_phyerr = extract_composite_phyerr_non_tlv,
  7564. .extract_rtt_hdr = extract_rtt_hdr_non_tlv,
  7565. .extract_rtt_ev = extract_rtt_ev_non_tlv,
  7566. .extract_rtt_error_report_ev = extract_rtt_error_report_ev_non_tlv,
  7567. .extract_all_stats_count = extract_all_stats_counts_non_tlv,
  7568. .extract_pdev_stats = extract_pdev_stats_non_tlv,
  7569. .extract_pdev_ext_stats = extract_pdev_ext_stats_non_tlv,
  7570. .extract_vdev_stats = extract_vdev_stats_non_tlv,
  7571. .extract_peer_stats = extract_peer_stats_non_tlv,
  7572. .extract_bcnflt_stats = extract_bcnflt_stats_non_tlv,
  7573. .extract_peer_extd_stats = extract_peer_extd_stats_non_tlv,
  7574. .extract_chan_stats = extract_chan_stats_non_tlv,
  7575. .extract_thermal_stats = extract_thermal_stats_non_tlv,
  7576. .extract_thermal_level_stats = extract_thermal_level_stats_non_tlv,
  7577. .extract_profile_ctx = extract_profile_ctx_non_tlv,
  7578. .extract_profile_data = extract_profile_data_non_tlv,
  7579. .extract_chan_info_event = extract_chan_info_event_non_tlv,
  7580. .extract_channel_hopping_event = extract_channel_hopping_event_non_tlv,
  7581. .extract_bss_chan_info_event = extract_bss_chan_info_event_non_tlv,
  7582. .extract_inst_rssi_stats_event = extract_inst_rssi_stats_event_non_tlv,
  7583. .extract_tx_data_traffic_ctrl_ev =
  7584. extract_tx_data_traffic_ctrl_ev_non_tlv,
  7585. .extract_vdev_extd_stats = extract_vdev_extd_stats_non_tlv,
  7586. .extract_fips_event_data = extract_fips_event_data_non_tlv,
  7587. .extract_mumimo_tx_count_ev_param =
  7588. extract_mumimo_tx_count_ev_param_non_tlv,
  7589. .extract_peer_gid_userpos_list_ev_param =
  7590. extract_peer_gid_userpos_list_ev_param_non_tlv,
  7591. .extract_pdev_caldata_version_check_ev_param =
  7592. extract_pdev_caldata_version_check_ev_param_non_tlv,
  7593. .extract_mu_db_entry = extract_mu_db_entry_non_tlv,
  7594. .extract_atf_peer_stats_ev = extract_atf_peer_stats_ev_non_tlv,
  7595. .extract_atf_token_info_ev = extract_atf_token_info_ev_non_tlv,
  7596. .extract_pdev_utf_event = extract_pdev_utf_event_non_tlv,
  7597. .wmi_set_htc_tx_tag = wmi_set_htc_tx_tag_non_tlv,
  7598. .is_management_record = is_management_record_non_tlv,
  7599. .send_dfs_phyerr_offload_en_cmd =
  7600. send_dfs_phyerr_offload_en_cmd_non_tlv,
  7601. .send_dfs_phyerr_offload_dis_cmd =
  7602. send_dfs_phyerr_offload_dis_cmd_non_tlv,
  7603. .send_wds_entry_list_cmd = send_wds_entry_list_cmd_non_tlv,
  7604. .extract_wds_entry = extract_wds_entry_non_tlv,
  7605. #ifdef WLAN_SUPPORT_FILS
  7606. .send_vdev_fils_enable_cmd = send_vdev_fils_enable_cmd_non_tlv,
  7607. .send_fils_discovery_send_cmd = send_fils_discovery_send_cmd_non_tlv,
  7608. .extract_swfda_vdev_id = extract_swfda_vdev_id_non_tlv,
  7609. #endif /* WLAN_SUPPORT_FILS */
  7610. };
  7611. /**
  7612. * populate_non_tlv_service() - populates wmi services
  7613. *
  7614. * @param wmi_service: Pointer to hold wmi_service
  7615. * Return: None
  7616. */
  7617. static void populate_non_tlv_service(uint32_t *wmi_service)
  7618. {
  7619. wmi_service[wmi_service_beacon_offload] = WMI_SERVICE_BEACON_OFFLOAD;
  7620. wmi_service[wmi_service_scan_offload] = WMI_SERVICE_SCAN_OFFLOAD;
  7621. wmi_service[wmi_service_roam_offload] = WMI_SERVICE_ROAM_OFFLOAD;
  7622. wmi_service[wmi_service_bcn_miss_offload] =
  7623. WMI_SERVICE_BCN_MISS_OFFLOAD;
  7624. wmi_service[wmi_service_sta_pwrsave] = WMI_SERVICE_STA_PWRSAVE;
  7625. wmi_service[wmi_service_sta_advanced_pwrsave] =
  7626. WMI_SERVICE_STA_ADVANCED_PWRSAVE;
  7627. wmi_service[wmi_service_ap_uapsd] = WMI_SERVICE_AP_UAPSD;
  7628. wmi_service[wmi_service_ap_dfs] = WMI_SERVICE_AP_DFS;
  7629. wmi_service[wmi_service_11ac] = WMI_SERVICE_11AC;
  7630. wmi_service[wmi_service_blockack] = WMI_SERVICE_BLOCKACK;
  7631. wmi_service[wmi_service_phyerr] = WMI_SERVICE_PHYERR;
  7632. wmi_service[wmi_service_bcn_filter] = WMI_SERVICE_BCN_FILTER;
  7633. wmi_service[wmi_service_rtt] = WMI_SERVICE_RTT;
  7634. wmi_service[wmi_service_ratectrl] = WMI_SERVICE_RATECTRL;
  7635. wmi_service[wmi_service_wow] = WMI_SERVICE_WOW;
  7636. wmi_service[wmi_service_ratectrl_cache] = WMI_SERVICE_RATECTRL_CACHE;
  7637. wmi_service[wmi_service_iram_tids] = WMI_SERVICE_IRAM_TIDS;
  7638. wmi_service[wmi_service_burst] = WMI_SERVICE_BURST;
  7639. wmi_service[wmi_service_smart_antenna_sw_support] =
  7640. WMI_SERVICE_SMART_ANTENNA_SW_SUPPORT;
  7641. wmi_service[wmi_service_gtk_offload] = WMI_SERVICE_GTK_OFFLOAD;
  7642. wmi_service[wmi_service_scan_sch] = WMI_SERVICE_SCAN_SCH;
  7643. wmi_service[wmi_service_csa_offload] = WMI_SERVICE_CSA_OFFLOAD;
  7644. wmi_service[wmi_service_chatter] = WMI_SERVICE_CHATTER;
  7645. wmi_service[wmi_service_coex_freqavoid] = WMI_SERVICE_COEX_FREQAVOID;
  7646. wmi_service[wmi_service_packet_power_save] =
  7647. WMI_SERVICE_PACKET_POWER_SAVE;
  7648. wmi_service[wmi_service_force_fw_hang] = WMI_SERVICE_FORCE_FW_HANG;
  7649. wmi_service[wmi_service_smart_antenna_hw_support] =
  7650. WMI_SERVICE_SMART_ANTENNA_HW_SUPPORT;
  7651. wmi_service[wmi_service_gpio] = WMI_SERVICE_GPIO;
  7652. wmi_service[wmi_sta_uapsd_basic_auto_trig] =
  7653. WMI_STA_UAPSD_BASIC_AUTO_TRIG;
  7654. wmi_service[wmi_sta_uapsd_var_auto_trig] = WMI_STA_UAPSD_VAR_AUTO_TRIG;
  7655. wmi_service[wmi_service_sta_keep_alive] = WMI_SERVICE_STA_KEEP_ALIVE;
  7656. wmi_service[wmi_service_tx_encap] = WMI_SERVICE_TX_ENCAP;
  7657. wmi_service[wmi_service_ap_ps_detect_out_of_sync] =
  7658. WMI_SERVICE_AP_PS_DETECT_OUT_OF_SYNC;
  7659. wmi_service[wmi_service_early_rx] =
  7660. WMI_SERVICE_EARLY_RX;
  7661. wmi_service[wmi_service_enhanced_proxy_sta] =
  7662. WMI_SERVICE_ENHANCED_PROXY_STA;
  7663. wmi_service[wmi_service_tt] = WMI_SERVICE_TT;
  7664. wmi_service[wmi_service_atf] = WMI_SERVICE_ATF;
  7665. wmi_service[wmi_service_peer_caching] = WMI_SERVICE_PEER_CACHING;
  7666. wmi_service[wmi_service_coex_gpio] = WMI_SERVICE_COEX_GPIO;
  7667. wmi_service[wmi_service_aux_spectral_intf] =
  7668. WMI_SERVICE_AUX_SPECTRAL_INTF;
  7669. wmi_service[wmi_service_aux_chan_load_intf] =
  7670. WMI_SERVICE_AUX_CHAN_LOAD_INTF;
  7671. wmi_service[wmi_service_bss_channel_info_64] =
  7672. WMI_SERVICE_BSS_CHANNEL_INFO_64;
  7673. wmi_service[wmi_service_ext_res_cfg_support] =
  7674. WMI_SERVICE_EXT_RES_CFG_SUPPORT;
  7675. wmi_service[wmi_service_mesh] = WMI_SERVICE_MESH;
  7676. wmi_service[wmi_service_restrt_chnl_support] =
  7677. WMI_SERVICE_RESTRT_CHNL_SUPPORT;
  7678. wmi_service[wmi_service_peer_stats] = WMI_SERVICE_PEER_STATS;
  7679. wmi_service[wmi_service_mesh_11s] = WMI_SERVICE_MESH_11S;
  7680. wmi_service[wmi_service_periodic_chan_stat_support] =
  7681. WMI_SERVICE_PERIODIC_CHAN_STAT_SUPPORT;
  7682. wmi_service[wmi_service_tx_mode_push_only] =
  7683. WMI_SERVICE_TX_MODE_PUSH_ONLY;
  7684. wmi_service[wmi_service_tx_mode_push_pull] =
  7685. WMI_SERVICE_TX_MODE_PUSH_PULL;
  7686. wmi_service[wmi_service_tx_mode_dynamic] = WMI_SERVICE_TX_MODE_DYNAMIC;
  7687. wmi_service[wmi_service_check_cal_version] =
  7688. WMI_SERVICE_CHECK_CAL_VERSION;
  7689. wmi_service[wmi_service_btcoex_duty_cycle] =
  7690. WMI_SERVICE_BTCOEX_DUTY_CYCLE;
  7691. wmi_service[wmi_service_4_wire_coex_support] =
  7692. WMI_SERVICE_4_WIRE_COEX_SUPPORT;
  7693. wmi_service[wmi_service_extended_nss_support] =
  7694. WMI_SERVICE_EXTENDED_NSS_SUPPORT;
  7695. wmi_service[wmi_service_roam_scan_offload] = WMI_SERVICE_UNAVAILABLE;
  7696. wmi_service[wmi_service_arpns_offload] = WMI_SERVICE_UNAVAILABLE;
  7697. wmi_service[wmi_service_nlo] = WMI_SERVICE_UNAVAILABLE;
  7698. wmi_service[wmi_service_sta_dtim_ps_modulated_dtim] =
  7699. WMI_SERVICE_UNAVAILABLE;
  7700. wmi_service[wmi_service_sta_smps] = WMI_SERVICE_UNAVAILABLE;
  7701. wmi_service[wmi_service_fwtest] = WMI_SERVICE_UNAVAILABLE;
  7702. wmi_service[wmi_service_sta_wmmac] = WMI_SERVICE_UNAVAILABLE;
  7703. wmi_service[wmi_service_tdls] = WMI_SERVICE_UNAVAILABLE;
  7704. wmi_service[wmi_service_mcc_bcn_interval_change] =
  7705. WMI_SERVICE_UNAVAILABLE;
  7706. wmi_service[wmi_service_adaptive_ocs] = WMI_SERVICE_UNAVAILABLE;
  7707. wmi_service[wmi_service_ba_ssn_support] = WMI_SERVICE_UNAVAILABLE;
  7708. wmi_service[wmi_service_filter_ipsec_natkeepalive] =
  7709. WMI_SERVICE_UNAVAILABLE;
  7710. wmi_service[wmi_service_wlan_hb] = WMI_SERVICE_UNAVAILABLE;
  7711. wmi_service[wmi_service_lte_ant_share_support] =
  7712. WMI_SERVICE_UNAVAILABLE;
  7713. wmi_service[wmi_service_batch_scan] = WMI_SERVICE_UNAVAILABLE;
  7714. wmi_service[wmi_service_qpower] = WMI_SERVICE_UNAVAILABLE;
  7715. wmi_service[wmi_service_plmreq] = WMI_SERVICE_UNAVAILABLE;
  7716. wmi_service[wmi_service_thermal_mgmt] = WMI_SERVICE_UNAVAILABLE;
  7717. wmi_service[wmi_service_rmc] = WMI_SERVICE_UNAVAILABLE;
  7718. wmi_service[wmi_service_mhf_offload] = WMI_SERVICE_UNAVAILABLE;
  7719. wmi_service[wmi_service_coex_sar] = WMI_SERVICE_UNAVAILABLE;
  7720. wmi_service[wmi_service_bcn_txrate_override] = WMI_SERVICE_UNAVAILABLE;
  7721. wmi_service[wmi_service_nan] = WMI_SERVICE_UNAVAILABLE;
  7722. wmi_service[wmi_service_l1ss_stat] = WMI_SERVICE_UNAVAILABLE;
  7723. wmi_service[wmi_service_estimate_linkspeed] = WMI_SERVICE_UNAVAILABLE;
  7724. wmi_service[wmi_service_obss_scan] = WMI_SERVICE_UNAVAILABLE;
  7725. wmi_service[wmi_service_tdls_offchan] = WMI_SERVICE_UNAVAILABLE;
  7726. wmi_service[wmi_service_tdls_uapsd_buffer_sta] =
  7727. WMI_SERVICE_UNAVAILABLE;
  7728. wmi_service[wmi_service_tdls_uapsd_sleep_sta] = WMI_SERVICE_UNAVAILABLE;
  7729. wmi_service[wmi_service_ibss_pwrsave] = WMI_SERVICE_UNAVAILABLE;
  7730. wmi_service[wmi_service_lpass] = WMI_SERVICE_UNAVAILABLE;
  7731. wmi_service[wmi_service_extscan] = WMI_SERVICE_UNAVAILABLE;
  7732. wmi_service[wmi_service_d0wow] = WMI_SERVICE_UNAVAILABLE;
  7733. wmi_service[wmi_service_hsoffload] = WMI_SERVICE_UNAVAILABLE;
  7734. wmi_service[wmi_service_roam_ho_offload] = WMI_SERVICE_UNAVAILABLE;
  7735. wmi_service[wmi_service_rx_full_reorder] = WMI_SERVICE_UNAVAILABLE;
  7736. wmi_service[wmi_service_dhcp_offload] = WMI_SERVICE_UNAVAILABLE;
  7737. wmi_service[wmi_service_sta_rx_ipa_offload_support] =
  7738. WMI_SERVICE_UNAVAILABLE;
  7739. wmi_service[wmi_service_mdns_offload] = WMI_SERVICE_UNAVAILABLE;
  7740. wmi_service[wmi_service_sap_auth_offload] = WMI_SERVICE_UNAVAILABLE;
  7741. wmi_service[wmi_service_dual_band_simultaneous_support] =
  7742. WMI_SERVICE_UNAVAILABLE;
  7743. wmi_service[wmi_service_ocb] = WMI_SERVICE_UNAVAILABLE;
  7744. wmi_service[wmi_service_ap_arpns_offload] = WMI_SERVICE_UNAVAILABLE;
  7745. wmi_service[wmi_service_per_band_chainmask_support] =
  7746. WMI_SERVICE_UNAVAILABLE;
  7747. wmi_service[wmi_service_packet_filter_offload] =
  7748. WMI_SERVICE_UNAVAILABLE;
  7749. wmi_service[wmi_service_mgmt_tx_htt] = WMI_SERVICE_UNAVAILABLE;
  7750. wmi_service[wmi_service_mgmt_tx_wmi] = WMI_SERVICE_UNAVAILABLE;
  7751. wmi_service[wmi_service_ext_msg] = WMI_SERVICE_UNAVAILABLE;
  7752. wmi_service[wmi_service_mawc] = WMI_SERVICE_UNAVAILABLE;
  7753. wmi_service[wmi_service_multiple_vdev_restart] =
  7754. WMI_SERVICE_UNAVAILABLE;
  7755. wmi_service[wmi_service_peer_assoc_conf] = WMI_SERVICE_UNAVAILABLE;
  7756. wmi_service[wmi_service_egap] = WMI_SERVICE_UNAVAILABLE;
  7757. wmi_service[wmi_service_sta_pmf_offload] = WMI_SERVICE_UNAVAILABLE;
  7758. wmi_service[wmi_service_unified_wow_capability] =
  7759. WMI_SERVICE_UNAVAILABLE;
  7760. wmi_service[wmi_service_enterprise_mesh] = WMI_SERVICE_UNAVAILABLE;
  7761. wmi_service[wmi_service_bpf_offload] = WMI_SERVICE_UNAVAILABLE;
  7762. wmi_service[wmi_service_sync_delete_cmds] = WMI_SERVICE_UNAVAILABLE;
  7763. wmi_service[wmi_service_ratectrl_limit_max_min_rates] =
  7764. WMI_SERVICE_UNAVAILABLE;
  7765. wmi_service[wmi_service_nan_data] = WMI_SERVICE_UNAVAILABLE;
  7766. wmi_service[wmi_service_nan_rtt] = WMI_SERVICE_UNAVAILABLE;
  7767. wmi_service[wmi_service_11ax] = WMI_SERVICE_UNAVAILABLE;
  7768. wmi_service[wmi_service_deprecated_replace] = WMI_SERVICE_UNAVAILABLE;
  7769. wmi_service[wmi_service_tdls_conn_tracker_in_host_mode] =
  7770. WMI_SERVICE_UNAVAILABLE;
  7771. wmi_service[wmi_service_enhanced_mcast_filter] =WMI_SERVICE_UNAVAILABLE;
  7772. wmi_service[wmi_service_half_rate_quarter_rate_support] =
  7773. WMI_SERVICE_UNAVAILABLE;
  7774. wmi_service[wmi_service_vdev_rx_filter] = WMI_SERVICE_UNAVAILABLE;
  7775. wmi_service[wmi_service_p2p_listen_offload_support] =
  7776. WMI_SERVICE_UNAVAILABLE;
  7777. wmi_service[wmi_service_mark_first_wakeup_packet] =
  7778. WMI_SERVICE_UNAVAILABLE;
  7779. wmi_service[wmi_service_multiple_mcast_filter_set] =
  7780. WMI_SERVICE_UNAVAILABLE;
  7781. wmi_service[wmi_service_host_managed_rx_reorder] =
  7782. WMI_SERVICE_UNAVAILABLE;
  7783. wmi_service[wmi_service_flash_rdwr_support] = WMI_SERVICE_UNAVAILABLE;
  7784. wmi_service[wmi_service_wlan_stats_report] = WMI_SERVICE_UNAVAILABLE;
  7785. wmi_service[wmi_service_tx_msdu_id_new_partition_support] =
  7786. WMI_SERVICE_UNAVAILABLE;
  7787. wmi_service[wmi_service_dfs_phyerr_offload] = WMI_SERVICE_UNAVAILABLE;
  7788. wmi_service[wmi_service_rcpi_support] = WMI_SERVICE_UNAVAILABLE;
  7789. wmi_service[wmi_service_fw_mem_dump_support] = WMI_SERVICE_UNAVAILABLE;
  7790. wmi_service[wmi_service_peer_stats_info] = WMI_SERVICE_UNAVAILABLE;
  7791. wmi_service[wmi_service_regulatory_db] = WMI_SERVICE_UNAVAILABLE;
  7792. wmi_service[wmi_service_11d_offload] = WMI_SERVICE_UNAVAILABLE;
  7793. wmi_service[wmi_service_hw_data_filtering] = WMI_SERVICE_UNAVAILABLE;
  7794. wmi_service[wmi_service_pkt_routing] = WMI_SERVICE_UNAVAILABLE;
  7795. wmi_service[wmi_service_offchan_tx_wmi] = WMI_SERVICE_UNAVAILABLE;
  7796. wmi_service[wmi_service_chan_load_info] = WMI_SERVICE_UNAVAILABLE;
  7797. wmi_service[wmi_service_ack_timeout] = WMI_SERVICE_UNAVAILABLE;
  7798. wmi_service[wmi_service_widebw_scan] = WMI_SERVICE_UNAVAILABLE;
  7799. wmi_service[wmi_service_support_dma] =
  7800. WMI_SERVICE_UNAVAILABLE;
  7801. }
  7802. /**
  7803. * populate_non_tlv_event_id() - populates wmi event ids
  7804. *
  7805. * @param event_ids: Pointer to hold event ids
  7806. * Return: None
  7807. */
  7808. static void populate_non_tlv_events_id(uint32_t *event_ids)
  7809. {
  7810. event_ids[wmi_service_ready_event_id] = WMI_SERVICE_READY_EVENTID;
  7811. event_ids[wmi_ready_event_id] = WMI_READY_EVENTID;
  7812. event_ids[wmi_dbg_msg_event_id] = WMI_DEBUG_MESG_EVENTID;
  7813. event_ids[wmi_scan_event_id] = WMI_SCAN_EVENTID;
  7814. event_ids[wmi_echo_event_id] = WMI_ECHO_EVENTID;
  7815. event_ids[wmi_update_stats_event_id] = WMI_UPDATE_STATS_EVENTID;
  7816. event_ids[wmi_inst_rssi_stats_event_id] = WMI_INST_RSSI_STATS_EVENTID;
  7817. event_ids[wmi_vdev_start_resp_event_id] = WMI_VDEV_START_RESP_EVENTID;
  7818. event_ids[wmi_vdev_standby_req_event_id] = WMI_VDEV_STANDBY_REQ_EVENTID;
  7819. event_ids[wmi_vdev_resume_req_event_id] = WMI_VDEV_RESUME_REQ_EVENTID;
  7820. event_ids[wmi_vdev_stopped_event_id] = WMI_VDEV_STOPPED_EVENTID;
  7821. event_ids[wmi_peer_sta_kickout_event_id] = WMI_PEER_STA_KICKOUT_EVENTID;
  7822. event_ids[wmi_host_swba_event_id] = WMI_HOST_SWBA_EVENTID;
  7823. event_ids[wmi_tbttoffset_update_event_id] =
  7824. WMI_TBTTOFFSET_UPDATE_EVENTID;
  7825. event_ids[wmi_mgmt_rx_event_id] = WMI_MGMT_RX_EVENTID;
  7826. event_ids[wmi_chan_info_event_id] = WMI_CHAN_INFO_EVENTID;
  7827. event_ids[wmi_phyerr_event_id] = WMI_PHYERR_EVENTID;
  7828. event_ids[wmi_roam_event_id] = WMI_ROAM_EVENTID;
  7829. event_ids[wmi_profile_match] = WMI_PROFILE_MATCH;
  7830. event_ids[wmi_debug_print_event_id] = WMI_DEBUG_PRINT_EVENTID;
  7831. event_ids[wmi_pdev_qvit_event_id] = WMI_PDEV_QVIT_EVENTID;
  7832. event_ids[wmi_wlan_profile_data_event_id] =
  7833. WMI_WLAN_PROFILE_DATA_EVENTID;
  7834. event_ids[wmi_rtt_meas_report_event_id] =
  7835. WMI_RTT_MEASUREMENT_REPORT_EVENTID;
  7836. event_ids[wmi_tsf_meas_report_event_id] =
  7837. WMI_TSF_MEASUREMENT_REPORT_EVENTID;
  7838. event_ids[wmi_rtt_error_report_event_id] = WMI_RTT_ERROR_REPORT_EVENTID;
  7839. event_ids[wmi_rtt_keepalive_event_id] = WMI_RTT_KEEPALIVE_EVENTID;
  7840. event_ids[wmi_oem_cap_event_id] = WMI_OEM_CAPABILITY_EVENTID;
  7841. event_ids[wmi_oem_meas_report_event_id] =
  7842. WMI_OEM_MEASUREMENT_REPORT_EVENTID;
  7843. event_ids[wmi_oem_report_event_id] = WMI_OEM_ERROR_REPORT_EVENTID;
  7844. event_ids[wmi_nan_event_id] = WMI_NAN_EVENTID;
  7845. event_ids[wmi_wow_wakeup_host_event_id] = WMI_WOW_WAKEUP_HOST_EVENTID;
  7846. event_ids[wmi_gtk_offload_status_event_id] =
  7847. WMI_GTK_OFFLOAD_STATUS_EVENTID;
  7848. event_ids[wmi_gtk_rekey_fail_event_id] = WMI_GTK_REKEY_FAIL_EVENTID;
  7849. event_ids[wmi_dcs_interference_event_id] = WMI_DCS_INTERFERENCE_EVENTID;
  7850. event_ids[wmi_pdev_tpc_config_event_id] = WMI_PDEV_TPC_CONFIG_EVENTID;
  7851. event_ids[wmi_csa_handling_event_id] = WMI_CSA_HANDLING_EVENTID;
  7852. event_ids[wmi_gpio_input_event_id] = WMI_GPIO_INPUT_EVENTID;
  7853. event_ids[wmi_peer_ratecode_list_event_id] =
  7854. WMI_PEER_RATECODE_LIST_EVENTID;
  7855. event_ids[wmi_generic_buffer_event_id] = WMI_GENERIC_BUFFER_EVENTID;
  7856. event_ids[wmi_mcast_buf_release_event_id] =
  7857. WMI_MCAST_BUF_RELEASE_EVENTID;
  7858. event_ids[wmi_mcast_list_ageout_event_id] =
  7859. WMI_MCAST_LIST_AGEOUT_EVENTID;
  7860. event_ids[wmi_vdev_get_keepalive_event_id] =
  7861. WMI_VDEV_GET_KEEPALIVE_EVENTID;
  7862. event_ids[wmi_wds_peer_event_id] = WMI_WDS_PEER_EVENTID;
  7863. event_ids[wmi_peer_sta_ps_statechg_event_id] =
  7864. WMI_PEER_STA_PS_STATECHG_EVENTID;
  7865. event_ids[wmi_pdev_fips_event_id] = WMI_PDEV_FIPS_EVENTID;
  7866. event_ids[wmi_tt_stats_event_id] = WMI_TT_STATS_EVENTID;
  7867. event_ids[wmi_pdev_channel_hopping_event_id] =
  7868. WMI_PDEV_CHANNEL_HOPPING_EVENTID;
  7869. event_ids[wmi_pdev_ani_cck_level_event_id] =
  7870. WMI_PDEV_ANI_CCK_LEVEL_EVENTID;
  7871. event_ids[wmi_pdev_ani_ofdm_level_event_id] =
  7872. WMI_PDEV_ANI_OFDM_LEVEL_EVENTID;
  7873. event_ids[wmi_pdev_reserve_ast_entry_event_id] =
  7874. WMI_PDEV_RESERVE_AST_ENTRY_EVENTID;
  7875. event_ids[wmi_pdev_nfcal_power_event_id] = WMI_PDEV_NFCAL_POWER_EVENTID;
  7876. event_ids[wmi_pdev_tpc_event_id] = WMI_PDEV_TPC_EVENTID;
  7877. event_ids[wmi_pdev_get_ast_info_event_id] =
  7878. WMI_PDEV_GET_AST_INFO_EVENTID;
  7879. event_ids[wmi_pdev_temperature_event_id] = WMI_PDEV_TEMPERATURE_EVENTID;
  7880. event_ids[wmi_pdev_nfcal_power_all_channels_event_id] =
  7881. WMI_PDEV_NFCAL_POWER_ALL_CHANNELS_EVENTID;
  7882. event_ids[wmi_pdev_bss_chan_info_event_id] =
  7883. WMI_PDEV_BSS_CHAN_INFO_EVENTID;
  7884. event_ids[wmi_mu_report_event_id] = WMI_MU_REPORT_EVENTID;
  7885. event_ids[wmi_tx_data_traffic_ctrl_event_id] =
  7886. WMI_TX_DATA_TRAFFIC_CTRL_EVENTID;
  7887. event_ids[wmi_pdev_utf_event_id] = WMI_PDEV_UTF_EVENTID;
  7888. event_ids[wmi_peer_tx_mu_txmit_count_event_id] =
  7889. WMI_PEER_TX_MU_TXMIT_COUNT_EVENTID;
  7890. event_ids[wmi_peer_gid_userpos_list_event_id] =
  7891. WMI_PEER_GID_USERPOS_LIST_EVENTID;
  7892. event_ids[wmi_pdev_check_cal_version_event_id] =
  7893. WMI_PDEV_CHECK_CAL_VERSION_EVENTID;
  7894. event_ids[wmi_atf_peer_stats_event_id] =
  7895. WMI_ATF_PEER_STATS_EVENTID;
  7896. event_ids[wmi_pdev_wds_entry_list_event_id] =
  7897. WMI_PDEV_WDS_ENTRY_LIST_EVENTID;
  7898. event_ids[wmi_host_swfda_event_id] = WMI_HOST_SWFDA_EVENTID;
  7899. }
  7900. /**
  7901. * populate_pdev_param_non_tlv() - populates pdev params
  7902. *
  7903. * @param pdev_param: Pointer to hold pdev params
  7904. * Return: None
  7905. */
  7906. static void populate_pdev_param_non_tlv(uint32_t *pdev_param)
  7907. {
  7908. pdev_param[wmi_pdev_param_tx_chain_mask] = WMI_PDEV_PARAM_TX_CHAIN_MASK;
  7909. pdev_param[wmi_pdev_param_rx_chain_mask] = WMI_PDEV_PARAM_RX_CHAIN_MASK;
  7910. pdev_param[wmi_pdev_param_txpower_limit2g] =
  7911. WMI_PDEV_PARAM_TXPOWER_LIMIT2G;
  7912. pdev_param[wmi_pdev_param_txpower_limit5g] =
  7913. WMI_PDEV_PARAM_TXPOWER_LIMIT5G;
  7914. pdev_param[wmi_pdev_param_txpower_scale] = WMI_PDEV_PARAM_TXPOWER_SCALE;
  7915. pdev_param[wmi_pdev_param_beacon_gen_mode] =
  7916. WMI_PDEV_PARAM_BEACON_GEN_MODE;
  7917. pdev_param[wmi_pdev_param_beacon_tx_mode] =
  7918. WMI_PDEV_PARAM_BEACON_TX_MODE;
  7919. pdev_param[wmi_pdev_param_resmgr_offchan_mode] =
  7920. WMI_PDEV_PARAM_RESMGR_OFFCHAN_MODE;
  7921. pdev_param[wmi_pdev_param_protection_mode] =
  7922. WMI_PDEV_PARAM_PROTECTION_MODE;
  7923. pdev_param[wmi_pdev_param_dynamic_bw] = WMI_PDEV_PARAM_DYNAMIC_BW;
  7924. pdev_param[wmi_pdev_param_non_agg_sw_retry_th] =
  7925. WMI_PDEV_PARAM_NON_AGG_SW_RETRY_TH;
  7926. pdev_param[wmi_pdev_param_agg_sw_retry_th] =
  7927. WMI_PDEV_PARAM_AGG_SW_RETRY_TH;
  7928. pdev_param[wmi_pdev_param_sta_kickout_th] =
  7929. WMI_PDEV_PARAM_STA_KICKOUT_TH;
  7930. pdev_param[wmi_pdev_param_ac_aggrsize_scaling] =
  7931. WMI_PDEV_PARAM_AC_AGGRSIZE_SCALING;
  7932. pdev_param[wmi_pdev_param_ltr_enable] = WMI_PDEV_PARAM_LTR_ENABLE;
  7933. pdev_param[wmi_pdev_param_ltr_ac_latency_be] =
  7934. WMI_PDEV_PARAM_LTR_AC_LATENCY_BE;
  7935. pdev_param[wmi_pdev_param_ltr_ac_latency_bk] =
  7936. WMI_PDEV_PARAM_LTR_AC_LATENCY_BK;
  7937. pdev_param[wmi_pdev_param_ltr_ac_latency_vi] =
  7938. WMI_PDEV_PARAM_LTR_AC_LATENCY_VI;
  7939. pdev_param[wmi_pdev_param_ltr_ac_latency_vo] =
  7940. WMI_PDEV_PARAM_LTR_AC_LATENCY_VO;
  7941. pdev_param[wmi_pdev_param_ltr_ac_latency_timeout] =
  7942. WMI_PDEV_PARAM_LTR_AC_LATENCY_TIMEOUT;
  7943. pdev_param[wmi_pdev_param_ltr_sleep_override] =
  7944. WMI_PDEV_PARAM_LTR_SLEEP_OVERRIDE;
  7945. pdev_param[wmi_pdev_param_ltr_rx_override] =
  7946. WMI_PDEV_PARAM_LTR_RX_OVERRIDE;
  7947. pdev_param[wmi_pdev_param_ltr_tx_activity_timeout] =
  7948. WMI_PDEV_PARAM_LTR_TX_ACTIVITY_TIMEOUT;
  7949. pdev_param[wmi_pdev_param_l1ss_enable] = WMI_PDEV_PARAM_L1SS_ENABLE;
  7950. pdev_param[wmi_pdev_param_dsleep_enable] = WMI_PDEV_PARAM_DSLEEP_ENABLE;
  7951. pdev_param[wmi_pdev_param_pcielp_txbuf_flush] =
  7952. WMI_PDEV_PARAM_PCIELP_TXBUF_FLUSH;
  7953. pdev_param[wmi_pdev_param_pcielp_txbuf_watermark] =
  7954. WMI_PDEV_PARAM_PCIELP_TXBUF_WATERMARK;
  7955. pdev_param[wmi_pdev_param_pcielp_txbuf_tmo_en] =
  7956. WMI_PDEV_PARAM_PCIELP_TXBUF_TMO_EN;
  7957. pdev_param[wmi_pdev_param_pcielp_txbuf_tmo_value] =
  7958. WMI_PDEV_PARAM_PCIELP_TXBUF_TMO_VALUE;
  7959. pdev_param[wmi_pdev_param_pdev_stats_update_period] =
  7960. WMI_PDEV_PARAM_PDEV_STATS_UPDATE_PERIOD;
  7961. pdev_param[wmi_pdev_param_vdev_stats_update_period] =
  7962. WMI_PDEV_PARAM_VDEV_STATS_UPDATE_PERIOD;
  7963. pdev_param[wmi_pdev_param_peer_stats_update_period] =
  7964. WMI_PDEV_PARAM_PEER_STATS_UPDATE_PERIOD;
  7965. pdev_param[wmi_pdev_param_bcnflt_stats_update_period] =
  7966. WMI_PDEV_PARAM_BCNFLT_STATS_UPDATE_PERIOD;
  7967. pdev_param[wmi_pdev_param_pmf_qos] =
  7968. WMI_PDEV_PARAM_PMF_QOS;
  7969. pdev_param[wmi_pdev_param_arp_ac_override] =
  7970. WMI_PDEV_PARAM_ARP_AC_OVERRIDE;
  7971. pdev_param[wmi_pdev_param_dcs] =
  7972. WMI_PDEV_PARAM_DCS;
  7973. pdev_param[wmi_pdev_param_ani_enable] = WMI_PDEV_PARAM_ANI_ENABLE;
  7974. pdev_param[wmi_pdev_param_ani_poll_period] =
  7975. WMI_PDEV_PARAM_ANI_POLL_PERIOD;
  7976. pdev_param[wmi_pdev_param_ani_listen_period] =
  7977. WMI_PDEV_PARAM_ANI_LISTEN_PERIOD;
  7978. pdev_param[wmi_pdev_param_ani_ofdm_level] =
  7979. WMI_PDEV_PARAM_ANI_OFDM_LEVEL;
  7980. pdev_param[wmi_pdev_param_ani_cck_level] = WMI_PDEV_PARAM_ANI_CCK_LEVEL;
  7981. pdev_param[wmi_pdev_param_dyntxchain] = WMI_PDEV_PARAM_DYNTXCHAIN;
  7982. pdev_param[wmi_pdev_param_proxy_sta] = WMI_PDEV_PARAM_PROXY_STA;
  7983. pdev_param[wmi_pdev_param_idle_ps_config] =
  7984. WMI_PDEV_PARAM_IDLE_PS_CONFIG;
  7985. pdev_param[wmi_pdev_param_power_gating_sleep] =
  7986. WMI_PDEV_PARAM_POWER_GATING_SLEEP;
  7987. pdev_param[wmi_pdev_param_aggr_burst] = WMI_PDEV_PARAM_AGGR_BURST;
  7988. pdev_param[wmi_pdev_param_rx_decap_mode] = WMI_PDEV_PARAM_RX_DECAP_MODE;
  7989. pdev_param[wmi_pdev_param_fast_channel_reset] =
  7990. WMI_PDEV_PARAM_FAST_CHANNEL_RESET;
  7991. pdev_param[wmi_pdev_param_burst_dur] = WMI_PDEV_PARAM_BURST_DUR;
  7992. pdev_param[wmi_pdev_param_burst_enable] = WMI_PDEV_PARAM_BURST_ENABLE;
  7993. pdev_param[wmi_pdev_param_smart_antenna_default_antenna] =
  7994. WMI_PDEV_PARAM_SMART_ANTENNA_DEFAULT_ANTENNA;
  7995. pdev_param[wmi_pdev_param_igmpmld_override] =
  7996. WMI_PDEV_PARAM_IGMPMLD_OVERRIDE;
  7997. pdev_param[wmi_pdev_param_igmpmld_tid] =
  7998. WMI_PDEV_PARAM_IGMPMLD_TID;
  7999. pdev_param[wmi_pdev_param_antenna_gain] = WMI_PDEV_PARAM_ANTENNA_GAIN;
  8000. pdev_param[wmi_pdev_param_rx_filter] = WMI_PDEV_PARAM_RX_FILTER;
  8001. pdev_param[wmi_pdev_set_mcast_to_ucast_tid] =
  8002. WMI_PDEV_SET_MCAST_TO_UCAST_TID;
  8003. pdev_param[wmi_pdev_param_proxy_sta_mode] =
  8004. WMI_PDEV_PARAM_PROXY_STA_MODE;
  8005. pdev_param[wmi_pdev_param_set_mcast2ucast_mode] =
  8006. WMI_PDEV_PARAM_SET_MCAST2UCAST_MODE;
  8007. pdev_param[wmi_pdev_param_set_mcast2ucast_buffer] =
  8008. WMI_PDEV_PARAM_SET_MCAST2UCAST_BUFFER;
  8009. pdev_param[wmi_pdev_param_remove_mcast2ucast_buffer] =
  8010. WMI_PDEV_PARAM_REMOVE_MCAST2UCAST_BUFFER;
  8011. pdev_param[wmi_pdev_peer_sta_ps_statechg_enable] =
  8012. WMI_PDEV_PEER_STA_PS_STATECHG_ENABLE;
  8013. pdev_param[wmi_pdev_param_igmpmld_ac_override] =
  8014. WMI_PDEV_PARAM_IGMPMLD_AC_OVERRIDE;
  8015. pdev_param[wmi_pdev_param_block_interbss] =
  8016. WMI_PDEV_PARAM_BLOCK_INTERBSS;
  8017. pdev_param[wmi_pdev_param_set_disable_reset_cmdid] =
  8018. WMI_PDEV_PARAM_SET_DISABLE_RESET_CMDID;
  8019. pdev_param[wmi_pdev_param_set_msdu_ttl_cmdid] =
  8020. WMI_PDEV_PARAM_SET_MSDU_TTL_CMDID;
  8021. pdev_param[wmi_pdev_param_set_ppdu_duration_cmdid] =
  8022. WMI_PDEV_PARAM_SET_PPDU_DURATION_CMDID;
  8023. pdev_param[wmi_pdev_param_txbf_sound_period_cmdid] =
  8024. WMI_PDEV_PARAM_TXBF_SOUND_PERIOD_CMDID;
  8025. pdev_param[wmi_pdev_param_set_promisc_mode_cmdid] =
  8026. WMI_PDEV_PARAM_SET_PROMISC_MODE_CMDID;
  8027. pdev_param[wmi_pdev_param_set_burst_mode_cmdid] =
  8028. WMI_PDEV_PARAM_SET_BURST_MODE_CMDID;
  8029. pdev_param[wmi_pdev_param_en_stats] = WMI_PDEV_PARAM_EN_STATS;
  8030. pdev_param[wmi_pdev_param_mu_group_policy] =
  8031. WMI_PDEV_PARAM_MU_GROUP_POLICY;
  8032. pdev_param[wmi_pdev_param_noise_detection] =
  8033. WMI_PDEV_PARAM_NOISE_DETECTION;
  8034. pdev_param[wmi_pdev_param_noise_threshold] =
  8035. WMI_PDEV_PARAM_NOISE_THRESHOLD;
  8036. pdev_param[wmi_pdev_param_dpd_enable] =
  8037. WMI_PDEV_PARAM_DPD_ENABLE;
  8038. pdev_param[wmi_pdev_param_set_mcast_bcast_echo] =
  8039. WMI_PDEV_PARAM_SET_MCAST_BCAST_ECHO;
  8040. pdev_param[wmi_pdev_param_atf_strict_sch] =
  8041. WMI_PDEV_PARAM_ATF_STRICT_SCH;
  8042. pdev_param[wmi_pdev_param_atf_sched_duration] =
  8043. WMI_PDEV_PARAM_ATF_SCHED_DURATION;
  8044. pdev_param[wmi_pdev_param_ant_plzn] = WMI_PDEV_PARAM_ANT_PLZN;
  8045. pdev_param[wmi_pdev_param_mgmt_retry_limit] =
  8046. WMI_PDEV_PARAM_MGMT_RETRY_LIMIT;
  8047. pdev_param[wmi_pdev_param_sensitivity_level] =
  8048. WMI_PDEV_PARAM_SENSITIVITY_LEVEL;
  8049. pdev_param[wmi_pdev_param_signed_txpower_2g] =
  8050. WMI_PDEV_PARAM_SIGNED_TXPOWER_2G;
  8051. pdev_param[wmi_pdev_param_signed_txpower_5g] =
  8052. WMI_PDEV_PARAM_SIGNED_TXPOWER_5G;
  8053. pdev_param[wmi_pdev_param_enable_per_tid_amsdu] =
  8054. WMI_PDEV_PARAM_ENABLE_PER_TID_AMSDU;
  8055. pdev_param[wmi_pdev_param_enable_per_tid_ampdu] =
  8056. WMI_PDEV_PARAM_ENABLE_PER_TID_AMPDU;
  8057. pdev_param[wmi_pdev_param_cca_threshold] = WMI_PDEV_PARAM_CCA_THRESHOLD;
  8058. pdev_param[wmi_pdev_param_rts_fixed_rate] =
  8059. WMI_PDEV_PARAM_RTS_FIXED_RATE;
  8060. pdev_param[wmi_pdev_param_cal_period] = WMI_PDEV_PARAM_CAL_PERIOD;
  8061. pdev_param[wmi_pdev_param_pdev_reset] = WMI_PDEV_PARAM_PDEV_RESET;
  8062. pdev_param[wmi_pdev_param_wapi_mbssid_offset] =
  8063. WMI_PDEV_PARAM_WAPI_MBSSID_OFFSET;
  8064. pdev_param[wmi_pdev_param_arp_srcaddr] = WMI_PDEV_PARAM_ARP_SRCADDR;
  8065. pdev_param[wmi_pdev_param_arp_dstaddr] = WMI_PDEV_PARAM_ARP_DSTADDR;
  8066. pdev_param[wmi_pdev_param_txpower_decr_db] =
  8067. WMI_PDEV_PARAM_TXPOWER_DECR_DB;
  8068. pdev_param[wmi_pdev_param_rx_batchmode] = WMI_PDEV_PARAM_RX_BATCHMODE;
  8069. pdev_param[wmi_pdev_param_packet_aggr_delay] =
  8070. WMI_PDEV_PARAM_PACKET_AGGR_DELAY;
  8071. pdev_param[wmi_pdev_param_atf_obss_noise_sch] =
  8072. WMI_PDEV_PARAM_ATF_OBSS_NOISE_SCH;
  8073. pdev_param[wmi_pdev_param_atf_obss_noise_scaling_factor] =
  8074. WMI_PDEV_PARAM_ATF_OBSS_NOISE_SCALING_FACTOR;
  8075. pdev_param[wmi_pdev_param_cust_txpower_scale] =
  8076. WMI_PDEV_PARAM_CUST_TXPOWER_SCALE;
  8077. pdev_param[wmi_pdev_param_atf_dynamic_enable] =
  8078. WMI_PDEV_PARAM_ATF_DYNAMIC_ENABLE;
  8079. pdev_param[wmi_pdev_param_atf_ssid_group_policy] =
  8080. WMI_PDEV_PARAM_ATF_SSID_GROUP_POLICY;
  8081. pdev_param[wmi_pdev_param_enable_btcoex] =
  8082. WMI_PDEV_PARAM_ENABLE_BTCOEX;
  8083. pdev_param[wmi_pdev_param_atf_peer_stats] =
  8084. WMI_PDEV_PARAM_ATF_PEER_STATS;
  8085. pdev_param[wmi_pdev_param_tx_ack_timeout] = WMI_UNAVAILABLE_PARAM;
  8086. pdev_param[wmi_pdev_param_soft_tx_chain_mask] =
  8087. WMI_PDEV_PARAM_SOFT_TX_CHAIN_MASK;
  8088. pdev_param[wmi_pdev_param_rfkill_enable] = WMI_UNAVAILABLE_PARAM;
  8089. pdev_param[wmi_pdev_param_hw_rfkill_config] = WMI_UNAVAILABLE_PARAM;
  8090. pdev_param[wmi_pdev_param_low_power_rf_enable] = WMI_UNAVAILABLE_PARAM;
  8091. pdev_param[wmi_pdev_param_l1ss_track] = WMI_UNAVAILABLE_PARAM;
  8092. pdev_param[wmi_pdev_param_hyst_en] = WMI_UNAVAILABLE_PARAM;
  8093. pdev_param[wmi_pdev_param_power_collapse_enable] =
  8094. WMI_UNAVAILABLE_PARAM;
  8095. pdev_param[wmi_pdev_param_led_sys_state] = WMI_UNAVAILABLE_PARAM;
  8096. pdev_param[wmi_pdev_param_led_enable] = WMI_UNAVAILABLE_PARAM;
  8097. pdev_param[wmi_pdev_param_audio_over_wlan_latency] =
  8098. WMI_UNAVAILABLE_PARAM;
  8099. pdev_param[wmi_pdev_param_audio_over_wlan_enable] =
  8100. WMI_UNAVAILABLE_PARAM;
  8101. pdev_param[wmi_pdev_param_whal_mib_stats_update_enable] =
  8102. WMI_UNAVAILABLE_PARAM;
  8103. pdev_param[wmi_pdev_param_vdev_rate_stats_update_period] =
  8104. WMI_UNAVAILABLE_PARAM;
  8105. pdev_param[wmi_pdev_param_cts_cbw] = WMI_UNAVAILABLE_PARAM;
  8106. pdev_param[wmi_pdev_param_wnts_config] = WMI_UNAVAILABLE_PARAM;
  8107. pdev_param[wmi_pdev_param_adaptive_early_rx_enable] =
  8108. WMI_UNAVAILABLE_PARAM;
  8109. pdev_param[wmi_pdev_param_adaptive_early_rx_min_sleep_slop] =
  8110. WMI_UNAVAILABLE_PARAM;
  8111. pdev_param[wmi_pdev_param_adaptive_early_rx_inc_dec_step] =
  8112. WMI_UNAVAILABLE_PARAM;
  8113. pdev_param[wmi_pdev_param_early_rx_fix_sleep_slop] =
  8114. WMI_UNAVAILABLE_PARAM;
  8115. pdev_param[wmi_pdev_param_bmiss_based_adaptive_bto_enable] =
  8116. WMI_UNAVAILABLE_PARAM;
  8117. pdev_param[wmi_pdev_param_bmiss_bto_min_bcn_timeout] =
  8118. WMI_UNAVAILABLE_PARAM;
  8119. pdev_param[wmi_pdev_param_bmiss_bto_inc_dec_step] =
  8120. WMI_UNAVAILABLE_PARAM;
  8121. pdev_param[wmi_pdev_param_bto_fix_bcn_timeout] =
  8122. WMI_UNAVAILABLE_PARAM;
  8123. pdev_param[wmi_pdev_param_ce_based_adaptive_bto_enable] =
  8124. WMI_UNAVAILABLE_PARAM;
  8125. pdev_param[wmi_pdev_param_ce_bto_combo_ce_value] =
  8126. WMI_UNAVAILABLE_PARAM;
  8127. pdev_param[wmi_pdev_param_tx_chain_mask_2g] = WMI_UNAVAILABLE_PARAM;
  8128. pdev_param[wmi_pdev_param_rx_chain_mask_2g] = WMI_UNAVAILABLE_PARAM;
  8129. pdev_param[wmi_pdev_param_tx_chain_mask_5g] = WMI_UNAVAILABLE_PARAM;
  8130. pdev_param[wmi_pdev_param_rx_chain_mask_5g] = WMI_UNAVAILABLE_PARAM;
  8131. pdev_param[wmi_pdev_param_tx_chain_mask_cck] = WMI_UNAVAILABLE_PARAM;
  8132. pdev_param[wmi_pdev_param_tx_chain_mask_1ss] = WMI_UNAVAILABLE_PARAM;
  8133. }
  8134. /**
  8135. * populate_vdev_param_non_tlv() - populates vdev params
  8136. *
  8137. * @param vdev_param: Pointer to hold vdev params
  8138. * Return: None
  8139. */
  8140. static void populate_vdev_param_non_tlv(uint32_t *vdev_param)
  8141. {
  8142. vdev_param[wmi_vdev_param_rts_threshold] = WMI_VDEV_PARAM_RTS_THRESHOLD;
  8143. vdev_param[wmi_vdev_param_fragmentation_threshold] =
  8144. WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD;
  8145. vdev_param[wmi_vdev_param_beacon_interval] =
  8146. WMI_VDEV_PARAM_BEACON_INTERVAL;
  8147. vdev_param[wmi_vdev_param_listen_interval] =
  8148. WMI_VDEV_PARAM_LISTEN_INTERVAL;
  8149. vdev_param[wmi_vdev_param_multicast_rate] =
  8150. WMI_VDEV_PARAM_MULTICAST_RATE;
  8151. vdev_param[wmi_vdev_param_mgmt_tx_rate] =
  8152. WMI_VDEV_PARAM_MGMT_TX_RATE;
  8153. vdev_param[wmi_vdev_param_slot_time] = WMI_VDEV_PARAM_SLOT_TIME;
  8154. vdev_param[wmi_vdev_param_preamble] = WMI_VDEV_PARAM_PREAMBLE;
  8155. vdev_param[wmi_vdev_param_swba_time] = WMI_VDEV_PARAM_SWBA_TIME;
  8156. vdev_param[wmi_vdev_stats_update_period] = WMI_VDEV_STATS_UPDATE_PERIOD;
  8157. vdev_param[wmi_vdev_pwrsave_ageout_time] = WMI_VDEV_PWRSAVE_AGEOUT_TIME;
  8158. vdev_param[wmi_vdev_host_swba_interval] = WMI_VDEV_HOST_SWBA_INTERVAL;
  8159. vdev_param[wmi_vdev_param_dtim_period] = WMI_VDEV_PARAM_DTIM_PERIOD;
  8160. vdev_param[wmi_vdev_oc_scheduler_air_time_limit] =
  8161. WMI_VDEV_OC_SCHEDULER_AIR_TIME_LIMIT;
  8162. vdev_param[wmi_vdev_param_wds] = WMI_VDEV_PARAM_WDS;
  8163. vdev_param[wmi_vdev_param_atim_window] = WMI_VDEV_PARAM_ATIM_WINDOW;
  8164. vdev_param[wmi_vdev_param_bmiss_count_max] =
  8165. WMI_VDEV_PARAM_BMISS_COUNT_MAX;
  8166. vdev_param[wmi_vdev_param_bmiss_first_bcnt] =
  8167. WMI_VDEV_PARAM_BMISS_FIRST_BCNT;
  8168. vdev_param[wmi_vdev_param_bmiss_final_bcnt] =
  8169. WMI_VDEV_PARAM_BMISS_FINAL_BCNT;
  8170. vdev_param[wmi_vdev_param_feature_wmm] = WMI_VDEV_PARAM_FEATURE_WMM;
  8171. vdev_param[wmi_vdev_param_chwidth] = WMI_VDEV_PARAM_CHWIDTH;
  8172. vdev_param[wmi_vdev_param_chextoffset] = WMI_VDEV_PARAM_CHEXTOFFSET;
  8173. vdev_param[wmi_vdev_param_disable_htprotection] =
  8174. WMI_VDEV_PARAM_DISABLE_HTPROTECTION;
  8175. vdev_param[wmi_vdev_param_sta_quickkickout] =
  8176. WMI_VDEV_PARAM_STA_QUICKKICKOUT;
  8177. vdev_param[wmi_vdev_param_mgmt_rate] = WMI_VDEV_PARAM_MGMT_RATE;
  8178. vdev_param[wmi_vdev_param_protection_mode] =
  8179. WMI_VDEV_PARAM_PROTECTION_MODE;
  8180. vdev_param[wmi_vdev_param_fixed_rate] = WMI_VDEV_PARAM_FIXED_RATE;
  8181. vdev_param[wmi_vdev_param_sgi] = WMI_VDEV_PARAM_SGI;
  8182. vdev_param[wmi_vdev_param_ldpc] = WMI_VDEV_PARAM_LDPC;
  8183. vdev_param[wmi_vdev_param_tx_stbc] = WMI_VDEV_PARAM_TX_STBC;
  8184. vdev_param[wmi_vdev_param_rx_stbc] = WMI_VDEV_PARAM_RX_STBC;
  8185. vdev_param[wmi_vdev_param_intra_bss_fwd] = WMI_VDEV_PARAM_INTRA_BSS_FWD;
  8186. vdev_param[wmi_vdev_param_def_keyid] = WMI_VDEV_PARAM_DEF_KEYID;
  8187. vdev_param[wmi_vdev_param_nss] = WMI_VDEV_PARAM_NSS;
  8188. vdev_param[wmi_vdev_param_bcast_data_rate] =
  8189. WMI_VDEV_PARAM_BCAST_DATA_RATE;
  8190. vdev_param[wmi_vdev_param_mcast_data_rate] =
  8191. WMI_VDEV_PARAM_MCAST_DATA_RATE;
  8192. vdev_param[wmi_vdev_param_mcast_indicate] =
  8193. WMI_VDEV_PARAM_MCAST_INDICATE;
  8194. vdev_param[wmi_vdev_param_dhcp_indicate] = WMI_VDEV_PARAM_DHCP_INDICATE;
  8195. vdev_param[wmi_vdev_param_unknown_dest_indicate] =
  8196. WMI_VDEV_PARAM_UNKNOWN_DEST_INDICATE;
  8197. vdev_param[wmi_vdev_param_ap_keepalive_min_idle_inactive_time_secs] =
  8198. WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS;
  8199. vdev_param[wmi_vdev_param_ap_keepalive_max_idle_inactive_time_secs] =
  8200. WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS;
  8201. vdev_param[wmi_vdev_param_ap_keepalive_max_unresponsive_time_secs] =
  8202. WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS;
  8203. vdev_param[wmi_vdev_param_ap_enable_nawds] =
  8204. WMI_VDEV_PARAM_AP_ENABLE_NAWDS;
  8205. vdev_param[wmi_vdev_param_mcast2ucast_set] =
  8206. WMI_VDEV_PARAM_MCAST2UCAST_SET;
  8207. vdev_param[wmi_vdev_param_enable_rtscts] = WMI_VDEV_PARAM_ENABLE_RTSCTS;
  8208. vdev_param[wmi_vdev_param_rc_num_retries] =
  8209. WMI_VDEV_PARAM_RC_NUM_RETRIES;
  8210. vdev_param[wmi_vdev_param_txbf] = WMI_VDEV_PARAM_TXBF;
  8211. vdev_param[wmi_vdev_param_packet_powersave] =
  8212. WMI_VDEV_PARAM_PACKET_POWERSAVE;
  8213. vdev_param[wmi_vdev_param_drop_unencry] = WMI_VDEV_PARAM_DROP_UNENCRY;
  8214. vdev_param[wmi_vdev_param_tx_encap_type] = WMI_VDEV_PARAM_TX_ENCAP_TYPE;
  8215. vdev_param[wmi_vdev_param_ap_detect_out_of_sync_sleeping_sta_time_secs]
  8216. = WMI_VDEV_PARAM_AP_DETECT_OUT_OF_SYNC_SLEEPING_STA_TIME_SECS;
  8217. vdev_param[wmi_vdev_param_cabq_maxdur] = WMI_VDEV_PARAM_CABQ_MAXDUR;
  8218. vdev_param[wmi_vdev_param_mfptest_set] = WMI_VDEV_PARAM_MFPTEST_SET;
  8219. vdev_param[wmi_vdev_param_rts_fixed_rate] =
  8220. WMI_VDEV_PARAM_RTS_FIXED_RATE;
  8221. vdev_param[wmi_vdev_param_vht_sgimask] = WMI_VDEV_PARAM_VHT_SGIMASK;
  8222. vdev_param[wmi_vdev_param_vht80_ratemask] =
  8223. WMI_VDEV_PARAM_VHT80_RATEMASK;
  8224. vdev_param[wmi_vdev_param_early_rx_adjust_enable] =
  8225. WMI_VDEV_PARAM_EARLY_RX_ADJUST_ENABLE;
  8226. vdev_param[wmi_vdev_param_early_rx_tgt_bmiss_num] =
  8227. WMI_VDEV_PARAM_EARLY_RX_TGT_BMISS_NUM;
  8228. vdev_param[wmi_vdev_param_early_rx_bmiss_sample_cycle] =
  8229. WMI_VDEV_PARAM_EARLY_RX_BMISS_SAMPLE_CYCLE;
  8230. vdev_param[wmi_vdev_param_early_rx_slop_step] =
  8231. WMI_VDEV_PARAM_EARLY_RX_SLOP_STEP;
  8232. vdev_param[wmi_vdev_param_early_rx_init_slop] =
  8233. WMI_VDEV_PARAM_EARLY_RX_INIT_SLOP;
  8234. vdev_param[wmi_vdev_param_early_rx_adjust_pause] =
  8235. WMI_VDEV_PARAM_EARLY_RX_ADJUST_PAUSE;
  8236. vdev_param[wmi_vdev_param_proxy_sta] = WMI_VDEV_PARAM_PROXY_STA;
  8237. vdev_param[wmi_vdev_param_meru_vc] = WMI_VDEV_PARAM_MERU_VC;
  8238. vdev_param[wmi_vdev_param_rx_decap_type] = WMI_VDEV_PARAM_RX_DECAP_TYPE;
  8239. vdev_param[wmi_vdev_param_bw_nss_ratemask] =
  8240. WMI_VDEV_PARAM_BW_NSS_RATEMASK;
  8241. vdev_param[wmi_vdev_param_sensor_ap] = WMI_VDEV_PARAM_SENSOR_AP;
  8242. vdev_param[wmi_vdev_param_beacon_rate] = WMI_VDEV_PARAM_BEACON_RATE;
  8243. vdev_param[wmi_vdev_param_dtim_enable_cts] =
  8244. WMI_VDEV_PARAM_DTIM_ENABLE_CTS;
  8245. vdev_param[wmi_vdev_param_sta_kickout] = WMI_VDEV_PARAM_STA_KICKOUT;
  8246. vdev_param[wmi_vdev_param_capabilities] =
  8247. WMI_VDEV_PARAM_CAPABILITIES;
  8248. vdev_param[wmi_vdev_param_mgmt_tx_power] = WMI_VDEV_PARAM_MGMT_TX_POWER;
  8249. vdev_param[wmi_vdev_param_atf_ssid_sched_policy] =
  8250. WMI_VDEV_PARAM_ATF_SSID_SCHED_POLICY;
  8251. vdev_param[wmi_vdev_param_disable_dyn_bw_rts] =
  8252. WMI_VDEV_PARAM_DISABLE_DYN_BW_RTS;
  8253. vdev_param[wmi_vdev_param_ampdu_subframe_size_per_ac] =
  8254. WMI_VDEV_PARAM_AMPDU_SUBFRAME_SIZE_PER_AC;
  8255. vdev_param[wmi_vdev_param_disable_cabq] =
  8256. WMI_VDEV_PARAM_DISABLE_CABQ;
  8257. }
  8258. #endif
  8259. /**
  8260. * wmi_get_non_tlv_ops() - gives pointer to wmi tlv ops
  8261. *
  8262. * Return: pointer to wmi tlv ops
  8263. */
  8264. void wmi_non_tlv_attach(struct wmi_unified *wmi_handle)
  8265. {
  8266. #if defined(WMI_NON_TLV_SUPPORT) || defined(WMI_TLV_AND_NON_TLV_SUPPORT)
  8267. wmi_handle->ops = &non_tlv_ops;
  8268. populate_non_tlv_service(wmi_handle->services);
  8269. populate_non_tlv_events_id(wmi_handle->wmi_events);
  8270. populate_pdev_param_non_tlv(wmi_handle->pdev_param);
  8271. populate_vdev_param_non_tlv(wmi_handle->vdev_param);
  8272. #ifdef WMI_INTERFACE_EVENT_LOGGING
  8273. wmi_handle->log_info.buf_offset_command = 0;
  8274. wmi_handle->log_info.buf_offset_event = 0;
  8275. /*(uint8 *)(*wmi_id_to_name)(uint32_t cmd_id);*/
  8276. #endif
  8277. #else
  8278. qdf_print("%s: Not supported\n", __func__);
  8279. #endif
  8280. }