wmi_unified_tlv.c 249 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199620062016202620362046205620662076208620962106211621262136214621562166217621862196220622162226223622462256226622762286229623062316232623362346235623662376238623962406241624262436244624562466247624862496250625162526253625462556256625762586259626062616262626362646265626662676268626962706271627262736274627562766277627862796280628162826283628462856286628762886289629062916292629362946295629662976298629963006301630263036304630563066307630863096310631163126313631463156316631763186319632063216322632363246325632663276328632963306331633263336334633563366337633863396340634163426343634463456346634763486349635063516352635363546355635663576358635963606361636263636364636563666367636863696370637163726373637463756376637763786379638063816382638363846385638663876388638963906391639263936394639563966397639863996400640164026403640464056406640764086409641064116412641364146415641664176418641964206421642264236424642564266427642864296430643164326433643464356436643764386439644064416442644364446445644664476448644964506451645264536454645564566457645864596460646164626463646464656466646764686469647064716472647364746475647664776478647964806481648264836484648564866487648864896490649164926493649464956496649764986499650065016502650365046505650665076508650965106511651265136514651565166517651865196520652165226523652465256526652765286529653065316532653365346535653665376538653965406541654265436544654565466547654865496550655165526553655465556556655765586559656065616562656365646565656665676568656965706571657265736574657565766577657865796580658165826583658465856586658765886589659065916592659365946595659665976598659966006601660266036604660566066607660866096610661166126613661466156616661766186619662066216622662366246625662666276628662966306631663266336634663566366637663866396640664166426643664466456646664766486649665066516652665366546655665666576658665966606661666266636664666566666667666866696670667166726673667466756676667766786679668066816682668366846685668666876688668966906691669266936694669566966697669866996700670167026703670467056706670767086709671067116712671367146715671667176718671967206721672267236724672567266727672867296730673167326733673467356736673767386739674067416742674367446745674667476748674967506751675267536754675567566757675867596760676167626763676467656766676767686769677067716772677367746775677667776778677967806781678267836784678567866787678867896790679167926793679467956796679767986799680068016802680368046805680668076808680968106811681268136814681568166817681868196820682168226823682468256826682768286829683068316832683368346835683668376838683968406841684268436844684568466847684868496850685168526853685468556856685768586859686068616862686368646865686668676868686968706871687268736874687568766877687868796880688168826883688468856886688768886889689068916892689368946895689668976898689969006901690269036904690569066907690869096910691169126913691469156916691769186919692069216922692369246925692669276928692969306931693269336934693569366937693869396940694169426943694469456946694769486949695069516952695369546955695669576958695969606961696269636964696569666967696869696970697169726973697469756976697769786979698069816982698369846985698669876988698969906991699269936994699569966997699869997000700170027003700470057006700770087009701070117012701370147015701670177018701970207021702270237024702570267027702870297030703170327033703470357036703770387039704070417042704370447045704670477048704970507051705270537054705570567057705870597060706170627063706470657066706770687069707070717072707370747075707670777078707970807081708270837084708570867087708870897090709170927093709470957096709770987099710071017102710371047105710671077108710971107111711271137114711571167117711871197120712171227123712471257126712771287129713071317132713371347135713671377138713971407141714271437144714571467147714871497150715171527153715471557156715771587159716071617162716371647165716671677168716971707171717271737174717571767177717871797180718171827183718471857186718771887189719071917192719371947195719671977198719972007201720272037204720572067207720872097210721172127213721472157216721772187219722072217222722372247225722672277228722972307231723272337234723572367237723872397240724172427243724472457246724772487249725072517252725372547255725672577258725972607261726272637264726572667267726872697270727172727273727472757276727772787279728072817282728372847285728672877288728972907291729272937294729572967297729872997300730173027303730473057306730773087309731073117312731373147315731673177318731973207321732273237324732573267327732873297330733173327333733473357336733773387339734073417342734373447345734673477348734973507351735273537354735573567357735873597360736173627363736473657366736773687369737073717372737373747375737673777378737973807381738273837384738573867387738873897390739173927393739473957396739773987399740074017402740374047405740674077408740974107411741274137414741574167417741874197420742174227423742474257426742774287429743074317432743374347435743674377438743974407441744274437444744574467447744874497450745174527453745474557456745774587459746074617462746374647465746674677468746974707471747274737474747574767477747874797480748174827483748474857486748774887489749074917492749374947495749674977498749975007501750275037504750575067507750875097510751175127513751475157516751775187519752075217522752375247525752675277528752975307531753275337534753575367537753875397540754175427543754475457546754775487549755075517552755375547555755675577558755975607561756275637564756575667567756875697570757175727573757475757576757775787579758075817582758375847585758675877588758975907591759275937594759575967597759875997600760176027603760476057606760776087609761076117612761376147615761676177618761976207621762276237624762576267627762876297630763176327633763476357636763776387639764076417642764376447645764676477648764976507651765276537654765576567657765876597660766176627663766476657666766776687669767076717672767376747675767676777678767976807681768276837684768576867687768876897690769176927693769476957696769776987699770077017702770377047705770677077708770977107711771277137714771577167717771877197720772177227723772477257726772777287729773077317732773377347735773677377738773977407741774277437744774577467747774877497750775177527753775477557756775777587759776077617762776377647765776677677768776977707771777277737774777577767777777877797780778177827783778477857786778777887789779077917792779377947795779677977798779978007801780278037804780578067807780878097810781178127813781478157816781778187819782078217822782378247825782678277828782978307831783278337834783578367837783878397840784178427843784478457846784778487849785078517852785378547855785678577858785978607861786278637864786578667867786878697870787178727873787478757876787778787879788078817882788378847885788678877888788978907891789278937894789578967897789878997900790179027903790479057906790779087909791079117912791379147915791679177918791979207921792279237924792579267927792879297930793179327933793479357936793779387939794079417942794379447945794679477948794979507951795279537954795579567957795879597960796179627963796479657966796779687969797079717972797379747975797679777978797979807981798279837984798579867987798879897990799179927993799479957996799779987999800080018002800380048005800680078008800980108011801280138014801580168017801880198020802180228023802480258026802780288029803080318032803380348035803680378038803980408041804280438044804580468047804880498050805180528053805480558056805780588059806080618062806380648065806680678068806980708071807280738074807580768077807880798080808180828083808480858086808780888089809080918092809380948095809680978098809981008101810281038104810581068107810881098110811181128113811481158116811781188119812081218122812381248125812681278128812981308131813281338134813581368137813881398140814181428143814481458146814781488149815081518152815381548155815681578158815981608161816281638164816581668167816881698170817181728173817481758176817781788179818081818182818381848185818681878188818981908191819281938194819581968197819881998200820182028203820482058206820782088209821082118212821382148215821682178218821982208221822282238224822582268227822882298230823182328233823482358236823782388239824082418242824382448245824682478248824982508251825282538254825582568257825882598260826182628263826482658266826782688269827082718272827382748275827682778278827982808281828282838284828582868287828882898290829182928293829482958296829782988299830083018302830383048305830683078308
  1. /*
  2. * Copyright (c) 2016 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_tlv.h"
  27. #include "wmi_unified_api.h"
  28. #include "wmi.h"
  29. #include "wmi_unified_priv.h"
  30. #include "wma_api.h"
  31. #include "wma.h"
  32. /**
  33. * send_vdev_create_cmd_tlv() - send VDEV create command to fw
  34. * @wmi_handle: wmi handle
  35. * @param: pointer to hold vdev create parameter
  36. * @macaddr: vdev mac address
  37. *
  38. * Return: 0 for success or error code
  39. */
  40. CDF_STATUS send_vdev_create_cmd_tlv(wmi_unified_t wmi_handle,
  41. uint8_t macaddr[IEEE80211_ADDR_LEN],
  42. struct vdev_create_params *param)
  43. {
  44. wmi_vdev_create_cmd_fixed_param *cmd;
  45. wmi_buf_t buf;
  46. int32_t len = sizeof(*cmd);
  47. int32_t ret;
  48. buf = wmi_buf_alloc(wmi_handle, len);
  49. if (!buf) {
  50. WMA_LOGP("%s:wmi_buf_alloc failed", __func__);
  51. return -ENOMEM;
  52. }
  53. cmd = (wmi_vdev_create_cmd_fixed_param *) wmi_buf_data(buf);
  54. WMITLV_SET_HDR(&cmd->tlv_header,
  55. WMITLV_TAG_STRUC_wmi_vdev_create_cmd_fixed_param,
  56. WMITLV_GET_STRUCT_TLVLEN
  57. (wmi_vdev_create_cmd_fixed_param));
  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. WMA_LOGD("%s: ID = %d VAP Addr = %02x:%02x:%02x:%02x:%02x:%02x",
  63. __func__, param->if_id,
  64. macaddr[0], macaddr[1], macaddr[2],
  65. macaddr[3], macaddr[4], macaddr[5]);
  66. ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_VDEV_CREATE_CMDID);
  67. if (ret != EOK) {
  68. WMA_LOGE("Failed to send WMI_VDEV_CREATE_CMDID");
  69. wmi_buf_free(buf);
  70. }
  71. return ret;
  72. }
  73. /**
  74. * send_vdev_delete_cmd_tlv() - send VDEV delete command to fw
  75. * @wmi_handle: wmi handle
  76. * @if_id: vdev id
  77. *
  78. * Return: 0 for success or error code
  79. */
  80. CDF_STATUS send_vdev_delete_cmd_tlv(wmi_unified_t wmi_handle,
  81. uint8_t if_id)
  82. {
  83. wmi_vdev_delete_cmd_fixed_param *cmd;
  84. wmi_buf_t buf;
  85. int32_t ret;
  86. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  87. if (!buf) {
  88. WMA_LOGP("%s:wmi_buf_alloc failed", __func__);
  89. return -ENOMEM;
  90. }
  91. cmd = (wmi_vdev_delete_cmd_fixed_param *) wmi_buf_data(buf);
  92. WMITLV_SET_HDR(&cmd->tlv_header,
  93. WMITLV_TAG_STRUC_wmi_vdev_delete_cmd_fixed_param,
  94. WMITLV_GET_STRUCT_TLVLEN
  95. (wmi_vdev_delete_cmd_fixed_param));
  96. cmd->vdev_id = if_id;
  97. ret = wmi_unified_cmd_send(wmi_handle, buf,
  98. sizeof(wmi_vdev_delete_cmd_fixed_param),
  99. WMI_VDEV_DELETE_CMDID);
  100. if (ret != EOK) {
  101. WMA_LOGE("Failed to send WMI_VDEV_DELETE_CMDID");
  102. wmi_buf_free(buf);
  103. }
  104. WMA_LOGD("%s:vdev id = %d", __func__, if_id);
  105. return ret;
  106. }
  107. /**
  108. * send_vdev_stop_cmd_tlv() - send vdev stop command to fw
  109. * @wmi: wmi handle
  110. * @vdev_id: vdev id
  111. *
  112. * Return: 0 for success or erro code
  113. */
  114. CDF_STATUS send_vdev_stop_cmd_tlv(wmi_unified_t wmi,
  115. uint8_t vdev_id)
  116. {
  117. wmi_vdev_stop_cmd_fixed_param *cmd;
  118. wmi_buf_t buf;
  119. int32_t len = sizeof(*cmd);
  120. buf = wmi_buf_alloc(wmi, len);
  121. if (!buf) {
  122. WMA_LOGP("%s : wmi_buf_alloc failed", __func__);
  123. return -ENOMEM;
  124. }
  125. cmd = (wmi_vdev_stop_cmd_fixed_param *) wmi_buf_data(buf);
  126. WMITLV_SET_HDR(&cmd->tlv_header,
  127. WMITLV_TAG_STRUC_wmi_vdev_stop_cmd_fixed_param,
  128. WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_stop_cmd_fixed_param));
  129. cmd->vdev_id = vdev_id;
  130. if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_STOP_CMDID)) {
  131. WMA_LOGP("%s: Failed to send vdev stop command", __func__);
  132. cdf_nbuf_free(buf);
  133. return -EIO;
  134. }
  135. return 0;
  136. }
  137. /**
  138. * send_vdev_down_cmd_tlv() - send vdev down command to fw
  139. * @wmi: wmi handle
  140. * @vdev_id: vdev id
  141. *
  142. * Return: 0 for success or error code
  143. */
  144. CDF_STATUS send_vdev_down_cmd_tlv(wmi_unified_t wmi, uint8_t vdev_id)
  145. {
  146. wmi_vdev_down_cmd_fixed_param *cmd;
  147. wmi_buf_t buf;
  148. int32_t len = sizeof(*cmd);
  149. buf = wmi_buf_alloc(wmi, len);
  150. if (!buf) {
  151. WMA_LOGP("%s : wmi_buf_alloc failed", __func__);
  152. return -ENOMEM;
  153. }
  154. cmd = (wmi_vdev_down_cmd_fixed_param *) wmi_buf_data(buf);
  155. WMITLV_SET_HDR(&cmd->tlv_header,
  156. WMITLV_TAG_STRUC_wmi_vdev_down_cmd_fixed_param,
  157. WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_down_cmd_fixed_param));
  158. cmd->vdev_id = vdev_id;
  159. if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_DOWN_CMDID)) {
  160. WMA_LOGP("%s: Failed to send vdev down", __func__);
  161. cdf_nbuf_free(buf);
  162. return -EIO;
  163. }
  164. WMA_LOGD("%s: vdev_id %d", __func__, vdev_id);
  165. return 0;
  166. }
  167. /**
  168. * send_peer_flush_tids_cmd_tlv() - flush peer tids packets in fw
  169. * @wmi: wmi handle
  170. * @peer_addr: peer mac address
  171. * @param: pointer to hold peer flush tid parameter
  172. *
  173. * Return: 0 for sucess or error code
  174. */
  175. CDF_STATUS send_peer_flush_tids_cmd_tlv(wmi_unified_t wmi,
  176. uint8_t peer_addr[IEEE80211_ADDR_LEN],
  177. struct peer_flush_params *param)
  178. {
  179. wmi_peer_flush_tids_cmd_fixed_param *cmd;
  180. wmi_buf_t buf;
  181. int32_t len = sizeof(*cmd);
  182. buf = wmi_buf_alloc(wmi, len);
  183. if (!buf) {
  184. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  185. return -ENOMEM;
  186. }
  187. cmd = (wmi_peer_flush_tids_cmd_fixed_param *) wmi_buf_data(buf);
  188. WMITLV_SET_HDR(&cmd->tlv_header,
  189. WMITLV_TAG_STRUC_wmi_peer_flush_tids_cmd_fixed_param,
  190. WMITLV_GET_STRUCT_TLVLEN
  191. (wmi_peer_flush_tids_cmd_fixed_param));
  192. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  193. cmd->peer_tid_bitmap = param->peer_tid_bitmap;
  194. cmd->vdev_id = param->vdev_id;
  195. WMA_LOGD("%s: peer_addr %pM vdev_id %d and peer bitmap %d", __func__,
  196. peer_addr, param->vdev_id,
  197. param->peer_tid_bitmap);
  198. if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_FLUSH_TIDS_CMDID)) {
  199. WMA_LOGP("%s: Failed to send flush tid command", __func__);
  200. cdf_nbuf_free(buf);
  201. return -EIO;
  202. }
  203. return 0;
  204. }
  205. /**
  206. * send_peer_delete_cmd_tlv() - send PEER delete command to fw
  207. * @wmi: wmi handle
  208. * @peer_addr: peer mac addr
  209. * @vdev_id: vdev id
  210. *
  211. * Return: 0 for success or error code
  212. */
  213. CDF_STATUS send_peer_delete_cmd_tlv(wmi_unified_t wmi,
  214. uint8_t peer_addr[IEEE80211_ADDR_LEN],
  215. uint8_t vdev_id)
  216. {
  217. wmi_peer_delete_cmd_fixed_param *cmd;
  218. wmi_buf_t buf;
  219. int32_t len = sizeof(*cmd);
  220. buf = wmi_buf_alloc(wmi, len);
  221. if (!buf) {
  222. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  223. return -ENOMEM;
  224. }
  225. cmd = (wmi_peer_delete_cmd_fixed_param *) wmi_buf_data(buf);
  226. WMITLV_SET_HDR(&cmd->tlv_header,
  227. WMITLV_TAG_STRUC_wmi_peer_delete_cmd_fixed_param,
  228. WMITLV_GET_STRUCT_TLVLEN
  229. (wmi_peer_delete_cmd_fixed_param));
  230. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  231. cmd->vdev_id = vdev_id;
  232. if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_DELETE_CMDID)) {
  233. WMA_LOGP("%s: Failed to send peer delete command", __func__);
  234. cdf_nbuf_free(buf);
  235. return -EIO;
  236. }
  237. WMA_LOGD("%s: peer_addr %pM vdev_id %d", __func__, peer_addr, vdev_id);
  238. return 0;
  239. }
  240. /**
  241. * send_peer_param_cmd_tlv() - set peer parameter in fw
  242. * @wmi: wmi handle
  243. * @peer_addr: peer mac address
  244. * @param : pointer to hold peer set parameter
  245. *
  246. * Return: 0 for success or error code
  247. */
  248. CDF_STATUS send_peer_param_cmd_tlv(wmi_unified_t wmi,
  249. uint8_t peer_addr[IEEE80211_ADDR_LEN],
  250. struct peer_set_params *param)
  251. {
  252. wmi_peer_set_param_cmd_fixed_param *cmd;
  253. wmi_buf_t buf;
  254. int32_t err;
  255. buf = wmi_buf_alloc(wmi, sizeof(*cmd));
  256. if (!buf) {
  257. WMA_LOGE("Failed to allocate buffer to send set_param cmd");
  258. return -ENOMEM;
  259. }
  260. cmd = (wmi_peer_set_param_cmd_fixed_param *) wmi_buf_data(buf);
  261. WMITLV_SET_HDR(&cmd->tlv_header,
  262. WMITLV_TAG_STRUC_wmi_peer_set_param_cmd_fixed_param,
  263. WMITLV_GET_STRUCT_TLVLEN
  264. (wmi_peer_set_param_cmd_fixed_param));
  265. cmd->vdev_id = param->vdev_id;
  266. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  267. cmd->param_id = param->param_id;
  268. cmd->param_value = param->param_value;
  269. err = wmi_unified_cmd_send(wmi, buf,
  270. sizeof(wmi_peer_set_param_cmd_fixed_param),
  271. WMI_PEER_SET_PARAM_CMDID);
  272. if (err) {
  273. WMA_LOGE("Failed to send set_param cmd");
  274. cdf_mem_free(buf);
  275. return -EIO;
  276. }
  277. return 0;
  278. }
  279. /**
  280. * send_vdev_up_cmd_tlv() - send vdev up command in fw
  281. * @wmi: wmi handle
  282. * @bssid: bssid
  283. * @vdev_up_params: pointer to hold vdev up parameter
  284. *
  285. * Return: 0 for success or error code
  286. */
  287. CDF_STATUS send_vdev_up_cmd_tlv(wmi_unified_t wmi,
  288. uint8_t bssid[IEEE80211_ADDR_LEN],
  289. struct vdev_up_params *params)
  290. {
  291. wmi_vdev_up_cmd_fixed_param *cmd;
  292. wmi_buf_t buf;
  293. int32_t len = sizeof(*cmd);
  294. WMA_LOGD("%s: VDEV_UP", __func__);
  295. WMA_LOGD("%s: vdev_id %d aid %d bssid %pM", __func__,
  296. params->vdev_id, params->assoc_id, bssid);
  297. buf = wmi_buf_alloc(wmi, len);
  298. if (!buf) {
  299. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  300. return -ENOMEM;
  301. }
  302. cmd = (wmi_vdev_up_cmd_fixed_param *) wmi_buf_data(buf);
  303. WMITLV_SET_HDR(&cmd->tlv_header,
  304. WMITLV_TAG_STRUC_wmi_vdev_up_cmd_fixed_param,
  305. WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_up_cmd_fixed_param));
  306. cmd->vdev_id = params->vdev_id;
  307. cmd->vdev_assoc_id = params->assoc_id;
  308. WMI_CHAR_ARRAY_TO_MAC_ADDR(bssid, &cmd->vdev_bssid);
  309. if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_UP_CMDID)) {
  310. WMA_LOGP("%s: Failed to send vdev up command", __func__);
  311. cdf_nbuf_free(buf);
  312. return -EIO;
  313. }
  314. return 0;
  315. }
  316. /**
  317. * send_peer_create_cmd_tlv() - send peer create command to fw
  318. * @wmi: wmi handle
  319. * @peer_addr: peer mac address
  320. * @peer_type: peer type
  321. * @vdev_id: vdev id
  322. *
  323. * Return: 0 for success or error code
  324. */
  325. CDF_STATUS send_peer_create_cmd_tlv(wmi_unified_t wmi,
  326. struct peer_create_params *param)
  327. {
  328. wmi_peer_create_cmd_fixed_param *cmd;
  329. wmi_buf_t buf;
  330. int32_t len = sizeof(*cmd);
  331. buf = wmi_buf_alloc(wmi, len);
  332. if (!buf) {
  333. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  334. return -ENOMEM;
  335. }
  336. cmd = (wmi_peer_create_cmd_fixed_param *) wmi_buf_data(buf);
  337. WMITLV_SET_HDR(&cmd->tlv_header,
  338. WMITLV_TAG_STRUC_wmi_peer_create_cmd_fixed_param,
  339. WMITLV_GET_STRUCT_TLVLEN
  340. (wmi_peer_create_cmd_fixed_param));
  341. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr);
  342. cmd->peer_type = param->peer_type;
  343. cmd->vdev_id = param->vdev_id;
  344. if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_CREATE_CMDID)) {
  345. WMA_LOGP("%s: failed to send WMI_PEER_CREATE_CMDID", __func__);
  346. cdf_nbuf_free(buf);
  347. return -EIO;
  348. }
  349. WMA_LOGD("%s: peer_addr %pM vdev_id %d", __func__, param->peer_addr,
  350. param->vdev_id);
  351. return 0;
  352. }
  353. /**
  354. * send_green_ap_ps_cmd_tlv() - enable green ap powersave command
  355. * @wmi_handle: wmi handle
  356. * @value: value
  357. * @mac_id: mac id to have radio context
  358. *
  359. * Return: 0 for success or error code
  360. */
  361. CDF_STATUS send_green_ap_ps_cmd_tlv(wmi_unified_t wmi_handle,
  362. uint32_t value, uint8_t mac_id)
  363. {
  364. wmi_pdev_green_ap_ps_enable_cmd_fixed_param *cmd;
  365. wmi_buf_t buf;
  366. int32_t len = sizeof(*cmd);
  367. WMA_LOGD("Set Green AP PS val %d", value);
  368. buf = wmi_buf_alloc(wmi_handle, len);
  369. if (!buf) {
  370. WMA_LOGP("%s: Green AP PS Mem Alloc Failed", __func__);
  371. return -ENOMEM;
  372. }
  373. cmd = (wmi_pdev_green_ap_ps_enable_cmd_fixed_param *) wmi_buf_data(buf);
  374. WMITLV_SET_HDR(&cmd->tlv_header,
  375. WMITLV_TAG_STRUC_wmi_pdev_green_ap_ps_enable_cmd_fixed_param,
  376. WMITLV_GET_STRUCT_TLVLEN
  377. (wmi_pdev_green_ap_ps_enable_cmd_fixed_param));
  378. cmd->reserved0 = 0;
  379. cmd->enable = value;
  380. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  381. WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID)) {
  382. WMA_LOGE("Set Green AP PS param Failed val %d", value);
  383. cdf_nbuf_free(buf);
  384. return -EIO;
  385. }
  386. return 0;
  387. }
  388. /**
  389. * send_pdev_utf_cmd_tlv() - send utf command to fw
  390. * @wmi_handle: wmi handle
  391. * @param: pointer to pdev_utf_params
  392. * @mac_id: mac id to have radio context
  393. *
  394. * Return: 0 for success or error code
  395. */
  396. CDF_STATUS
  397. send_pdev_utf_cmd_tlv(wmi_unified_t wmi_handle,
  398. struct pdev_utf_params *param,
  399. uint8_t mac_id)
  400. {
  401. wmi_buf_t buf;
  402. uint8_t *cmd;
  403. int32_t ret = 0;
  404. static uint8_t msgref = 1;
  405. uint8_t segNumber = 0, segInfo, numSegments;
  406. uint16_t chunk_len, total_bytes;
  407. uint8_t *bufpos;
  408. struct seg_hdr_info segHdrInfo;
  409. bufpos = param->utf_payload;
  410. total_bytes = param->len;
  411. ASSERT(total_bytes / MAX_WMI_UTF_LEN ==
  412. (uint8_t) (total_bytes / MAX_WMI_UTF_LEN));
  413. numSegments = (uint8_t) (total_bytes / MAX_WMI_UTF_LEN);
  414. if (param->len - (numSegments * MAX_WMI_UTF_LEN))
  415. numSegments++;
  416. while (param->len) {
  417. if (param->len > MAX_WMI_UTF_LEN)
  418. chunk_len = MAX_WMI_UTF_LEN; /* MAX messsage */
  419. else
  420. chunk_len = param->len;
  421. buf = wmi_buf_alloc(wmi_handle,
  422. (chunk_len + sizeof(segHdrInfo) +
  423. WMI_TLV_HDR_SIZE));
  424. if (!buf) {
  425. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  426. return -ENOMEM;
  427. }
  428. cmd = (uint8_t *) wmi_buf_data(buf);
  429. segHdrInfo.len = total_bytes;
  430. segHdrInfo.msgref = msgref;
  431. segInfo = ((numSegments << 4) & 0xF0) | (segNumber & 0xF);
  432. segHdrInfo.segmentInfo = segInfo;
  433. segHdrInfo.pad = 0;
  434. WMA_LOGD("%s:segHdrInfo.len = %d, segHdrInfo.msgref = %d,"
  435. " segHdrInfo.segmentInfo = %d",
  436. __func__, segHdrInfo.len, segHdrInfo.msgref,
  437. segHdrInfo.segmentInfo);
  438. WMA_LOGD("%s:total_bytes %d segNumber %d totalSegments %d"
  439. "chunk len %d", __func__, total_bytes, segNumber,
  440. numSegments, chunk_len);
  441. segNumber++;
  442. WMITLV_SET_HDR(cmd, WMITLV_TAG_ARRAY_BYTE,
  443. (chunk_len + sizeof(segHdrInfo)));
  444. cmd += WMI_TLV_HDR_SIZE;
  445. memcpy(cmd, &segHdrInfo, sizeof(segHdrInfo)); /* 4 bytes */
  446. memcpy(&cmd[sizeof(segHdrInfo)], bufpos, chunk_len);
  447. ret = wmi_unified_cmd_send(wmi_handle, buf,
  448. (chunk_len + sizeof(segHdrInfo) +
  449. WMI_TLV_HDR_SIZE),
  450. WMI_PDEV_UTF_CMDID);
  451. if (ret != EOK) {
  452. WMA_LOGE("Failed to send WMI_PDEV_UTF_CMDID command");
  453. wmi_buf_free(buf);
  454. break;
  455. }
  456. param->len -= chunk_len;
  457. bufpos += chunk_len;
  458. }
  459. msgref++;
  460. return ret;
  461. }
  462. /**
  463. * send_pdev_param_cmd_tlv() - set pdev parameters
  464. * @wmi_handle: wmi handle
  465. * @param: pointer to pdev parameter
  466. * @mac_id: radio context
  467. *
  468. * Return: 0 on success, errno on failure
  469. */
  470. CDF_STATUS
  471. send_pdev_param_cmd_tlv(wmi_unified_t wmi_handle,
  472. struct pdev_params *param,
  473. uint8_t mac_id)
  474. {
  475. int32_t ret;
  476. wmi_pdev_set_param_cmd_fixed_param *cmd;
  477. wmi_buf_t buf;
  478. uint16_t len = sizeof(*cmd);
  479. buf = wmi_buf_alloc(wmi_handle, len);
  480. if (!buf) {
  481. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  482. return -ENOMEM;
  483. }
  484. cmd = (wmi_pdev_set_param_cmd_fixed_param *) wmi_buf_data(buf);
  485. WMITLV_SET_HDR(&cmd->tlv_header,
  486. WMITLV_TAG_STRUC_wmi_pdev_set_param_cmd_fixed_param,
  487. WMITLV_GET_STRUCT_TLVLEN
  488. (wmi_pdev_set_param_cmd_fixed_param));
  489. cmd->reserved0 = 0;
  490. cmd->param_id = param->param_id;
  491. cmd->param_value = param->param_value;
  492. WMA_LOGD("Setting pdev param = %x, value = %u", param->param_id,
  493. param->param_value);
  494. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  495. WMI_PDEV_SET_PARAM_CMDID);
  496. if (ret != EOK) {
  497. WMA_LOGE("Failed to send set param command ret = %d", ret);
  498. wmi_buf_free(buf);
  499. }
  500. return ret;
  501. }
  502. /**
  503. * send_suspend_cmd_tlv() - WMI suspend function
  504. * @param wmi_handle : handle to WMI.
  505. * @param param : pointer to hold suspend parameter
  506. * @mac_id: radio context
  507. *
  508. * Return 0 on success and -ve on failure.
  509. */
  510. CDF_STATUS send_suspend_cmd_tlv(wmi_unified_t wmi_handle,
  511. struct suspend_params *param,
  512. uint8_t mac_id)
  513. {
  514. wmi_pdev_suspend_cmd_fixed_param *cmd;
  515. wmi_buf_t wmibuf;
  516. uint32_t len = sizeof(*cmd);
  517. int32_t ret;
  518. /*
  519. * send the comand to Target to ignore the
  520. * PCIE reset so as to ensure that Host and target
  521. * states are in sync
  522. */
  523. wmibuf = wmi_buf_alloc(wmi_handle, len);
  524. if (wmibuf == NULL)
  525. return -ENOMEM;
  526. cmd = (wmi_pdev_suspend_cmd_fixed_param *) wmi_buf_data(wmibuf);
  527. WMITLV_SET_HDR(&cmd->tlv_header,
  528. WMITLV_TAG_STRUC_wmi_pdev_suspend_cmd_fixed_param,
  529. WMITLV_GET_STRUCT_TLVLEN
  530. (wmi_pdev_suspend_cmd_fixed_param));
  531. if (param->disable_target_intr)
  532. cmd->suspend_opt = WMI_PDEV_SUSPEND_AND_DISABLE_INTR;
  533. else
  534. cmd->suspend_opt = WMI_PDEV_SUSPEND;
  535. ret = wmi_unified_cmd_send(wmi_handle, wmibuf, len,
  536. WMI_PDEV_SUSPEND_CMDID);
  537. if (ret) {
  538. cdf_nbuf_free(wmibuf);
  539. WMA_LOGE("Failed to send WMI_PDEV_SUSPEND_CMDID command");
  540. }
  541. return ret;
  542. }
  543. /**
  544. * send_resume_cmd_tlv() - WMI resume function
  545. * @param wmi_handle : handle to WMI.
  546. * @mac_id: radio context
  547. *
  548. * Return: 0 on success and -ve on failure.
  549. */
  550. CDF_STATUS send_resume_cmd_tlv(wmi_unified_t wmi_handle,
  551. uint8_t mac_id)
  552. {
  553. wmi_buf_t wmibuf;
  554. wmi_pdev_resume_cmd_fixed_param *cmd;
  555. int32_t ret;
  556. wmibuf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  557. if (wmibuf == NULL)
  558. return -ENOMEM;
  559. cmd = (wmi_pdev_resume_cmd_fixed_param *) wmi_buf_data(wmibuf);
  560. WMITLV_SET_HDR(&cmd->tlv_header,
  561. WMITLV_TAG_STRUC_wmi_pdev_resume_cmd_fixed_param,
  562. WMITLV_GET_STRUCT_TLVLEN
  563. (wmi_pdev_resume_cmd_fixed_param));
  564. cmd->reserved0 = 0;
  565. ret = wmi_unified_cmd_send(wmi_handle, wmibuf, sizeof(*cmd),
  566. WMI_PDEV_RESUME_CMDID);
  567. if (ret != EOK) {
  568. WMA_LOGE("Failed to send WMI_PDEV_RESUME_CMDID command");
  569. wmi_buf_free(wmibuf);
  570. }
  571. return ret;
  572. }
  573. /**
  574. * send_wow_enable_cmd_tlv() - WMI wow enable function
  575. * @param wmi_handle : handle to WMI.
  576. * @param param : pointer to hold wow enable parameter
  577. * @mac_id: radio context
  578. *
  579. * Return: 0 on success and -ve on failure.
  580. */
  581. CDF_STATUS send_wow_enable_cmd_tlv(wmi_unified_t wmi_handle,
  582. struct wow_cmd_params *param,
  583. uint8_t mac_id)
  584. {
  585. wmi_wow_enable_cmd_fixed_param *cmd;
  586. wmi_buf_t buf;
  587. int32_t len;
  588. int32_t ret;
  589. len = sizeof(wmi_wow_enable_cmd_fixed_param);
  590. buf = wmi_buf_alloc(wmi_handle, len);
  591. if (!buf) {
  592. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  593. return CDF_STATUS_E_NOMEM;
  594. }
  595. cmd = (wmi_wow_enable_cmd_fixed_param *) wmi_buf_data(buf);
  596. WMITLV_SET_HDR(&cmd->tlv_header,
  597. WMITLV_TAG_STRUC_wmi_wow_enable_cmd_fixed_param,
  598. WMITLV_GET_STRUCT_TLVLEN
  599. (wmi_wow_enable_cmd_fixed_param));
  600. cmd->enable = param->enable;
  601. if (param->can_suspend_link)
  602. cmd->pause_iface_config = WOW_IFACE_PAUSE_ENABLED;
  603. else
  604. cmd->pause_iface_config = WOW_IFACE_PAUSE_DISABLED;
  605. WMA_LOGI("suspend type: %s",
  606. cmd->pause_iface_config == WOW_IFACE_PAUSE_ENABLED ?
  607. "WOW_IFACE_PAUSE_ENABLED" : "WOW_IFACE_PAUSE_DISABLED");
  608. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  609. WMI_WOW_ENABLE_CMDID);
  610. if (ret)
  611. wmi_buf_free(buf);
  612. return ret;
  613. }
  614. /**
  615. * send_set_ap_ps_param_cmd_tlv() - set ap powersave parameters
  616. * @wmi_handle: wmi handle
  617. * @peer_addr: peer mac address
  618. * @param: pointer to ap_ps parameter structure
  619. *
  620. * Return: 0 for success or error code
  621. */
  622. CDF_STATUS send_set_ap_ps_param_cmd_tlv(wmi_unified_t wmi_handle,
  623. uint8_t *peer_addr,
  624. struct ap_ps_params *param)
  625. {
  626. wmi_ap_ps_peer_cmd_fixed_param *cmd;
  627. wmi_buf_t buf;
  628. int32_t err;
  629. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  630. if (!buf) {
  631. WMA_LOGE("Failed to allocate buffer to send set_ap_ps_param cmd");
  632. return -ENOMEM;
  633. }
  634. cmd = (wmi_ap_ps_peer_cmd_fixed_param *) wmi_buf_data(buf);
  635. WMITLV_SET_HDR(&cmd->tlv_header,
  636. WMITLV_TAG_STRUC_wmi_ap_ps_peer_cmd_fixed_param,
  637. WMITLV_GET_STRUCT_TLVLEN
  638. (wmi_ap_ps_peer_cmd_fixed_param));
  639. cmd->vdev_id = param->vdev_id;
  640. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  641. cmd->param = param->param;
  642. cmd->value = param->value;
  643. err = wmi_unified_cmd_send(wmi_handle, buf,
  644. sizeof(*cmd), WMI_AP_PS_PEER_PARAM_CMDID);
  645. if (err) {
  646. WMA_LOGE("Failed to send set_ap_ps_param cmd");
  647. cdf_mem_free(buf);
  648. return -EIO;
  649. }
  650. return 0;
  651. }
  652. /**
  653. * send_set_sta_ps_param_cmd_tlv() - set sta powersave parameters
  654. * @wmi_handle: wmi handle
  655. * @peer_addr: peer mac address
  656. * @param: pointer to sta_ps parameter structure
  657. *
  658. * Return: 0 for success or error code
  659. */
  660. CDF_STATUS send_set_sta_ps_param_cmd_tlv(wmi_unified_t wmi_handle,
  661. struct sta_ps_params *param)
  662. {
  663. wmi_sta_powersave_param_cmd_fixed_param *cmd;
  664. wmi_buf_t buf;
  665. int32_t len = sizeof(*cmd);
  666. buf = wmi_buf_alloc(wmi_handle, len);
  667. if (!buf) {
  668. WMA_LOGP("%s: Set Sta Ps param Mem Alloc Failed", __func__);
  669. return -ENOMEM;
  670. }
  671. cmd = (wmi_sta_powersave_param_cmd_fixed_param *) wmi_buf_data(buf);
  672. WMITLV_SET_HDR(&cmd->tlv_header,
  673. WMITLV_TAG_STRUC_wmi_sta_powersave_param_cmd_fixed_param,
  674. WMITLV_GET_STRUCT_TLVLEN
  675. (wmi_sta_powersave_param_cmd_fixed_param));
  676. cmd->vdev_id = param->vdev_id;
  677. cmd->param = param->param;
  678. cmd->value = param->value;
  679. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  680. WMI_STA_POWERSAVE_PARAM_CMDID)) {
  681. WMA_LOGE("Set Sta Ps param Failed vdevId %d Param %d val %d",
  682. param->vdev_id, param->param, param->value);
  683. cdf_nbuf_free(buf);
  684. return -EIO;
  685. }
  686. return 0;
  687. }
  688. /**
  689. * send_crash_inject_cmd_tlv() - inject fw crash
  690. * @wmi_handle: wmi handle
  691. * @param: ponirt to crash inject paramter structure
  692. *
  693. * Return: 0 for success or return error
  694. */
  695. CDF_STATUS send_crash_inject_cmd_tlv(wmi_unified_t wmi_handle,
  696. struct crash_inject *param)
  697. {
  698. int32_t ret = 0;
  699. WMI_FORCE_FW_HANG_CMD_fixed_param *cmd;
  700. uint16_t len = sizeof(*cmd);
  701. wmi_buf_t buf;
  702. buf = wmi_buf_alloc(wmi_handle, len);
  703. if (!buf) {
  704. WMA_LOGE("%s: wmi_buf_alloc failed!", __func__);
  705. return -ENOMEM;
  706. }
  707. cmd = (WMI_FORCE_FW_HANG_CMD_fixed_param *) wmi_buf_data(buf);
  708. WMITLV_SET_HDR(&cmd->tlv_header,
  709. WMITLV_TAG_STRUC_WMI_FORCE_FW_HANG_CMD_fixed_param,
  710. WMITLV_GET_STRUCT_TLVLEN
  711. (WMI_FORCE_FW_HANG_CMD_fixed_param));
  712. cmd->type = param->type;
  713. cmd->delay_time_ms = param->delay_time_ms;
  714. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  715. WMI_FORCE_FW_HANG_CMDID);
  716. if (ret) {
  717. WMA_LOGE("%s: Failed to send set param command, ret = %d",
  718. __func__, ret);
  719. wmi_buf_free(buf);
  720. }
  721. return ret;
  722. }
  723. /**
  724. * send_dbglog_cmd_tlv() - set debug log level
  725. * @param wmi_handle : handle to WMI.
  726. * @param param : pointer to hold dbglog level parameter
  727. *
  728. * Return: 0 on success and -ve on failure.
  729. */
  730. CDF_STATUS
  731. send_dbglog_cmd_tlv(wmi_unified_t wmi_handle,
  732. struct dbglog_params *dbglog_param)
  733. {
  734. wmi_buf_t buf;
  735. wmi_debug_log_config_cmd_fixed_param *configmsg;
  736. A_STATUS status = A_OK;
  737. int32_t i;
  738. int32_t len;
  739. int8_t *buf_ptr;
  740. int32_t *module_id_bitmap_array; /* Used to fomr the second tlv */
  741. ASSERT(bitmap_len < MAX_MODULE_ID_BITMAP_WORDS);
  742. /* Allocate size for 2 tlvs - including tlv hdr space for second tlv */
  743. len = sizeof(wmi_debug_log_config_cmd_fixed_param) + WMI_TLV_HDR_SIZE +
  744. (sizeof(int32_t) * MAX_MODULE_ID_BITMAP_WORDS);
  745. buf = wmi_buf_alloc(wmi_handle, len);
  746. if (buf == NULL)
  747. return A_NO_MEMORY;
  748. configmsg =
  749. (wmi_debug_log_config_cmd_fixed_param *) (wmi_buf_data(buf));
  750. buf_ptr = (int8_t *) configmsg;
  751. WMITLV_SET_HDR(&configmsg->tlv_header,
  752. WMITLV_TAG_STRUC_wmi_debug_log_config_cmd_fixed_param,
  753. WMITLV_GET_STRUCT_TLVLEN
  754. (wmi_debug_log_config_cmd_fixed_param));
  755. configmsg->dbg_log_param = dbglog_param->param;
  756. configmsg->value = dbglog_param->val;
  757. /* Filling in the data part of second tlv -- should
  758. * follow first tlv _ WMI_TLV_HDR_SIZE */
  759. module_id_bitmap_array = (A_UINT32 *) (buf_ptr +
  760. sizeof
  761. (wmi_debug_log_config_cmd_fixed_param)
  762. + WMI_TLV_HDR_SIZE);
  763. WMITLV_SET_HDR(buf_ptr + sizeof(wmi_debug_log_config_cmd_fixed_param),
  764. WMITLV_TAG_ARRAY_UINT32,
  765. sizeof(A_UINT32) * MAX_MODULE_ID_BITMAP_WORDS);
  766. if (dbglog_param->module_id_bitmap) {
  767. for (i = 0; i < dbglog_param->bitmap_len; ++i) {
  768. module_id_bitmap_array[i] =
  769. dbglog_param->module_id_bitmap[i];
  770. }
  771. }
  772. status = wmi_unified_cmd_send(wmi_handle, buf,
  773. len, WMI_DBGLOG_CFG_CMDID);
  774. if (status != A_OK)
  775. cdf_nbuf_free(buf);
  776. return status;
  777. }
  778. /**
  779. * send_vdev_set_param_cmd_tlv() - WMI vdev set parameter function
  780. * @param wmi_handle : handle to WMI.
  781. * @param macaddr : MAC address
  782. * @param param : pointer to hold vdev set parameter
  783. *
  784. * Return: 0 on success and -ve on failure.
  785. */
  786. CDF_STATUS send_vdev_set_param_cmd_tlv(wmi_unified_t wmi_handle,
  787. struct vdev_set_params *param)
  788. {
  789. int32_t ret;
  790. wmi_vdev_set_param_cmd_fixed_param *cmd;
  791. wmi_buf_t buf;
  792. uint16_t len = sizeof(*cmd);
  793. buf = wmi_buf_alloc(wmi_handle, len);
  794. if (!buf) {
  795. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  796. return -ENOMEM;
  797. }
  798. cmd = (wmi_vdev_set_param_cmd_fixed_param *) wmi_buf_data(buf);
  799. WMITLV_SET_HDR(&cmd->tlv_header,
  800. WMITLV_TAG_STRUC_wmi_vdev_set_param_cmd_fixed_param,
  801. WMITLV_GET_STRUCT_TLVLEN
  802. (wmi_vdev_set_param_cmd_fixed_param));
  803. cmd->vdev_id = param->if_id;
  804. cmd->param_id = param->param_id;
  805. cmd->param_value = param->param_value;
  806. WMA_LOGD("Setting vdev %d param = %x, value = %u",
  807. param->if_id, param->param_id, param->param_value);
  808. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  809. WMI_VDEV_SET_PARAM_CMDID);
  810. if (ret < 0) {
  811. WMA_LOGE("Failed to send set param command ret = %d", ret);
  812. wmi_buf_free(buf);
  813. }
  814. return ret;
  815. }
  816. /**
  817. * send_stats_request_cmd_tlv() - WMI request stats function
  818. * @param wmi_handle : handle to WMI.
  819. * @param macaddr : MAC address
  820. * @param param : pointer to hold stats request parameter
  821. *
  822. * Return: 0 on success and -ve on failure.
  823. */
  824. CDF_STATUS send_stats_request_cmd_tlv(wmi_unified_t wmi_handle,
  825. uint8_t macaddr[IEEE80211_ADDR_LEN],
  826. struct stats_request_params *param)
  827. {
  828. int32_t ret;
  829. wmi_request_stats_cmd_fixed_param *cmd;
  830. wmi_buf_t buf;
  831. uint16_t len = sizeof(wmi_request_stats_cmd_fixed_param);
  832. buf = wmi_buf_alloc(wmi_handle, len);
  833. if (!buf) {
  834. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  835. return -CDF_STATUS_E_NOMEM;
  836. }
  837. cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
  838. WMITLV_SET_HDR(&cmd->tlv_header,
  839. WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
  840. WMITLV_GET_STRUCT_TLVLEN
  841. (wmi_request_stats_cmd_fixed_param));
  842. cmd->stats_id = param->stats_id;
  843. cmd->vdev_id = param->vdev_id;
  844. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  845. WMI_REQUEST_STATS_CMDID);
  846. if (ret) {
  847. WMA_LOGE("Failed to send status request to fw =%d", ret);
  848. wmi_buf_free(buf);
  849. }
  850. return ret;
  851. }
  852. /**
  853. * send_packet_log_enable_cmd_tlv() - WMI request stats function
  854. * @param wmi_handle : handle to WMI.
  855. * @param macaddr : MAC address
  856. * @param param : pointer to hold stats request parameter
  857. *
  858. * Return: 0 on success and -ve on failure.
  859. */
  860. CDF_STATUS send_packet_log_enable_cmd_tlv(wmi_unified_t wmi_handle,
  861. uint8_t macaddr[IEEE80211_ADDR_LEN],
  862. struct packet_enable_params *param)
  863. {
  864. return 0;
  865. }
  866. /**
  867. * send_beacon_send_cmd_tlv() - WMI beacon send function
  868. * @param wmi_handle : handle to WMI.
  869. * @param param : pointer to hold beacon send cmd parameter
  870. *
  871. * Return: 0 on success and -ve on failure.
  872. */
  873. CDF_STATUS send_beacon_send_cmd_tlv(wmi_unified_t wmi_handle,
  874. struct beacon_params *param)
  875. {
  876. int32_t ret;
  877. wmi_bcn_tmpl_cmd_fixed_param *cmd;
  878. wmi_bcn_prb_info *bcn_prb_info;
  879. wmi_buf_t wmi_buf;
  880. uint8_t *buf_ptr;
  881. uint32_t wmi_buf_len;
  882. wmi_buf_len = sizeof(wmi_bcn_tmpl_cmd_fixed_param) +
  883. sizeof(wmi_bcn_prb_info) + WMI_TLV_HDR_SIZE +
  884. param->tmpl_len_aligned;
  885. wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len);
  886. if (!wmi_buf) {
  887. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  888. return -ENOMEM;
  889. }
  890. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  891. cmd = (wmi_bcn_tmpl_cmd_fixed_param *) buf_ptr;
  892. WMITLV_SET_HDR(&cmd->tlv_header,
  893. WMITLV_TAG_STRUC_wmi_bcn_tmpl_cmd_fixed_param,
  894. WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_tmpl_cmd_fixed_param));
  895. cmd->vdev_id = param->vdev_id;
  896. cmd->tim_ie_offset = param->tim_ie_offset;
  897. cmd->buf_len = param->tmpl_len;
  898. buf_ptr += sizeof(wmi_bcn_tmpl_cmd_fixed_param);
  899. bcn_prb_info = (wmi_bcn_prb_info *) buf_ptr;
  900. WMITLV_SET_HDR(&bcn_prb_info->tlv_header,
  901. WMITLV_TAG_STRUC_wmi_bcn_prb_info,
  902. WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_prb_info));
  903. bcn_prb_info->caps = 0;
  904. bcn_prb_info->erp = 0;
  905. buf_ptr += sizeof(wmi_bcn_prb_info);
  906. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, param->tmpl_len_aligned);
  907. buf_ptr += WMI_TLV_HDR_SIZE;
  908. cdf_mem_copy(buf_ptr, param->frm, param->tmpl_len);
  909. ret = wmi_unified_cmd_send(wmi_handle,
  910. wmi_buf, wmi_buf_len, WMI_BCN_TMPL_CMDID);
  911. if (ret) {
  912. WMA_LOGE("%s: Failed to send bcn tmpl: %d", __func__, ret);
  913. wmi_buf_free(wmi_buf);
  914. }
  915. return 0;
  916. }
  917. /**
  918. * send_peer_assoc_cmd_tlv() - WMI peer assoc function
  919. * @param wmi_handle : handle to WMI.
  920. * @param param : pointer to peer assoc parameter
  921. *
  922. * Return: 0 on success and -ve on failure.
  923. */
  924. CDF_STATUS send_peer_assoc_cmd_tlv(wmi_unified_t wmi_handle,
  925. struct peer_assoc_params *param)
  926. {
  927. wmi_peer_assoc_complete_cmd_fixed_param *cmd;
  928. wmi_vht_rate_set *mcs;
  929. wmi_buf_t buf;
  930. int32_t len;
  931. uint8_t *buf_ptr;
  932. int ret;
  933. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
  934. (param->num_peer_legacy_rates * sizeof(uint8_t)) +
  935. WMI_TLV_HDR_SIZE +
  936. (param->num_peer_ht_rates * sizeof(uint8_t)) +
  937. sizeof(wmi_vht_rate_set);
  938. buf = wmi_buf_alloc(wmi_handle, len);
  939. if (!buf) {
  940. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  941. return -ENOMEM;
  942. }
  943. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  944. cmd = (wmi_peer_assoc_complete_cmd_fixed_param *) buf_ptr;
  945. WMITLV_SET_HDR(&cmd->tlv_header,
  946. WMITLV_TAG_STRUC_wmi_peer_assoc_complete_cmd_fixed_param,
  947. WMITLV_GET_STRUCT_TLVLEN
  948. (wmi_peer_assoc_complete_cmd_fixed_param));
  949. cmd->vdev_id = param->vdev_id;
  950. cmd->peer_new_assoc = param->peer_new_assoc;
  951. cmd->peer_associd = param->peer_associd;
  952. cmd->peer_flags = param->peer_flags;
  953. cmd->peer_rate_caps = param->peer_rate_caps;
  954. cmd->peer_caps = param->peer_caps;
  955. cmd->peer_listen_intval = param->peer_listen_intval;
  956. cmd->peer_ht_caps = param->peer_ht_caps;
  957. cmd->peer_max_mpdu = param->peer_max_mpdu;
  958. cmd->peer_mpdu_density = param->peer_mpdu_density;
  959. cmd->num_peer_legacy_rates = param->num_peer_legacy_rates;
  960. cmd->num_peer_ht_rates = param->num_peer_ht_rates;
  961. cmd->peer_vht_caps = param->peer_vht_caps;
  962. cmd->peer_phymode = param->peer_phymode;
  963. /* Update peer legacy rate information */
  964. buf_ptr += sizeof(*cmd);
  965. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  966. param->num_peer_legacy_rates);
  967. buf_ptr += WMI_TLV_HDR_SIZE;
  968. cmd->num_peer_legacy_rates = param->num_peer_legacy_rates;
  969. cdf_mem_copy(buf_ptr, param->peer_legacy_rates.rates,
  970. param->peer_legacy_rates.num_rates);
  971. /* Update peer HT rate information */
  972. buf_ptr += param->num_peer_legacy_rates;
  973. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  974. param->num_peer_ht_rates);
  975. buf_ptr += WMI_TLV_HDR_SIZE;
  976. cmd->num_peer_ht_rates = param->num_peer_ht_rates;
  977. cdf_mem_copy(buf_ptr, param->peer_ht_rates.rates,
  978. param->peer_ht_rates.num_rates);
  979. /* VHT Rates */
  980. buf_ptr += param->num_peer_ht_rates;
  981. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_STRUC_wmi_vht_rate_set,
  982. WMITLV_GET_STRUCT_TLVLEN(wmi_vht_rate_set));
  983. cmd->peer_nss = param->peer_nss;
  984. mcs = (wmi_vht_rate_set *) buf_ptr;
  985. if (param->vht_capable) {
  986. mcs->rx_max_rate = param->rx_max_rate;
  987. mcs->rx_mcs_set = param->rx_mcs_set;
  988. mcs->tx_max_rate = param->tx_max_rate;
  989. mcs->tx_mcs_set = param->tx_mcs_set;
  990. }
  991. WMA_LOGD("%s: vdev_id %d associd %d peer_flags %x rate_caps %x "
  992. "peer_caps %x listen_intval %d ht_caps %x max_mpdu %d "
  993. "nss %d phymode %d peer_mpdu_density %d "
  994. "cmd->peer_vht_caps %x", __func__,
  995. cmd->vdev_id, cmd->peer_associd, cmd->peer_flags,
  996. cmd->peer_rate_caps, cmd->peer_caps,
  997. cmd->peer_listen_intval, cmd->peer_ht_caps,
  998. cmd->peer_max_mpdu, cmd->peer_nss, cmd->peer_phymode,
  999. cmd->peer_mpdu_density,
  1000. cmd->peer_vht_caps);
  1001. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1002. WMI_PEER_ASSOC_CMDID);
  1003. if (ret != EOK) {
  1004. WMA_LOGP("%s: Failed to send peer assoc command ret = %d",
  1005. __func__, ret);
  1006. cdf_nbuf_free(buf);
  1007. }
  1008. return ret;
  1009. }
  1010. /**
  1011. * send_scan_start_cmd_tlv() - WMI scan start function
  1012. * @param wmi_handle : handle to WMI.
  1013. * @param param : pointer to hold scan start cmd parameter
  1014. *
  1015. * Return: 0 on success and -ve on failure.
  1016. */
  1017. CDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
  1018. struct scan_start_params *params)
  1019. {
  1020. int32_t ret = 0;
  1021. int32_t i;
  1022. wmi_buf_t wmi_buf;
  1023. wmi_start_scan_cmd_fixed_param *cmd;
  1024. uint8_t *buf_ptr;
  1025. uint32_t *tmp_ptr;
  1026. wmi_ssid *ssid = NULL;
  1027. wmi_mac_addr *bssid;
  1028. int len = sizeof(*cmd);
  1029. /* Length TLV placeholder for array of uint32_t */
  1030. len += WMI_TLV_HDR_SIZE;
  1031. /* calculate the length of buffer required */
  1032. if (params->num_chan)
  1033. len += params->num_chan * sizeof(uint32_t);
  1034. /* Length TLV placeholder for array of wmi_ssid structures */
  1035. len += WMI_TLV_HDR_SIZE;
  1036. if (params->num_ssids)
  1037. len += params->num_ssids * sizeof(wmi_ssid);
  1038. /* Length TLV placeholder for array of wmi_mac_addr structures */
  1039. len += WMI_TLV_HDR_SIZE;
  1040. len += sizeof(wmi_mac_addr);
  1041. /* Length TLV placeholder for array of bytes */
  1042. len += WMI_TLV_HDR_SIZE;
  1043. if (params->ie_len)
  1044. len += roundup(params->ie_len, sizeof(uint32_t));
  1045. /* Allocate the memory */
  1046. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  1047. if (!wmi_buf) {
  1048. WMA_LOGP("%s: failed to allocate memory for start scan cmd",
  1049. __func__);
  1050. return CDF_STATUS_E_FAILURE;
  1051. }
  1052. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  1053. cmd = (wmi_start_scan_cmd_fixed_param *) buf_ptr;
  1054. WMITLV_SET_HDR(&cmd->tlv_header,
  1055. WMITLV_TAG_STRUC_wmi_start_scan_cmd_fixed_param,
  1056. WMITLV_GET_STRUCT_TLVLEN
  1057. (wmi_start_scan_cmd_fixed_param));
  1058. cmd->scan_id = params->scan_id;
  1059. cmd->scan_req_id = params->scan_req_id;
  1060. cmd->vdev_id = params->vdev_id;
  1061. cmd->scan_priority = params->scan_priority;
  1062. cmd->notify_scan_events = params->notify_scan_events;
  1063. cmd->dwell_time_active = params->dwell_time_active;
  1064. cmd->dwell_time_passive = params->dwell_time_passive;
  1065. cmd->min_rest_time = params->min_rest_time;
  1066. cmd->max_rest_time = params->max_rest_time;
  1067. cmd->repeat_probe_time = params->repeat_probe_time;
  1068. cmd->probe_spacing_time = params->probe_spacing_time;
  1069. cmd->idle_time = params->idle_time;
  1070. cmd->max_scan_time = params->max_scan_time;
  1071. cmd->probe_delay = params->probe_delay;
  1072. cmd->scan_ctrl_flags = params->scan_ctrl_flags;
  1073. cmd->burst_duration = params->burst_duration;
  1074. cmd->num_chan = params->num_chan;
  1075. cmd->num_bssid = params->num_bssid;
  1076. cmd->num_ssids = params->num_ssids;
  1077. cmd->ie_len = params->ie_len;
  1078. cmd->n_probes = params->n_probes;
  1079. buf_ptr += sizeof(*cmd);
  1080. tmp_ptr = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE);
  1081. for (i = 0; i < params->num_chan; ++i)
  1082. tmp_ptr[i] = params->chan_list[i];
  1083. WMITLV_SET_HDR(buf_ptr,
  1084. WMITLV_TAG_ARRAY_UINT32,
  1085. (params->num_chan * sizeof(uint32_t)));
  1086. buf_ptr += WMI_TLV_HDR_SIZE + (params->num_chan * sizeof(uint32_t));
  1087. if (params->num_ssids > WMI_SCAN_MAX_NUM_SSID) {
  1088. WMA_LOGE("Invalid value for numSsid");
  1089. goto error;
  1090. }
  1091. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC,
  1092. (params->num_ssids * sizeof(wmi_ssid)));
  1093. if (params->num_ssids) {
  1094. ssid = (wmi_ssid *) (buf_ptr + WMI_TLV_HDR_SIZE);
  1095. for (i = 0; i < params->num_ssids; ++i) {
  1096. ssid->ssid_len = params->ssid[i].length;
  1097. cdf_mem_copy(ssid->ssid, params->ssid[i].mac_ssid,
  1098. params->ssid[i].length);
  1099. ssid++;
  1100. }
  1101. }
  1102. buf_ptr += WMI_TLV_HDR_SIZE + (params->num_ssids * sizeof(wmi_ssid));
  1103. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC,
  1104. (params->num_bssid * sizeof(wmi_mac_addr)));
  1105. bssid = (wmi_mac_addr *) (buf_ptr + WMI_TLV_HDR_SIZE);
  1106. WMI_CHAR_ARRAY_TO_MAC_ADDR(params->mac_add_bytes, bssid);
  1107. buf_ptr += WMI_TLV_HDR_SIZE + (params->num_bssid * sizeof(wmi_mac_addr));
  1108. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, params->ie_len_with_pad);
  1109. if (params->ie_len) {
  1110. cdf_mem_copy(buf_ptr + WMI_TLV_HDR_SIZE,
  1111. (uint8_t *) params->ie_base +
  1112. (params->uie_fieldOffset), params->ie_len);
  1113. }
  1114. buf_ptr += WMI_TLV_HDR_SIZE + params->ie_len_with_pad;
  1115. ret = wmi_unified_cmd_send(wmi_handle, wmi_buf,
  1116. len, WMI_START_SCAN_CMDID);
  1117. if (ret) {
  1118. WMA_LOGE("%s: Failed to start scan: %d", __func__, ret);
  1119. wmi_buf_free(wmi_buf);
  1120. }
  1121. return ret;
  1122. error:
  1123. cdf_nbuf_free(wmi_buf);
  1124. return CDF_STATUS_E_FAILURE;
  1125. }
  1126. /**
  1127. * send_scan_stop_cmd_tlv() - WMI scan start function
  1128. * @param wmi_handle : handle to WMI.
  1129. * @param param : pointer to hold scan start cmd parameter
  1130. *
  1131. * Return: 0 on success and -ve on failure.
  1132. */
  1133. CDF_STATUS send_scan_stop_cmd_tlv(wmi_unified_t wmi_handle,
  1134. struct scan_stop_params *param)
  1135. {
  1136. wmi_stop_scan_cmd_fixed_param *cmd;
  1137. int ret;
  1138. int len = sizeof(*cmd);
  1139. wmi_buf_t wmi_buf;
  1140. /* Allocate the memory */
  1141. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  1142. if (!wmi_buf) {
  1143. WMA_LOGP("%s: failed to allocate memory for stop scan cmd",
  1144. __func__);
  1145. ret = -ENOMEM;
  1146. goto error;
  1147. }
  1148. cmd = (wmi_stop_scan_cmd_fixed_param *) wmi_buf_data(wmi_buf);
  1149. WMITLV_SET_HDR(&cmd->tlv_header,
  1150. WMITLV_TAG_STRUC_wmi_stop_scan_cmd_fixed_param,
  1151. WMITLV_GET_STRUCT_TLVLEN(wmi_stop_scan_cmd_fixed_param));
  1152. cmd->vdev_id = param->vdev_id;
  1153. cmd->requestor = param->requestor;
  1154. cmd->scan_id = param->scan_id;
  1155. /* stop the scan with the corresponding scan_id */
  1156. cmd->req_type = param->req_type;
  1157. ret = wmi_unified_cmd_send(wmi_handle, wmi_buf,
  1158. len, WMI_STOP_SCAN_CMDID);
  1159. if (ret) {
  1160. WMA_LOGE("%s: Failed to send stop scan: %d", __func__, ret);
  1161. wmi_buf_free(wmi_buf);
  1162. }
  1163. error:
  1164. return ret;
  1165. }
  1166. /**
  1167. * send_scan_chan_list_cmd_tlv() - WMI scan channel list function
  1168. * @param wmi_handle : handle to WMI.
  1169. * @param param : pointer to hold scan channel list parameter
  1170. *
  1171. * Return: 0 on success and -ve on failure.
  1172. */
  1173. CDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle,
  1174. struct scan_chan_list_params *chan_list)
  1175. {
  1176. wmi_buf_t buf;
  1177. CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
  1178. wmi_scan_chan_list_cmd_fixed_param *cmd;
  1179. int status, i;
  1180. uint8_t *buf_ptr;
  1181. wmi_channel *chan_info, *tchan_info;
  1182. uint16_t len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
  1183. len += sizeof(wmi_channel) * chan_list->num_scan_chans;
  1184. buf = wmi_buf_alloc(wmi_handle, len);
  1185. if (!buf) {
  1186. WMA_LOGE("Failed to allocate memory");
  1187. cdf_status = CDF_STATUS_E_NOMEM;
  1188. goto end;
  1189. }
  1190. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1191. cmd = (wmi_scan_chan_list_cmd_fixed_param *) buf_ptr;
  1192. WMITLV_SET_HDR(&cmd->tlv_header,
  1193. WMITLV_TAG_STRUC_wmi_scan_chan_list_cmd_fixed_param,
  1194. WMITLV_GET_STRUCT_TLVLEN
  1195. (wmi_scan_chan_list_cmd_fixed_param));
  1196. WMA_LOGD("no of channels = %d, len = %d", chan_list->num_scan_chans, len);
  1197. cmd->num_scan_chans = chan_list->num_scan_chans;
  1198. WMITLV_SET_HDR((buf_ptr + sizeof(wmi_scan_chan_list_cmd_fixed_param)),
  1199. WMITLV_TAG_ARRAY_STRUC,
  1200. sizeof(wmi_channel) * chan_list->num_scan_chans);
  1201. chan_info = (wmi_channel *) (buf_ptr + sizeof(*cmd) + WMI_TLV_HDR_SIZE);
  1202. tchan_info = chan_list->chan_info;
  1203. for (i = 0; i < chan_list->num_scan_chans; ++i) {
  1204. WMITLV_SET_HDR(&chan_info->tlv_header,
  1205. WMITLV_TAG_STRUC_wmi_channel,
  1206. WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
  1207. chan_info->mhz = tchan_info->mhz;
  1208. chan_info->band_center_freq1 =
  1209. tchan_info->band_center_freq1;
  1210. chan_info->band_center_freq2 =
  1211. tchan_info->band_center_freq2;
  1212. chan_info->info = tchan_info->info;
  1213. chan_info->reg_info_1 = tchan_info->reg_info_1;
  1214. chan_info->reg_info_2 = tchan_info->reg_info_2;
  1215. WMA_LOGD("chan[%d] = %u", i, chan_info->mhz);
  1216. /*TODO: Set WMI_SET_CHANNEL_MIN_POWER */
  1217. /*TODO: Set WMI_SET_CHANNEL_ANTENNA_MAX */
  1218. /*TODO: WMI_SET_CHANNEL_REG_CLASSID */
  1219. tchan_info++;
  1220. chan_info++;
  1221. }
  1222. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  1223. WMI_SCAN_CHAN_LIST_CMDID);
  1224. if (status != EOK) {
  1225. cdf_status = CDF_STATUS_E_FAILURE;
  1226. WMA_LOGE("Failed to send WMI_SCAN_CHAN_LIST_CMDID");
  1227. wmi_buf_free(buf);
  1228. }
  1229. end:
  1230. return cdf_status;
  1231. }
  1232. /**
  1233. * send_mgmt_cmd_tlv() - WMI scan start function
  1234. * @wmi_handle : handle to WMI.
  1235. * @param : pointer to hold mgmt cmd parameter
  1236. *
  1237. * Return: 0 on success and -ve on failure.
  1238. */
  1239. CDF_STATUS send_mgmt_cmd_tlv(wmi_unified_t wmi_handle,
  1240. struct wmi_mgmt_params *param)
  1241. {
  1242. wmi_buf_t buf;
  1243. wmi_mgmt_tx_send_cmd_fixed_param *cmd;
  1244. int32_t cmd_len;
  1245. uint64_t dma_addr;
  1246. struct wmi_desc_t *wmi_desc = NULL;
  1247. void *cdf_ctx = param->cdf_ctx;
  1248. uint8_t *bufp;
  1249. int32_t bufp_len = (param->frm_len < mgmt_tx_dl_frm_len) ? param->frm_len :
  1250. mgmt_tx_dl_frm_len;
  1251. cmd_len = sizeof(wmi_mgmt_tx_send_cmd_fixed_param) +
  1252. WMI_TLV_HDR_SIZE + roundup(bufp_len, sizeof(uint32_t));
  1253. buf = wmi_buf_alloc(wmi_handle, cmd_len);
  1254. if (!buf) {
  1255. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  1256. return CDF_STATUS_E_NOMEM;
  1257. }
  1258. cmd = (wmi_mgmt_tx_send_cmd_fixed_param *)wmi_buf_data(buf);
  1259. bufp = (uint8_t *) cmd;
  1260. WMITLV_SET_HDR(&cmd->tlv_header,
  1261. WMITLV_TAG_STRUC_wmi_mgmt_tx_send_cmd_fixed_param,
  1262. WMITLV_GET_STRUCT_TLVLEN
  1263. (wmi_mgmt_tx_send_cmd_fixed_param));
  1264. cmd->vdev_id = param->vdev_id;
  1265. wmi_desc = param->wmi_desc;
  1266. if (!wmi_desc) {
  1267. WMA_LOGE("%s: Failed to get wmi_desc", __func__);
  1268. goto err1;
  1269. }
  1270. wmi_desc->nbuf = param->tx_frame;
  1271. wmi_desc->tx_cmpl_cb = param->tx_complete_cb;
  1272. wmi_desc->ota_post_proc_cb = param->tx_ota_post_proc_cb;
  1273. cmd->desc_id = wmi_desc->desc_id;
  1274. cmd->chanfreq = param->chanfreq;
  1275. bufp += sizeof(wmi_mgmt_tx_send_cmd_fixed_param);
  1276. WMITLV_SET_HDR(bufp, WMITLV_TAG_ARRAY_BYTE, roundup(bufp_len,
  1277. sizeof(uint32_t)));
  1278. bufp += WMI_TLV_HDR_SIZE;
  1279. cdf_mem_copy(bufp, param->pdata, bufp_len);
  1280. cdf_nbuf_map_single(cdf_ctx, param->tx_frame, CDF_DMA_TO_DEVICE);
  1281. dma_addr = cdf_nbuf_get_frag_paddr_lo(param->tx_frame, 0);
  1282. cmd->paddr_lo = (uint32_t)(dma_addr & 0xffffffff);
  1283. #if defined(HELIUMPLUS_PADDR64)
  1284. cmd->paddr_hi = (uint32_t)((dma_addr >> 32) & 0x1F);
  1285. #endif
  1286. cmd->frame_len = param->frm_len;
  1287. cmd->buf_len = bufp_len;
  1288. if (wmi_unified_cmd_send(wmi_handle, buf, cmd_len,
  1289. WMI_MGMT_TX_SEND_CMDID)) {
  1290. WMA_LOGE("%s: Failed to send mgmt Tx", __func__);
  1291. goto err1;
  1292. }
  1293. return CDF_STATUS_SUCCESS;
  1294. err1:
  1295. wmi_buf_free(buf);
  1296. return CDF_STATUS_E_FAILURE;
  1297. }
  1298. /**
  1299. * send_modem_power_state_cmd_tlv() - set modem power state to fw
  1300. * @wmi_handle: wmi handle
  1301. * @param_value: parameter value
  1302. *
  1303. * Return: 0 for success or error code
  1304. */
  1305. CDF_STATUS send_modem_power_state_cmd_tlv(wmi_unified_t wmi_handle,
  1306. uint32_t param_value)
  1307. {
  1308. int ret;
  1309. wmi_modem_power_state_cmd_param *cmd;
  1310. wmi_buf_t buf;
  1311. uint16_t len = sizeof(*cmd);
  1312. buf = wmi_buf_alloc(wmi_handle, len);
  1313. if (!buf) {
  1314. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  1315. return -ENOMEM;
  1316. }
  1317. cmd = (wmi_modem_power_state_cmd_param *) wmi_buf_data(buf);
  1318. WMITLV_SET_HDR(&cmd->tlv_header,
  1319. WMITLV_TAG_STRUC_wmi_modem_power_state_cmd_param,
  1320. WMITLV_GET_STRUCT_TLVLEN
  1321. (wmi_modem_power_state_cmd_param));
  1322. cmd->modem_power_state = param_value;
  1323. WMA_LOGD("%s: Setting cmd->modem_power_state = %u", __func__,
  1324. param_value);
  1325. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1326. WMI_MODEM_POWER_STATE_CMDID);
  1327. if (ret != EOK) {
  1328. WMA_LOGE("Failed to send notify cmd ret = %d", ret);
  1329. wmi_buf_free(buf);
  1330. }
  1331. return ret;
  1332. }
  1333. /**
  1334. * send_set_sta_ps_mode_cmd_tlv() - set sta powersave mode in fw
  1335. * @wmi_handle: wmi handle
  1336. * @vdev_id: vdev id
  1337. * @val: value
  1338. *
  1339. * Return: 0 for success or error code.
  1340. */
  1341. CDF_STATUS send_set_sta_ps_mode_cmd_tlv(wmi_unified_t wmi_handle,
  1342. uint32_t vdev_id, uint8_t val)
  1343. {
  1344. wmi_sta_powersave_mode_cmd_fixed_param *cmd;
  1345. wmi_buf_t buf;
  1346. int32_t len = sizeof(*cmd);
  1347. WMA_LOGD("Set Sta Mode Ps vdevId %d val %d", vdev_id, val);
  1348. buf = wmi_buf_alloc(wmi_handle, len);
  1349. if (!buf) {
  1350. WMA_LOGP("%s: Set Sta Mode Ps Mem Alloc Failed", __func__);
  1351. return -ENOMEM;
  1352. }
  1353. cmd = (wmi_sta_powersave_mode_cmd_fixed_param *) wmi_buf_data(buf);
  1354. WMITLV_SET_HDR(&cmd->tlv_header,
  1355. WMITLV_TAG_STRUC_wmi_sta_powersave_mode_cmd_fixed_param,
  1356. WMITLV_GET_STRUCT_TLVLEN
  1357. (wmi_sta_powersave_mode_cmd_fixed_param));
  1358. cmd->vdev_id = vdev_id;
  1359. if (val)
  1360. cmd->sta_ps_mode = WMI_STA_PS_MODE_ENABLED;
  1361. else
  1362. cmd->sta_ps_mode = WMI_STA_PS_MODE_DISABLED;
  1363. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1364. WMI_STA_POWERSAVE_MODE_CMDID)) {
  1365. WMA_LOGE("Set Sta Mode Ps Failed vdevId %d val %d",
  1366. vdev_id, val);
  1367. cdf_nbuf_free(buf);
  1368. return -EIO;
  1369. }
  1370. return 0;
  1371. }
  1372. /**
  1373. * send_set_mimops_cmd_tlv() - set MIMO powersave
  1374. * @wmi_handle: wmi handle
  1375. * @vdev_id: vdev id
  1376. * @value: value
  1377. *
  1378. * Return: CDF_STATUS_SUCCESS for success or error code.
  1379. */
  1380. CDF_STATUS send_set_mimops_cmd_tlv(wmi_unified_t wmi_handle,
  1381. uint8_t vdev_id, int value)
  1382. {
  1383. int ret = CDF_STATUS_SUCCESS;
  1384. wmi_sta_smps_force_mode_cmd_fixed_param *cmd;
  1385. wmi_buf_t buf;
  1386. uint16_t len = sizeof(*cmd);
  1387. buf = wmi_buf_alloc(wmi_handle, len);
  1388. if (!buf) {
  1389. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  1390. return -ENOMEM;
  1391. }
  1392. cmd = (wmi_sta_smps_force_mode_cmd_fixed_param *) wmi_buf_data(buf);
  1393. WMITLV_SET_HDR(&cmd->tlv_header,
  1394. WMITLV_TAG_STRUC_wmi_sta_smps_force_mode_cmd_fixed_param,
  1395. WMITLV_GET_STRUCT_TLVLEN
  1396. (wmi_sta_smps_force_mode_cmd_fixed_param));
  1397. cmd->vdev_id = vdev_id;
  1398. switch (value) {
  1399. case 0:
  1400. cmd->forced_mode = WMI_SMPS_FORCED_MODE_NONE;
  1401. break;
  1402. case 1:
  1403. cmd->forced_mode = WMI_SMPS_FORCED_MODE_DISABLED;
  1404. break;
  1405. case 2:
  1406. cmd->forced_mode = WMI_SMPS_FORCED_MODE_STATIC;
  1407. break;
  1408. case 3:
  1409. cmd->forced_mode = WMI_SMPS_FORCED_MODE_DYNAMIC;
  1410. break;
  1411. default:
  1412. WMA_LOGE("%s:INVALID Mimo PS CONFIG", __func__);
  1413. return CDF_STATUS_E_FAILURE;
  1414. }
  1415. WMA_LOGD("Setting vdev %d value = %u", vdev_id, value);
  1416. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1417. WMI_STA_SMPS_FORCE_MODE_CMDID);
  1418. if (ret < 0) {
  1419. WMA_LOGE("Failed to send set Mimo PS ret = %d", ret);
  1420. wmi_buf_free(buf);
  1421. }
  1422. return ret;
  1423. }
  1424. /**
  1425. * send_set_smps_params_cmd_tlv() - set smps params
  1426. * @wmi_handle: wmi handle
  1427. * @vdev_id: vdev id
  1428. * @value: value
  1429. *
  1430. * Return: CDF_STATUS_SUCCESS for success or error code.
  1431. */
  1432. CDF_STATUS send_set_smps_params_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
  1433. int value)
  1434. {
  1435. int ret = CDF_STATUS_SUCCESS;
  1436. wmi_sta_smps_param_cmd_fixed_param *cmd;
  1437. wmi_buf_t buf;
  1438. uint16_t len = sizeof(*cmd);
  1439. buf = wmi_buf_alloc(wmi_handle, len);
  1440. if (!buf) {
  1441. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  1442. return -ENOMEM;
  1443. }
  1444. cmd = (wmi_sta_smps_param_cmd_fixed_param *) wmi_buf_data(buf);
  1445. WMITLV_SET_HDR(&cmd->tlv_header,
  1446. WMITLV_TAG_STRUC_wmi_sta_smps_param_cmd_fixed_param,
  1447. WMITLV_GET_STRUCT_TLVLEN
  1448. (wmi_sta_smps_param_cmd_fixed_param));
  1449. cmd->vdev_id = vdev_id;
  1450. cmd->value = value & WMI_SMPS_MASK_LOWER_16BITS;
  1451. cmd->param =
  1452. (value >> WMI_SMPS_PARAM_VALUE_S) & WMI_SMPS_MASK_UPPER_3BITS;
  1453. WMA_LOGD("Setting vdev %d value = %x param %x", vdev_id, cmd->value,
  1454. cmd->param);
  1455. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1456. WMI_STA_SMPS_PARAM_CMDID);
  1457. if (ret < 0) {
  1458. WMA_LOGE("Failed to send set Mimo PS ret = %d", ret);
  1459. wmi_buf_free(buf);
  1460. }
  1461. return ret;
  1462. }
  1463. /**
  1464. * send_set_p2pgo_noa_req_cmd_tlv() - send p2p go noa request to fw
  1465. * @wmi_handle: wmi handle
  1466. * @noa: p2p power save parameters
  1467. *
  1468. * Return: CDF status
  1469. */
  1470. CDF_STATUS send_set_p2pgo_noa_req_cmd_tlv(wmi_unified_t wmi_handle,
  1471. struct p2p_ps_params *noa)
  1472. {
  1473. wmi_p2p_set_noa_cmd_fixed_param *cmd;
  1474. wmi_p2p_noa_descriptor *noa_discriptor;
  1475. wmi_buf_t buf;
  1476. uint8_t *buf_ptr;
  1477. uint16_t len;
  1478. int32_t status;
  1479. uint32_t duration;
  1480. WMA_LOGD("%s: Enter", __func__);
  1481. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + sizeof(*noa_discriptor);
  1482. buf = wmi_buf_alloc(wmi_handle, len);
  1483. if (!buf) {
  1484. WMA_LOGE("Failed to allocate memory");
  1485. status = CDF_STATUS_E_FAILURE;
  1486. goto end;
  1487. }
  1488. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1489. cmd = (wmi_p2p_set_noa_cmd_fixed_param *) buf_ptr;
  1490. WMITLV_SET_HDR(&cmd->tlv_header,
  1491. WMITLV_TAG_STRUC_wmi_p2p_set_noa_cmd_fixed_param,
  1492. WMITLV_GET_STRUCT_TLVLEN
  1493. (wmi_p2p_set_noa_cmd_fixed_param));
  1494. duration = (noa->count == 1) ? noa->single_noa_duration : noa->duration;
  1495. cmd->vdev_id = noa->session_id;
  1496. cmd->enable = (duration) ? true : false;
  1497. cmd->num_noa = 1;
  1498. WMITLV_SET_HDR((buf_ptr + sizeof(wmi_p2p_set_noa_cmd_fixed_param)),
  1499. WMITLV_TAG_ARRAY_STRUC, sizeof(wmi_p2p_noa_descriptor));
  1500. noa_discriptor = (wmi_p2p_noa_descriptor *) (buf_ptr +
  1501. sizeof
  1502. (wmi_p2p_set_noa_cmd_fixed_param)
  1503. + WMI_TLV_HDR_SIZE);
  1504. WMITLV_SET_HDR(&noa_discriptor->tlv_header,
  1505. WMITLV_TAG_STRUC_wmi_p2p_noa_descriptor,
  1506. WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_noa_descriptor));
  1507. noa_discriptor->type_count = noa->count;
  1508. noa_discriptor->duration = duration;
  1509. noa_discriptor->interval = noa->interval;
  1510. noa_discriptor->start_time = 0;
  1511. WMA_LOGI("SET P2P GO NOA:vdev_id:%d count:%d duration:%d interval:%d",
  1512. cmd->vdev_id, noa->count, noa_discriptor->duration,
  1513. noa->interval);
  1514. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  1515. WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID);
  1516. if (status != EOK) {
  1517. WMA_LOGE("Failed to send WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID");
  1518. wmi_buf_free(buf);
  1519. }
  1520. end:
  1521. WMA_LOGD("%s: Exit", __func__);
  1522. return status;
  1523. }
  1524. /**
  1525. * send_set_p2pgo_oppps_req_cmd_tlv() - send p2p go opp power save request to fw
  1526. * @wmi_handle: wmi handle
  1527. * @noa: p2p opp power save parameters
  1528. *
  1529. * Return: CDF status
  1530. */
  1531. CDF_STATUS send_set_p2pgo_oppps_req_cmd_tlv(wmi_unified_t wmi_handle,
  1532. struct p2p_ps_params *oppps)
  1533. {
  1534. wmi_p2p_set_oppps_cmd_fixed_param *cmd;
  1535. wmi_buf_t buf;
  1536. int32_t status;
  1537. WMA_LOGD("%s: Enter", __func__);
  1538. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  1539. if (!buf) {
  1540. WMA_LOGE("Failed to allocate memory");
  1541. status = CDF_STATUS_E_FAILURE;
  1542. goto end;
  1543. }
  1544. cmd = (wmi_p2p_set_oppps_cmd_fixed_param *) wmi_buf_data(buf);
  1545. WMITLV_SET_HDR(&cmd->tlv_header,
  1546. WMITLV_TAG_STRUC_wmi_p2p_set_oppps_cmd_fixed_param,
  1547. WMITLV_GET_STRUCT_TLVLEN
  1548. (wmi_p2p_set_oppps_cmd_fixed_param));
  1549. cmd->vdev_id = oppps->session_id;
  1550. if (oppps->ctwindow)
  1551. WMI_UNIFIED_OPPPS_ATTR_ENABLED_SET(cmd);
  1552. WMI_UNIFIED_OPPPS_ATTR_CTWIN_SET(cmd, oppps->ctwindow);
  1553. WMA_LOGI("SET P2P GO OPPPS:vdev_id:%d ctwindow:%d",
  1554. cmd->vdev_id, oppps->ctwindow);
  1555. status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
  1556. WMI_P2P_SET_OPPPS_PARAM_CMDID);
  1557. if (status != EOK) {
  1558. WMA_LOGE("Failed to send WMI_P2P_SET_OPPPS_PARAM_CMDID");
  1559. wmi_buf_free(buf);
  1560. }
  1561. end:
  1562. WMA_LOGD("%s: Exit", __func__);
  1563. return status;
  1564. }
  1565. /**
  1566. * send_get_temperature_cmd_tlv() - get pdev temperature req
  1567. * @wmi_handle: wmi handle
  1568. *
  1569. * Return: CDF_STATUS_SUCCESS for success or error code.
  1570. */
  1571. CDF_STATUS send_get_temperature_cmd_tlv(wmi_unified_t wmi_handle)
  1572. {
  1573. wmi_pdev_get_temperature_cmd_fixed_param *cmd;
  1574. wmi_buf_t wmi_buf;
  1575. uint32_t len = sizeof(wmi_pdev_get_temperature_cmd_fixed_param);
  1576. uint8_t *buf_ptr;
  1577. if (!wmi_handle) {
  1578. WMA_LOGE(FL("WMA is closed, can not issue cmd"));
  1579. return CDF_STATUS_E_INVAL;
  1580. }
  1581. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  1582. if (!wmi_buf) {
  1583. WMA_LOGE(FL("wmi_buf_alloc failed"));
  1584. return CDF_STATUS_E_NOMEM;
  1585. }
  1586. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  1587. cmd = (wmi_pdev_get_temperature_cmd_fixed_param *) buf_ptr;
  1588. WMITLV_SET_HDR(&cmd->tlv_header,
  1589. WMITLV_TAG_STRUC_wmi_pdev_get_temperature_cmd_fixed_param,
  1590. WMITLV_GET_STRUCT_TLVLEN
  1591. (wmi_pdev_get_temperature_cmd_fixed_param));
  1592. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  1593. WMI_PDEV_GET_TEMPERATURE_CMDID)) {
  1594. WMA_LOGE(FL("failed to send get temperature command"));
  1595. wmi_buf_free(wmi_buf);
  1596. return CDF_STATUS_E_FAILURE;
  1597. }
  1598. return CDF_STATUS_SUCCESS;
  1599. }
  1600. /**
  1601. * send_set_sta_uapsd_auto_trig_cmd_tlv() - set uapsd auto trigger command
  1602. * @wmi_handle: wmi handle
  1603. * @vdevid: vdev id
  1604. * @peer_addr: peer mac address
  1605. * @auto_triggerparam: auto trigger parameters
  1606. * @num_ac: number of access category
  1607. *
  1608. * This function sets the trigger
  1609. * uapsd params such as service interval, delay interval
  1610. * and suspend interval which will be used by the firmware
  1611. * to send trigger frames periodically when there is no
  1612. * traffic on the transmit side.
  1613. *
  1614. * Return: 0 for success or error code.
  1615. */
  1616. CDF_STATUS send_set_sta_uapsd_auto_trig_cmd_tlv(wmi_unified_t wmi_handle,
  1617. struct sta_uapsd_trig_params *param)
  1618. {
  1619. wmi_sta_uapsd_auto_trig_cmd_fixed_param *cmd;
  1620. int32_t ret;
  1621. uint32_t param_len = param->num_ac * sizeof(wmi_sta_uapsd_auto_trig_param);
  1622. uint32_t cmd_len = sizeof(*cmd) + param_len + WMI_TLV_HDR_SIZE;
  1623. uint32_t i;
  1624. wmi_buf_t buf;
  1625. uint8_t *buf_ptr;
  1626. buf = wmi_buf_alloc(wmi_handle, cmd_len);
  1627. if (!buf) {
  1628. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  1629. return -ENOMEM;
  1630. }
  1631. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1632. cmd = (wmi_sta_uapsd_auto_trig_cmd_fixed_param *) buf_ptr;
  1633. WMITLV_SET_HDR(&cmd->tlv_header,
  1634. WMITLV_TAG_STRUC_wmi_sta_uapsd_auto_trig_cmd_fixed_param,
  1635. WMITLV_GET_STRUCT_TLVLEN
  1636. (wmi_sta_uapsd_auto_trig_cmd_fixed_param));
  1637. cmd->vdev_id = param->vdevid;
  1638. cmd->num_ac = param->num_ac;
  1639. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr);
  1640. /* TLV indicating array of structures to follow */
  1641. buf_ptr += sizeof(*cmd);
  1642. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, param_len);
  1643. buf_ptr += WMI_TLV_HDR_SIZE;
  1644. cdf_mem_copy(buf_ptr, param->auto_triggerparam, param_len);
  1645. /*
  1646. * Update tag and length for uapsd auto trigger params (this will take
  1647. * care of updating tag and length if it is not pre-filled by caller).
  1648. */
  1649. for (i = 0; i < param->num_ac; i++) {
  1650. WMITLV_SET_HDR((buf_ptr +
  1651. (i * sizeof(wmi_sta_uapsd_auto_trig_param))),
  1652. WMITLV_TAG_STRUC_wmi_sta_uapsd_auto_trig_param,
  1653. WMITLV_GET_STRUCT_TLVLEN
  1654. (wmi_sta_uapsd_auto_trig_param));
  1655. }
  1656. ret = wmi_unified_cmd_send(wmi_handle, buf, cmd_len,
  1657. WMI_STA_UAPSD_AUTO_TRIG_CMDID);
  1658. if (ret != EOK) {
  1659. WMA_LOGE("Failed to send set uapsd param ret = %d", ret);
  1660. wmi_buf_free(buf);
  1661. }
  1662. return ret;
  1663. }
  1664. /**
  1665. * send_ocb_set_utc_time_cmd() - send the UTC time to the firmware
  1666. * @wmi_handle: pointer to the wmi handle
  1667. * @utc: pointer to the UTC time struct
  1668. *
  1669. * Return: 0 on succes
  1670. */
  1671. CDF_STATUS send_ocb_set_utc_time_cmd_tlv(wmi_unified_t wmi_handle,
  1672. struct ocb_utc_param *utc)
  1673. {
  1674. int32_t ret;
  1675. wmi_ocb_set_utc_time_cmd_fixed_param *cmd;
  1676. uint8_t *buf_ptr;
  1677. uint32_t len, i;
  1678. wmi_buf_t buf;
  1679. len = sizeof(*cmd);
  1680. buf = wmi_buf_alloc(wmi_handle, len);
  1681. if (!buf) {
  1682. WMA_LOGE(FL("wmi_buf_alloc failed"));
  1683. return -ENOMEM;
  1684. }
  1685. buf_ptr = (uint8_t *)wmi_buf_data(buf);
  1686. cmd = (wmi_ocb_set_utc_time_cmd_fixed_param *)buf_ptr;
  1687. WMITLV_SET_HDR(&cmd->tlv_header,
  1688. WMITLV_TAG_STRUC_wmi_ocb_set_utc_time_cmd_fixed_param,
  1689. WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_set_utc_time_cmd_fixed_param));
  1690. cmd->vdev_id = utc->vdev_id;
  1691. for (i = 0; i < SIZE_UTC_TIME; i++)
  1692. WMI_UTC_TIME_SET(cmd, i, utc->utc_time[i]);
  1693. for (i = 0; i < SIZE_UTC_TIME_ERROR; i++)
  1694. WMI_TIME_ERROR_SET(cmd, i, utc->time_error[i]);
  1695. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1696. WMI_OCB_SET_UTC_TIME_CMDID);
  1697. if (ret != EOK) {
  1698. WMA_LOGE(FL("Failed to set OCB UTC time"));
  1699. wmi_buf_free(buf);
  1700. return -EIO;
  1701. }
  1702. return CDF_STATUS_SUCCESS;
  1703. }
  1704. /**
  1705. * send_ocb_start_timing_advert_cmd_tlv() - start sending the timing advertisement
  1706. * frames on a channel
  1707. * @wmi_handle: pointer to the wmi handle
  1708. * @timing_advert: pointer to the timing advertisement struct
  1709. *
  1710. * Return: 0 on succes
  1711. */
  1712. CDF_STATUS send_ocb_start_timing_advert_cmd_tlv(wmi_unified_t wmi_handle,
  1713. struct ocb_timing_advert_param *timing_advert)
  1714. {
  1715. int32_t ret;
  1716. wmi_ocb_start_timing_advert_cmd_fixed_param *cmd;
  1717. uint8_t *buf_ptr;
  1718. uint32_t len, len_template;
  1719. wmi_buf_t buf;
  1720. len = sizeof(*cmd) +
  1721. WMI_TLV_HDR_SIZE;
  1722. len_template = timing_advert->template_length;
  1723. /* Add padding to the template if needed */
  1724. if (len_template % 4 != 0)
  1725. len_template += 4 - (len_template % 4);
  1726. len += len_template;
  1727. buf = wmi_buf_alloc(wmi_handle, len);
  1728. if (!buf) {
  1729. WMA_LOGE(FL("wmi_buf_alloc failed"));
  1730. return -ENOMEM;
  1731. }
  1732. buf_ptr = (uint8_t *)wmi_buf_data(buf);
  1733. cmd = (wmi_ocb_start_timing_advert_cmd_fixed_param *)buf_ptr;
  1734. WMITLV_SET_HDR(&cmd->tlv_header,
  1735. WMITLV_TAG_STRUC_wmi_ocb_start_timing_advert_cmd_fixed_param,
  1736. WMITLV_GET_STRUCT_TLVLEN(
  1737. wmi_ocb_start_timing_advert_cmd_fixed_param));
  1738. cmd->vdev_id = timing_advert->vdev_id;
  1739. cmd->repeat_rate = timing_advert->repeat_rate;
  1740. cmd->channel_freq = timing_advert->chan_freq;
  1741. cmd->timestamp_offset = timing_advert->timestamp_offset;
  1742. cmd->time_value_offset = timing_advert->time_value_offset;
  1743. cmd->timing_advert_template_length = timing_advert->template_length;
  1744. buf_ptr += sizeof(*cmd);
  1745. /* Add the timing advert template */
  1746. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  1747. len_template);
  1748. cdf_mem_copy(buf_ptr + WMI_TLV_HDR_SIZE,
  1749. (uint8_t *)timing_advert->template_value,
  1750. timing_advert->template_length);
  1751. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1752. WMI_OCB_START_TIMING_ADVERT_CMDID);
  1753. if (ret != EOK) {
  1754. WMA_LOGE(FL("Failed to start OCB timing advert"));
  1755. wmi_buf_free(buf);
  1756. return -EIO;
  1757. }
  1758. return CDF_STATUS_SUCCESS;
  1759. }
  1760. /**
  1761. * send_ocb_stop_timing_advert_cmd_tlv() - stop sending the timing advertisement frames
  1762. * on a channel
  1763. * @wmi_handle: pointer to the wmi handle
  1764. * @timing_advert: pointer to the timing advertisement struct
  1765. *
  1766. * Return: 0 on succes
  1767. */
  1768. CDF_STATUS send_ocb_stop_timing_advert_cmd_tlv(wmi_unified_t wmi_handle,
  1769. struct ocb_timing_advert_param *timing_advert)
  1770. {
  1771. int32_t ret;
  1772. wmi_ocb_stop_timing_advert_cmd_fixed_param *cmd;
  1773. uint8_t *buf_ptr;
  1774. uint32_t len;
  1775. wmi_buf_t buf;
  1776. len = sizeof(*cmd);
  1777. buf = wmi_buf_alloc(wmi_handle, len);
  1778. if (!buf) {
  1779. WMA_LOGE(FL("wmi_buf_alloc failed"));
  1780. return -ENOMEM;
  1781. }
  1782. buf_ptr = (uint8_t *)wmi_buf_data(buf);
  1783. cmd = (wmi_ocb_stop_timing_advert_cmd_fixed_param *)buf_ptr;
  1784. WMITLV_SET_HDR(&cmd->tlv_header,
  1785. WMITLV_TAG_STRUC_wmi_ocb_stop_timing_advert_cmd_fixed_param,
  1786. WMITLV_GET_STRUCT_TLVLEN(
  1787. wmi_ocb_stop_timing_advert_cmd_fixed_param));
  1788. cmd->vdev_id = timing_advert->vdev_id;
  1789. cmd->channel_freq = timing_advert->chan_freq;
  1790. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1791. WMI_OCB_STOP_TIMING_ADVERT_CMDID);
  1792. if (ret != EOK) {
  1793. WMA_LOGE(FL("Failed to stop OCB timing advert"));
  1794. wmi_buf_free(buf);
  1795. return -EIO;
  1796. }
  1797. return CDF_STATUS_SUCCESS;
  1798. }
  1799. /**
  1800. * send_ocb_get_tsf_timer_cmd_tlv() - get ocb tsf timer val
  1801. * @wmi_handle: pointer to the wmi handle
  1802. * @request: pointer to the request
  1803. *
  1804. * Return: 0 on succes
  1805. */
  1806. CDF_STATUS send_ocb_get_tsf_timer_cmd_tlv(wmi_unified_t wmi_handle,
  1807. uint8_t vdev_id)
  1808. {
  1809. CDF_STATUS ret;
  1810. wmi_ocb_get_tsf_timer_cmd_fixed_param *cmd;
  1811. uint8_t *buf_ptr;
  1812. wmi_buf_t buf;
  1813. int32_t len;
  1814. len = sizeof(*cmd);
  1815. buf = wmi_buf_alloc(wmi_handle, len);
  1816. if (!buf) {
  1817. WMA_LOGE(FL("wmi_buf_alloc failed"));
  1818. return -ENOMEM;
  1819. }
  1820. buf_ptr = (uint8_t *)wmi_buf_data(buf);
  1821. cmd = (wmi_ocb_get_tsf_timer_cmd_fixed_param *)buf_ptr;
  1822. cdf_mem_zero(cmd, len);
  1823. WMITLV_SET_HDR(&cmd->tlv_header,
  1824. WMITLV_TAG_STRUC_wmi_ocb_get_tsf_timer_cmd_fixed_param,
  1825. WMITLV_GET_STRUCT_TLVLEN(
  1826. wmi_ocb_get_tsf_timer_cmd_fixed_param));
  1827. cmd->vdev_id = vdev_id;
  1828. /* Send the WMI command */
  1829. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1830. WMI_OCB_GET_TSF_TIMER_CMDID);
  1831. /* If there is an error, set the completion event */
  1832. if (ret != EOK) {
  1833. WMA_LOGE(FL("Failed to send WMI message: %d"), ret);
  1834. wmi_buf_free(buf);
  1835. return -EIO;
  1836. }
  1837. return CDF_STATUS_SUCCESS;
  1838. }
  1839. /**
  1840. * send_dcc_get_stats_cmd_tlv() - get the DCC channel stats
  1841. * @wmi_handle: pointer to the wmi handle
  1842. * @get_stats_param: pointer to the dcc stats
  1843. *
  1844. * Return: 0 on succes
  1845. */
  1846. CDF_STATUS send_dcc_get_stats_cmd_tlv(wmi_unified_t wmi_handle,
  1847. struct dcc_get_stats_param *get_stats_param)
  1848. {
  1849. int32_t ret;
  1850. wmi_dcc_get_stats_cmd_fixed_param *cmd;
  1851. wmi_dcc_channel_stats_request *channel_stats_array;
  1852. wmi_buf_t buf;
  1853. uint8_t *buf_ptr;
  1854. uint32_t len;
  1855. uint32_t i;
  1856. /* Validate the input */
  1857. if (get_stats_param->request_array_len !=
  1858. get_stats_param->channel_count * sizeof(*channel_stats_array)) {
  1859. WMA_LOGE(FL("Invalid parameter"));
  1860. return -EINVAL;
  1861. }
  1862. /* Allocate memory for the WMI command */
  1863. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
  1864. get_stats_param->request_array_len;
  1865. buf = wmi_buf_alloc(wmi_handle, len);
  1866. if (!buf) {
  1867. WMA_LOGE(FL("wmi_buf_alloc failed"));
  1868. return CDF_STATUS_E_NOMEM;
  1869. }
  1870. buf_ptr = wmi_buf_data(buf);
  1871. cdf_mem_zero(buf_ptr, len);
  1872. /* Populate the WMI command */
  1873. cmd = (wmi_dcc_get_stats_cmd_fixed_param *)buf_ptr;
  1874. buf_ptr += sizeof(*cmd);
  1875. WMITLV_SET_HDR(&cmd->tlv_header,
  1876. WMITLV_TAG_STRUC_wmi_dcc_get_stats_cmd_fixed_param,
  1877. WMITLV_GET_STRUCT_TLVLEN(
  1878. wmi_dcc_get_stats_cmd_fixed_param));
  1879. cmd->vdev_id = get_stats_param->vdev_id;
  1880. cmd->num_channels = get_stats_param->channel_count;
  1881. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  1882. get_stats_param->request_array_len);
  1883. buf_ptr += WMI_TLV_HDR_SIZE;
  1884. channel_stats_array = (wmi_dcc_channel_stats_request *)buf_ptr;
  1885. cdf_mem_copy(channel_stats_array, get_stats_param->request_array,
  1886. get_stats_param->request_array_len);
  1887. for (i = 0; i < cmd->num_channels; i++)
  1888. WMITLV_SET_HDR(&channel_stats_array[i].tlv_header,
  1889. WMITLV_TAG_STRUC_wmi_dcc_channel_stats_request,
  1890. WMITLV_GET_STRUCT_TLVLEN(
  1891. wmi_dcc_channel_stats_request));
  1892. /* Send the WMI command */
  1893. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1894. WMI_DCC_GET_STATS_CMDID);
  1895. if (ret != EOK) {
  1896. WMA_LOGE(FL("Failed to send WMI message: %d"), ret);
  1897. wmi_buf_free(buf);
  1898. return -EIO;
  1899. }
  1900. return CDF_STATUS_SUCCESS;
  1901. }
  1902. /**
  1903. * send_dcc_clear_stats_cmd_tlv() - command to clear the DCC stats
  1904. * @wmi_handle: pointer to the wmi handle
  1905. * @vdev_id: vdev id
  1906. * @dcc_stats_bitmap: dcc status bitmap
  1907. *
  1908. * Return: 0 on succes
  1909. */
  1910. CDF_STATUS send_dcc_clear_stats_cmd_tlv(wmi_unified_t wmi_handle,
  1911. uint32_t vdev_id, uint32_t dcc_stats_bitmap)
  1912. {
  1913. int32_t ret;
  1914. wmi_dcc_clear_stats_cmd_fixed_param *cmd;
  1915. wmi_buf_t buf;
  1916. uint8_t *buf_ptr;
  1917. uint32_t len;
  1918. /* Allocate memory for the WMI command */
  1919. len = sizeof(*cmd);
  1920. buf = wmi_buf_alloc(wmi_handle, len);
  1921. if (!buf) {
  1922. WMA_LOGE(FL("wmi_buf_alloc failed"));
  1923. return -ENOMEM;
  1924. }
  1925. buf_ptr = wmi_buf_data(buf);
  1926. cdf_mem_zero(buf_ptr, len);
  1927. /* Populate the WMI command */
  1928. cmd = (wmi_dcc_clear_stats_cmd_fixed_param *)buf_ptr;
  1929. WMITLV_SET_HDR(&cmd->tlv_header,
  1930. WMITLV_TAG_STRUC_wmi_dcc_clear_stats_cmd_fixed_param,
  1931. WMITLV_GET_STRUCT_TLVLEN(
  1932. wmi_dcc_clear_stats_cmd_fixed_param));
  1933. cmd->vdev_id = vdev_id;
  1934. cmd->dcc_stats_bitmap = dcc_stats_bitmap;
  1935. /* Send the WMI command */
  1936. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1937. WMI_DCC_CLEAR_STATS_CMDID);
  1938. if (ret != EOK) {
  1939. WMA_LOGE(FL("Failed to send the WMI command"));
  1940. wmi_buf_free(buf);
  1941. return -EIO;
  1942. }
  1943. return CDF_STATUS_SUCCESS;
  1944. }
  1945. /**
  1946. * send_dcc_update_ndl_cmd_tlv() - command to update the NDL data
  1947. * @wmi_handle: pointer to the wmi handle
  1948. * @update_ndl_param: pointer to the request parameters
  1949. *
  1950. * Return: 0 on success
  1951. */
  1952. CDF_STATUS send_dcc_update_ndl_cmd_tlv(wmi_unified_t wmi_handle,
  1953. struct dcc_update_ndl_param *update_ndl_param)
  1954. {
  1955. CDF_STATUS cdf_status;
  1956. wmi_dcc_update_ndl_cmd_fixed_param *cmd;
  1957. wmi_dcc_ndl_chan *ndl_chan_array;
  1958. wmi_dcc_ndl_active_state_config *ndl_active_state_array;
  1959. uint32_t active_state_count;
  1960. wmi_buf_t buf;
  1961. uint8_t *buf_ptr;
  1962. uint32_t len;
  1963. uint32_t i;
  1964. /* validate the input */
  1965. if (update_ndl_param->dcc_ndl_chan_list_len !=
  1966. update_ndl_param->channel_count * sizeof(*ndl_chan_array)) {
  1967. WMA_LOGE(FL("Invalid parameter"));
  1968. return CDF_STATUS_E_INVAL;
  1969. }
  1970. active_state_count = 0;
  1971. ndl_chan_array = update_ndl_param->dcc_ndl_chan_list;
  1972. for (i = 0; i < update_ndl_param->channel_count; i++)
  1973. active_state_count +=
  1974. WMI_NDL_NUM_ACTIVE_STATE_GET(&ndl_chan_array[i]);
  1975. if (update_ndl_param->dcc_ndl_active_state_list_len !=
  1976. active_state_count * sizeof(*ndl_active_state_array)) {
  1977. WMA_LOGE(FL("Invalid parameter"));
  1978. return CDF_STATUS_E_INVAL;
  1979. }
  1980. /* Allocate memory for the WMI command */
  1981. len = sizeof(*cmd) +
  1982. WMI_TLV_HDR_SIZE + update_ndl_param->dcc_ndl_chan_list_len +
  1983. WMI_TLV_HDR_SIZE +
  1984. update_ndl_param->dcc_ndl_active_state_list_len;
  1985. buf = wmi_buf_alloc(wmi_handle, len);
  1986. if (!buf) {
  1987. WMA_LOGE(FL("wmi_buf_alloc failed"));
  1988. return -ENOMEM;
  1989. }
  1990. buf_ptr = wmi_buf_data(buf);
  1991. cdf_mem_zero(buf_ptr, len);
  1992. /* Populate the WMI command */
  1993. cmd = (wmi_dcc_update_ndl_cmd_fixed_param *)buf_ptr;
  1994. buf_ptr += sizeof(*cmd);
  1995. WMITLV_SET_HDR(&cmd->tlv_header,
  1996. WMITLV_TAG_STRUC_wmi_dcc_update_ndl_cmd_fixed_param,
  1997. WMITLV_GET_STRUCT_TLVLEN(
  1998. wmi_dcc_update_ndl_cmd_fixed_param));
  1999. cmd->vdev_id = update_ndl_param->vdev_id;
  2000. cmd->num_channel = update_ndl_param->channel_count;
  2001. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2002. update_ndl_param->dcc_ndl_chan_list_len);
  2003. buf_ptr += WMI_TLV_HDR_SIZE;
  2004. ndl_chan_array = (wmi_dcc_ndl_chan *)buf_ptr;
  2005. cdf_mem_copy(ndl_chan_array, update_ndl_param->dcc_ndl_chan_list,
  2006. update_ndl_param->dcc_ndl_chan_list_len);
  2007. for (i = 0; i < cmd->num_channel; i++)
  2008. WMITLV_SET_HDR(&ndl_chan_array[i].tlv_header,
  2009. WMITLV_TAG_STRUC_wmi_dcc_ndl_chan,
  2010. WMITLV_GET_STRUCT_TLVLEN(
  2011. wmi_dcc_ndl_chan));
  2012. buf_ptr += update_ndl_param->dcc_ndl_chan_list_len;
  2013. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2014. update_ndl_param->dcc_ndl_active_state_list_len);
  2015. buf_ptr += WMI_TLV_HDR_SIZE;
  2016. ndl_active_state_array = (wmi_dcc_ndl_active_state_config *) buf_ptr;
  2017. cdf_mem_copy(ndl_active_state_array,
  2018. update_ndl_param->dcc_ndl_active_state_list,
  2019. update_ndl_param->dcc_ndl_active_state_list_len);
  2020. for (i = 0; i < active_state_count; i++) {
  2021. WMITLV_SET_HDR(&ndl_active_state_array[i].tlv_header,
  2022. WMITLV_TAG_STRUC_wmi_dcc_ndl_active_state_config,
  2023. WMITLV_GET_STRUCT_TLVLEN(
  2024. wmi_dcc_ndl_active_state_config));
  2025. }
  2026. buf_ptr += update_ndl_param->dcc_ndl_active_state_list_len;
  2027. /* Send the WMI command */
  2028. cdf_status = wmi_unified_cmd_send(wmi_handle, buf, len,
  2029. WMI_DCC_UPDATE_NDL_CMDID);
  2030. /* If there is an error, set the completion event */
  2031. if (cdf_status) {
  2032. WMA_LOGE(FL("Failed to send WMI message: %d"), cdf_status);
  2033. wmi_buf_free(buf);
  2034. return -EIO;
  2035. }
  2036. return 0;
  2037. }
  2038. /**
  2039. * send_ocb_set_config_cmd_tlv() - send the OCB config to the FW
  2040. * @wmi_handle: pointer to the wmi handle
  2041. * @config: the OCB configuration
  2042. *
  2043. * Return: 0 on success
  2044. */
  2045. CDF_STATUS send_ocb_set_config_cmd_tlv(wmi_unified_t wmi_handle,
  2046. struct ocb_config_param *config, uint32_t *ch_mhz)
  2047. {
  2048. int32_t ret;
  2049. wmi_ocb_set_config_cmd_fixed_param *cmd;
  2050. wmi_channel *chan;
  2051. wmi_ocb_channel *ocb_chan;
  2052. wmi_qos_parameter *qos_param;
  2053. wmi_dcc_ndl_chan *ndl_chan;
  2054. wmi_dcc_ndl_active_state_config *ndl_active_config;
  2055. wmi_ocb_schedule_element *sched_elem;
  2056. uint8_t *buf_ptr;
  2057. wmi_buf_t buf;
  2058. int32_t len;
  2059. int32_t i, j, active_state_count;
  2060. /*
  2061. * Validate the dcc_ndl_chan_list_len and count the number of active
  2062. * states. Validate dcc_ndl_active_state_list_len.
  2063. */
  2064. active_state_count = 0;
  2065. if (config->dcc_ndl_chan_list_len) {
  2066. if (!config->dcc_ndl_chan_list ||
  2067. config->dcc_ndl_chan_list_len !=
  2068. config->channel_count * sizeof(wmi_dcc_ndl_chan)) {
  2069. WMA_LOGE(FL("NDL channel is invalid. List len: %d"),
  2070. config->dcc_ndl_chan_list_len);
  2071. return -EINVAL;
  2072. }
  2073. for (i = 0, ndl_chan = config->dcc_ndl_chan_list;
  2074. i < config->channel_count; ++i, ++ndl_chan)
  2075. active_state_count +=
  2076. WMI_NDL_NUM_ACTIVE_STATE_GET(ndl_chan);
  2077. if (active_state_count) {
  2078. if (!config->dcc_ndl_active_state_list ||
  2079. config->dcc_ndl_active_state_list_len !=
  2080. active_state_count *
  2081. sizeof(wmi_dcc_ndl_active_state_config)) {
  2082. WMA_LOGE(FL("NDL active state is invalid."));
  2083. return -EINVAL;
  2084. }
  2085. }
  2086. }
  2087. len = sizeof(*cmd) +
  2088. WMI_TLV_HDR_SIZE + config->channel_count *
  2089. sizeof(wmi_channel) +
  2090. WMI_TLV_HDR_SIZE + config->channel_count *
  2091. sizeof(wmi_ocb_channel) +
  2092. WMI_TLV_HDR_SIZE + config->channel_count *
  2093. sizeof(wmi_qos_parameter) * WMI_MAX_NUM_AC +
  2094. WMI_TLV_HDR_SIZE + config->dcc_ndl_chan_list_len +
  2095. WMI_TLV_HDR_SIZE + active_state_count *
  2096. sizeof(wmi_dcc_ndl_active_state_config) +
  2097. WMI_TLV_HDR_SIZE + config->schedule_size *
  2098. sizeof(wmi_ocb_schedule_element);
  2099. buf = wmi_buf_alloc(wmi_handle, len);
  2100. if (!buf) {
  2101. WMA_LOGE(FL("wmi_buf_alloc failed"));
  2102. return -ENOMEM;
  2103. }
  2104. buf_ptr = (uint8_t *)wmi_buf_data(buf);
  2105. cmd = (wmi_ocb_set_config_cmd_fixed_param *)buf_ptr;
  2106. WMITLV_SET_HDR(&cmd->tlv_header,
  2107. WMITLV_TAG_STRUC_wmi_ocb_set_config_cmd_fixed_param,
  2108. WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_set_config_cmd_fixed_param));
  2109. cmd->vdev_id = config->session_id;
  2110. cmd->channel_count = config->channel_count;
  2111. cmd->schedule_size = config->schedule_size;
  2112. cmd->flags = config->flags;
  2113. buf_ptr += sizeof(*cmd);
  2114. /* Add the wmi_channel info */
  2115. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2116. config->channel_count*sizeof(wmi_channel));
  2117. buf_ptr += WMI_TLV_HDR_SIZE;
  2118. for (i = 0; i < config->channel_count; i++) {
  2119. chan = (wmi_channel *)buf_ptr;
  2120. WMITLV_SET_HDR(&chan->tlv_header,
  2121. WMITLV_TAG_STRUC_wmi_channel,
  2122. WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
  2123. chan->mhz = config->channels[i].chan_freq;
  2124. chan->band_center_freq1 = config->channels[i].chan_freq;
  2125. chan->band_center_freq2 = 0;
  2126. chan->info = 0;
  2127. WMI_SET_CHANNEL_MODE(chan, ch_mhz[i]);
  2128. WMI_SET_CHANNEL_MAX_POWER(chan, config->channels[i].max_pwr);
  2129. WMI_SET_CHANNEL_MIN_POWER(chan, config->channels[i].min_pwr);
  2130. WMI_SET_CHANNEL_MAX_TX_POWER(chan, config->channels[i].max_pwr);
  2131. WMI_SET_CHANNEL_REG_POWER(chan, config->channels[i].reg_pwr);
  2132. WMI_SET_CHANNEL_ANTENNA_MAX(chan,
  2133. config->channels[i].antenna_max);
  2134. if (config->channels[i].bandwidth < 10)
  2135. WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_QUARTER_RATE);
  2136. else if (config->channels[i].bandwidth < 20)
  2137. WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_HALF_RATE);
  2138. buf_ptr += sizeof(*chan);
  2139. }
  2140. /* Add the wmi_ocb_channel info */
  2141. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2142. config->channel_count*sizeof(wmi_ocb_channel));
  2143. buf_ptr += WMI_TLV_HDR_SIZE;
  2144. for (i = 0; i < config->channel_count; i++) {
  2145. ocb_chan = (wmi_ocb_channel *)buf_ptr;
  2146. WMITLV_SET_HDR(&ocb_chan->tlv_header,
  2147. WMITLV_TAG_STRUC_wmi_ocb_channel,
  2148. WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_channel));
  2149. ocb_chan->bandwidth = config->channels[i].bandwidth;
  2150. WMI_CHAR_ARRAY_TO_MAC_ADDR(
  2151. config->channels[i].mac_address.bytes,
  2152. &ocb_chan->mac_address);
  2153. buf_ptr += sizeof(*ocb_chan);
  2154. }
  2155. /* Add the wmi_qos_parameter info */
  2156. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2157. config->channel_count * sizeof(wmi_qos_parameter)*WMI_MAX_NUM_AC);
  2158. buf_ptr += WMI_TLV_HDR_SIZE;
  2159. /* WMI_MAX_NUM_AC parameters for each channel */
  2160. for (i = 0; i < config->channel_count; i++) {
  2161. for (j = 0; j < WMI_MAX_NUM_AC; j++) {
  2162. qos_param = (wmi_qos_parameter *)buf_ptr;
  2163. WMITLV_SET_HDR(&qos_param->tlv_header,
  2164. WMITLV_TAG_STRUC_wmi_qos_parameter,
  2165. WMITLV_GET_STRUCT_TLVLEN(wmi_qos_parameter));
  2166. qos_param->aifsn =
  2167. config->channels[i].qos_params[j].aifsn;
  2168. qos_param->cwmin =
  2169. config->channels[i].qos_params[j].cwmin;
  2170. qos_param->cwmax =
  2171. config->channels[i].qos_params[j].cwmax;
  2172. buf_ptr += sizeof(*qos_param);
  2173. }
  2174. }
  2175. /* Add the wmi_dcc_ndl_chan (per channel) */
  2176. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2177. config->dcc_ndl_chan_list_len);
  2178. buf_ptr += WMI_TLV_HDR_SIZE;
  2179. if (config->dcc_ndl_chan_list_len) {
  2180. ndl_chan = (wmi_dcc_ndl_chan *)buf_ptr;
  2181. cdf_mem_copy(ndl_chan, config->dcc_ndl_chan_list,
  2182. config->dcc_ndl_chan_list_len);
  2183. for (i = 0; i < config->channel_count; i++)
  2184. WMITLV_SET_HDR(&(ndl_chan[i].tlv_header),
  2185. WMITLV_TAG_STRUC_wmi_dcc_ndl_chan,
  2186. WMITLV_GET_STRUCT_TLVLEN(wmi_dcc_ndl_chan));
  2187. buf_ptr += config->dcc_ndl_chan_list_len;
  2188. }
  2189. /* Add the wmi_dcc_ndl_active_state_config */
  2190. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, active_state_count *
  2191. sizeof(wmi_dcc_ndl_active_state_config));
  2192. buf_ptr += WMI_TLV_HDR_SIZE;
  2193. if (active_state_count) {
  2194. ndl_active_config = (wmi_dcc_ndl_active_state_config *)buf_ptr;
  2195. cdf_mem_copy(ndl_active_config,
  2196. config->dcc_ndl_active_state_list,
  2197. active_state_count * sizeof(*ndl_active_config));
  2198. for (i = 0; i < active_state_count; ++i)
  2199. WMITLV_SET_HDR(&(ndl_active_config[i].tlv_header),
  2200. WMITLV_TAG_STRUC_wmi_dcc_ndl_active_state_config,
  2201. WMITLV_GET_STRUCT_TLVLEN(
  2202. wmi_dcc_ndl_active_state_config));
  2203. buf_ptr += active_state_count *
  2204. sizeof(*ndl_active_config);
  2205. }
  2206. /* Add the wmi_ocb_schedule_element info */
  2207. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2208. config->schedule_size * sizeof(wmi_ocb_schedule_element));
  2209. buf_ptr += WMI_TLV_HDR_SIZE;
  2210. for (i = 0; i < config->schedule_size; i++) {
  2211. sched_elem = (wmi_ocb_schedule_element *)buf_ptr;
  2212. WMITLV_SET_HDR(&sched_elem->tlv_header,
  2213. WMITLV_TAG_STRUC_wmi_ocb_schedule_element,
  2214. WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_schedule_element));
  2215. sched_elem->channel_freq = config->schedule[i].chan_freq;
  2216. sched_elem->total_duration = config->schedule[i].total_duration;
  2217. sched_elem->guard_interval = config->schedule[i].guard_interval;
  2218. buf_ptr += sizeof(*sched_elem);
  2219. }
  2220. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2221. WMI_OCB_SET_CONFIG_CMDID);
  2222. if (ret != EOK) {
  2223. WMA_LOGE("Failed to set OCB config");
  2224. wmi_buf_free(buf);
  2225. return -EIO;
  2226. }
  2227. return 0;
  2228. }
  2229. /**
  2230. * send_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv() -enable/disable mcc scheduler
  2231. * @wmi_handle: wmi handle
  2232. * @mcc_adaptive_scheduler: enable/disable
  2233. *
  2234. * This function enable/disable mcc adaptive scheduler in fw.
  2235. *
  2236. * Return: CDF_STATUS_SUCCESS for sucess or error code
  2237. */
  2238. CDF_STATUS send_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv(
  2239. wmi_unified_t wmi_handle, uint32_t mcc_adaptive_scheduler)
  2240. {
  2241. int ret = -1;
  2242. wmi_buf_t buf = 0;
  2243. wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param *cmd = NULL;
  2244. uint16_t len =
  2245. sizeof(wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param);
  2246. buf = wmi_buf_alloc(wmi_handle, len);
  2247. if (!buf) {
  2248. WMA_LOGP("%s : wmi_buf_alloc failed", __func__);
  2249. return CDF_STATUS_E_NOMEM;
  2250. }
  2251. cmd = (wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param *)
  2252. wmi_buf_data(buf);
  2253. WMITLV_SET_HDR(&cmd->tlv_header,
  2254. WMITLV_TAG_STRUC_wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param,
  2255. WMITLV_GET_STRUCT_TLVLEN
  2256. (wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param));
  2257. cmd->enable = mcc_adaptive_scheduler;
  2258. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2259. WMI_RESMGR_ADAPTIVE_OCS_ENABLE_DISABLE_CMDID);
  2260. if (ret) {
  2261. WMA_LOGP("%s: Failed to send enable/disable MCC"
  2262. " adaptive scheduler command", __func__);
  2263. cdf_nbuf_free(buf);
  2264. }
  2265. return CDF_STATUS_SUCCESS;
  2266. }
  2267. /**
  2268. * send_set_mcc_channel_time_latency_cmd_tlv() -set MCC channel time latency
  2269. * @wmi: wmi handle
  2270. * @mcc_channel: mcc channel
  2271. * @mcc_channel_time_latency: MCC channel time latency.
  2272. *
  2273. * Currently used to set time latency for an MCC vdev/adapter using operating
  2274. * channel of it and channel number. The info is provided run time using
  2275. * iwpriv command: iwpriv <wlan0 | p2p0> setMccLatency <latency in ms>.
  2276. *
  2277. * Return: CDF status
  2278. */
  2279. CDF_STATUS send_set_mcc_channel_time_latency_cmd_tlv(wmi_unified_t wmi_handle,
  2280. uint32_t mcc_channel_freq, uint32_t mcc_channel_time_latency)
  2281. {
  2282. int ret = -1;
  2283. wmi_buf_t buf = 0;
  2284. wmi_resmgr_set_chan_latency_cmd_fixed_param *cmdTL = NULL;
  2285. uint16_t len = 0;
  2286. uint8_t *buf_ptr = NULL;
  2287. wmi_resmgr_chan_latency chan_latency;
  2288. /* Note: we only support MCC time latency for a single channel */
  2289. uint32_t num_channels = 1;
  2290. uint32_t chan1_freq = mcc_channel_freq;
  2291. uint32_t latency_chan1 = mcc_channel_time_latency;
  2292. /* If 0ms latency is provided, then FW will set to a default.
  2293. * Otherwise, latency must be at least 30ms.
  2294. */
  2295. if ((latency_chan1 > 0) &&
  2296. (latency_chan1 < WMI_MCC_MIN_NON_ZERO_CHANNEL_LATENCY)) {
  2297. WMA_LOGE("%s: Invalid time latency for Channel #1 = %dms "
  2298. "Minimum is 30ms (or 0 to use default value by "
  2299. "firmware)", __func__, latency_chan1);
  2300. return CDF_STATUS_E_INVAL;
  2301. }
  2302. /* Set WMI CMD for channel time latency here */
  2303. len = sizeof(wmi_resmgr_set_chan_latency_cmd_fixed_param) +
  2304. WMI_TLV_HDR_SIZE + /*Place holder for chan_time_latency array */
  2305. num_channels * sizeof(wmi_resmgr_chan_latency);
  2306. buf = wmi_buf_alloc(wmi_handle, len);
  2307. if (!buf) {
  2308. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  2309. return CDF_STATUS_E_NOMEM;
  2310. }
  2311. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  2312. cmdTL = (wmi_resmgr_set_chan_latency_cmd_fixed_param *)
  2313. wmi_buf_data(buf);
  2314. WMITLV_SET_HDR(&cmdTL->tlv_header,
  2315. WMITLV_TAG_STRUC_wmi_resmgr_set_chan_latency_cmd_fixed_param,
  2316. WMITLV_GET_STRUCT_TLVLEN
  2317. (wmi_resmgr_set_chan_latency_cmd_fixed_param));
  2318. cmdTL->num_chans = num_channels;
  2319. /* Update channel time latency information for home channel(s) */
  2320. buf_ptr += sizeof(*cmdTL);
  2321. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  2322. num_channels * sizeof(wmi_resmgr_chan_latency));
  2323. buf_ptr += WMI_TLV_HDR_SIZE;
  2324. chan_latency.chan_mhz = chan1_freq;
  2325. chan_latency.latency = latency_chan1;
  2326. cdf_mem_copy(buf_ptr, &chan_latency, sizeof(chan_latency));
  2327. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2328. WMI_RESMGR_SET_CHAN_LATENCY_CMDID);
  2329. if (ret) {
  2330. WMA_LOGE("%s: Failed to send MCC Channel Time Latency command",
  2331. __func__);
  2332. cdf_nbuf_free(buf);
  2333. CDF_ASSERT(0);
  2334. return CDF_STATUS_E_FAILURE;
  2335. }
  2336. return CDF_STATUS_SUCCESS;
  2337. }
  2338. /**
  2339. * send_set_mcc_channel_time_quota_cmd_tlv() -set MCC channel time quota
  2340. * @wmi: wmi handle
  2341. * @adapter_1_chan_number: adapter 1 channel number
  2342. * @adapter_1_quota: adapter 1 quota
  2343. * @adapter_2_chan_number: adapter 2 channel number
  2344. *
  2345. * Return: CDF status
  2346. */
  2347. CDF_STATUS send_set_mcc_channel_time_quota_cmd_tlv(wmi_unified_t wmi_handle,
  2348. uint32_t adapter_1_chan_freq,
  2349. uint32_t adapter_1_quota, uint32_t adapter_2_chan_freq)
  2350. {
  2351. int ret = -1;
  2352. wmi_buf_t buf = 0;
  2353. uint16_t len = 0;
  2354. uint8_t *buf_ptr = NULL;
  2355. wmi_resmgr_set_chan_time_quota_cmd_fixed_param *cmdTQ = NULL;
  2356. wmi_resmgr_chan_time_quota chan_quota;
  2357. uint32_t quota_chan1 = adapter_1_quota;
  2358. /* Knowing quota of 1st chan., derive quota for 2nd chan. */
  2359. uint32_t quota_chan2 = 100 - quota_chan1;
  2360. /* Note: setting time quota for MCC requires info for 2 channels */
  2361. uint32_t num_channels = 2;
  2362. uint32_t chan1_freq = adapter_1_chan_freq;
  2363. uint32_t chan2_freq = adapter_2_chan_freq;
  2364. WMA_LOGD("%s: freq1:%dMHz, Quota1:%dms, "
  2365. "freq2:%dMHz, Quota2:%dms", __func__,
  2366. chan1_freq, quota_chan1, chan2_freq,
  2367. quota_chan2);
  2368. /*
  2369. * Perform sanity check on time quota values provided.
  2370. */
  2371. if (quota_chan1 < WMI_MCC_MIN_CHANNEL_QUOTA ||
  2372. quota_chan1 > WMI_MCC_MAX_CHANNEL_QUOTA) {
  2373. WMA_LOGE("%s: Invalid time quota for Channel #1=%dms. Minimum "
  2374. "is 20ms & maximum is 80ms", __func__, quota_chan1);
  2375. return CDF_STATUS_E_INVAL;
  2376. }
  2377. /* Set WMI CMD for channel time quota here */
  2378. len = sizeof(wmi_resmgr_set_chan_time_quota_cmd_fixed_param) +
  2379. WMI_TLV_HDR_SIZE + /* Place holder for chan_time_quota array */
  2380. num_channels * sizeof(wmi_resmgr_chan_time_quota);
  2381. buf = wmi_buf_alloc(wmi_handle, len);
  2382. if (!buf) {
  2383. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  2384. CDF_ASSERT(0);
  2385. return CDF_STATUS_E_NOMEM;
  2386. }
  2387. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  2388. cmdTQ = (wmi_resmgr_set_chan_time_quota_cmd_fixed_param *)
  2389. wmi_buf_data(buf);
  2390. WMITLV_SET_HDR(&cmdTQ->tlv_header,
  2391. WMITLV_TAG_STRUC_wmi_resmgr_set_chan_time_quota_cmd_fixed_param,
  2392. WMITLV_GET_STRUCT_TLVLEN
  2393. (wmi_resmgr_set_chan_time_quota_cmd_fixed_param));
  2394. cmdTQ->num_chans = num_channels;
  2395. /* Update channel time quota information for home channel(s) */
  2396. buf_ptr += sizeof(*cmdTQ);
  2397. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  2398. num_channels * sizeof(wmi_resmgr_chan_time_quota));
  2399. buf_ptr += WMI_TLV_HDR_SIZE;
  2400. chan_quota.chan_mhz = chan1_freq;
  2401. chan_quota.channel_time_quota = quota_chan1;
  2402. cdf_mem_copy(buf_ptr, &chan_quota, sizeof(chan_quota));
  2403. /* Construct channel and quota record for the 2nd MCC mode. */
  2404. buf_ptr += sizeof(chan_quota);
  2405. chan_quota.chan_mhz = chan2_freq;
  2406. chan_quota.channel_time_quota = quota_chan2;
  2407. cdf_mem_copy(buf_ptr, &chan_quota, sizeof(chan_quota));
  2408. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2409. WMI_RESMGR_SET_CHAN_TIME_QUOTA_CMDID);
  2410. if (ret) {
  2411. WMA_LOGE("Failed to send MCC Channel Time Quota command");
  2412. cdf_nbuf_free(buf);
  2413. CDF_ASSERT(0);
  2414. return CDF_STATUS_E_FAILURE;
  2415. }
  2416. return CDF_STATUS_SUCCESS;
  2417. }
  2418. /**
  2419. * send_set_thermal_mgmt_cmd_tlv() - set thermal mgmt command to fw
  2420. * @wmi_handle: Pointer to wmi handle
  2421. * @thermal_info: Thermal command information
  2422. *
  2423. * This function sends the thermal management command
  2424. * to the firmware
  2425. *
  2426. * Return: CDF_STATUS_SUCCESS for success otherwise failure
  2427. */
  2428. CDF_STATUS send_set_thermal_mgmt_cmd_tlv(wmi_unified_t wmi_handle,
  2429. struct thermal_cmd_params *thermal_info)
  2430. {
  2431. wmi_thermal_mgmt_cmd_fixed_param *cmd = NULL;
  2432. wmi_buf_t buf = NULL;
  2433. int status = 0;
  2434. uint32_t len = 0;
  2435. len = sizeof(*cmd);
  2436. buf = wmi_buf_alloc(wmi_handle, len);
  2437. if (!buf) {
  2438. WMA_LOGE("Failed to allocate buffer to send set key cmd");
  2439. return CDF_STATUS_E_FAILURE;
  2440. }
  2441. cmd = (wmi_thermal_mgmt_cmd_fixed_param *) wmi_buf_data(buf);
  2442. WMITLV_SET_HDR(&cmd->tlv_header,
  2443. WMITLV_TAG_STRUC_wmi_thermal_mgmt_cmd_fixed_param,
  2444. WMITLV_GET_STRUCT_TLVLEN
  2445. (wmi_thermal_mgmt_cmd_fixed_param));
  2446. cmd->lower_thresh_degreeC = thermal_info->min_temp;
  2447. cmd->upper_thresh_degreeC = thermal_info->max_temp;
  2448. cmd->enable = thermal_info->thermal_enable;
  2449. WMA_LOGE("TM Sending thermal mgmt cmd: low temp %d, upper temp %d, enabled %d",
  2450. cmd->lower_thresh_degreeC, cmd->upper_thresh_degreeC, cmd->enable);
  2451. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  2452. WMI_THERMAL_MGMT_CMDID);
  2453. if (status) {
  2454. cdf_nbuf_free(buf);
  2455. WMA_LOGE("%s:Failed to send thermal mgmt command", __func__);
  2456. return CDF_STATUS_E_FAILURE;
  2457. }
  2458. return CDF_STATUS_SUCCESS;
  2459. }
  2460. /**
  2461. * send_lro_config_cmd_tlv() - process the LRO config command
  2462. * @wmi: Pointer to WMA handle
  2463. * @wmi_lro_cmd: Pointer to LRO configuration parameters
  2464. *
  2465. * This function sends down the LRO configuration parameters to
  2466. * the firmware to enable LRO, sets the TCP flags and sets the
  2467. * seed values for the toeplitz hash generation
  2468. *
  2469. * Return: CDF_STATUS_SUCCESS for success otherwise failure
  2470. */
  2471. CDF_STATUS send_lro_config_cmd_tlv(wmi_unified_t wmi_handle,
  2472. struct wmi_lro_config_cmd_t *wmi_lro_cmd)
  2473. {
  2474. wmi_lro_info_cmd_fixed_param *cmd;
  2475. wmi_buf_t buf;
  2476. int status;
  2477. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  2478. if (!buf) {
  2479. WMA_LOGE("Failed to allocate buffer to send set key cmd");
  2480. return CDF_STATUS_E_FAILURE;
  2481. }
  2482. cmd = (wmi_lro_info_cmd_fixed_param *) wmi_buf_data(buf);
  2483. WMITLV_SET_HDR(&cmd->tlv_header,
  2484. WMITLV_TAG_STRUC_wmi_lro_info_cmd_fixed_param,
  2485. WMITLV_GET_STRUCT_TLVLEN(wmi_lro_info_cmd_fixed_param));
  2486. cmd->lro_enable = wmi_lro_cmd->lro_enable;
  2487. WMI_LRO_INFO_TCP_FLAG_VALS_SET(cmd->tcp_flag_u32,
  2488. wmi_lro_cmd->tcp_flag);
  2489. WMI_LRO_INFO_TCP_FLAGS_MASK_SET(cmd->tcp_flag_u32,
  2490. wmi_lro_cmd->tcp_flag_mask);
  2491. cmd->toeplitz_hash_ipv4_0_3 =
  2492. wmi_lro_cmd->toeplitz_hash_ipv4[0];
  2493. cmd->toeplitz_hash_ipv4_4_7 =
  2494. wmi_lro_cmd->toeplitz_hash_ipv4[1];
  2495. cmd->toeplitz_hash_ipv4_8_11 =
  2496. wmi_lro_cmd->toeplitz_hash_ipv4[2];
  2497. cmd->toeplitz_hash_ipv4_12_15 =
  2498. wmi_lro_cmd->toeplitz_hash_ipv4[3];
  2499. cmd->toeplitz_hash_ipv4_16 =
  2500. wmi_lro_cmd->toeplitz_hash_ipv4[4];
  2501. cmd->toeplitz_hash_ipv6_0_3 =
  2502. wmi_lro_cmd->toeplitz_hash_ipv6[0];
  2503. cmd->toeplitz_hash_ipv6_4_7 =
  2504. wmi_lro_cmd->toeplitz_hash_ipv6[1];
  2505. cmd->toeplitz_hash_ipv6_8_11 =
  2506. wmi_lro_cmd->toeplitz_hash_ipv6[2];
  2507. cmd->toeplitz_hash_ipv6_12_15 =
  2508. wmi_lro_cmd->toeplitz_hash_ipv6[3];
  2509. cmd->toeplitz_hash_ipv6_16_19 =
  2510. wmi_lro_cmd->toeplitz_hash_ipv6[4];
  2511. cmd->toeplitz_hash_ipv6_20_23 =
  2512. wmi_lro_cmd->toeplitz_hash_ipv6[5];
  2513. cmd->toeplitz_hash_ipv6_24_27 =
  2514. wmi_lro_cmd->toeplitz_hash_ipv6[6];
  2515. cmd->toeplitz_hash_ipv6_28_31 =
  2516. wmi_lro_cmd->toeplitz_hash_ipv6[7];
  2517. cmd->toeplitz_hash_ipv6_32_35 =
  2518. wmi_lro_cmd->toeplitz_hash_ipv6[8];
  2519. cmd->toeplitz_hash_ipv6_36_39 =
  2520. wmi_lro_cmd->toeplitz_hash_ipv6[9];
  2521. cmd->toeplitz_hash_ipv6_40 =
  2522. wmi_lro_cmd->toeplitz_hash_ipv6[10];
  2523. WMA_LOGD("WMI_LRO_CONFIG: lro_enable %d, tcp_flag 0x%x",
  2524. cmd->lro_enable, cmd->tcp_flag_u32);
  2525. status = wmi_unified_cmd_send(wmi_handle, buf,
  2526. sizeof(*cmd), WMI_LRO_CONFIG_CMDID);
  2527. if (status) {
  2528. cdf_nbuf_free(buf);
  2529. WMA_LOGE("%s:Failed to send WMI_LRO_CONFIG_CMDID", __func__);
  2530. return CDF_STATUS_E_FAILURE;
  2531. }
  2532. return CDF_STATUS_SUCCESS;
  2533. }
  2534. /**
  2535. * send_bcn_buf_ll_cmd_tlv() - prepare and send beacon buffer to fw for LL
  2536. * @wmi_handle: wmi handle
  2537. * @param: bcn ll cmd parameter
  2538. *
  2539. * Return: CDF_STATUS_SUCCESS for success otherwise failure
  2540. */
  2541. CDF_STATUS send_bcn_buf_ll_cmd_tlv(wmi_unified_t wmi_handle,
  2542. wmi_bcn_send_from_host_cmd_fixed_param *param)
  2543. {
  2544. wmi_bcn_send_from_host_cmd_fixed_param *cmd;
  2545. wmi_buf_t wmi_buf;
  2546. CDF_STATUS ret;
  2547. wmi_buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  2548. if (!wmi_buf) {
  2549. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  2550. return CDF_STATUS_E_FAILURE;
  2551. }
  2552. cmd = (wmi_bcn_send_from_host_cmd_fixed_param *) wmi_buf_data(wmi_buf);
  2553. WMITLV_SET_HDR(&cmd->tlv_header,
  2554. WMITLV_TAG_STRUC_wmi_bcn_send_from_host_cmd_fixed_param,
  2555. WMITLV_GET_STRUCT_TLVLEN
  2556. (wmi_bcn_send_from_host_cmd_fixed_param));
  2557. cmd->vdev_id = param->vdev_id;
  2558. cmd->data_len = param->data_len;
  2559. cmd->frame_ctrl = param->frame_ctrl;
  2560. cmd->frag_ptr = param->frag_ptr;
  2561. cmd->dtim_flag = param->dtim_flag;
  2562. ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, sizeof(*cmd),
  2563. WMI_PDEV_SEND_BCN_CMDID);
  2564. if (ret != EOK) {
  2565. WMA_LOGE("Failed to send WMI_PDEV_SEND_BCN_CMDID command");
  2566. wmi_buf_free(wmi_buf);
  2567. }
  2568. return ret;
  2569. }
  2570. /**
  2571. * send_set_sta_sa_query_param_cmd_tlv() - set sta sa query parameters
  2572. * @wmi_handle: wmi handle
  2573. * @vdev_id: vdev id
  2574. * @max_retries: max retries
  2575. * @retry_interval: retry interval
  2576. * This function sets sta query related parameters in fw.
  2577. *
  2578. * Return: CDF_STATUS_SUCCESS for success otherwise failure
  2579. */
  2580. CDF_STATUS send_set_sta_sa_query_param_cmd_tlv(wmi_unified_t wmi_handle,
  2581. uint8_t vdev_id, uint32_t max_retries,
  2582. uint32_t retry_interval)
  2583. {
  2584. wmi_buf_t buf;
  2585. WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param *cmd;
  2586. int len;
  2587. len = sizeof(*cmd);
  2588. buf = wmi_buf_alloc(wmi_handle, len);
  2589. if (!buf) {
  2590. WMA_LOGE(FL("wmi_buf_alloc failed"));
  2591. return CDF_STATUS_E_FAILURE;
  2592. }
  2593. cmd = (WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param *)wmi_buf_data(buf);
  2594. WMITLV_SET_HDR(&cmd->tlv_header,
  2595. WMITLV_TAG_STRUC_WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param,
  2596. WMITLV_GET_STRUCT_TLVLEN
  2597. (WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param));
  2598. cmd->vdev_id = vdev_id;
  2599. cmd->sa_query_max_retry_count = max_retries;
  2600. cmd->sa_query_retry_interval = retry_interval;
  2601. WMA_LOGD(FL("STA sa query: vdev_id:%d interval:%u retry count:%d"),
  2602. vdev_id, retry_interval, max_retries);
  2603. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  2604. WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID)) {
  2605. WMA_LOGE(FL("Failed to offload STA SA Query"));
  2606. cdf_nbuf_free(buf);
  2607. return CDF_STATUS_E_FAILURE;
  2608. }
  2609. WMA_LOGD(FL("Exit :"));
  2610. return 0;
  2611. }
  2612. /**
  2613. * send_set_sta_keep_alive_cmd_tlv() - set sta keep alive parameters
  2614. * @wmi_handle: wmi handle
  2615. * @params: sta keep alive parameter
  2616. *
  2617. * This function sets keep alive related parameters in fw.
  2618. *
  2619. * Return: CDF status
  2620. */
  2621. CDF_STATUS send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle,
  2622. struct sta_params *params)
  2623. {
  2624. wmi_buf_t buf;
  2625. WMI_STA_KEEPALIVE_CMD_fixed_param *cmd;
  2626. WMI_STA_KEEPALVE_ARP_RESPONSE *arp_rsp;
  2627. uint8_t *buf_ptr;
  2628. int len;
  2629. WMA_LOGD("%s: Enter", __func__);
  2630. if (params->timeperiod > WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD_STAMAX) {
  2631. WMA_LOGE("Invalid period %d Max limit %d", params->timeperiod,
  2632. WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD_STAMAX);
  2633. return CDF_STATUS_E_FAILURE;
  2634. }
  2635. len = sizeof(*cmd) + sizeof(*arp_rsp);
  2636. buf = wmi_buf_alloc(wmi_handle, len);
  2637. if (!buf) {
  2638. WMA_LOGE("wmi_buf_alloc failed");
  2639. return CDF_STATUS_E_FAILURE;
  2640. }
  2641. cmd = (WMI_STA_KEEPALIVE_CMD_fixed_param *) wmi_buf_data(buf);
  2642. buf_ptr = (uint8_t *) cmd;
  2643. WMITLV_SET_HDR(&cmd->tlv_header,
  2644. WMITLV_TAG_STRUC_WMI_STA_KEEPALIVE_CMD_fixed_param,
  2645. WMITLV_GET_STRUCT_TLVLEN
  2646. (WMI_STA_KEEPALIVE_CMD_fixed_param));
  2647. cmd->interval = params->timeperiod;
  2648. cmd->enable = (params->timeperiod) ? 1 : 0;
  2649. cmd->vdev_id = params->vdev_id;
  2650. WMA_LOGD("Keep Alive: vdev_id:%d interval:%u method:%d", params->vdev_id,
  2651. params->timeperiod, params->method);
  2652. arp_rsp = (WMI_STA_KEEPALVE_ARP_RESPONSE *) (buf_ptr + sizeof(*cmd));
  2653. WMITLV_SET_HDR(&arp_rsp->tlv_header,
  2654. WMITLV_TAG_STRUC_WMI_STA_KEEPALVE_ARP_RESPONSE,
  2655. WMITLV_GET_STRUCT_TLVLEN(WMI_STA_KEEPALVE_ARP_RESPONSE));
  2656. if (params->method == WMI_KEEP_ALIVE_UNSOLICIT_ARP_RSP) {
  2657. if ((NULL == params->hostv4addr) ||
  2658. (NULL == params->destv4addr) ||
  2659. (NULL == params->destmac)) {
  2660. WMA_LOGE("%s: received null pointer, hostv4addr:%p "
  2661. "destv4addr:%p destmac:%p ", __func__,
  2662. params->hostv4addr, params->destv4addr, params->destmac);
  2663. cdf_nbuf_free(buf);
  2664. return CDF_STATUS_E_FAILURE;
  2665. }
  2666. cmd->method = WMI_STA_KEEPALIVE_METHOD_UNSOLICITED_ARP_RESPONSE;
  2667. cdf_mem_copy(&arp_rsp->sender_prot_addr, params->hostv4addr,
  2668. WMI_IPV4_ADDR_LEN);
  2669. cdf_mem_copy(&arp_rsp->target_prot_addr, params->destv4addr,
  2670. WMI_IPV4_ADDR_LEN);
  2671. WMI_CHAR_ARRAY_TO_MAC_ADDR(params->destmac, &arp_rsp->dest_mac_addr);
  2672. } else {
  2673. cmd->method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;
  2674. }
  2675. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  2676. WMI_STA_KEEPALIVE_CMDID)) {
  2677. WMA_LOGE("Failed to set KeepAlive");
  2678. cdf_nbuf_free(buf);
  2679. }
  2680. WMA_LOGD("%s: Exit", __func__);
  2681. return 0;
  2682. }
  2683. /**
  2684. * send_vdev_set_gtx_cfg_cmd_tlv() - set GTX params
  2685. * @wmi_handle: wmi handle
  2686. * @if_id: vdev id
  2687. * @gtx_info: GTX config params
  2688. *
  2689. * This function set GTX related params in firmware.
  2690. *
  2691. * Return: 0 for success or error code
  2692. */
  2693. CDF_STATUS send_vdev_set_gtx_cfg_cmd_tlv(wmi_unified_t wmi_handle, uint32_t if_id,
  2694. struct wmi_gtx_config *gtx_info)
  2695. {
  2696. wmi_vdev_set_gtx_params_cmd_fixed_param *cmd;
  2697. wmi_buf_t buf;
  2698. int len = sizeof(wmi_vdev_set_gtx_params_cmd_fixed_param);
  2699. buf = wmi_buf_alloc(wmi_handle, len);
  2700. if (!buf) {
  2701. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  2702. return -ENOMEM;
  2703. }
  2704. cmd = (wmi_vdev_set_gtx_params_cmd_fixed_param *) wmi_buf_data(buf);
  2705. WMITLV_SET_HDR(&cmd->tlv_header,
  2706. WMITLV_TAG_STRUC_wmi_vdev_set_gtx_params_cmd_fixed_param,
  2707. WMITLV_GET_STRUCT_TLVLEN
  2708. (wmi_vdev_set_gtx_params_cmd_fixed_param));
  2709. cmd->vdev_id = if_id;
  2710. cmd->gtxRTMask[0] = gtx_info->gtx_rt_mask[0];
  2711. cmd->gtxRTMask[1] = gtx_info->gtx_rt_mask[1];
  2712. cmd->userGtxMask = gtx_info->gtx_usrcfg;
  2713. cmd->gtxPERThreshold = gtx_info->gtx_threshold;
  2714. cmd->gtxPERMargin = gtx_info->gtx_margin;
  2715. cmd->gtxTPCstep = gtx_info->gtx_tpcstep;
  2716. cmd->gtxTPCMin = gtx_info->gtx_tpcmin;
  2717. cmd->gtxBWMask = gtx_info->gtx_bwmask;
  2718. WMA_LOGD("Setting vdev%d GTX values:htmcs 0x%x, vhtmcs 0x%x, usermask 0x%x, \
  2719. gtxPERThreshold %d, gtxPERMargin %d, gtxTPCstep %d, gtxTPCMin %d, \
  2720. gtxBWMask 0x%x.", if_id, cmd->gtxRTMask[0], cmd->gtxRTMask[1],
  2721. cmd->userGtxMask, cmd->gtxPERThreshold, cmd->gtxPERMargin,
  2722. cmd->gtxTPCstep, cmd->gtxTPCMin, cmd->gtxBWMask);
  2723. return wmi_unified_cmd_send(wmi_handle, buf, len,
  2724. WMI_VDEV_SET_GTX_PARAMS_CMDID);
  2725. }
  2726. /**
  2727. * send_process_update_edca_param_cmd_tlv() - update EDCA params
  2728. * @wmi_handle: wmi handle
  2729. * @edca_params: edca parameters
  2730. *
  2731. * This function updates EDCA parameters to the target
  2732. *
  2733. * Return: CDF Status
  2734. */
  2735. CDF_STATUS send_process_update_edca_param_cmd_tlv(wmi_unified_t wmi_handle,
  2736. uint8_t vdev_id,
  2737. wmi_wmm_vparams gwmm_param[WMI_MAX_NUM_AC])
  2738. {
  2739. uint8_t *buf_ptr;
  2740. wmi_buf_t buf;
  2741. wmi_vdev_set_wmm_params_cmd_fixed_param *cmd;
  2742. wmi_wmm_vparams *wmm_param, *twmm_param;
  2743. int len = sizeof(*cmd);
  2744. int ac;
  2745. buf = wmi_buf_alloc(wmi_handle, len);
  2746. if (!buf) {
  2747. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  2748. return CDF_STATUS_E_NOMEM;
  2749. }
  2750. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  2751. cmd = (wmi_vdev_set_wmm_params_cmd_fixed_param *) buf_ptr;
  2752. WMITLV_SET_HDR(&cmd->tlv_header,
  2753. WMITLV_TAG_STRUC_wmi_vdev_set_wmm_params_cmd_fixed_param,
  2754. WMITLV_GET_STRUCT_TLVLEN
  2755. (wmi_vdev_set_wmm_params_cmd_fixed_param));
  2756. cmd->vdev_id = vdev_id;
  2757. for (ac = 0; ac < WMI_MAX_NUM_AC; ac++) {
  2758. wmm_param = (wmi_wmm_vparams *) (&cmd->wmm_params[ac]);
  2759. twmm_param = (wmi_wmm_vparams *) (&gwmm_param[ac]);
  2760. WMITLV_SET_HDR(&wmm_param->tlv_header,
  2761. WMITLV_TAG_STRUC_wmi_vdev_set_wmm_params_cmd_fixed_param,
  2762. WMITLV_GET_STRUCT_TLVLEN(wmi_wmm_vparams));
  2763. wmm_param->cwmin = twmm_param->cwmin;
  2764. wmm_param->cwmax = twmm_param->cwmax;
  2765. wmm_param->aifs = twmm_param->aifs;
  2766. wmm_param->txoplimit = twmm_param->txoplimit;
  2767. wmm_param->acm = twmm_param->acm;
  2768. wmm_param->no_ack = twmm_param->no_ack;
  2769. }
  2770. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  2771. WMI_VDEV_SET_WMM_PARAMS_CMDID))
  2772. goto fail;
  2773. return CDF_STATUS_SUCCESS;
  2774. fail:
  2775. wmi_buf_free(buf);
  2776. WMA_LOGE("%s: Failed to set WMM Paremeters", __func__);
  2777. return CDF_STATUS_E_FAILURE;
  2778. }
  2779. /**
  2780. * send_probe_rsp_tmpl_send_cmd_tlv() - send probe response template to fw
  2781. * @wmi_handle: wmi handle
  2782. * @vdev_id: vdev id
  2783. * @probe_rsp_info: probe response info
  2784. *
  2785. * Return: 0 for success or error code
  2786. */
  2787. CDF_STATUS send_probe_rsp_tmpl_send_cmd_tlv(wmi_unified_t wmi_handle,
  2788. uint8_t vdev_id,
  2789. struct wmi_probe_resp_params *probe_rsp_info,
  2790. uint8_t *frm)
  2791. {
  2792. wmi_prb_tmpl_cmd_fixed_param *cmd;
  2793. wmi_bcn_prb_info *bcn_prb_info;
  2794. wmi_buf_t wmi_buf;
  2795. uint32_t tmpl_len, tmpl_len_aligned, wmi_buf_len;
  2796. uint8_t *buf_ptr;
  2797. int ret;
  2798. WMA_LOGD(FL("Send probe response template for vdev %d"), vdev_id);
  2799. tmpl_len = probe_rsp_info->probeRespTemplateLen;
  2800. tmpl_len_aligned = roundup(tmpl_len, sizeof(A_UINT32));
  2801. wmi_buf_len = sizeof(wmi_prb_tmpl_cmd_fixed_param) +
  2802. sizeof(wmi_bcn_prb_info) + WMI_TLV_HDR_SIZE +
  2803. tmpl_len_aligned;
  2804. if (wmi_buf_len > WMI_BEACON_TX_BUFFER_SIZE) {
  2805. WMA_LOGE(FL("wmi_buf_len: %d > %d. Can't send wmi cmd"),
  2806. wmi_buf_len, WMI_BEACON_TX_BUFFER_SIZE);
  2807. return -EINVAL;
  2808. }
  2809. wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len);
  2810. if (!wmi_buf) {
  2811. WMA_LOGE(FL("wmi_buf_alloc failed"));
  2812. return -ENOMEM;
  2813. }
  2814. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  2815. cmd = (wmi_prb_tmpl_cmd_fixed_param *) buf_ptr;
  2816. WMITLV_SET_HDR(&cmd->tlv_header,
  2817. WMITLV_TAG_STRUC_wmi_prb_tmpl_cmd_fixed_param,
  2818. WMITLV_GET_STRUCT_TLVLEN(wmi_prb_tmpl_cmd_fixed_param));
  2819. cmd->vdev_id = vdev_id;
  2820. cmd->buf_len = tmpl_len;
  2821. buf_ptr += sizeof(wmi_prb_tmpl_cmd_fixed_param);
  2822. bcn_prb_info = (wmi_bcn_prb_info *) buf_ptr;
  2823. WMITLV_SET_HDR(&bcn_prb_info->tlv_header,
  2824. WMITLV_TAG_STRUC_wmi_bcn_prb_info,
  2825. WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_prb_info));
  2826. bcn_prb_info->caps = 0;
  2827. bcn_prb_info->erp = 0;
  2828. buf_ptr += sizeof(wmi_bcn_prb_info);
  2829. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, tmpl_len_aligned);
  2830. buf_ptr += WMI_TLV_HDR_SIZE;
  2831. cdf_mem_copy(buf_ptr, frm, tmpl_len);
  2832. ret = wmi_unified_cmd_send(wmi_handle,
  2833. wmi_buf, wmi_buf_len, WMI_PRB_TMPL_CMDID);
  2834. if (ret) {
  2835. WMA_LOGE(FL("Failed to send PRB RSP tmpl: %d"), ret);
  2836. wmi_buf_free(wmi_buf);
  2837. }
  2838. return ret;
  2839. }
  2840. /**
  2841. * send_p2p_go_set_beacon_ie_cmd_tlv() - set beacon IE for p2p go
  2842. * @wmi_handle: wmi handle
  2843. * @vdev_id: vdev id
  2844. * @p2p_ie: p2p IE
  2845. *
  2846. * Return: 0 for success or error code
  2847. */
  2848. CDF_STATUS send_p2p_go_set_beacon_ie_cmd_tlv(wmi_unified_t wmi_handle,
  2849. A_UINT32 vdev_id, uint8_t *p2p_ie)
  2850. {
  2851. int ret;
  2852. wmi_p2p_go_set_beacon_ie_fixed_param *cmd;
  2853. wmi_buf_t wmi_buf;
  2854. uint32_t ie_len, ie_len_aligned, wmi_buf_len;
  2855. uint8_t *buf_ptr;
  2856. ie_len = (uint32_t) (p2p_ie[1] + 2);
  2857. /* More than one P2P IE may be included in a single frame.
  2858. If multiple P2P IEs are present, the complete P2P attribute
  2859. data consists of the concatenation of the P2P Attribute
  2860. fields of the P2P IEs. The P2P Attributes field of each
  2861. P2P IE may be any length up to the maximum (251 octets).
  2862. In this case host sends one P2P IE to firmware so the length
  2863. should not exceed more than 251 bytes
  2864. */
  2865. if (ie_len > 251) {
  2866. WMA_LOGE("%s : invalid p2p ie length %u", __func__, ie_len);
  2867. return -EINVAL;
  2868. }
  2869. ie_len_aligned = roundup(ie_len, sizeof(A_UINT32));
  2870. wmi_buf_len =
  2871. sizeof(wmi_p2p_go_set_beacon_ie_fixed_param) + ie_len_aligned +
  2872. WMI_TLV_HDR_SIZE;
  2873. wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len);
  2874. if (!wmi_buf) {
  2875. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  2876. return -ENOMEM;
  2877. }
  2878. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  2879. cmd = (wmi_p2p_go_set_beacon_ie_fixed_param *) buf_ptr;
  2880. WMITLV_SET_HDR(&cmd->tlv_header,
  2881. WMITLV_TAG_STRUC_wmi_p2p_go_set_beacon_ie_fixed_param,
  2882. WMITLV_GET_STRUCT_TLVLEN
  2883. (wmi_p2p_go_set_beacon_ie_fixed_param));
  2884. cmd->vdev_id = vdev_id;
  2885. cmd->ie_buf_len = ie_len;
  2886. buf_ptr += sizeof(wmi_p2p_go_set_beacon_ie_fixed_param);
  2887. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ie_len_aligned);
  2888. buf_ptr += WMI_TLV_HDR_SIZE;
  2889. cdf_mem_copy(buf_ptr, p2p_ie, ie_len);
  2890. WMA_LOGI("%s: Sending WMI_P2P_GO_SET_BEACON_IE", __func__);
  2891. ret = wmi_unified_cmd_send(wmi_handle,
  2892. wmi_buf, wmi_buf_len,
  2893. WMI_P2P_GO_SET_BEACON_IE);
  2894. if (ret) {
  2895. WMA_LOGE("Failed to send bcn tmpl: %d", ret);
  2896. wmi_buf_free(wmi_buf);
  2897. }
  2898. WMA_LOGI("%s: Successfully sent WMI_P2P_GO_SET_BEACON_IE", __func__);
  2899. return ret;
  2900. }
  2901. /**
  2902. * send_set_gateway_params_cmd_tlv() - set gateway parameters
  2903. * @wmi_handle: wmi handle
  2904. * @req: gateway parameter update request structure
  2905. *
  2906. * This function reads the incoming @req and fill in the destination
  2907. * WMI structure and sends down the gateway configs down to the firmware
  2908. *
  2909. * Return: CDF_STATUS
  2910. */
  2911. CDF_STATUS send_set_gateway_params_cmd_tlv(wmi_unified_t wmi_handle,
  2912. struct gateway_update_req_param *req)
  2913. {
  2914. wmi_roam_subnet_change_config_fixed_param *cmd;
  2915. wmi_buf_t buf;
  2916. int ret;
  2917. int len = sizeof(*cmd);
  2918. buf = wmi_buf_alloc(wmi_handle, len);
  2919. if (!buf) {
  2920. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  2921. return CDF_STATUS_E_NOMEM;
  2922. }
  2923. cmd = (wmi_roam_subnet_change_config_fixed_param *) wmi_buf_data(buf);
  2924. WMITLV_SET_HDR(&cmd->tlv_header,
  2925. WMITLV_TAG_STRUC_wmi_roam_subnet_change_config_fixed_param,
  2926. WMITLV_GET_STRUCT_TLVLEN(
  2927. wmi_roam_subnet_change_config_fixed_param));
  2928. cmd->vdev_id = req->session_id;
  2929. cdf_mem_copy(&cmd->inet_gw_ip_v4_addr, req->ipv4_addr,
  2930. CDF_IPV4_ADDR_SIZE);
  2931. cdf_mem_copy(&cmd->inet_gw_ip_v6_addr, req->ipv6_addr,
  2932. CDF_IPV6_ADDR_SIZE);
  2933. WMI_CHAR_ARRAY_TO_MAC_ADDR(req->gw_mac_addr.bytes,
  2934. &cmd->inet_gw_mac_addr);
  2935. cmd->max_retries = req->max_retries;
  2936. cmd->timeout = req->timeout;
  2937. cmd->num_skip_subnet_change_detection_bssid_list = 0;
  2938. cmd->flag = 0;
  2939. if (req->ipv4_addr_type)
  2940. WMI_SET_ROAM_SUBNET_CHANGE_FLAG_IP4_ENABLED(cmd->flag);
  2941. if (req->ipv6_addr_type)
  2942. WMI_SET_ROAM_SUBNET_CHANGE_FLAG_IP6_ENABLED(cmd->flag);
  2943. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2944. WMI_ROAM_SUBNET_CHANGE_CONFIG_CMDID);
  2945. if (ret != EOK) {
  2946. WMA_LOGE("Failed to send gw config parameter to fw, ret: %d",
  2947. ret);
  2948. wmi_buf_free(buf);
  2949. return CDF_STATUS_E_FAILURE;
  2950. }
  2951. return CDF_STATUS_SUCCESS;
  2952. }
  2953. /**
  2954. * send_set_rssi_monitoring_cmd_tlv() - set rssi monitoring
  2955. * @wmi_handle: wmi handle
  2956. * @req: rssi monitoring request structure
  2957. *
  2958. * This function reads the incoming @req and fill in the destination
  2959. * WMI structure and send down the rssi monitoring configs down to the firmware
  2960. *
  2961. * Return: 0 on success; error number otherwise
  2962. */
  2963. CDF_STATUS send_set_rssi_monitoring_cmd_tlv(wmi_unified_t wmi_handle,
  2964. struct rssi_monitor_param *req)
  2965. {
  2966. wmi_rssi_breach_monitor_config_fixed_param *cmd;
  2967. wmi_buf_t buf;
  2968. int ret, len = sizeof(*cmd);
  2969. buf = wmi_buf_alloc(wmi_handle, len);
  2970. if (!buf) {
  2971. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  2972. return CDF_STATUS_E_NOMEM;
  2973. }
  2974. cmd = (wmi_rssi_breach_monitor_config_fixed_param *) wmi_buf_data(buf);
  2975. WMITLV_SET_HDR(&cmd->tlv_header,
  2976. WMITLV_TAG_STRUC_wmi_rssi_breach_monitor_config_fixed_param,
  2977. WMITLV_GET_STRUCT_TLVLEN(
  2978. wmi_rssi_breach_monitor_config_fixed_param));
  2979. cmd->vdev_id = req->session_id;
  2980. cmd->request_id = req->request_id;
  2981. cmd->lo_rssi_reenable_hysteresis = 0;
  2982. cmd->hi_rssi_reenable_histeresis = 0;
  2983. cmd->min_report_interval = 0;
  2984. cmd->max_num_report = 1;
  2985. if (req->control) {
  2986. /* enable one threshold for each min/max */
  2987. cmd->enabled_bitmap = 0x09;
  2988. cmd->low_rssi_breach_threshold[0] = req->min_rssi;
  2989. cmd->hi_rssi_breach_threshold[0] = req->max_rssi;
  2990. } else {
  2991. cmd->enabled_bitmap = 0;
  2992. cmd->low_rssi_breach_threshold[0] = 0;
  2993. cmd->hi_rssi_breach_threshold[0] = 0;
  2994. }
  2995. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2996. WMI_RSSI_BREACH_MONITOR_CONFIG_CMDID);
  2997. if (ret != EOK) {
  2998. WMA_LOGE("Failed to send WMI_RSSI_BREACH_MONITOR_CONFIG_CMDID");
  2999. wmi_buf_free(buf);
  3000. return CDF_STATUS_E_FAILURE;
  3001. }
  3002. WMA_LOGI("Sent WMI_RSSI_BREACH_MONITOR_CONFIG_CMDID to FW");
  3003. return CDF_STATUS_SUCCESS;
  3004. }
  3005. /**
  3006. * send_scan_probe_setoui_cmd_tlv() - set scan probe OUI
  3007. * @wmi_handle: wmi handle
  3008. * @psetoui: OUI parameters
  3009. *
  3010. * set scan probe OUI parameters in firmware
  3011. *
  3012. * Return: CDF status
  3013. */
  3014. CDF_STATUS send_scan_probe_setoui_cmd_tlv(wmi_unified_t wmi_handle,
  3015. struct scan_mac_oui *psetoui)
  3016. {
  3017. wmi_scan_prob_req_oui_cmd_fixed_param *cmd;
  3018. wmi_buf_t wmi_buf;
  3019. uint32_t len;
  3020. uint8_t *buf_ptr;
  3021. uint32_t *oui_buf;
  3022. len = sizeof(*cmd);
  3023. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  3024. if (!wmi_buf) {
  3025. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  3026. return CDF_STATUS_E_NOMEM;
  3027. }
  3028. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  3029. cmd = (wmi_scan_prob_req_oui_cmd_fixed_param *) buf_ptr;
  3030. WMITLV_SET_HDR(&cmd->tlv_header,
  3031. WMITLV_TAG_STRUC_wmi_scan_prob_req_oui_cmd_fixed_param,
  3032. WMITLV_GET_STRUCT_TLVLEN
  3033. (wmi_scan_prob_req_oui_cmd_fixed_param));
  3034. oui_buf = &cmd->prob_req_oui;
  3035. cdf_mem_zero(oui_buf, sizeof(cmd->prob_req_oui));
  3036. *oui_buf = psetoui->oui[0] << 16 | psetoui->oui[1] << 8
  3037. | psetoui->oui[2];
  3038. WMA_LOGD("%s: wmi:oui received from hdd %08x", __func__,
  3039. cmd->prob_req_oui);
  3040. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  3041. WMI_SCAN_PROB_REQ_OUI_CMDID)) {
  3042. WMA_LOGE("%s: failed to send command", __func__);
  3043. cdf_nbuf_free(wmi_buf);
  3044. return CDF_STATUS_E_FAILURE;
  3045. }
  3046. return CDF_STATUS_SUCCESS;
  3047. }
  3048. /**
  3049. * send_reset_passpoint_network_list_cmd_tlv() - reset passpoint network list
  3050. * @wmi_handle: wmi handle
  3051. * @req: passpoint network request structure
  3052. *
  3053. * This function sends down WMI command with network id set to wildcard id.
  3054. * firmware shall clear all the config entries
  3055. *
  3056. * Return: CDF_STATUS enumeration
  3057. */
  3058. CDF_STATUS send_reset_passpoint_network_list_cmd_tlv(wmi_unified_t wmi_handle,
  3059. struct wifi_passpoint_req_param *req)
  3060. {
  3061. wmi_passpoint_config_cmd_fixed_param *cmd;
  3062. wmi_buf_t buf;
  3063. uint32_t len;
  3064. int ret;
  3065. len = sizeof(*cmd);
  3066. buf = wmi_buf_alloc(wmi_handle, len);
  3067. if (!buf) {
  3068. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  3069. return CDF_STATUS_E_NOMEM;
  3070. }
  3071. cmd = (wmi_passpoint_config_cmd_fixed_param *) wmi_buf_data(buf);
  3072. WMITLV_SET_HDR(&cmd->tlv_header,
  3073. WMITLV_TAG_STRUC_wmi_passpoint_config_cmd_fixed_param,
  3074. WMITLV_GET_STRUCT_TLVLEN(
  3075. wmi_passpoint_config_cmd_fixed_param));
  3076. cmd->id = WMI_PASSPOINT_NETWORK_ID_WILDCARD;
  3077. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  3078. WMI_PASSPOINT_LIST_CONFIG_CMDID);
  3079. if (ret) {
  3080. WMA_LOGE("%s: Failed to send reset passpoint network list wmi cmd",
  3081. __func__);
  3082. wmi_buf_free(buf);
  3083. return CDF_STATUS_E_FAILURE;
  3084. }
  3085. return CDF_STATUS_SUCCESS;
  3086. }
  3087. /**
  3088. * send_set_passpoint_network_list_cmd_tlv() - set passpoint network list
  3089. * @wmi_handle: wmi handle
  3090. * @req: passpoint network request structure
  3091. *
  3092. * This function reads the incoming @req and fill in the destination
  3093. * WMI structure and send down the passpoint configs down to the firmware
  3094. *
  3095. * Return: CDF_STATUS enumeration
  3096. */
  3097. CDF_STATUS send_set_passpoint_network_list_cmd_tlv(wmi_unified_t wmi_handle,
  3098. struct wifi_passpoint_req_param *req)
  3099. {
  3100. wmi_passpoint_config_cmd_fixed_param *cmd;
  3101. u_int8_t i, j, *bytes;
  3102. wmi_buf_t buf;
  3103. uint32_t len;
  3104. int ret;
  3105. len = sizeof(*cmd);
  3106. for (i = 0; i < req->num_networks; i++) {
  3107. buf = wmi_buf_alloc(wmi_handle, len);
  3108. if (!buf) {
  3109. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  3110. return CDF_STATUS_E_NOMEM;
  3111. }
  3112. cmd = (wmi_passpoint_config_cmd_fixed_param *)
  3113. wmi_buf_data(buf);
  3114. WMITLV_SET_HDR(&cmd->tlv_header,
  3115. WMITLV_TAG_STRUC_wmi_passpoint_config_cmd_fixed_param,
  3116. WMITLV_GET_STRUCT_TLVLEN(
  3117. wmi_passpoint_config_cmd_fixed_param));
  3118. cmd->id = req->networks[i].id;
  3119. WMA_LOGD("%s: network id: %u", __func__, cmd->id);
  3120. cdf_mem_copy(cmd->realm, req->networks[i].realm,
  3121. strlen(req->networks[i].realm) + 1);
  3122. WMA_LOGD("%s: realm: %s", __func__, cmd->realm);
  3123. for (j = 0; j < PASSPOINT_ROAMING_CONSORTIUM_ID_NUM; j++) {
  3124. bytes = (uint8_t *) &req->networks[i].roaming_consortium_ids[j];
  3125. WMA_LOGD("index: %d rcids: %02x %02x %02x %02x %02x %02x %02x %02x",
  3126. j, bytes[0], bytes[1], bytes[2], bytes[3],
  3127. bytes[4], bytes[5], bytes[6], bytes[7]);
  3128. cdf_mem_copy(&cmd->roaming_consortium_ids[j],
  3129. &req->networks[i].roaming_consortium_ids[j],
  3130. PASSPOINT_ROAMING_CONSORTIUM_ID_LEN);
  3131. }
  3132. cdf_mem_copy(cmd->plmn, req->networks[i].plmn,
  3133. PASSPOINT_PLMN_ID_LEN);
  3134. WMA_LOGD("%s: plmn: %02x:%02x:%02x", __func__,
  3135. cmd->plmn[0], cmd->plmn[1], cmd->plmn[2]);
  3136. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  3137. WMI_PASSPOINT_LIST_CONFIG_CMDID);
  3138. if (ret) {
  3139. WMA_LOGE("%s: Failed to send set passpoint network list wmi cmd",
  3140. __func__);
  3141. wmi_buf_free(buf);
  3142. return CDF_STATUS_E_FAILURE;
  3143. }
  3144. }
  3145. return CDF_STATUS_SUCCESS;
  3146. }
  3147. /** send_set_epno_network_list_cmd_tlv() - set epno network list
  3148. * @wmi_handle: wmi handle
  3149. * @req: epno config params request structure
  3150. *
  3151. * This function reads the incoming epno config request structure
  3152. * and constructs the WMI message to the firmware.
  3153. *
  3154. * Returns: 0 on success, error number otherwise
  3155. */
  3156. CDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
  3157. struct wifi_enhanched_pno_params *req)
  3158. {
  3159. wmi_nlo_config_cmd_fixed_param *cmd;
  3160. nlo_configured_parameters *nlo_list;
  3161. u_int8_t i, *buf_ptr;
  3162. wmi_buf_t buf;
  3163. uint32_t len;
  3164. int ret;
  3165. /* TLV place holder for array of structures
  3166. * nlo_configured_parameters(nlo_list) */
  3167. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
  3168. len += sizeof(nlo_configured_parameters) *
  3169. CDF_MIN(req->num_networks, WMI_NLO_MAX_SSIDS);
  3170. len += WMI_TLV_HDR_SIZE; /* TLV for channel_list */
  3171. len += WMI_TLV_HDR_SIZE; /* TLV for channel prediction cfg*/
  3172. buf = wmi_buf_alloc(wmi_handle, len);
  3173. if (!buf) {
  3174. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  3175. return CDF_STATUS_E_NOMEM;
  3176. }
  3177. cmd = (wmi_nlo_config_cmd_fixed_param *) wmi_buf_data(buf);
  3178. buf_ptr = (u_int8_t *) cmd;
  3179. WMITLV_SET_HDR(&cmd->tlv_header,
  3180. WMITLV_TAG_STRUC_wmi_nlo_config_cmd_fixed_param,
  3181. WMITLV_GET_STRUCT_TLVLEN(
  3182. wmi_nlo_config_cmd_fixed_param));
  3183. cmd->vdev_id = req->session_id;
  3184. cmd->flags = WMI_NLO_CONFIG_ENLO;
  3185. buf_ptr += sizeof(wmi_nlo_config_cmd_fixed_param);
  3186. cmd->no_of_ssids = CDF_MIN(req->num_networks, WMI_NLO_MAX_SSIDS);
  3187. WMA_LOGD("SSID count: %d", cmd->no_of_ssids);
  3188. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3189. cmd->no_of_ssids * sizeof(nlo_configured_parameters));
  3190. buf_ptr += WMI_TLV_HDR_SIZE;
  3191. nlo_list = (nlo_configured_parameters *) buf_ptr;
  3192. for (i = 0; i < cmd->no_of_ssids; i++) {
  3193. WMITLV_SET_HDR(&nlo_list[i].tlv_header,
  3194. WMITLV_TAG_ARRAY_BYTE,
  3195. WMITLV_GET_STRUCT_TLVLEN(nlo_configured_parameters));
  3196. /* Copy ssid and it's length */
  3197. nlo_list[i].ssid.valid = true;
  3198. nlo_list[i].ssid.ssid.ssid_len = req->networks[i].ssid.length;
  3199. cdf_mem_copy(nlo_list[i].ssid.ssid.ssid,
  3200. req->networks[i].ssid.mac_ssid,
  3201. nlo_list[i].ssid.ssid.ssid_len);
  3202. WMA_LOGD("index: %d ssid: %.*s len: %d", i,
  3203. nlo_list[i].ssid.ssid.ssid_len,
  3204. (char *) nlo_list[i].ssid.ssid.ssid,
  3205. nlo_list[i].ssid.ssid.ssid_len);
  3206. /* Copy rssi threshold */
  3207. nlo_list[i].rssi_cond.valid = true;
  3208. nlo_list[i].rssi_cond.rssi =
  3209. req->networks[i].rssi_threshold;
  3210. WMA_LOGD("RSSI threshold : %d dBm",
  3211. nlo_list[i].rssi_cond.rssi);
  3212. /* Copy pno flags */
  3213. nlo_list[i].bcast_nw_type.valid = true;
  3214. nlo_list[i].bcast_nw_type.bcast_nw_type =
  3215. req->networks[i].flags;
  3216. WMA_LOGD("PNO flags (%u)",
  3217. nlo_list[i].bcast_nw_type.bcast_nw_type);
  3218. /* Copy auth bit field */
  3219. nlo_list[i].auth_type.valid = true;
  3220. nlo_list[i].auth_type.auth_type =
  3221. req->networks[i].auth_bit_field;
  3222. WMA_LOGD("Auth bit field (%u)",
  3223. nlo_list[i].auth_type.auth_type);
  3224. }
  3225. buf_ptr += cmd->no_of_ssids * sizeof(nlo_configured_parameters);
  3226. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
  3227. buf_ptr += WMI_TLV_HDR_SIZE;
  3228. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  3229. buf_ptr += WMI_TLV_HDR_SIZE;
  3230. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  3231. WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
  3232. if (ret) {
  3233. WMA_LOGE("%s: Failed to send nlo wmi cmd", __func__);
  3234. wmi_buf_free(buf);
  3235. return CDF_STATUS_E_FAILURE;
  3236. }
  3237. WMA_LOGD("set ePNO list request sent successfully for vdev %d",
  3238. req->session_id);
  3239. return CDF_STATUS_SUCCESS;
  3240. }
  3241. /** send_ipa_offload_control_cmd_tlv() - ipa offload control parameter
  3242. * @wmi_handle: wmi handle
  3243. * @ipa_offload: ipa offload control parameter
  3244. *
  3245. * Returns: 0 on success, error number otherwise
  3246. */
  3247. CDF_STATUS send_ipa_offload_control_cmd_tlv(wmi_unified_t wmi_handle,
  3248. struct ipa_offload_control_params *ipa_offload)
  3249. {
  3250. wmi_ipa_offload_enable_disable_cmd_fixed_param *cmd;
  3251. wmi_buf_t wmi_buf;
  3252. uint32_t len;
  3253. u_int8_t *buf_ptr;
  3254. len = sizeof(*cmd);
  3255. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  3256. if (!wmi_buf) {
  3257. WMA_LOGE("%s: wmi_buf_alloc failed (len=%d)", __func__, len);
  3258. return CDF_STATUS_E_NOMEM;
  3259. }
  3260. WMA_LOGE("%s: offload_type=%d, enable=%d", __func__,
  3261. ipa_offload->offload_type, ipa_offload->enable);
  3262. buf_ptr = (u_int8_t *)wmi_buf_data(wmi_buf);
  3263. cmd = (wmi_ipa_offload_enable_disable_cmd_fixed_param *)buf_ptr;
  3264. WMITLV_SET_HDR(&cmd->tlv_header,
  3265. WMITLV_TAG_STRUCT_wmi_ipa_offload_enable_disable_cmd_fixed_param,
  3266. WMITLV_GET_STRUCT_TLVLEN(
  3267. wmi_ipa_offload_enable_disable_cmd_fixed_param));
  3268. cmd->offload_type = ipa_offload->offload_type;
  3269. cmd->vdev_id = ipa_offload->vdev_id;
  3270. cmd->enable = ipa_offload->enable;
  3271. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  3272. WMI_IPA_OFFLOAD_ENABLE_DISABLE_CMDID)) {
  3273. WMA_LOGE("%s: failed to command", __func__);
  3274. wmi_buf_free(wmi_buf);
  3275. return CDF_STATUS_E_FAILURE;
  3276. }
  3277. return CDF_STATUS_SUCCESS;
  3278. }
  3279. /**
  3280. * send_extscan_get_capabilities_cmd_tlv() - extscan get capabilities
  3281. * @wmi_handle: wmi handle
  3282. * @pgetcapab: get capabilities params
  3283. *
  3284. * This function send request to fw to get extscan capabilities.
  3285. *
  3286. * Return: CDF status
  3287. */
  3288. CDF_STATUS send_extscan_get_capabilities_cmd_tlv(wmi_unified_t wmi_handle,
  3289. struct extscan_capabilities_params *pgetcapab)
  3290. {
  3291. wmi_extscan_get_capabilities_cmd_fixed_param *cmd;
  3292. wmi_buf_t wmi_buf;
  3293. uint32_t len;
  3294. uint8_t *buf_ptr;
  3295. len = sizeof(*cmd);
  3296. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  3297. if (!wmi_buf) {
  3298. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  3299. return CDF_STATUS_E_NOMEM;
  3300. }
  3301. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  3302. cmd = (wmi_extscan_get_capabilities_cmd_fixed_param *) buf_ptr;
  3303. WMITLV_SET_HDR(&cmd->tlv_header,
  3304. WMITLV_TAG_STRUC_wmi_extscan_get_capabilities_cmd_fixed_param,
  3305. WMITLV_GET_STRUCT_TLVLEN
  3306. (wmi_extscan_get_capabilities_cmd_fixed_param));
  3307. cmd->request_id = pgetcapab->request_id;
  3308. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  3309. WMI_EXTSCAN_GET_CAPABILITIES_CMDID)) {
  3310. WMA_LOGE("%s: failed to command", __func__);
  3311. cdf_nbuf_free(wmi_buf);
  3312. return CDF_STATUS_E_FAILURE;
  3313. }
  3314. return CDF_STATUS_SUCCESS;
  3315. }
  3316. /**
  3317. * send_extscan_get_cached_results_cmd_tlv() - extscan get cached results
  3318. * @wmi_handle: wmi handle
  3319. * @pcached_results: cached results parameters
  3320. *
  3321. * This function send request to fw to get cached results.
  3322. *
  3323. * Return: CDF status
  3324. */
  3325. CDF_STATUS send_extscan_get_cached_results_cmd_tlv(wmi_unified_t wmi_handle,
  3326. struct extscan_cached_result_params *pcached_results)
  3327. {
  3328. wmi_extscan_get_cached_results_cmd_fixed_param *cmd;
  3329. wmi_buf_t wmi_buf;
  3330. uint32_t len;
  3331. uint8_t *buf_ptr;
  3332. len = sizeof(*cmd);
  3333. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  3334. if (!wmi_buf) {
  3335. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  3336. return CDF_STATUS_E_NOMEM;
  3337. }
  3338. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  3339. cmd = (wmi_extscan_get_cached_results_cmd_fixed_param *) buf_ptr;
  3340. WMITLV_SET_HDR(&cmd->tlv_header,
  3341. WMITLV_TAG_STRUC_wmi_extscan_get_cached_results_cmd_fixed_param,
  3342. WMITLV_GET_STRUCT_TLVLEN
  3343. (wmi_extscan_get_cached_results_cmd_fixed_param));
  3344. cmd->request_id = pcached_results->request_id;
  3345. cmd->vdev_id = pcached_results->session_id;
  3346. cmd->control_flags = pcached_results->flush;
  3347. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  3348. WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID)) {
  3349. WMA_LOGE("%s: failed to command", __func__);
  3350. cdf_nbuf_free(wmi_buf);
  3351. return CDF_STATUS_E_FAILURE;
  3352. }
  3353. return CDF_STATUS_SUCCESS;
  3354. }
  3355. /**
  3356. * send_extscan_stop_change_monitor_cmd_tlv() - send stop change monitor cmd
  3357. * @wmi_handle: wmi handle
  3358. * @reset_req: Reset change request params
  3359. *
  3360. * This function sends stop change monitor request to fw.
  3361. *
  3362. * Return: CDF status
  3363. */
  3364. CDF_STATUS send_extscan_stop_change_monitor_cmd_tlv(wmi_unified_t wmi_handle,
  3365. struct extscan_capabilities_reset_params *reset_req)
  3366. {
  3367. wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param *cmd;
  3368. wmi_buf_t wmi_buf;
  3369. uint32_t len;
  3370. uint8_t *buf_ptr;
  3371. int change_list = 0;
  3372. len = sizeof(*cmd);
  3373. /* reset significant change tlv is set to 0 */
  3374. len += WMI_TLV_HDR_SIZE;
  3375. len += change_list * sizeof(wmi_extscan_wlan_change_bssid_param);
  3376. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  3377. if (!wmi_buf) {
  3378. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  3379. return CDF_STATUS_E_NOMEM;
  3380. }
  3381. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  3382. cmd = (wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param *)
  3383. buf_ptr;
  3384. WMITLV_SET_HDR(&cmd->tlv_header,
  3385. WMITLV_TAG_STRUC_wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param,
  3386. WMITLV_GET_STRUCT_TLVLEN
  3387. (wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param));
  3388. cmd->request_id = reset_req->request_id;
  3389. cmd->vdev_id = reset_req->session_id;
  3390. cmd->mode = 0;
  3391. buf_ptr += sizeof(*cmd);
  3392. WMITLV_SET_HDR(buf_ptr,
  3393. WMITLV_TAG_ARRAY_STRUC,
  3394. change_list *
  3395. sizeof(wmi_extscan_wlan_change_bssid_param));
  3396. buf_ptr += WMI_TLV_HDR_SIZE + (change_list *
  3397. sizeof
  3398. (wmi_extscan_wlan_change_bssid_param));
  3399. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  3400. WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID)) {
  3401. WMA_LOGE("%s: failed to command", __func__);
  3402. cdf_nbuf_free(wmi_buf);
  3403. return CDF_STATUS_E_FAILURE;
  3404. }
  3405. return CDF_STATUS_SUCCESS;
  3406. }
  3407. /**
  3408. * wmi_get_buf_extscan_change_monitor_cmd() - fill change monitor request
  3409. * @wmi_handle: wmi handle
  3410. * @psigchange: change monitor request params
  3411. * @buf: wmi buffer
  3412. * @buf_len: buffer length
  3413. *
  3414. * This function fills elements of change monitor request buffer.
  3415. *
  3416. * Return: CDF status
  3417. */
  3418. static CDF_STATUS wmi_get_buf_extscan_change_monitor_cmd(wmi_unified_t wmi_handle,
  3419. struct extscan_set_sig_changereq_params
  3420. *psigchange, wmi_buf_t *buf, int *buf_len)
  3421. {
  3422. wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param *cmd;
  3423. wmi_extscan_wlan_change_bssid_param *dest_chglist;
  3424. uint8_t *buf_ptr;
  3425. int j;
  3426. int len = sizeof(*cmd);
  3427. int numap = psigchange->num_ap;
  3428. struct ap_threshold_params *src_ap = psigchange->ap;
  3429. if (!numap) {
  3430. WMA_LOGE("%s: Invalid number of bssid's", __func__);
  3431. return CDF_STATUS_E_INVAL;
  3432. }
  3433. len += WMI_TLV_HDR_SIZE;
  3434. len += numap * sizeof(wmi_extscan_wlan_change_bssid_param);
  3435. *buf = wmi_buf_alloc(wmi_handle, len);
  3436. if (!*buf) {
  3437. WMA_LOGP("%s: failed to allocate memory for change monitor cmd",
  3438. __func__);
  3439. return CDF_STATUS_E_FAILURE;
  3440. }
  3441. buf_ptr = (uint8_t *) wmi_buf_data(*buf);
  3442. cmd =
  3443. (wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param *)
  3444. buf_ptr;
  3445. WMITLV_SET_HDR(&cmd->tlv_header,
  3446. WMITLV_TAG_STRUC_wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param,
  3447. WMITLV_GET_STRUCT_TLVLEN
  3448. (wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param));
  3449. cmd->request_id = psigchange->request_id;
  3450. cmd->vdev_id = psigchange->session_id;
  3451. cmd->total_entries = numap;
  3452. cmd->mode = 1;
  3453. cmd->num_entries_in_page = numap;
  3454. cmd->lost_ap_scan_count = psigchange->lostap_sample_size;
  3455. cmd->max_rssi_samples = psigchange->rssi_sample_size;
  3456. cmd->rssi_averaging_samples = psigchange->rssi_sample_size;
  3457. cmd->max_out_of_range_count = psigchange->min_breaching;
  3458. buf_ptr += sizeof(*cmd);
  3459. WMITLV_SET_HDR(buf_ptr,
  3460. WMITLV_TAG_ARRAY_STRUC,
  3461. numap * sizeof(wmi_extscan_wlan_change_bssid_param));
  3462. dest_chglist = (wmi_extscan_wlan_change_bssid_param *)
  3463. (buf_ptr + WMI_TLV_HDR_SIZE);
  3464. for (j = 0; j < numap; j++) {
  3465. WMITLV_SET_HDR(dest_chglist,
  3466. WMITLV_TAG_STRUC_wmi_extscan_bucket_cmd_fixed_param,
  3467. WMITLV_GET_STRUCT_TLVLEN
  3468. (wmi_extscan_wlan_change_bssid_param));
  3469. dest_chglist->lower_rssi_limit = src_ap->low;
  3470. dest_chglist->upper_rssi_limit = src_ap->high;
  3471. WMI_CHAR_ARRAY_TO_MAC_ADDR(src_ap->bssid.bytes,
  3472. &dest_chglist->bssid);
  3473. WMA_LOGD("%s: min_rssi %d", __func__,
  3474. dest_chglist->lower_rssi_limit);
  3475. dest_chglist++;
  3476. src_ap++;
  3477. }
  3478. buf_ptr += WMI_TLV_HDR_SIZE +
  3479. (numap * sizeof(wmi_extscan_wlan_change_bssid_param));
  3480. *buf_len = len;
  3481. return CDF_STATUS_SUCCESS;
  3482. }
  3483. /**
  3484. * send_extscan_start_change_monitor_cmd_tlv() - send start change monitor cmd
  3485. * @wmi_handle: wmi handle
  3486. * @psigchange: change monitor request params
  3487. *
  3488. * This function sends start change monitor request to fw.
  3489. *
  3490. * Return: CDF status
  3491. */
  3492. CDF_STATUS send_extscan_start_change_monitor_cmd_tlv(wmi_unified_t wmi_handle,
  3493. struct extscan_set_sig_changereq_params *
  3494. psigchange)
  3495. {
  3496. CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
  3497. wmi_buf_t buf;
  3498. int len;
  3499. cdf_status = wmi_get_buf_extscan_change_monitor_cmd(wmi_handle,
  3500. psigchange, &buf,
  3501. &len);
  3502. if (cdf_status != CDF_STATUS_SUCCESS) {
  3503. WMA_LOGE("%s: Failed to get buffer for change monitor cmd",
  3504. __func__);
  3505. return CDF_STATUS_E_FAILURE;
  3506. }
  3507. if (!buf) {
  3508. WMA_LOGE("%s: Failed to get buffer", __func__);
  3509. return CDF_STATUS_E_FAILURE;
  3510. }
  3511. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  3512. WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID)) {
  3513. WMA_LOGE("%s: failed to send command", __func__);
  3514. cdf_nbuf_free(buf);
  3515. return CDF_STATUS_E_FAILURE;
  3516. }
  3517. return CDF_STATUS_SUCCESS;
  3518. }
  3519. /**
  3520. * send_extscan_stop_hotlist_monitor_cmd_tlv() - stop hotlist monitor
  3521. * @wmi_handle: wmi handle
  3522. * @photlist_reset: hotlist reset params
  3523. *
  3524. * This function configures hotlist monitor to stop in fw.
  3525. *
  3526. * Return: CDF status
  3527. */
  3528. CDF_STATUS send_extscan_stop_hotlist_monitor_cmd_tlv(wmi_unified_t wmi_handle,
  3529. struct extscan_bssid_hotlist_reset_params *photlist_reset)
  3530. {
  3531. wmi_extscan_configure_hotlist_monitor_cmd_fixed_param *cmd;
  3532. wmi_buf_t wmi_buf;
  3533. uint32_t len;
  3534. uint8_t *buf_ptr;
  3535. int hotlist_entries = 0;
  3536. len = sizeof(*cmd);
  3537. /* reset bssid hotlist with tlv set to 0 */
  3538. len += WMI_TLV_HDR_SIZE;
  3539. len += hotlist_entries * sizeof(wmi_extscan_hotlist_entry);
  3540. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  3541. if (!wmi_buf) {
  3542. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  3543. return CDF_STATUS_E_NOMEM;
  3544. }
  3545. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  3546. cmd = (wmi_extscan_configure_hotlist_monitor_cmd_fixed_param *)
  3547. buf_ptr;
  3548. WMITLV_SET_HDR(&cmd->tlv_header,
  3549. WMITLV_TAG_STRUC_wmi_extscan_configure_hotlist_monitor_cmd_fixed_param,
  3550. WMITLV_GET_STRUCT_TLVLEN
  3551. (wmi_extscan_configure_hotlist_monitor_cmd_fixed_param));
  3552. cmd->request_id = photlist_reset->request_id;
  3553. cmd->vdev_id = photlist_reset->session_id;
  3554. cmd->mode = 0;
  3555. buf_ptr += sizeof(*cmd);
  3556. WMITLV_SET_HDR(buf_ptr,
  3557. WMITLV_TAG_ARRAY_STRUC,
  3558. hotlist_entries * sizeof(wmi_extscan_hotlist_entry));
  3559. buf_ptr += WMI_TLV_HDR_SIZE +
  3560. (hotlist_entries * sizeof(wmi_extscan_hotlist_entry));
  3561. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  3562. WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID)) {
  3563. WMA_LOGE("%s: failed to command", __func__);
  3564. cdf_nbuf_free(wmi_buf);
  3565. return CDF_STATUS_E_FAILURE;
  3566. }
  3567. return CDF_STATUS_SUCCESS;
  3568. }
  3569. /**
  3570. * send_stop_extscan_cmd_tlv() - stop extscan command to fw.
  3571. * @wmi_handle: wmi handle
  3572. * @pstopcmd: stop scan command request params
  3573. *
  3574. * This function sends stop extscan request to fw.
  3575. *
  3576. * Return: CDF Status.
  3577. */
  3578. CDF_STATUS send_stop_extscan_cmd_tlv(wmi_unified_t wmi_handle,
  3579. struct extscan_stop_req_params *pstopcmd)
  3580. {
  3581. wmi_extscan_stop_cmd_fixed_param *cmd;
  3582. wmi_buf_t wmi_buf;
  3583. uint32_t len;
  3584. uint8_t *buf_ptr;
  3585. len = sizeof(*cmd);
  3586. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  3587. if (!wmi_buf) {
  3588. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  3589. return CDF_STATUS_E_NOMEM;
  3590. }
  3591. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  3592. cmd = (wmi_extscan_stop_cmd_fixed_param *) buf_ptr;
  3593. WMITLV_SET_HDR(&cmd->tlv_header,
  3594. WMITLV_TAG_STRUC_wmi_extscan_stop_cmd_fixed_param,
  3595. WMITLV_GET_STRUCT_TLVLEN
  3596. (wmi_extscan_stop_cmd_fixed_param));
  3597. cmd->request_id = pstopcmd->request_id;
  3598. cmd->vdev_id = pstopcmd->session_id;
  3599. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  3600. WMI_EXTSCAN_STOP_CMDID)) {
  3601. WMA_LOGE("%s: failed to command", __func__);
  3602. cdf_nbuf_free(wmi_buf);
  3603. return CDF_STATUS_E_FAILURE;
  3604. }
  3605. return CDF_STATUS_SUCCESS;
  3606. }
  3607. /**
  3608. * wmi_get_buf_extscan_start_cmd() - Fill extscan start request
  3609. * @wmi_handle: wmi handle
  3610. * @pstart: scan command request params
  3611. * @buf: event buffer
  3612. * @buf_len: length of buffer
  3613. *
  3614. * This function fills individual elements of extscan request and
  3615. * TLV for buckets, channel list.
  3616. *
  3617. * Return: CDF Status.
  3618. */
  3619. CDF_STATUS wmi_get_buf_extscan_start_cmd(wmi_unified_t wmi_handle,
  3620. struct wifi_scan_cmd_req_params *pstart,
  3621. wmi_buf_t *buf, int *buf_len)
  3622. {
  3623. wmi_extscan_start_cmd_fixed_param *cmd;
  3624. wmi_extscan_bucket *dest_blist;
  3625. wmi_extscan_bucket_channel *dest_clist;
  3626. struct wifi_scan_bucket_params *src_bucket = pstart->buckets;
  3627. struct wifi_scan_channelspec_params *src_channel = src_bucket->channels;
  3628. struct wifi_scan_channelspec_params save_channel[WMI_WLAN_EXTSCAN_MAX_CHANNELS];
  3629. uint8_t *buf_ptr;
  3630. int i, k, count = 0;
  3631. int len = sizeof(*cmd);
  3632. int nbuckets = pstart->numBuckets;
  3633. int nchannels = 0;
  3634. /* These TLV's are are NULL by default */
  3635. uint32_t ie_len_with_pad = 0;
  3636. int num_ssid = 0;
  3637. int num_bssid = 0;
  3638. int ie_len = 0;
  3639. uint32_t base_period = pstart->basePeriod;
  3640. /* TLV placeholder for ssid_list (NULL) */
  3641. len += WMI_TLV_HDR_SIZE;
  3642. len += num_ssid * sizeof(wmi_ssid);
  3643. /* TLV placeholder for bssid_list (NULL) */
  3644. len += WMI_TLV_HDR_SIZE;
  3645. len += num_bssid * sizeof(wmi_mac_addr);
  3646. /* TLV placeholder for ie_data (NULL) */
  3647. len += WMI_TLV_HDR_SIZE;
  3648. len += ie_len * sizeof(uint32_t);
  3649. /* TLV placeholder for bucket */
  3650. len += WMI_TLV_HDR_SIZE;
  3651. len += nbuckets * sizeof(wmi_extscan_bucket);
  3652. /* TLV channel placeholder */
  3653. len += WMI_TLV_HDR_SIZE;
  3654. for (i = 0; i < nbuckets; i++) {
  3655. nchannels += src_bucket->numChannels;
  3656. src_bucket++;
  3657. }
  3658. WMA_LOGD("%s: Total buckets: %d total #of channels is %d",
  3659. __func__, nbuckets, nchannels);
  3660. len += nchannels * sizeof(wmi_extscan_bucket_channel);
  3661. /* Allocate the memory */
  3662. *buf = wmi_buf_alloc(wmi_handle, len);
  3663. if (!*buf) {
  3664. WMA_LOGP("%s: failed to allocate memory"
  3665. " for start extscan cmd", __func__);
  3666. return CDF_STATUS_E_NOMEM;
  3667. }
  3668. buf_ptr = (uint8_t *) wmi_buf_data(*buf);
  3669. cmd = (wmi_extscan_start_cmd_fixed_param *) buf_ptr;
  3670. WMITLV_SET_HDR(&cmd->tlv_header,
  3671. WMITLV_TAG_STRUC_wmi_extscan_start_cmd_fixed_param,
  3672. WMITLV_GET_STRUCT_TLVLEN
  3673. (wmi_extscan_start_cmd_fixed_param));
  3674. cmd->request_id = pstart->requestId;
  3675. cmd->vdev_id = pstart->sessionId;
  3676. cmd->base_period = pstart->basePeriod;
  3677. cmd->num_buckets = nbuckets;
  3678. cmd->configuration_flags = 0;
  3679. if (pstart->configuration_flags & EXTSCAN_LP_EXTENDED_BATCHING)
  3680. cmd->configuration_flags |= WMI_EXTSCAN_EXTENDED_BATCHING_EN;
  3681. WMA_LOGI("%s: configuration_flags: 0x%x", __func__,
  3682. cmd->configuration_flags);
  3683. cmd->min_rest_time = WMA_EXTSCAN_REST_TIME;
  3684. cmd->max_rest_time = WMA_EXTSCAN_REST_TIME;
  3685. cmd->max_bssids_per_scan_cycle = pstart->maxAPperScan;
  3686. /* The max dwell time is retrieved from the first channel
  3687. * of the first bucket and kept common for all channels.
  3688. */
  3689. cmd->min_dwell_time_active = pstart->min_dwell_time_active;
  3690. cmd->max_dwell_time_active = pstart->max_dwell_time_active;
  3691. cmd->min_dwell_time_passive = pstart->min_dwell_time_passive;
  3692. cmd->max_dwell_time_passive = pstart->max_dwell_time_passive;
  3693. cmd->max_bssids_per_scan_cycle = pstart->maxAPperScan;
  3694. cmd->max_table_usage = pstart->report_threshold_percent;
  3695. cmd->report_threshold_num_scans = pstart->report_threshold_num_scans;
  3696. cmd->repeat_probe_time = cmd->max_dwell_time_active /
  3697. WMA_SCAN_NPROBES_DEFAULT;
  3698. cmd->max_scan_time = WMA_EXTSCAN_MAX_SCAN_TIME;
  3699. cmd->probe_delay = 0;
  3700. cmd->probe_spacing_time = 0;
  3701. cmd->idle_time = 0;
  3702. cmd->burst_duration = WMA_EXTSCAN_BURST_DURATION;
  3703. cmd->scan_ctrl_flags = WMI_SCAN_ADD_BCAST_PROBE_REQ |
  3704. WMI_SCAN_ADD_CCK_RATES |
  3705. WMI_SCAN_ADD_OFDM_RATES |
  3706. WMI_SCAN_ADD_SPOOFED_MAC_IN_PROBE_REQ |
  3707. WMI_SCAN_ADD_DS_IE_IN_PROBE_REQ;
  3708. cmd->scan_priority = WMI_SCAN_PRIORITY_HIGH;
  3709. cmd->num_ssids = 0;
  3710. cmd->num_bssid = 0;
  3711. cmd->ie_len = 0;
  3712. cmd->n_probes = (cmd->repeat_probe_time > 0) ?
  3713. cmd->max_dwell_time_active / cmd->repeat_probe_time : 0;
  3714. buf_ptr += sizeof(*cmd);
  3715. WMITLV_SET_HDR(buf_ptr,
  3716. WMITLV_TAG_ARRAY_FIXED_STRUC,
  3717. num_ssid * sizeof(wmi_ssid));
  3718. buf_ptr += WMI_TLV_HDR_SIZE + (num_ssid * sizeof(wmi_ssid));
  3719. WMITLV_SET_HDR(buf_ptr,
  3720. WMITLV_TAG_ARRAY_FIXED_STRUC,
  3721. num_bssid * sizeof(wmi_mac_addr));
  3722. buf_ptr += WMI_TLV_HDR_SIZE + (num_bssid * sizeof(wmi_mac_addr));
  3723. ie_len_with_pad = 0;
  3724. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  3725. ie_len_with_pad);
  3726. buf_ptr += WMI_TLV_HDR_SIZE + ie_len_with_pad;
  3727. WMITLV_SET_HDR(buf_ptr,
  3728. WMITLV_TAG_ARRAY_STRUC,
  3729. nbuckets * sizeof(wmi_extscan_bucket));
  3730. dest_blist = (wmi_extscan_bucket *)
  3731. (buf_ptr + WMI_TLV_HDR_SIZE);
  3732. src_bucket = pstart->buckets;
  3733. /* Retrieve scanning information from each bucket and
  3734. * channels and send it to the target
  3735. */
  3736. for (i = 0; i < nbuckets; i++) {
  3737. WMITLV_SET_HDR(dest_blist,
  3738. WMITLV_TAG_STRUC_wmi_extscan_bucket_cmd_fixed_param,
  3739. WMITLV_GET_STRUCT_TLVLEN(wmi_extscan_bucket));
  3740. dest_blist->bucket_id = src_bucket->bucket;
  3741. dest_blist->base_period_multiplier =
  3742. src_bucket->period / base_period;
  3743. dest_blist->min_period = src_bucket->period;
  3744. dest_blist->max_period = src_bucket->max_period;
  3745. dest_blist->exp_backoff = src_bucket->exponent;
  3746. dest_blist->exp_max_step_count = src_bucket->step_count;
  3747. dest_blist->channel_band = src_bucket->band;
  3748. dest_blist->num_channels = src_bucket->numChannels;
  3749. dest_blist->notify_extscan_events = 0;
  3750. if (src_bucket->reportEvents & WMI_EXTSCAN_REPORT_EVENTS_EACH_SCAN)
  3751. dest_blist->notify_extscan_events =
  3752. WMI_EXTSCAN_BUCKET_COMPLETED_EVENT;
  3753. if (src_bucket->reportEvents &
  3754. WMI_EXTSCAN_REPORT_EVENTS_FULL_RESULTS) {
  3755. dest_blist->forwarding_flags =
  3756. WMI_EXTSCAN_FORWARD_FRAME_TO_HOST;
  3757. dest_blist->notify_extscan_events |=
  3758. WMI_EXTSCAN_BUCKET_COMPLETED_EVENT |
  3759. WMI_EXTSCAN_CYCLE_STARTED_EVENT |
  3760. WMI_EXTSCAN_CYCLE_COMPLETED_EVENT;
  3761. } else {
  3762. dest_blist->forwarding_flags =
  3763. WMI_EXTSCAN_NO_FORWARDING;
  3764. }
  3765. if (src_bucket->reportEvents & WMI_EXTSCAN_REPORT_EVENTS_NO_BATCH)
  3766. dest_blist->configuration_flags = 0;
  3767. else
  3768. dest_blist->configuration_flags =
  3769. WMI_EXTSCAN_BUCKET_CACHE_RESULTS;
  3770. WMA_LOGI("%s: ntfy_extscan_events:%u cfg_flags:%u fwd_flags:%u",
  3771. __func__, dest_blist->notify_extscan_events,
  3772. dest_blist->configuration_flags,
  3773. dest_blist->forwarding_flags);
  3774. dest_blist->min_dwell_time_active =
  3775. src_bucket->min_dwell_time_active;
  3776. dest_blist->max_dwell_time_active =
  3777. src_bucket->max_dwell_time_active;
  3778. dest_blist->min_dwell_time_passive =
  3779. src_bucket->min_dwell_time_passive;
  3780. dest_blist->max_dwell_time_passive =
  3781. src_bucket->max_dwell_time_passive;
  3782. src_channel = src_bucket->channels;
  3783. /* save the channel info to later populate
  3784. * the channel TLV
  3785. */
  3786. for (k = 0; k < src_bucket->numChannels; k++) {
  3787. save_channel[count++].channel = src_channel->channel;
  3788. src_channel++;
  3789. }
  3790. dest_blist++;
  3791. src_bucket++;
  3792. }
  3793. buf_ptr += WMI_TLV_HDR_SIZE + (nbuckets * sizeof(wmi_extscan_bucket));
  3794. WMITLV_SET_HDR(buf_ptr,
  3795. WMITLV_TAG_ARRAY_STRUC,
  3796. nchannels * sizeof(wmi_extscan_bucket_channel));
  3797. dest_clist = (wmi_extscan_bucket_channel *)
  3798. (buf_ptr + WMI_TLV_HDR_SIZE);
  3799. /* Active or passive scan is based on the bucket dwell time
  3800. * and channel specific active,passive scans are not
  3801. * supported yet
  3802. */
  3803. for (i = 0; i < nchannels; i++) {
  3804. WMITLV_SET_HDR(dest_clist,
  3805. WMITLV_TAG_STRUC_wmi_extscan_bucket_channel_event_fixed_param,
  3806. WMITLV_GET_STRUCT_TLVLEN
  3807. (wmi_extscan_bucket_channel));
  3808. dest_clist->channel = save_channel[i].channel;
  3809. dest_clist++;
  3810. }
  3811. buf_ptr += WMI_TLV_HDR_SIZE +
  3812. (nchannels * sizeof(wmi_extscan_bucket_channel));
  3813. *buf_len = len;
  3814. return CDF_STATUS_SUCCESS;
  3815. }
  3816. /**
  3817. * send_start_extscan_cmd_tlv() - start extscan command to fw.
  3818. * @wmi_handle: wmi handle
  3819. * @pstart: scan command request params
  3820. *
  3821. * This function sends start extscan request to fw.
  3822. *
  3823. * Return: CDF Status.
  3824. */
  3825. CDF_STATUS send_start_extscan_cmd_tlv(wmi_unified_t wmi_handle,
  3826. struct wifi_scan_cmd_req_params *pstart)
  3827. {
  3828. CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
  3829. wmi_buf_t buf;
  3830. int len;
  3831. /* Fill individual elements of extscan request and
  3832. * TLV for buckets, channel list.
  3833. */
  3834. cdf_status = wmi_get_buf_extscan_start_cmd(wmi_handle,
  3835. pstart, &buf, &len);
  3836. if (cdf_status != CDF_STATUS_SUCCESS) {
  3837. WMA_LOGE("%s: Failed to get buffer for ext scan cmd", __func__);
  3838. return CDF_STATUS_E_FAILURE;
  3839. }
  3840. if (!buf) {
  3841. WMA_LOGE("%s:Failed to get buffer"
  3842. "for current extscan info", __func__);
  3843. return CDF_STATUS_E_FAILURE;
  3844. }
  3845. if (wmi_unified_cmd_send(wmi_handle, buf,
  3846. len, WMI_EXTSCAN_START_CMDID)) {
  3847. WMA_LOGE("%s: failed to send command", __func__);
  3848. cdf_nbuf_free(buf);
  3849. return CDF_STATUS_E_FAILURE;
  3850. }
  3851. return CDF_STATUS_SUCCESS;
  3852. }
  3853. /**
  3854. * send_plm_stop_cmd_tlv() - plm stop request
  3855. * @wmi_handle: wmi handle
  3856. * @plm: plm request parameters
  3857. *
  3858. * This function request FW to stop PLM.
  3859. *
  3860. * Return: CDF status
  3861. */
  3862. CDF_STATUS send_plm_stop_cmd_tlv(wmi_unified_t wmi_handle,
  3863. const struct plm_req_params *plm)
  3864. {
  3865. wmi_vdev_plmreq_stop_cmd_fixed_param *cmd;
  3866. int32_t len;
  3867. wmi_buf_t buf;
  3868. uint8_t *buf_ptr;
  3869. int ret;
  3870. len = sizeof(*cmd);
  3871. buf = wmi_buf_alloc(wmi_handle, len);
  3872. if (!buf) {
  3873. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  3874. return CDF_STATUS_E_NOMEM;
  3875. }
  3876. cmd = (wmi_vdev_plmreq_stop_cmd_fixed_param *) wmi_buf_data(buf);
  3877. buf_ptr = (uint8_t *) cmd;
  3878. WMITLV_SET_HDR(&cmd->tlv_header,
  3879. WMITLV_TAG_STRUC_wmi_vdev_plmreq_stop_cmd_fixed_param,
  3880. WMITLV_GET_STRUCT_TLVLEN
  3881. (wmi_vdev_plmreq_stop_cmd_fixed_param));
  3882. cmd->vdev_id = plm->session_id;
  3883. cmd->meas_token = plm->meas_token;
  3884. WMA_LOGD("vdev %d meas token %d", cmd->vdev_id, cmd->meas_token);
  3885. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  3886. WMI_VDEV_PLMREQ_STOP_CMDID);
  3887. if (ret) {
  3888. WMA_LOGE("%s: Failed to send plm stop wmi cmd", __func__);
  3889. wmi_buf_free(buf);
  3890. return CDF_STATUS_E_FAILURE;
  3891. }
  3892. return CDF_STATUS_SUCCESS;
  3893. }
  3894. /**
  3895. * send_plm_start_cmd_tlv() - plm start request
  3896. * @wmi_handle: wmi handle
  3897. * @plm: plm request parameters
  3898. *
  3899. * This function request FW to start PLM.
  3900. *
  3901. * Return: CDF status
  3902. */
  3903. CDF_STATUS send_plm_start_cmd_tlv(wmi_unified_t wmi_handle,
  3904. const struct plm_req_params *plm,
  3905. uint32_t *gchannel_list)
  3906. {
  3907. wmi_vdev_plmreq_start_cmd_fixed_param *cmd;
  3908. uint32_t *channel_list;
  3909. int32_t len;
  3910. wmi_buf_t buf;
  3911. uint8_t *buf_ptr;
  3912. uint8_t count;
  3913. int ret;
  3914. /* TLV place holder for channel_list */
  3915. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
  3916. len += sizeof(uint32_t) * plm->plm_num_ch;
  3917. buf = wmi_buf_alloc(wmi_handle, len);
  3918. if (!buf) {
  3919. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  3920. return CDF_STATUS_E_NOMEM;
  3921. }
  3922. cmd = (wmi_vdev_plmreq_start_cmd_fixed_param *) wmi_buf_data(buf);
  3923. buf_ptr = (uint8_t *) cmd;
  3924. WMITLV_SET_HDR(&cmd->tlv_header,
  3925. WMITLV_TAG_STRUC_wmi_vdev_plmreq_start_cmd_fixed_param,
  3926. WMITLV_GET_STRUCT_TLVLEN
  3927. (wmi_vdev_plmreq_start_cmd_fixed_param));
  3928. cmd->vdev_id = plm->session_id;
  3929. cmd->meas_token = plm->meas_token;
  3930. cmd->dialog_token = plm->diag_token;
  3931. cmd->number_bursts = plm->num_bursts;
  3932. cmd->burst_interval = WMA_SEC_TO_MSEC(plm->burst_int);
  3933. cmd->off_duration = plm->meas_duration;
  3934. cmd->burst_cycle = plm->burst_len;
  3935. cmd->tx_power = plm->desired_tx_pwr;
  3936. WMI_CHAR_ARRAY_TO_MAC_ADDR(plm->mac_addr.bytes, &cmd->dest_mac);
  3937. cmd->num_chans = plm->plm_num_ch;
  3938. buf_ptr += sizeof(wmi_vdev_plmreq_start_cmd_fixed_param);
  3939. WMA_LOGD("vdev : %d measu token : %d", cmd->vdev_id, cmd->meas_token);
  3940. WMA_LOGD("dialog_token: %d", cmd->dialog_token);
  3941. WMA_LOGD("number_bursts: %d", cmd->number_bursts);
  3942. WMA_LOGD("burst_interval: %d", cmd->burst_interval);
  3943. WMA_LOGD("off_duration: %d", cmd->off_duration);
  3944. WMA_LOGD("burst_cycle: %d", cmd->burst_cycle);
  3945. WMA_LOGD("tx_power: %d", cmd->tx_power);
  3946. WMA_LOGD("Number of channels : %d", cmd->num_chans);
  3947. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  3948. (cmd->num_chans * sizeof(uint32_t)));
  3949. buf_ptr += WMI_TLV_HDR_SIZE;
  3950. if (cmd->num_chans) {
  3951. channel_list = (uint32_t *) buf_ptr;
  3952. for (count = 0; count < cmd->num_chans; count++) {
  3953. channel_list[count] = plm->plm_ch_list[count];
  3954. if (channel_list[count] < WMA_NLO_FREQ_THRESH)
  3955. channel_list[count] =
  3956. gchannel_list[count];
  3957. WMA_LOGD("Ch[%d]: %d MHz", count, channel_list[count]);
  3958. }
  3959. buf_ptr += cmd->num_chans * sizeof(uint32_t);
  3960. }
  3961. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  3962. WMI_VDEV_PLMREQ_START_CMDID);
  3963. if (ret) {
  3964. WMA_LOGE("%s: Failed to send plm start wmi cmd", __func__);
  3965. wmi_buf_free(buf);
  3966. return CDF_STATUS_E_FAILURE;
  3967. }
  3968. return CDF_STATUS_SUCCESS;
  3969. }
  3970. /**
  3971. * send_pno_stop_cmd_tlv() - PNO stop request
  3972. * @wmi_handle: wmi handle
  3973. * @vdev_id: vdev id
  3974. *
  3975. * This function request FW to stop ongoing PNO operation.
  3976. *
  3977. * Return: CDF status
  3978. */
  3979. CDF_STATUS send_pno_stop_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id)
  3980. {
  3981. wmi_nlo_config_cmd_fixed_param *cmd;
  3982. int32_t len = sizeof(*cmd);
  3983. wmi_buf_t buf;
  3984. uint8_t *buf_ptr;
  3985. int ret;
  3986. /*
  3987. * TLV place holder for array of structures nlo_configured_parameters
  3988. * TLV place holder for array of uint32_t channel_list
  3989. * TLV place holder for chnl prediction cfg
  3990. */
  3991. len += WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE;
  3992. buf = wmi_buf_alloc(wmi_handle, len);
  3993. if (!buf) {
  3994. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  3995. return CDF_STATUS_E_NOMEM;
  3996. }
  3997. cmd = (wmi_nlo_config_cmd_fixed_param *) wmi_buf_data(buf);
  3998. buf_ptr = (uint8_t *) cmd;
  3999. WMITLV_SET_HDR(&cmd->tlv_header,
  4000. WMITLV_TAG_STRUC_wmi_nlo_config_cmd_fixed_param,
  4001. WMITLV_GET_STRUCT_TLVLEN
  4002. (wmi_nlo_config_cmd_fixed_param));
  4003. cmd->vdev_id = vdev_id;
  4004. cmd->flags = WMI_NLO_CONFIG_STOP;
  4005. buf_ptr += sizeof(*cmd);
  4006. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  4007. buf_ptr += WMI_TLV_HDR_SIZE;
  4008. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
  4009. buf_ptr += WMI_TLV_HDR_SIZE;
  4010. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  4011. buf_ptr += WMI_TLV_HDR_SIZE;
  4012. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4013. WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
  4014. if (ret) {
  4015. WMA_LOGE("%s: Failed to send nlo wmi cmd", __func__);
  4016. wmi_buf_free(buf);
  4017. return CDF_STATUS_E_FAILURE;
  4018. }
  4019. return CDF_STATUS_SUCCESS;
  4020. }
  4021. /**
  4022. * send_pno_start_cmd_tlv() - PNO start request
  4023. * @wmi_handle: wmi handle
  4024. * @pno: PNO request
  4025. *
  4026. * This function request FW to start PNO request.
  4027. * Request: CDF status
  4028. */
  4029. CDF_STATUS send_pno_start_cmd_tlv(wmi_unified_t wmi_handle,
  4030. struct pno_scan_req_params *pno,
  4031. uint32_t *gchannel_freq_list)
  4032. {
  4033. wmi_nlo_config_cmd_fixed_param *cmd;
  4034. nlo_configured_parameters *nlo_list;
  4035. uint32_t *channel_list;
  4036. int32_t len;
  4037. wmi_buf_t buf;
  4038. uint8_t *buf_ptr;
  4039. uint8_t i;
  4040. int ret;
  4041. /*
  4042. * TLV place holder for array nlo_configured_parameters(nlo_list)
  4043. * TLV place holder for array of uint32_t channel_list
  4044. * TLV place holder for chnnl prediction cfg
  4045. */
  4046. len = sizeof(*cmd) +
  4047. WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE;
  4048. len += sizeof(uint32_t) * CDF_MIN(pno->aNetworks[0].ucChannelCount,
  4049. WMI_NLO_MAX_CHAN);
  4050. len += sizeof(nlo_configured_parameters) *
  4051. CDF_MIN(pno->ucNetworksCount, WMI_NLO_MAX_SSIDS);
  4052. len += sizeof(nlo_channel_prediction_cfg);
  4053. buf = wmi_buf_alloc(wmi_handle, len);
  4054. if (!buf) {
  4055. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  4056. return CDF_STATUS_E_NOMEM;
  4057. }
  4058. cmd = (wmi_nlo_config_cmd_fixed_param *) wmi_buf_data(buf);
  4059. buf_ptr = (uint8_t *) cmd;
  4060. WMITLV_SET_HDR(&cmd->tlv_header,
  4061. WMITLV_TAG_STRUC_wmi_nlo_config_cmd_fixed_param,
  4062. WMITLV_GET_STRUCT_TLVLEN
  4063. (wmi_nlo_config_cmd_fixed_param));
  4064. cmd->vdev_id = pno->sessionId;
  4065. cmd->flags = WMI_NLO_CONFIG_START | WMI_NLO_CONFIG_SSID_HIDE_EN;
  4066. /* Current FW does not support min-max range for dwell time */
  4067. cmd->active_dwell_time = pno->active_max_time;
  4068. cmd->passive_dwell_time = pno->passive_max_time;
  4069. /* Copy scan interval */
  4070. cmd->fast_scan_period = pno->fast_scan_period;
  4071. cmd->slow_scan_period = pno->slow_scan_period;
  4072. cmd->fast_scan_max_cycles = pno->fast_scan_max_cycles;
  4073. WMA_LOGD("fast_scan_period: %d msec slow_scan_period: %d msec",
  4074. cmd->fast_scan_period, cmd->slow_scan_period);
  4075. WMA_LOGD("fast_scan_max_cycles: %d", cmd->fast_scan_max_cycles);
  4076. buf_ptr += sizeof(wmi_nlo_config_cmd_fixed_param);
  4077. cmd->no_of_ssids = CDF_MIN(pno->ucNetworksCount, WMI_NLO_MAX_SSIDS);
  4078. WMA_LOGD("SSID count : %d", cmd->no_of_ssids);
  4079. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  4080. cmd->no_of_ssids * sizeof(nlo_configured_parameters));
  4081. buf_ptr += WMI_TLV_HDR_SIZE;
  4082. nlo_list = (nlo_configured_parameters *) buf_ptr;
  4083. for (i = 0; i < cmd->no_of_ssids; i++) {
  4084. WMITLV_SET_HDR(&nlo_list[i].tlv_header,
  4085. WMITLV_TAG_ARRAY_BYTE,
  4086. WMITLV_GET_STRUCT_TLVLEN
  4087. (nlo_configured_parameters));
  4088. /* Copy ssid and it's length */
  4089. nlo_list[i].ssid.valid = true;
  4090. nlo_list[i].ssid.ssid.ssid_len = pno->aNetworks[i].ssid.length;
  4091. cdf_mem_copy(nlo_list[i].ssid.ssid.ssid,
  4092. pno->aNetworks[i].ssid.mac_ssid,
  4093. nlo_list[i].ssid.ssid.ssid_len);
  4094. WMA_LOGD("index: %d ssid: %.*s len: %d", i,
  4095. nlo_list[i].ssid.ssid.ssid_len,
  4096. (char *)nlo_list[i].ssid.ssid.ssid,
  4097. nlo_list[i].ssid.ssid.ssid_len);
  4098. /* Copy rssi threshold */
  4099. if (pno->aNetworks[i].rssiThreshold &&
  4100. pno->aNetworks[i].rssiThreshold > WMI_RSSI_THOLD_DEFAULT) {
  4101. nlo_list[i].rssi_cond.valid = true;
  4102. nlo_list[i].rssi_cond.rssi =
  4103. pno->aNetworks[i].rssiThreshold;
  4104. WMA_LOGD("RSSI threshold : %d dBm",
  4105. nlo_list[i].rssi_cond.rssi);
  4106. }
  4107. nlo_list[i].bcast_nw_type.valid = true;
  4108. nlo_list[i].bcast_nw_type.bcast_nw_type =
  4109. pno->aNetworks[i].bcastNetwType;
  4110. WMA_LOGI("Broadcast NW type (%u)",
  4111. nlo_list[i].bcast_nw_type.bcast_nw_type);
  4112. }
  4113. buf_ptr += cmd->no_of_ssids * sizeof(nlo_configured_parameters);
  4114. /* Copy channel info */
  4115. cmd->num_of_channels = CDF_MIN(pno->aNetworks[0].ucChannelCount,
  4116. WMI_NLO_MAX_CHAN);
  4117. WMA_LOGD("Channel count: %d", cmd->num_of_channels);
  4118. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  4119. (cmd->num_of_channels * sizeof(uint32_t)));
  4120. buf_ptr += WMI_TLV_HDR_SIZE;
  4121. channel_list = (uint32_t *) buf_ptr;
  4122. for (i = 0; i < cmd->num_of_channels; i++) {
  4123. channel_list[i] = pno->aNetworks[0].aChannels[i];
  4124. if (channel_list[i] < WMI_NLO_FREQ_THRESH)
  4125. channel_list[i] = gchannel_freq_list[i];
  4126. WMA_LOGD("Ch[%d]: %d MHz", i, channel_list[i]);
  4127. }
  4128. buf_ptr += cmd->num_of_channels * sizeof(uint32_t);
  4129. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  4130. sizeof(nlo_channel_prediction_cfg));
  4131. buf_ptr += WMI_TLV_HDR_SIZE;
  4132. buf_ptr += WMI_TLV_HDR_SIZE;
  4133. /** TODO: Discrete firmware doesn't have command/option to configure
  4134. * App IE which comes from wpa_supplicant as of part PNO start request.
  4135. */
  4136. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4137. WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
  4138. if (ret) {
  4139. WMA_LOGE("%s: Failed to send nlo wmi cmd", __func__);
  4140. wmi_buf_free(buf);
  4141. return CDF_STATUS_E_FAILURE;
  4142. }
  4143. return CDF_STATUS_SUCCESS;
  4144. }
  4145. /* send_set_ric_req_cmd_tlv() - set ric request element
  4146. * @wmi_handle: wmi handle
  4147. * @msg: message
  4148. * @is_add_ts: is addts required
  4149. *
  4150. * This function sets ric request element for 11r roaming.
  4151. *
  4152. * Return: CDF status
  4153. */
  4154. CDF_STATUS send_set_ric_req_cmd_tlv(wmi_unified_t wmi_handle,
  4155. void *msg, uint8_t is_add_ts)
  4156. {
  4157. wmi_ric_request_fixed_param *cmd;
  4158. wmi_ric_tspec *tspec_param;
  4159. wmi_buf_t buf;
  4160. uint8_t *buf_ptr;
  4161. struct mac_tspec_ie *ptspecIE;
  4162. int32_t len = sizeof(wmi_ric_request_fixed_param) +
  4163. WMI_TLV_HDR_SIZE + sizeof(wmi_ric_tspec);
  4164. buf = wmi_buf_alloc(wmi_handle, len);
  4165. if (!buf) {
  4166. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  4167. return CDF_STATUS_E_NOMEM;
  4168. }
  4169. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4170. cmd = (wmi_ric_request_fixed_param *) buf_ptr;
  4171. WMITLV_SET_HDR(&cmd->tlv_header,
  4172. WMITLV_TAG_STRUC_wmi_ric_request_fixed_param,
  4173. WMITLV_GET_STRUCT_TLVLEN(wmi_ric_request_fixed_param));
  4174. if (is_add_ts)
  4175. cmd->vdev_id = ((struct add_ts_param *) msg)->sessionId;
  4176. else
  4177. cmd->vdev_id = ((struct del_ts_params *) msg)->sessionId;
  4178. cmd->num_ric_request = 1;
  4179. cmd->is_add_ric = is_add_ts;
  4180. buf_ptr += sizeof(wmi_ric_request_fixed_param);
  4181. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, sizeof(wmi_ric_tspec));
  4182. buf_ptr += WMI_TLV_HDR_SIZE;
  4183. tspec_param = (wmi_ric_tspec *) buf_ptr;
  4184. WMITLV_SET_HDR(&tspec_param->tlv_header,
  4185. WMITLV_TAG_STRUC_wmi_ric_tspec,
  4186. WMITLV_GET_STRUCT_TLVLEN(wmi_ric_tspec));
  4187. if (is_add_ts)
  4188. ptspecIE = &(((struct add_ts_param *) msg)->tspec);
  4189. else
  4190. ptspecIE = &(((struct del_ts_params *) msg)->delTsInfo.tspec);
  4191. /* Fill the tsinfo in the format expected by firmware */
  4192. #ifndef ANI_LITTLE_BIT_ENDIAN
  4193. cdf_mem_copy(((uint8_t *) &tspec_param->ts_info) + 1,
  4194. ((uint8_t *) &ptspecIE->tsinfo) + 1, 2);
  4195. #else
  4196. cdf_mem_copy(((uint8_t *) &tspec_param->ts_info),
  4197. ((uint8_t *) &ptspecIE->tsinfo) + 1, 2);
  4198. #endif /* ANI_LITTLE_BIT_ENDIAN */
  4199. tspec_param->nominal_msdu_size = ptspecIE->nomMsduSz;
  4200. tspec_param->maximum_msdu_size = ptspecIE->maxMsduSz;
  4201. tspec_param->min_service_interval = ptspecIE->minSvcInterval;
  4202. tspec_param->max_service_interval = ptspecIE->maxSvcInterval;
  4203. tspec_param->inactivity_interval = ptspecIE->inactInterval;
  4204. tspec_param->suspension_interval = ptspecIE->suspendInterval;
  4205. tspec_param->svc_start_time = ptspecIE->svcStartTime;
  4206. tspec_param->min_data_rate = ptspecIE->minDataRate;
  4207. tspec_param->mean_data_rate = ptspecIE->meanDataRate;
  4208. tspec_param->peak_data_rate = ptspecIE->peakDataRate;
  4209. tspec_param->max_burst_size = ptspecIE->maxBurstSz;
  4210. tspec_param->delay_bound = ptspecIE->delayBound;
  4211. tspec_param->min_phy_rate = ptspecIE->minPhyRate;
  4212. tspec_param->surplus_bw_allowance = ptspecIE->surplusBw;
  4213. tspec_param->medium_time = 0;
  4214. WMA_LOGI("%s: Set RIC Req is_add_ts:%d", __func__, is_add_ts);
  4215. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  4216. WMI_ROAM_SET_RIC_REQUEST_CMDID)) {
  4217. WMA_LOGP("%s: Failed to send vdev Set RIC Req command",
  4218. __func__);
  4219. if (is_add_ts)
  4220. ((struct add_ts_param *) msg)->status =
  4221. CDF_STATUS_E_FAILURE;
  4222. cdf_nbuf_free(buf);
  4223. return CDF_STATUS_E_FAILURE;
  4224. }
  4225. return CDF_STATUS_SUCCESS;
  4226. }
  4227. /**
  4228. * send_process_ll_stats_clear_cmd_tlv() - clear link layer stats
  4229. * @wmi_handle: wmi handle
  4230. * @clear_req: ll stats clear request command params
  4231. *
  4232. * Return: CDF_STATUS_SUCCESS for success or error code
  4233. */
  4234. CDF_STATUS send_process_ll_stats_clear_cmd_tlv(wmi_unified_t wmi_handle,
  4235. const struct ll_stats_clear_params *clear_req,
  4236. uint8_t addr[IEEE80211_ADDR_LEN])
  4237. {
  4238. wmi_clear_link_stats_cmd_fixed_param *cmd;
  4239. int32_t len;
  4240. wmi_buf_t buf;
  4241. uint8_t *buf_ptr;
  4242. int ret;
  4243. len = sizeof(*cmd);
  4244. buf = wmi_buf_alloc(wmi_handle, len);
  4245. if (!buf) {
  4246. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  4247. return CDF_STATUS_E_NOMEM;
  4248. }
  4249. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4250. cdf_mem_zero(buf_ptr, len);
  4251. cmd = (wmi_clear_link_stats_cmd_fixed_param *) buf_ptr;
  4252. WMITLV_SET_HDR(&cmd->tlv_header,
  4253. WMITLV_TAG_STRUC_wmi_clear_link_stats_cmd_fixed_param,
  4254. WMITLV_GET_STRUCT_TLVLEN
  4255. (wmi_clear_link_stats_cmd_fixed_param));
  4256. cmd->stop_stats_collection_req = clear_req->stop_req;
  4257. cmd->vdev_id = clear_req->sta_id;
  4258. cmd->stats_clear_req_mask = clear_req->stats_clear_mask;
  4259. WMI_CHAR_ARRAY_TO_MAC_ADDR(addr,
  4260. &cmd->peer_macaddr);
  4261. WMA_LOGD("LINK_LAYER_STATS - Clear Request Params");
  4262. WMA_LOGD("StopReq : %d", cmd->stop_stats_collection_req);
  4263. WMA_LOGD("Vdev Id : %d", cmd->vdev_id);
  4264. WMA_LOGD("Clear Stat Mask : %d", cmd->stats_clear_req_mask);
  4265. /* WMA_LOGD("Peer MAC Addr : %pM",
  4266. cmd->peer_macaddr); */
  4267. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4268. WMI_CLEAR_LINK_STATS_CMDID);
  4269. if (ret) {
  4270. WMA_LOGE("%s: Failed to send clear link stats req", __func__);
  4271. wmi_buf_free(buf);
  4272. return CDF_STATUS_E_FAILURE;
  4273. }
  4274. WMA_LOGD("Clear Link Layer Stats request sent successfully");
  4275. return CDF_STATUS_SUCCESS;
  4276. }
  4277. /**
  4278. * send_process_ll_stats_set_cmd_tlv() - link layer stats set request
  4279. * @wmi_handle: wmi handle
  4280. * @setReq: ll stats set request command params
  4281. *
  4282. * Return: CDF_STATUS_SUCCESS for success or error code
  4283. */
  4284. CDF_STATUS send_process_ll_stats_set_cmd_tlv(wmi_unified_t wmi_handle,
  4285. const struct ll_stats_set_params *set_req)
  4286. {
  4287. wmi_start_link_stats_cmd_fixed_param *cmd;
  4288. int32_t len;
  4289. wmi_buf_t buf;
  4290. uint8_t *buf_ptr;
  4291. int ret;
  4292. len = sizeof(*cmd);
  4293. buf = wmi_buf_alloc(wmi_handle, len);
  4294. if (!buf) {
  4295. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  4296. return CDF_STATUS_E_NOMEM;
  4297. }
  4298. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4299. cdf_mem_zero(buf_ptr, len);
  4300. cmd = (wmi_start_link_stats_cmd_fixed_param *) buf_ptr;
  4301. WMITLV_SET_HDR(&cmd->tlv_header,
  4302. WMITLV_TAG_STRUC_wmi_start_link_stats_cmd_fixed_param,
  4303. WMITLV_GET_STRUCT_TLVLEN
  4304. (wmi_start_link_stats_cmd_fixed_param));
  4305. cmd->mpdu_size_threshold = set_req->mpdu_size_threshold;
  4306. cmd->aggressive_statistics_gathering =
  4307. set_req->aggressive_statistics_gathering;
  4308. WMA_LOGD("LINK_LAYER_STATS - Start/Set Request Params");
  4309. WMA_LOGD("MPDU Size Thresh : %d", cmd->mpdu_size_threshold);
  4310. WMA_LOGD("Aggressive Gather: %d", cmd->aggressive_statistics_gathering);
  4311. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4312. WMI_START_LINK_STATS_CMDID);
  4313. if (ret) {
  4314. WMA_LOGE("%s: Failed to send set link stats request", __func__);
  4315. wmi_buf_free(buf);
  4316. return CDF_STATUS_E_FAILURE;
  4317. }
  4318. return CDF_STATUS_SUCCESS;
  4319. }
  4320. /**
  4321. * send_process_ll_stats_get_cmd_tlv() - link layer stats get request
  4322. * @wmi_handle:wmi handle
  4323. * @get_req:ll stats get request command params
  4324. * @addr: mac address
  4325. *
  4326. * Return: CDF_STATUS_SUCCESS for success or error code
  4327. */
  4328. CDF_STATUS send_process_ll_stats_get_cmd_tlv(wmi_unified_t wmi_handle,
  4329. const struct ll_stats_get_params *get_req,
  4330. uint8_t addr[IEEE80211_ADDR_LEN])
  4331. {
  4332. wmi_request_link_stats_cmd_fixed_param *cmd;
  4333. int32_t len;
  4334. wmi_buf_t buf;
  4335. uint8_t *buf_ptr;
  4336. int ret;
  4337. len = sizeof(*cmd);
  4338. buf = wmi_buf_alloc(wmi_handle, len);
  4339. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4340. cdf_mem_zero(buf_ptr, len);
  4341. cmd = (wmi_request_link_stats_cmd_fixed_param *) buf_ptr;
  4342. WMITLV_SET_HDR(&cmd->tlv_header,
  4343. WMITLV_TAG_STRUC_wmi_request_link_stats_cmd_fixed_param,
  4344. WMITLV_GET_STRUCT_TLVLEN
  4345. (wmi_request_link_stats_cmd_fixed_param));
  4346. cmd->request_id = get_req->req_id;
  4347. cmd->stats_type = get_req->param_id_mask;
  4348. cmd->vdev_id = get_req->sta_id;
  4349. WMI_CHAR_ARRAY_TO_MAC_ADDR(addr,
  4350. &cmd->peer_macaddr);
  4351. WMA_LOGD("LINK_LAYER_STATS - Get Request Params");
  4352. WMA_LOGD("Request ID : %d", cmd->request_id);
  4353. WMA_LOGD("Stats Type : %d", cmd->stats_type);
  4354. WMA_LOGD("Vdev ID : %d", cmd->vdev_id);
  4355. WMA_LOGD("Peer MAC Addr : %pM", addr);
  4356. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4357. WMI_REQUEST_LINK_STATS_CMDID);
  4358. if (ret) {
  4359. WMA_LOGE("%s: Failed to send get link stats request", __func__);
  4360. wmi_buf_free(buf);
  4361. return CDF_STATUS_E_FAILURE;
  4362. }
  4363. return CDF_STATUS_SUCCESS;
  4364. }
  4365. /**
  4366. * send_get_stats_cmd_tlv() - get stats request
  4367. * @wmi_handle: wmi handle
  4368. * @get_stats_param: stats params
  4369. * @addr: mac address
  4370. *
  4371. * Return: CDF status
  4372. */
  4373. CDF_STATUS send_get_stats_cmd_tlv(wmi_unified_t wmi_handle,
  4374. struct pe_stats_req *get_stats_param,
  4375. uint8_t addr[IEEE80211_ADDR_LEN])
  4376. {
  4377. wmi_buf_t buf;
  4378. wmi_request_stats_cmd_fixed_param *cmd;
  4379. uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
  4380. buf = wmi_buf_alloc(wmi_handle, len);
  4381. if (!buf) {
  4382. WMA_LOGE("%s: Failed to allocate wmi buffer", __func__);
  4383. return CDF_STATUS_E_FAILURE;
  4384. }
  4385. cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
  4386. WMITLV_SET_HDR(&cmd->tlv_header,
  4387. WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
  4388. WMITLV_GET_STRUCT_TLVLEN
  4389. (wmi_request_stats_cmd_fixed_param));
  4390. cmd->stats_id =
  4391. WMI_REQUEST_PEER_STAT | WMI_REQUEST_PDEV_STAT |
  4392. WMI_REQUEST_VDEV_STAT;
  4393. cmd->vdev_id = get_stats_param->session_id;
  4394. WMI_CHAR_ARRAY_TO_MAC_ADDR(addr, &cmd->peer_macaddr);
  4395. WMA_LOGD("STATS REQ VDEV_ID:%d-->", cmd->vdev_id);
  4396. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  4397. WMI_REQUEST_STATS_CMDID)) {
  4398. WMA_LOGE("%s: Failed to send WMI_REQUEST_STATS_CMDID",
  4399. __func__);
  4400. wmi_buf_free(buf);
  4401. return CDF_STATUS_E_FAILURE;
  4402. }
  4403. return CDF_STATUS_SUCCESS;
  4404. }
  4405. /**
  4406. * send_snr_request_cmd_tlv() - send request to fw to get RSSI stats
  4407. * @wmi_handle: wmi handle
  4408. * @rssi_req: get RSSI request
  4409. *
  4410. * Return: CDF status
  4411. */
  4412. CDF_STATUS send_snr_request_cmd_tlv(wmi_unified_t wmi_handle)
  4413. {
  4414. wmi_buf_t buf;
  4415. wmi_request_stats_cmd_fixed_param *cmd;
  4416. uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
  4417. buf = wmi_buf_alloc(wmi_handle, len);
  4418. if (!buf) {
  4419. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  4420. return CDF_STATUS_E_FAILURE;
  4421. }
  4422. cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
  4423. WMITLV_SET_HDR(&cmd->tlv_header,
  4424. WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
  4425. WMITLV_GET_STRUCT_TLVLEN
  4426. (wmi_request_stats_cmd_fixed_param));
  4427. cmd->stats_id = WMI_REQUEST_VDEV_STAT;
  4428. if (wmi_unified_cmd_send
  4429. (wmi_handle, buf, len, WMI_REQUEST_STATS_CMDID)) {
  4430. WMA_LOGE("Failed to send host stats request to fw");
  4431. wmi_buf_free(buf);
  4432. return CDF_STATUS_E_FAILURE;
  4433. }
  4434. return CDF_STATUS_SUCCESS;
  4435. }
  4436. /**
  4437. * send_snr_cmd_tlv() - get RSSI from fw
  4438. * @wmi_handle: wmi handle
  4439. * @vdev_id: vdev id
  4440. *
  4441. * Return: CDF status
  4442. */
  4443. CDF_STATUS send_snr_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id)
  4444. {
  4445. wmi_buf_t buf;
  4446. wmi_request_stats_cmd_fixed_param *cmd;
  4447. uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
  4448. buf = wmi_buf_alloc(wmi_handle, len);
  4449. if (!buf) {
  4450. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  4451. return CDF_STATUS_E_FAILURE;
  4452. }
  4453. cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
  4454. cmd->vdev_id = vdev_id;
  4455. WMITLV_SET_HDR(&cmd->tlv_header,
  4456. WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
  4457. WMITLV_GET_STRUCT_TLVLEN
  4458. (wmi_request_stats_cmd_fixed_param));
  4459. cmd->stats_id = WMI_REQUEST_VDEV_STAT;
  4460. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  4461. WMI_REQUEST_STATS_CMDID)) {
  4462. WMA_LOGE("Failed to send host stats request to fw");
  4463. wmi_buf_free(buf);
  4464. return CDF_STATUS_E_FAILURE;
  4465. }
  4466. return CDF_STATUS_SUCCESS;
  4467. }
  4468. /**
  4469. * send_link_status_req_cmd_tlv() - process link status request from UMAC
  4470. * @wmi_handle: wmi handle
  4471. * @link_status: get link params
  4472. *
  4473. * Return: CDF status
  4474. */
  4475. CDF_STATUS send_link_status_req_cmd_tlv(wmi_unified_t wmi_handle,
  4476. struct link_status_params *link_status)
  4477. {
  4478. wmi_buf_t buf;
  4479. wmi_request_stats_cmd_fixed_param *cmd;
  4480. uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
  4481. buf = wmi_buf_alloc(wmi_handle, len);
  4482. if (!buf) {
  4483. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  4484. return CDF_STATUS_E_FAILURE;
  4485. }
  4486. cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
  4487. WMITLV_SET_HDR(&cmd->tlv_header,
  4488. WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
  4489. WMITLV_GET_STRUCT_TLVLEN
  4490. (wmi_request_stats_cmd_fixed_param));
  4491. cmd->stats_id = WMI_REQUEST_VDEV_RATE_STAT;
  4492. cmd->vdev_id = link_status->session_id;
  4493. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  4494. WMI_REQUEST_STATS_CMDID)) {
  4495. WMA_LOGE("Failed to send WMI link status request to fw");
  4496. wmi_buf_free(buf);
  4497. return CDF_STATUS_E_FAILURE;
  4498. }
  4499. return CDF_STATUS_SUCCESS;
  4500. }
  4501. #ifdef FEATURE_WLAN_LPHB
  4502. /**
  4503. * send_lphb_config_hbenable_cmd_tlv() - enable command of LPHB configuration
  4504. * @wmi_handle: wmi handle
  4505. * @lphb_conf_req: configuration info
  4506. *
  4507. * Return: CDF status
  4508. */
  4509. CDF_STATUS send_lphb_config_hbenable_cmd_tlv(wmi_unified_t wmi_handle,
  4510. wmi_hb_set_enable_cmd_fixed_param *params)
  4511. {
  4512. CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
  4513. int status = 0;
  4514. wmi_buf_t buf = NULL;
  4515. uint8_t *buf_ptr;
  4516. wmi_hb_set_enable_cmd_fixed_param *hb_enable_fp;
  4517. int len = sizeof(wmi_hb_set_enable_cmd_fixed_param);
  4518. buf = wmi_buf_alloc(wmi_handle, len);
  4519. if (!buf) {
  4520. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  4521. return CDF_STATUS_E_NOMEM;
  4522. }
  4523. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4524. hb_enable_fp = (wmi_hb_set_enable_cmd_fixed_param *) buf_ptr;
  4525. WMITLV_SET_HDR(&hb_enable_fp->tlv_header,
  4526. WMITLV_TAG_STRUC_wmi_hb_set_enable_cmd_fixed_param,
  4527. WMITLV_GET_STRUCT_TLVLEN
  4528. (wmi_hb_set_enable_cmd_fixed_param));
  4529. /* fill in values */
  4530. hb_enable_fp->vdev_id = params->session;
  4531. hb_enable_fp->enable = params->enable;
  4532. hb_enable_fp->item = params->item;
  4533. hb_enable_fp->session = params->session;
  4534. status = wmi_unified_cmd_send(wmi_handle, buf,
  4535. len, WMI_HB_SET_ENABLE_CMDID);
  4536. if (status != EOK) {
  4537. WMA_LOGE("wmi_unified_cmd_send WMI_HB_SET_ENABLE returned Error %d",
  4538. status);
  4539. cdf_status = CDF_STATUS_E_FAILURE;
  4540. goto error;
  4541. }
  4542. return CDF_STATUS_SUCCESS;
  4543. error:
  4544. return cdf_status;
  4545. }
  4546. /**
  4547. * send_lphb_config_tcp_params_cmd_tlv() - set tcp params of LPHB configuration
  4548. * @wmi_handle: wmi handle
  4549. * @lphb_conf_req: lphb config request
  4550. *
  4551. * Return: CDF status
  4552. */
  4553. CDF_STATUS send_lphb_config_tcp_params_cmd_tlv(wmi_unified_t wmi_handle,
  4554. wmi_hb_set_tcp_params_cmd_fixed_param *lphb_conf_req)
  4555. {
  4556. CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
  4557. int status = 0;
  4558. wmi_buf_t buf = NULL;
  4559. uint8_t *buf_ptr;
  4560. wmi_hb_set_tcp_params_cmd_fixed_param *hb_tcp_params_fp;
  4561. int len = sizeof(wmi_hb_set_tcp_params_cmd_fixed_param);
  4562. buf = wmi_buf_alloc(wmi_handle, len);
  4563. if (!buf) {
  4564. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  4565. return CDF_STATUS_E_NOMEM;
  4566. }
  4567. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4568. hb_tcp_params_fp = (wmi_hb_set_tcp_params_cmd_fixed_param *) buf_ptr;
  4569. WMITLV_SET_HDR(&hb_tcp_params_fp->tlv_header,
  4570. WMITLV_TAG_STRUC_wmi_hb_set_tcp_params_cmd_fixed_param,
  4571. WMITLV_GET_STRUCT_TLVLEN
  4572. (wmi_hb_set_tcp_params_cmd_fixed_param));
  4573. /* fill in values */
  4574. hb_tcp_params_fp->vdev_id = lphb_conf_req->vdev_id;
  4575. hb_tcp_params_fp->srv_ip = lphb_conf_req->srv_ip;
  4576. hb_tcp_params_fp->dev_ip = lphb_conf_req->dev_ip;
  4577. hb_tcp_params_fp->seq = lphb_conf_req->seq;
  4578. hb_tcp_params_fp->src_port = lphb_conf_req->src_port;
  4579. hb_tcp_params_fp->dst_port = lphb_conf_req->dst_port;
  4580. hb_tcp_params_fp->interval = lphb_conf_req->interval;
  4581. hb_tcp_params_fp->timeout = lphb_conf_req->timeout;
  4582. hb_tcp_params_fp->session = lphb_conf_req->session;
  4583. cdf_mem_copy(&hb_tcp_params_fp->gateway_mac,
  4584. &lphb_conf_req->gateway_mac,
  4585. sizeof(hb_tcp_params_fp->gateway_mac));
  4586. status = wmi_unified_cmd_send(wmi_handle, buf,
  4587. len, WMI_HB_SET_TCP_PARAMS_CMDID);
  4588. if (status != EOK) {
  4589. WMA_LOGE("wmi_unified_cmd_send WMI_HB_SET_TCP_PARAMS returned Error %d",
  4590. status);
  4591. cdf_status = CDF_STATUS_E_FAILURE;
  4592. goto error;
  4593. }
  4594. return CDF_STATUS_SUCCESS;
  4595. error:
  4596. return cdf_status;
  4597. }
  4598. /**
  4599. * send_lphb_config_tcp_pkt_filter_cmd_tlv() - configure tcp packet filter cmd
  4600. * @wmi_handle: wmi handle
  4601. * @lphb_conf_req: lphb config request
  4602. *
  4603. * Return: CDF status
  4604. */
  4605. CDF_STATUS send_lphb_config_tcp_pkt_filter_cmd_tlv(wmi_unified_t wmi_handle,
  4606. wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *g_hb_tcp_filter_fp)
  4607. {
  4608. CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
  4609. int status = 0;
  4610. wmi_buf_t buf = NULL;
  4611. uint8_t *buf_ptr;
  4612. wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *hb_tcp_filter_fp;
  4613. int len = sizeof(wmi_hb_set_tcp_pkt_filter_cmd_fixed_param);
  4614. buf = wmi_buf_alloc(wmi_handle, len);
  4615. if (!buf) {
  4616. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  4617. return CDF_STATUS_E_NOMEM;
  4618. }
  4619. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4620. hb_tcp_filter_fp =
  4621. (wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *) buf_ptr;
  4622. WMITLV_SET_HDR(&hb_tcp_filter_fp->tlv_header,
  4623. WMITLV_TAG_STRUC_wmi_hb_set_tcp_pkt_filter_cmd_fixed_param,
  4624. WMITLV_GET_STRUCT_TLVLEN
  4625. (wmi_hb_set_tcp_pkt_filter_cmd_fixed_param));
  4626. /* fill in values */
  4627. hb_tcp_filter_fp->vdev_id = g_hb_tcp_filter_fp->vdev_id;
  4628. hb_tcp_filter_fp->length = g_hb_tcp_filter_fp->length;
  4629. hb_tcp_filter_fp->offset = g_hb_tcp_filter_fp->offset;
  4630. hb_tcp_filter_fp->session = g_hb_tcp_filter_fp->session;
  4631. memcpy((void *)&hb_tcp_filter_fp->filter,
  4632. (void *)&g_hb_tcp_filter_fp->filter,
  4633. WMI_WLAN_HB_MAX_FILTER_SIZE);
  4634. status = wmi_unified_cmd_send(wmi_handle, buf,
  4635. len, WMI_HB_SET_TCP_PKT_FILTER_CMDID);
  4636. if (status != EOK) {
  4637. WMA_LOGE("wmi_unified_cmd_send WMI_HB_SET_TCP_PKT_FILTER returned Error %d",
  4638. status);
  4639. cdf_status = CDF_STATUS_E_FAILURE;
  4640. goto error;
  4641. }
  4642. return CDF_STATUS_SUCCESS;
  4643. error:
  4644. return cdf_status;
  4645. }
  4646. /**
  4647. * send_lphb_config_udp_params_cmd_tlv() - configure udp param command of LPHB
  4648. * @wmi_handle: wmi handle
  4649. * @lphb_conf_req: lphb config request
  4650. *
  4651. * Return: CDF status
  4652. */
  4653. CDF_STATUS send_lphb_config_udp_params_cmd_tlv(wmi_unified_t wmi_handle,
  4654. wmi_hb_set_udp_params_cmd_fixed_param *lphb_conf_req)
  4655. {
  4656. CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
  4657. int status = 0;
  4658. wmi_buf_t buf = NULL;
  4659. uint8_t *buf_ptr;
  4660. wmi_hb_set_udp_params_cmd_fixed_param *hb_udp_params_fp;
  4661. int len = sizeof(wmi_hb_set_udp_params_cmd_fixed_param);
  4662. buf = wmi_buf_alloc(wmi_handle, len);
  4663. if (!buf) {
  4664. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  4665. return CDF_STATUS_E_NOMEM;
  4666. }
  4667. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4668. hb_udp_params_fp = (wmi_hb_set_udp_params_cmd_fixed_param *) buf_ptr;
  4669. WMITLV_SET_HDR(&hb_udp_params_fp->tlv_header,
  4670. WMITLV_TAG_STRUC_wmi_hb_set_udp_params_cmd_fixed_param,
  4671. WMITLV_GET_STRUCT_TLVLEN
  4672. (wmi_hb_set_udp_params_cmd_fixed_param));
  4673. /* fill in values */
  4674. hb_udp_params_fp->vdev_id = lphb_conf_req->vdev_id;
  4675. hb_udp_params_fp->srv_ip = lphb_conf_req->srv_ip;
  4676. hb_udp_params_fp->dev_ip = lphb_conf_req->dev_ip;
  4677. hb_udp_params_fp->src_port = lphb_conf_req->src_port;
  4678. hb_udp_params_fp->dst_port = lphb_conf_req->dst_port;
  4679. hb_udp_params_fp->interval = lphb_conf_req->interval;
  4680. hb_udp_params_fp->timeout = lphb_conf_req->timeout;
  4681. hb_udp_params_fp->session = lphb_conf_req->session;
  4682. cdf_mem_copy(&hb_udp_params_fp->gateway_mac,
  4683. &lphb_conf_req->gateway_mac,
  4684. sizeof(lphb_conf_req->gateway_mac));
  4685. status = wmi_unified_cmd_send(wmi_handle, buf,
  4686. len, WMI_HB_SET_UDP_PARAMS_CMDID);
  4687. if (status != EOK) {
  4688. WMA_LOGE("wmi_unified_cmd_send WMI_HB_SET_UDP_PARAMS returned Error %d",
  4689. status);
  4690. cdf_status = CDF_STATUS_E_FAILURE;
  4691. goto error;
  4692. }
  4693. return CDF_STATUS_SUCCESS;
  4694. error:
  4695. return cdf_status;
  4696. }
  4697. /**
  4698. * send_lphb_config_udp_pkt_filter_cmd_tlv() - configure udp pkt filter command
  4699. * @wmi_handle: wmi handle
  4700. * @lphb_conf_req: lphb config request
  4701. *
  4702. * Return: CDF status
  4703. */
  4704. CDF_STATUS send_lphb_config_udp_pkt_filter_cmd_tlv(wmi_unified_t wmi_handle,
  4705. wmi_hb_set_udp_pkt_filter_cmd_fixed_param *lphb_conf_req)
  4706. {
  4707. CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
  4708. int status = 0;
  4709. wmi_buf_t buf = NULL;
  4710. uint8_t *buf_ptr;
  4711. wmi_hb_set_udp_pkt_filter_cmd_fixed_param *hb_udp_filter_fp;
  4712. int len = sizeof(wmi_hb_set_udp_pkt_filter_cmd_fixed_param);
  4713. buf = wmi_buf_alloc(wmi_handle, len);
  4714. if (!buf) {
  4715. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  4716. return CDF_STATUS_E_NOMEM;
  4717. }
  4718. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4719. hb_udp_filter_fp =
  4720. (wmi_hb_set_udp_pkt_filter_cmd_fixed_param *) buf_ptr;
  4721. WMITLV_SET_HDR(&hb_udp_filter_fp->tlv_header,
  4722. WMITLV_TAG_STRUC_wmi_hb_set_udp_pkt_filter_cmd_fixed_param,
  4723. WMITLV_GET_STRUCT_TLVLEN
  4724. (wmi_hb_set_udp_pkt_filter_cmd_fixed_param));
  4725. /* fill in values */
  4726. hb_udp_filter_fp->vdev_id = lphb_conf_req->vdev_id;
  4727. hb_udp_filter_fp->length = lphb_conf_req->length;
  4728. hb_udp_filter_fp->offset = lphb_conf_req->offset;
  4729. hb_udp_filter_fp->session = lphb_conf_req->session;
  4730. memcpy((void *)&hb_udp_filter_fp->filter,
  4731. (void *)&lphb_conf_req->filter,
  4732. WMI_WLAN_HB_MAX_FILTER_SIZE);
  4733. status = wmi_unified_cmd_send(wmi_handle, buf,
  4734. len, WMI_HB_SET_UDP_PKT_FILTER_CMDID);
  4735. if (status != EOK) {
  4736. WMA_LOGE("wmi_unified_cmd_send WMI_HB_SET_UDP_PKT_FILTER returned Error %d",
  4737. status);
  4738. cdf_status = CDF_STATUS_E_FAILURE;
  4739. goto error;
  4740. }
  4741. return CDF_STATUS_SUCCESS;
  4742. error:
  4743. return cdf_status;
  4744. }
  4745. #endif /* FEATURE_WLAN_LPHB */
  4746. /**
  4747. * send_process_dhcp_ind_cmd_tlv() - process dhcp indication from SME
  4748. * @wmi_handle: wmi handle
  4749. * @ta_dhcp_ind: DHCP indication parameter
  4750. *
  4751. * Return: CDF Status
  4752. */
  4753. CDF_STATUS send_process_dhcp_ind_cmd_tlv(wmi_unified_t wmi_handle,
  4754. wmi_peer_set_param_cmd_fixed_param *ta_dhcp_ind)
  4755. {
  4756. int status = 0;
  4757. wmi_buf_t buf = NULL;
  4758. uint8_t *buf_ptr;
  4759. wmi_peer_set_param_cmd_fixed_param *peer_set_param_fp;
  4760. int len = sizeof(wmi_peer_set_param_cmd_fixed_param);
  4761. buf = wmi_buf_alloc(wmi_handle, len);
  4762. if (!buf) {
  4763. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  4764. return CDF_STATUS_E_NOMEM;
  4765. }
  4766. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4767. peer_set_param_fp = (wmi_peer_set_param_cmd_fixed_param *) buf_ptr;
  4768. WMITLV_SET_HDR(&peer_set_param_fp->tlv_header,
  4769. WMITLV_TAG_STRUC_wmi_peer_set_param_cmd_fixed_param,
  4770. WMITLV_GET_STRUCT_TLVLEN
  4771. (wmi_peer_set_param_cmd_fixed_param));
  4772. /* fill in values */
  4773. peer_set_param_fp->vdev_id = ta_dhcp_ind->vdev_id;
  4774. peer_set_param_fp->param_id = ta_dhcp_ind->param_id;
  4775. peer_set_param_fp->param_value = ta_dhcp_ind->param_value;
  4776. cdf_mem_copy(&peer_set_param_fp->peer_macaddr,
  4777. &ta_dhcp_ind->peer_macaddr,
  4778. sizeof(ta_dhcp_ind->peer_macaddr));
  4779. status = wmi_unified_cmd_send(wmi_handle, buf,
  4780. len, WMI_PEER_SET_PARAM_CMDID);
  4781. if (status != EOK) {
  4782. WMA_LOGE("%s: wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
  4783. " returned Error %d", __func__, status);
  4784. return CDF_STATUS_E_FAILURE;
  4785. }
  4786. return CDF_STATUS_SUCCESS;
  4787. }
  4788. /**
  4789. * send_get_link_speed_cmd_tlv() -send command to get linkspeed
  4790. * @wmi_handle: wmi handle
  4791. * @pLinkSpeed: link speed info
  4792. *
  4793. * Return: CDF status
  4794. */
  4795. CDF_STATUS send_get_link_speed_cmd_tlv(wmi_unified_t wmi_handle,
  4796. wmi_mac_addr peer_macaddr)
  4797. {
  4798. wmi_peer_get_estimated_linkspeed_cmd_fixed_param *cmd;
  4799. wmi_buf_t wmi_buf;
  4800. uint32_t len;
  4801. uint8_t *buf_ptr;
  4802. len = sizeof(wmi_peer_get_estimated_linkspeed_cmd_fixed_param);
  4803. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  4804. if (!wmi_buf) {
  4805. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  4806. return CDF_STATUS_E_NOMEM;
  4807. }
  4808. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  4809. cmd = (wmi_peer_get_estimated_linkspeed_cmd_fixed_param *) buf_ptr;
  4810. WMITLV_SET_HDR(&cmd->tlv_header,
  4811. WMITLV_TAG_STRUC_wmi_peer_get_estimated_linkspeed_cmd_fixed_param,
  4812. WMITLV_GET_STRUCT_TLVLEN
  4813. (wmi_peer_get_estimated_linkspeed_cmd_fixed_param));
  4814. /* Copy the peer macaddress to the wma buffer */
  4815. cdf_mem_copy(&cmd->peer_macaddr,
  4816. &peer_macaddr,
  4817. sizeof(peer_macaddr));
  4818. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  4819. WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID)) {
  4820. WMA_LOGE("%s: failed to send link speed command", __func__);
  4821. cdf_nbuf_free(wmi_buf);
  4822. return CDF_STATUS_E_FAILURE;
  4823. }
  4824. return CDF_STATUS_SUCCESS;
  4825. }
  4826. /**
  4827. * send_egap_conf_params_cmd_tlv() - send wmi cmd of egap configuration params
  4828. * @wmi_handle: wmi handler
  4829. * @egap_params: pointer to egap_params
  4830. *
  4831. * Return: 0 for success, otherwise appropriate error code
  4832. */
  4833. CDF_STATUS send_egap_conf_params_cmd_tlv(wmi_unified_t wmi_handle,
  4834. wmi_ap_ps_egap_param_cmd_fixed_param *egap_params)
  4835. {
  4836. wmi_ap_ps_egap_param_cmd_fixed_param *cmd;
  4837. wmi_buf_t buf;
  4838. int32_t err;
  4839. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  4840. if (!buf) {
  4841. WMA_LOGE("Failed to allocate buffer to send ap_ps_egap cmd");
  4842. return CDF_STATUS_E_NOMEM;
  4843. }
  4844. cmd = (wmi_ap_ps_egap_param_cmd_fixed_param *) wmi_buf_data(buf);
  4845. WMITLV_SET_HDR(&cmd->tlv_header,
  4846. WMITLV_TAG_STRUC_wmi_ap_ps_egap_param_cmd_fixed_param,
  4847. WMITLV_GET_STRUCT_TLVLEN(
  4848. wmi_ap_ps_egap_param_cmd_fixed_param));
  4849. cmd->enable = egap_params->enable;
  4850. cmd->inactivity_time = egap_params->inactivity_time;
  4851. cmd->wait_time = egap_params->wait_time;
  4852. cmd->flags = egap_params->flags;
  4853. err = wmi_unified_cmd_send(wmi_handle, buf,
  4854. sizeof(*cmd), WMI_AP_PS_EGAP_PARAM_CMDID);
  4855. if (err) {
  4856. WMA_LOGE("Failed to send ap_ps_egap cmd");
  4857. wmi_buf_free(buf);
  4858. return CDF_STATUS_E_FAILURE;
  4859. }
  4860. return CDF_STATUS_SUCCESS;
  4861. }
  4862. /**
  4863. * send_fw_profiling_cmd_tlv() - send FW profiling cmd to WLAN FW
  4864. * @wmi_handl: wmi handle
  4865. * @cmd: Profiling command index
  4866. * @value1: parameter1 value
  4867. * @value2: parameter2 value
  4868. *
  4869. * Return: 0 for success else error code
  4870. */
  4871. CDF_STATUS send_fw_profiling_cmd_tlv(wmi_unified_t wmi_handle,
  4872. uint32_t cmd, uint32_t value1, uint32_t value2)
  4873. {
  4874. wmi_buf_t buf;
  4875. int32_t len = 0;
  4876. int ret;
  4877. wmi_wlan_profile_trigger_cmd_fixed_param *prof_trig_cmd;
  4878. wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *hist_intvl_cmd;
  4879. wmi_wlan_profile_enable_profile_id_cmd_fixed_param *profile_enable_cmd;
  4880. wmi_wlan_profile_get_prof_data_cmd_fixed_param *profile_getdata_cmd;
  4881. switch (cmd) {
  4882. case WMI_WLAN_PROFILE_TRIGGER_CMDID:
  4883. len = sizeof(wmi_wlan_profile_trigger_cmd_fixed_param);
  4884. buf = wmi_buf_alloc(wmi_handle, len);
  4885. if (!buf) {
  4886. WMA_LOGP("%s: wmi_buf_alloc Failed", __func__);
  4887. return -ENOMEM;
  4888. }
  4889. prof_trig_cmd =
  4890. (wmi_wlan_profile_trigger_cmd_fixed_param *)
  4891. wmi_buf_data(buf);
  4892. WMITLV_SET_HDR(&prof_trig_cmd->tlv_header,
  4893. WMITLV_TAG_STRUC_wmi_wlan_profile_trigger_cmd_fixed_param,
  4894. WMITLV_GET_STRUCT_TLVLEN
  4895. (wmi_wlan_profile_trigger_cmd_fixed_param));
  4896. prof_trig_cmd->enable = value1;
  4897. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4898. WMI_WLAN_PROFILE_TRIGGER_CMDID);
  4899. if (ret) {
  4900. WMA_LOGE("PROFILE_TRIGGER cmd Failed with value %d",
  4901. value1);
  4902. cdf_nbuf_free(buf);
  4903. return ret;
  4904. }
  4905. break;
  4906. case WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID:
  4907. len = sizeof(wmi_wlan_profile_get_prof_data_cmd_fixed_param);
  4908. buf = wmi_buf_alloc(wmi_handle, len);
  4909. if (!buf) {
  4910. WMA_LOGP("%s: wmi_buf_alloc Failed", __func__);
  4911. return -ENOMEM;
  4912. }
  4913. profile_getdata_cmd =
  4914. (wmi_wlan_profile_get_prof_data_cmd_fixed_param *)
  4915. wmi_buf_data(buf);
  4916. WMITLV_SET_HDR(&profile_getdata_cmd->tlv_header,
  4917. WMITLV_TAG_STRUC_wmi_wlan_profile_get_prof_data_cmd_fixed_param,
  4918. WMITLV_GET_STRUCT_TLVLEN
  4919. (wmi_wlan_profile_get_prof_data_cmd_fixed_param));
  4920. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4921. WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID);
  4922. if (ret) {
  4923. WMA_LOGE("PROFILE_DATA cmd Failed for id %d value %d",
  4924. value1, value2);
  4925. cdf_nbuf_free(buf);
  4926. return ret;
  4927. }
  4928. break;
  4929. case WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID:
  4930. len = sizeof(wmi_wlan_profile_set_hist_intvl_cmd_fixed_param);
  4931. buf = wmi_buf_alloc(wmi_handle, len);
  4932. if (!buf) {
  4933. WMA_LOGP("%s: wmi_buf_alloc Failed", __func__);
  4934. return -ENOMEM;
  4935. }
  4936. hist_intvl_cmd =
  4937. (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *)
  4938. wmi_buf_data(buf);
  4939. WMITLV_SET_HDR(&hist_intvl_cmd->tlv_header,
  4940. WMITLV_TAG_STRUC_wmi_wlan_profile_set_hist_intvl_cmd_fixed_param,
  4941. WMITLV_GET_STRUCT_TLVLEN
  4942. (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param));
  4943. hist_intvl_cmd->profile_id = value1;
  4944. hist_intvl_cmd->value = value2;
  4945. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4946. WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID);
  4947. if (ret) {
  4948. WMA_LOGE("HIST_INTVL cmd Failed for id %d value %d",
  4949. value1, value2);
  4950. cdf_nbuf_free(buf);
  4951. return ret;
  4952. }
  4953. break;
  4954. case WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID:
  4955. len =
  4956. sizeof(wmi_wlan_profile_enable_profile_id_cmd_fixed_param);
  4957. buf = wmi_buf_alloc(wmi_handle, len);
  4958. if (!buf) {
  4959. WMA_LOGP("%s: wmi_buf_alloc Failed", __func__);
  4960. return -ENOMEM;
  4961. }
  4962. profile_enable_cmd =
  4963. (wmi_wlan_profile_enable_profile_id_cmd_fixed_param *)
  4964. wmi_buf_data(buf);
  4965. WMITLV_SET_HDR(&profile_enable_cmd->tlv_header,
  4966. WMITLV_TAG_STRUC_wmi_wlan_profile_enable_profile_id_cmd_fixed_param,
  4967. WMITLV_GET_STRUCT_TLVLEN
  4968. (wmi_wlan_profile_enable_profile_id_cmd_fixed_param));
  4969. profile_enable_cmd->profile_id = value1;
  4970. profile_enable_cmd->enable = value2;
  4971. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4972. WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID);
  4973. if (ret) {
  4974. WMA_LOGE("enable cmd Failed for id %d value %d",
  4975. value1, value2);
  4976. cdf_nbuf_free(buf);
  4977. return ret;
  4978. }
  4979. break;
  4980. default:
  4981. WMA_LOGD("%s: invalid profiling command", __func__);
  4982. break;
  4983. }
  4984. return 0;
  4985. }
  4986. #ifdef FEATURE_WLAN_RA_FILTERING
  4987. /**
  4988. * send_wow_sta_ra_filter_cmd_tlv() - set RA filter pattern in fw
  4989. * @wmi_handle: wmi handle
  4990. * @vdev_id: vdev id
  4991. *
  4992. * Return: CDF status
  4993. */
  4994. CDF_STATUS send_wow_sta_ra_filter_cmd_tlv(wmi_unified_t wmi_handle,
  4995. uint8_t vdev_id, uint8_t default_pattern,
  4996. uint16_t rate_limit_interval)
  4997. {
  4998. WMI_WOW_ADD_PATTERN_CMD_fixed_param *cmd;
  4999. wmi_buf_t buf;
  5000. uint8_t *buf_ptr;
  5001. int32_t len;
  5002. int ret;
  5003. len = sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param) +
  5004. WMI_TLV_HDR_SIZE +
  5005. 0 * sizeof(WOW_BITMAP_PATTERN_T) +
  5006. WMI_TLV_HDR_SIZE +
  5007. 0 * sizeof(WOW_IPV4_SYNC_PATTERN_T) +
  5008. WMI_TLV_HDR_SIZE +
  5009. 0 * sizeof(WOW_IPV6_SYNC_PATTERN_T) +
  5010. WMI_TLV_HDR_SIZE +
  5011. 0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
  5012. WMI_TLV_HDR_SIZE +
  5013. 0 * sizeof(A_UINT32) + WMI_TLV_HDR_SIZE + 1 * sizeof(A_UINT32);
  5014. buf = wmi_buf_alloc(wmi_handle, len);
  5015. if (!buf) {
  5016. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  5017. return CDF_STATUS_E_NOMEM;
  5018. }
  5019. cmd = (WMI_WOW_ADD_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
  5020. buf_ptr = (uint8_t *) cmd;
  5021. WMITLV_SET_HDR(&cmd->tlv_header,
  5022. WMITLV_TAG_STRUC_WMI_WOW_ADD_PATTERN_CMD_fixed_param,
  5023. WMITLV_GET_STRUCT_TLVLEN
  5024. (WMI_WOW_ADD_PATTERN_CMD_fixed_param));
  5025. cmd->vdev_id = vdev_id;
  5026. cmd->pattern_id = default_pattern,
  5027. cmd->pattern_type = WOW_IPV6_RA_PATTERN;
  5028. buf_ptr += sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param);
  5029. /* Fill TLV for WMITLV_TAG_STRUC_WOW_BITMAP_PATTERN_T but no data. */
  5030. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5031. buf_ptr += WMI_TLV_HDR_SIZE;
  5032. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV4_SYNC_PATTERN_T but no data. */
  5033. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5034. buf_ptr += WMI_TLV_HDR_SIZE;
  5035. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV6_SYNC_PATTERN_T but no data. */
  5036. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5037. buf_ptr += WMI_TLV_HDR_SIZE;
  5038. /* Fill TLV for WMITLV_TAG_STRUC_WOW_MAGIC_PATTERN_CMD but no data. */
  5039. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5040. buf_ptr += WMI_TLV_HDR_SIZE;
  5041. /* Fill TLV for pattern_info_timeout but no data. */
  5042. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
  5043. buf_ptr += WMI_TLV_HDR_SIZE;
  5044. /* Fill TLV for ra_ratelimit_interval. */
  5045. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(A_UINT32));
  5046. buf_ptr += WMI_TLV_HDR_SIZE;
  5047. *((A_UINT32 *) buf_ptr) = rate_limit_interval;
  5048. WMA_LOGD("%s: send RA rate limit [%d] to fw vdev = %d", __func__,
  5049. rate_limit_interval, vdev_id);
  5050. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5051. WMI_WOW_ADD_WAKE_PATTERN_CMDID);
  5052. if (ret) {
  5053. WMA_LOGE("%s: Failed to send RA rate limit to fw", __func__);
  5054. wmi_buf_free(buf);
  5055. return CDF_STATUS_E_FAILURE;
  5056. }
  5057. return CDF_STATUS_SUCCESS;
  5058. }
  5059. #endif /* FEATURE_WLAN_RA_FILTERING */
  5060. /**
  5061. * send_nat_keepalive_en_cmd_tlv() - enable NAT keepalive filter
  5062. * @wmi_handle: wmi handle
  5063. * @vdev_id: vdev id
  5064. *
  5065. * Return: 0 for success or error code
  5066. */
  5067. CDF_STATUS send_nat_keepalive_en_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id)
  5068. {
  5069. WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param *cmd;
  5070. wmi_buf_t buf;
  5071. int32_t len = sizeof(*cmd);
  5072. WMA_LOGD("%s: vdev_id %d", __func__, vdev_id);
  5073. buf = wmi_buf_alloc(wmi_handle, len);
  5074. if (!buf) {
  5075. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  5076. return -ENOMEM;
  5077. }
  5078. cmd = (WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param *)
  5079. wmi_buf_data(buf);
  5080. WMITLV_SET_HDR(&cmd->tlv_header,
  5081. WMITLV_TAG_STRUC_WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param,
  5082. WMITLV_GET_STRUCT_TLVLEN
  5083. (WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param));
  5084. cmd->vdev_id = vdev_id;
  5085. cmd->action = IPSEC_NATKEEPALIVE_FILTER_ENABLE;
  5086. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5087. WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMDID)) {
  5088. WMA_LOGP("%s: Failed to send NAT keepalive enable command",
  5089. __func__);
  5090. wmi_buf_free(buf);
  5091. return -EIO;
  5092. }
  5093. return 0;
  5094. }
  5095. /**
  5096. * wmi_unified_csa_offload_enable() - sen CSA offload enable command
  5097. * @wmi_handle: wmi handle
  5098. * @vdev_id: vdev id
  5099. *
  5100. * Return: 0 for success or error code
  5101. */
  5102. CDF_STATUS send_csa_offload_enable_cmd_tlv(wmi_unified_t wmi_handle,
  5103. uint8_t vdev_id)
  5104. {
  5105. wmi_csa_offload_enable_cmd_fixed_param *cmd;
  5106. wmi_buf_t buf;
  5107. int32_t len = sizeof(*cmd);
  5108. WMA_LOGD("%s: vdev_id %d", __func__, vdev_id);
  5109. buf = wmi_buf_alloc(wmi_handle, len);
  5110. if (!buf) {
  5111. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  5112. return -ENOMEM;
  5113. }
  5114. cmd = (wmi_csa_offload_enable_cmd_fixed_param *) wmi_buf_data(buf);
  5115. WMITLV_SET_HDR(&cmd->tlv_header,
  5116. WMITLV_TAG_STRUC_wmi_csa_offload_enable_cmd_fixed_param,
  5117. WMITLV_GET_STRUCT_TLVLEN
  5118. (wmi_csa_offload_enable_cmd_fixed_param));
  5119. cmd->vdev_id = vdev_id;
  5120. cmd->csa_offload_enable = WMI_CSA_OFFLOAD_ENABLE;
  5121. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5122. WMI_CSA_OFFLOAD_ENABLE_CMDID)) {
  5123. WMA_LOGP("%s: Failed to send CSA offload enable command",
  5124. __func__);
  5125. wmi_buf_free(buf);
  5126. return -EIO;
  5127. }
  5128. return 0;
  5129. }
  5130. /**
  5131. * send_start_oem_data_cmd_tlv() - start OEM data request to target
  5132. * @wmi_handle: wmi handle
  5133. * @startOemDataReq: start request params
  5134. *
  5135. * Return: CDF status
  5136. */
  5137. CDF_STATUS send_start_oem_data_cmd_tlv(wmi_unified_t wmi_handle,
  5138. uint8_t data_len,
  5139. uint8_t *data)
  5140. {
  5141. wmi_buf_t buf;
  5142. uint8_t *cmd;
  5143. int ret = 0;
  5144. buf = wmi_buf_alloc(wmi_handle,
  5145. (data_len + WMI_TLV_HDR_SIZE));
  5146. if (!buf) {
  5147. WMA_LOGE(FL("wmi_buf_alloc failed"));
  5148. return CDF_STATUS_E_FAILURE;
  5149. }
  5150. cmd = (uint8_t *) wmi_buf_data(buf);
  5151. WMITLV_SET_HDR(cmd, WMITLV_TAG_ARRAY_BYTE, data_len);
  5152. cmd += WMI_TLV_HDR_SIZE;
  5153. cdf_mem_copy(cmd, data,
  5154. data_len);
  5155. WMA_LOGI(FL("Sending OEM Data Request to target, data len %d"),
  5156. data_len);
  5157. ret = wmi_unified_cmd_send(wmi_handle, buf,
  5158. (data_len +
  5159. WMI_TLV_HDR_SIZE), WMI_OEM_REQ_CMDID);
  5160. if (ret != EOK) {
  5161. WMA_LOGE(FL(":wmi cmd send failed"));
  5162. cdf_nbuf_free(buf);
  5163. return CDF_STATUS_E_FAILURE;
  5164. }
  5165. return CDF_STATUS_SUCCESS;
  5166. }
  5167. /**
  5168. * send_dfs_phyerr_filter_offload_en_cmd_tlv() - enable dfs phyerr filter
  5169. * @wmi_handle: wmi handle
  5170. * @dfs_phyerr_filter_offload: is dfs phyerr filter offload
  5171. *
  5172. * Send WMI_DFS_PHYERR_FILTER_ENA_CMDID or
  5173. * WMI_DFS_PHYERR_FILTER_DIS_CMDID command
  5174. * to firmware based on phyerr filtering
  5175. * offload status.
  5176. *
  5177. * Return: 1 success, 0 failure
  5178. */
  5179. CDF_STATUS
  5180. send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle,
  5181. bool dfs_phyerr_filter_offload)
  5182. {
  5183. wmi_dfs_phyerr_filter_ena_cmd_fixed_param *enable_phyerr_offload_cmd;
  5184. wmi_dfs_phyerr_filter_dis_cmd_fixed_param *disable_phyerr_offload_cmd;
  5185. wmi_buf_t buf;
  5186. uint16_t len;
  5187. int ret;
  5188. if (dfs_phyerr_filter_offload) {
  5189. WMA_LOGD("%s:Phyerror Filtering offload is Disabled in ini",
  5190. __func__);
  5191. len = sizeof(*disable_phyerr_offload_cmd);
  5192. buf = wmi_buf_alloc(wmi_handle, len);
  5193. if (!buf) {
  5194. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  5195. return 0;
  5196. }
  5197. disable_phyerr_offload_cmd =
  5198. (wmi_dfs_phyerr_filter_dis_cmd_fixed_param *)
  5199. wmi_buf_data(buf);
  5200. WMITLV_SET_HDR(&disable_phyerr_offload_cmd->tlv_header,
  5201. WMITLV_TAG_STRUC_wmi_dfs_phyerr_filter_dis_cmd_fixed_param,
  5202. WMITLV_GET_STRUCT_TLVLEN
  5203. (wmi_dfs_phyerr_filter_dis_cmd_fixed_param));
  5204. /*
  5205. * Send WMI_DFS_PHYERR_FILTER_DIS_CMDID
  5206. * to the firmware to disable the phyerror
  5207. * filtering offload.
  5208. */
  5209. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5210. WMI_DFS_PHYERR_FILTER_DIS_CMDID);
  5211. if (ret < 0) {
  5212. WMA_LOGE("%s: Failed to send WMI_DFS_PHYERR_FILTER_DIS_CMDID ret=%d",
  5213. __func__, ret);
  5214. wmi_buf_free(buf);
  5215. return CDF_STATUS_E_FAILURE;
  5216. }
  5217. WMA_LOGD("%s: WMI_DFS_PHYERR_FILTER_DIS_CMDID Send Success",
  5218. __func__);
  5219. } else {
  5220. WMA_LOGD("%s:Phyerror Filtering offload is Enabled in ini",
  5221. __func__);
  5222. len = sizeof(*enable_phyerr_offload_cmd);
  5223. buf = wmi_buf_alloc(wmi_handle, len);
  5224. if (!buf) {
  5225. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  5226. return CDF_STATUS_E_FAILURE;
  5227. }
  5228. enable_phyerr_offload_cmd =
  5229. (wmi_dfs_phyerr_filter_ena_cmd_fixed_param *)
  5230. wmi_buf_data(buf);
  5231. WMITLV_SET_HDR(&enable_phyerr_offload_cmd->tlv_header,
  5232. WMITLV_TAG_STRUC_wmi_dfs_phyerr_filter_ena_cmd_fixed_param,
  5233. WMITLV_GET_STRUCT_TLVLEN
  5234. (wmi_dfs_phyerr_filter_ena_cmd_fixed_param));
  5235. /*
  5236. * Send a WMI_DFS_PHYERR_FILTER_ENA_CMDID
  5237. * to the firmware to enable the phyerror
  5238. * filtering offload.
  5239. */
  5240. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5241. WMI_DFS_PHYERR_FILTER_ENA_CMDID);
  5242. if (ret < 0) {
  5243. WMA_LOGE("%s: Failed to send DFS PHYERR CMD ret=%d",
  5244. __func__, ret);
  5245. wmi_buf_free(buf);
  5246. return CDF_STATUS_E_FAILURE;
  5247. }
  5248. WMA_LOGD("%s: WMI_DFS_PHYERR_FILTER_ENA_CMDID Send Success",
  5249. __func__);
  5250. }
  5251. return CDF_STATUS_SUCCESS;
  5252. }
  5253. #if !defined(REMOVE_PKT_LOG)
  5254. /**
  5255. * send_pktlog_wmi_send_cmd_tlv() - send pktlog enable/disable command to target
  5256. * @wmi_handle: wmi handle
  5257. * @pktlog_event: pktlog event
  5258. * @cmd_id: pktlog cmd id
  5259. *
  5260. * Return: CDF status
  5261. */
  5262. CDF_STATUS send_pktlog_wmi_send_cmd_tlv(wmi_unified_t wmi_handle,
  5263. WMI_PKTLOG_EVENT pktlog_event,
  5264. WMI_CMD_ID cmd_id)
  5265. {
  5266. WMI_PKTLOG_EVENT PKTLOG_EVENT;
  5267. WMI_CMD_ID CMD_ID;
  5268. wmi_pdev_pktlog_enable_cmd_fixed_param *cmd;
  5269. wmi_pdev_pktlog_disable_cmd_fixed_param *disable_cmd;
  5270. int len = 0;
  5271. wmi_buf_t buf;
  5272. PKTLOG_EVENT = pktlog_event;
  5273. CMD_ID = cmd_id;
  5274. switch (CMD_ID) {
  5275. case WMI_PDEV_PKTLOG_ENABLE_CMDID:
  5276. len = sizeof(*cmd);
  5277. buf = wmi_buf_alloc(wmi_handle, len);
  5278. if (!buf) {
  5279. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  5280. return CDF_STATUS_E_NOMEM;
  5281. }
  5282. cmd = (wmi_pdev_pktlog_enable_cmd_fixed_param *)
  5283. wmi_buf_data(buf);
  5284. WMITLV_SET_HDR(&cmd->tlv_header,
  5285. WMITLV_TAG_STRUC_wmi_pdev_pktlog_enable_cmd_fixed_param,
  5286. WMITLV_GET_STRUCT_TLVLEN
  5287. (wmi_pdev_pktlog_enable_cmd_fixed_param));
  5288. cmd->evlist = PKTLOG_EVENT;
  5289. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5290. WMI_PDEV_PKTLOG_ENABLE_CMDID)) {
  5291. WMA_LOGE("failed to send pktlog enable cmdid");
  5292. goto wmi_send_failed;
  5293. }
  5294. break;
  5295. case WMI_PDEV_PKTLOG_DISABLE_CMDID:
  5296. len = sizeof(*disable_cmd);
  5297. buf = wmi_buf_alloc(wmi_handle, len);
  5298. if (!buf) {
  5299. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  5300. return CDF_STATUS_E_NOMEM;
  5301. }
  5302. disable_cmd = (wmi_pdev_pktlog_disable_cmd_fixed_param *)
  5303. wmi_buf_data(buf);
  5304. WMITLV_SET_HDR(&disable_cmd->tlv_header,
  5305. WMITLV_TAG_STRUC_wmi_pdev_pktlog_disable_cmd_fixed_param,
  5306. WMITLV_GET_STRUCT_TLVLEN
  5307. (wmi_pdev_pktlog_disable_cmd_fixed_param));
  5308. disable_cmd->reserved0 = 0;
  5309. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5310. WMI_PDEV_PKTLOG_DISABLE_CMDID)) {
  5311. WMA_LOGE("failed to send pktlog disable cmdid");
  5312. goto wmi_send_failed;
  5313. }
  5314. break;
  5315. default:
  5316. WMA_LOGD("%s: invalid PKTLOG command", __func__);
  5317. break;
  5318. }
  5319. return CDF_STATUS_SUCCESS;
  5320. wmi_send_failed:
  5321. wmi_buf_free(buf);
  5322. return CDF_STATUS_E_FAILURE;
  5323. }
  5324. #endif /* REMOVE_PKT_LOG */
  5325. /**
  5326. * send_add_wow_wakeup_event_cmd_tlv() - Configures wow wakeup events.
  5327. * @wmi_handle: wmi handle
  5328. * @vdev_id: vdev id
  5329. * @bitmap: Event bitmap
  5330. * @enable: enable/disable
  5331. *
  5332. * Return: CDF status
  5333. */
  5334. CDF_STATUS send_add_wow_wakeup_event_cmd_tlv(wmi_unified_t wmi_handle,
  5335. uint32_t vdev_id,
  5336. uint32_t bitmap,
  5337. bool enable)
  5338. {
  5339. WMI_WOW_ADD_DEL_EVT_CMD_fixed_param *cmd;
  5340. uint16_t len;
  5341. wmi_buf_t buf;
  5342. int ret;
  5343. len = sizeof(WMI_WOW_ADD_DEL_EVT_CMD_fixed_param);
  5344. buf = wmi_buf_alloc(wmi_handle, len);
  5345. if (!buf) {
  5346. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  5347. return CDF_STATUS_E_NOMEM;
  5348. }
  5349. cmd = (WMI_WOW_ADD_DEL_EVT_CMD_fixed_param *) wmi_buf_data(buf);
  5350. WMITLV_SET_HDR(&cmd->tlv_header,
  5351. WMITLV_TAG_STRUC_WMI_WOW_ADD_DEL_EVT_CMD_fixed_param,
  5352. WMITLV_GET_STRUCT_TLVLEN
  5353. (WMI_WOW_ADD_DEL_EVT_CMD_fixed_param));
  5354. cmd->vdev_id = vdev_id;
  5355. cmd->is_add = enable;
  5356. cmd->event_bitmap = bitmap;
  5357. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5358. WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID);
  5359. if (ret) {
  5360. WMA_LOGE("Failed to config wow wakeup event");
  5361. wmi_buf_free(buf);
  5362. return CDF_STATUS_E_FAILURE;
  5363. }
  5364. WMA_LOGD("Wakeup pattern 0x%x %s in fw", bitmap,
  5365. enable ? "enabled" : "disabled");
  5366. return CDF_STATUS_SUCCESS;
  5367. }
  5368. /**
  5369. * send_wow_patterns_to_fw_cmd_tlv() - Sends WOW patterns to FW.
  5370. * @wmi_handle: wmi handle
  5371. * @vdev_id: vdev id
  5372. * @ptrn_id: pattern id
  5373. * @ptrn: pattern
  5374. * @ptrn_len: pattern length
  5375. * @ptrn_offset: pattern offset
  5376. * @mask: mask
  5377. * @mask_len: mask length
  5378. * @user: true for user configured pattern and false for default pattern
  5379. * @default_patterns: default patterns
  5380. *
  5381. * Return: CDF status
  5382. */
  5383. CDF_STATUS send_wow_patterns_to_fw_cmd_tlv(wmi_unified_t wmi_handle,
  5384. uint8_t vdev_id, uint8_t ptrn_id,
  5385. const uint8_t *ptrn, uint8_t ptrn_len,
  5386. uint8_t ptrn_offset, const uint8_t *mask,
  5387. uint8_t mask_len, bool user,
  5388. uint8_t default_patterns)
  5389. {
  5390. WMI_WOW_ADD_PATTERN_CMD_fixed_param *cmd;
  5391. WOW_BITMAP_PATTERN_T *bitmap_pattern;
  5392. wmi_buf_t buf;
  5393. uint8_t *buf_ptr;
  5394. int32_t len;
  5395. int ret;
  5396. len = sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param) +
  5397. WMI_TLV_HDR_SIZE +
  5398. 1 * sizeof(WOW_BITMAP_PATTERN_T) +
  5399. WMI_TLV_HDR_SIZE +
  5400. 0 * sizeof(WOW_IPV4_SYNC_PATTERN_T) +
  5401. WMI_TLV_HDR_SIZE +
  5402. 0 * sizeof(WOW_IPV6_SYNC_PATTERN_T) +
  5403. WMI_TLV_HDR_SIZE +
  5404. 0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
  5405. WMI_TLV_HDR_SIZE +
  5406. 0 * sizeof(A_UINT32) + WMI_TLV_HDR_SIZE + 1 * sizeof(A_UINT32);
  5407. buf = wmi_buf_alloc(wmi_handle, len);
  5408. if (!buf) {
  5409. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  5410. return CDF_STATUS_E_NOMEM;
  5411. }
  5412. cmd = (WMI_WOW_ADD_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
  5413. buf_ptr = (uint8_t *) cmd;
  5414. WMITLV_SET_HDR(&cmd->tlv_header,
  5415. WMITLV_TAG_STRUC_WMI_WOW_ADD_PATTERN_CMD_fixed_param,
  5416. WMITLV_GET_STRUCT_TLVLEN
  5417. (WMI_WOW_ADD_PATTERN_CMD_fixed_param));
  5418. cmd->vdev_id = vdev_id;
  5419. cmd->pattern_id = ptrn_id;
  5420. cmd->pattern_type = WOW_BITMAP_PATTERN;
  5421. buf_ptr += sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param);
  5422. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  5423. sizeof(WOW_BITMAP_PATTERN_T));
  5424. buf_ptr += WMI_TLV_HDR_SIZE;
  5425. bitmap_pattern = (WOW_BITMAP_PATTERN_T *) buf_ptr;
  5426. WMITLV_SET_HDR(&bitmap_pattern->tlv_header,
  5427. WMITLV_TAG_STRUC_WOW_BITMAP_PATTERN_T,
  5428. WMITLV_GET_STRUCT_TLVLEN(WOW_BITMAP_PATTERN_T));
  5429. cdf_mem_copy(&bitmap_pattern->patternbuf[0], ptrn, ptrn_len);
  5430. cdf_mem_copy(&bitmap_pattern->bitmaskbuf[0], mask, mask_len);
  5431. bitmap_pattern->pattern_offset = ptrn_offset;
  5432. bitmap_pattern->pattern_len = ptrn_len;
  5433. if (bitmap_pattern->pattern_len > WOW_DEFAULT_BITMAP_PATTERN_SIZE)
  5434. bitmap_pattern->pattern_len = WOW_DEFAULT_BITMAP_PATTERN_SIZE;
  5435. if (bitmap_pattern->pattern_len > WOW_DEFAULT_BITMASK_SIZE)
  5436. bitmap_pattern->pattern_len = WOW_DEFAULT_BITMASK_SIZE;
  5437. bitmap_pattern->bitmask_len = bitmap_pattern->pattern_len;
  5438. bitmap_pattern->pattern_id = ptrn_id;
  5439. WMA_LOGI("vdev id : %d, ptrn id: %d, ptrn len: %d, ptrn offset: %d user %d",
  5440. cmd->vdev_id, cmd->pattern_id, bitmap_pattern->pattern_len,
  5441. bitmap_pattern->pattern_offset, user);
  5442. WMA_LOGI("Pattern : ");
  5443. CDF_TRACE_HEX_DUMP(CDF_MODULE_ID_WMA, CDF_TRACE_LEVEL_INFO,
  5444. &bitmap_pattern->patternbuf[0], bitmap_pattern->pattern_len);
  5445. WMA_LOGI("Mask : ");
  5446. CDF_TRACE_HEX_DUMP(CDF_MODULE_ID_WMA, CDF_TRACE_LEVEL_INFO,
  5447. &bitmap_pattern->bitmaskbuf[0], bitmap_pattern->pattern_len);
  5448. buf_ptr += sizeof(WOW_BITMAP_PATTERN_T);
  5449. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV4_SYNC_PATTERN_T but no data. */
  5450. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5451. buf_ptr += WMI_TLV_HDR_SIZE;
  5452. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV6_SYNC_PATTERN_T but no data. */
  5453. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5454. buf_ptr += WMI_TLV_HDR_SIZE;
  5455. /* Fill TLV for WMITLV_TAG_STRUC_WOW_MAGIC_PATTERN_CMD but no data. */
  5456. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5457. buf_ptr += WMI_TLV_HDR_SIZE;
  5458. /* Fill TLV for pattern_info_timeout but no data. */
  5459. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
  5460. buf_ptr += WMI_TLV_HDR_SIZE;
  5461. /* Fill TLV for ratelimit_interval with dummy data as this fix elem */
  5462. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 1 * sizeof(A_UINT32));
  5463. buf_ptr += WMI_TLV_HDR_SIZE;
  5464. *(A_UINT32 *) buf_ptr = 0;
  5465. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5466. WMI_WOW_ADD_WAKE_PATTERN_CMDID);
  5467. if (ret) {
  5468. WMA_LOGE("%s: Failed to send wow ptrn to fw", __func__);
  5469. wmi_buf_free(buf);
  5470. return CDF_STATUS_E_FAILURE;
  5471. }
  5472. return CDF_STATUS_SUCCESS;
  5473. }
  5474. /**
  5475. * send_wow_delete_pattern_cmd_tlv() - delete wow pattern in target
  5476. * @wmi_handle: wmi handle
  5477. * @ptrn_id: pattern id
  5478. * @vdev_id: vdev id
  5479. *
  5480. * Return: CDF status
  5481. */
  5482. CDF_STATUS send_wow_delete_pattern_cmd_tlv(wmi_unified_t wmi_handle, uint8_t ptrn_id,
  5483. uint8_t vdev_id)
  5484. {
  5485. WMI_WOW_DEL_PATTERN_CMD_fixed_param *cmd;
  5486. wmi_buf_t buf;
  5487. int32_t len;
  5488. int ret;
  5489. len = sizeof(WMI_WOW_DEL_PATTERN_CMD_fixed_param);
  5490. buf = wmi_buf_alloc(wmi_handle, len);
  5491. if (!buf) {
  5492. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  5493. return CDF_STATUS_E_NOMEM;
  5494. }
  5495. cmd = (WMI_WOW_DEL_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
  5496. WMITLV_SET_HDR(&cmd->tlv_header,
  5497. WMITLV_TAG_STRUC_WMI_WOW_DEL_PATTERN_CMD_fixed_param,
  5498. WMITLV_GET_STRUCT_TLVLEN(
  5499. WMI_WOW_DEL_PATTERN_CMD_fixed_param));
  5500. cmd->vdev_id = vdev_id;
  5501. cmd->pattern_id = ptrn_id;
  5502. cmd->pattern_type = WOW_BITMAP_PATTERN;
  5503. WMA_LOGI("Deleting pattern id: %d vdev id %d in fw",
  5504. cmd->pattern_id, vdev_id);
  5505. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5506. WMI_WOW_DEL_WAKE_PATTERN_CMDID);
  5507. if (ret) {
  5508. WMA_LOGE("%s: Failed to delete wow ptrn from fw", __func__);
  5509. wmi_buf_free(buf);
  5510. return CDF_STATUS_E_FAILURE;
  5511. }
  5512. return CDF_STATUS_SUCCESS;
  5513. }
  5514. /**
  5515. * send_host_wakeup_ind_to_fw_cmd_tlv() - send wakeup ind to fw
  5516. * @wmi_handle: wmi handle
  5517. *
  5518. * Sends host wakeup indication to FW. On receiving this indication,
  5519. * FW will come out of WOW.
  5520. *
  5521. * Return: CDF status
  5522. */
  5523. CDF_STATUS send_host_wakeup_ind_to_fw_cmd_tlv(wmi_unified_t wmi_handle)
  5524. {
  5525. wmi_wow_hostwakeup_from_sleep_cmd_fixed_param *cmd;
  5526. wmi_buf_t buf;
  5527. CDF_STATUS cdf_status = CDF_STATUS_SUCCESS;
  5528. int32_t len;
  5529. int ret;
  5530. len = sizeof(wmi_wow_hostwakeup_from_sleep_cmd_fixed_param);
  5531. buf = wmi_buf_alloc(wmi_handle, len);
  5532. if (!buf) {
  5533. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  5534. return CDF_STATUS_E_NOMEM;
  5535. }
  5536. cmd = (wmi_wow_hostwakeup_from_sleep_cmd_fixed_param *)
  5537. wmi_buf_data(buf);
  5538. WMITLV_SET_HDR(&cmd->tlv_header,
  5539. WMITLV_TAG_STRUC_wmi_wow_hostwakeup_from_sleep_cmd_fixed_param,
  5540. WMITLV_GET_STRUCT_TLVLEN
  5541. (wmi_wow_hostwakeup_from_sleep_cmd_fixed_param));
  5542. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5543. WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID);
  5544. if (ret) {
  5545. WMA_LOGE("Failed to send host wakeup indication to fw");
  5546. wmi_buf_free(buf);
  5547. return CDF_STATUS_E_FAILURE;
  5548. }
  5549. return cdf_status;
  5550. }
  5551. /**
  5552. * send_del_ts_cmd_tlv() - send DELTS request to fw
  5553. * @wmi_handle: wmi handle
  5554. * @msg: delts params
  5555. *
  5556. * Return: CDF status
  5557. */
  5558. CDF_STATUS send_del_ts_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
  5559. uint8_t ac)
  5560. {
  5561. wmi_vdev_wmm_delts_cmd_fixed_param *cmd;
  5562. wmi_buf_t buf;
  5563. int32_t len = sizeof(*cmd);
  5564. buf = wmi_buf_alloc(wmi_handle, len);
  5565. if (!buf) {
  5566. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  5567. return CDF_STATUS_E_NOMEM;
  5568. }
  5569. cmd = (wmi_vdev_wmm_delts_cmd_fixed_param *) wmi_buf_data(buf);
  5570. WMITLV_SET_HDR(&cmd->tlv_header,
  5571. WMITLV_TAG_STRUC_wmi_vdev_wmm_delts_cmd_fixed_param,
  5572. WMITLV_GET_STRUCT_TLVLEN
  5573. (wmi_vdev_wmm_delts_cmd_fixed_param));
  5574. cmd->vdev_id = vdev_id;
  5575. cmd->ac = ac;
  5576. WMA_LOGD("Delts vdev:%d, ac:%d, %s:%d",
  5577. cmd->vdev_id, cmd->ac, __func__, __LINE__);
  5578. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5579. WMI_VDEV_WMM_DELTS_CMDID)) {
  5580. WMA_LOGP("%s: Failed to send vdev DELTS command", __func__);
  5581. cdf_nbuf_free(buf);
  5582. return CDF_STATUS_E_FAILURE;
  5583. }
  5584. return CDF_STATUS_SUCCESS;
  5585. }
  5586. /**
  5587. * send_aggr_qos_cmd_tlv() - send aggr qos request to fw
  5588. * @wmi_handle: handle to wmi
  5589. * @aggr_qos_rsp_msg - combined struct for all ADD_TS requests.
  5590. *
  5591. * A function to handle WMA_AGGR_QOS_REQ. This will send out
  5592. * ADD_TS requestes to firmware in loop for all the ACs with
  5593. * active flow.
  5594. *
  5595. * Return: CDF status
  5596. */
  5597. CDF_STATUS send_aggr_qos_cmd_tlv(wmi_unified_t wmi_handle,
  5598. struct aggr_add_ts_param *aggr_qos_rsp_msg)
  5599. {
  5600. int i = 0;
  5601. wmi_vdev_wmm_addts_cmd_fixed_param *cmd;
  5602. wmi_buf_t buf;
  5603. int32_t len = sizeof(*cmd);
  5604. for (i = 0; i < WMI_QOS_NUM_AC_MAX; i++) {
  5605. /* if flow in this AC is active */
  5606. if (((1 << i) & aggr_qos_rsp_msg->tspecIdx)) {
  5607. /*
  5608. * as per implementation of wma_add_ts_req() we
  5609. * are not waiting any response from firmware so
  5610. * apart from sending ADDTS to firmware just send
  5611. * success to upper layers
  5612. */
  5613. aggr_qos_rsp_msg->status[i] = CDF_STATUS_SUCCESS;
  5614. buf = wmi_buf_alloc(wmi_handle, len);
  5615. if (!buf) {
  5616. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  5617. return CDF_STATUS_E_NOMEM;
  5618. }
  5619. cmd = (wmi_vdev_wmm_addts_cmd_fixed_param *)
  5620. wmi_buf_data(buf);
  5621. WMITLV_SET_HDR(&cmd->tlv_header,
  5622. WMITLV_TAG_STRUC_wmi_vdev_wmm_addts_cmd_fixed_param,
  5623. WMITLV_GET_STRUCT_TLVLEN
  5624. (wmi_vdev_wmm_addts_cmd_fixed_param));
  5625. cmd->vdev_id = aggr_qos_rsp_msg->sessionId;
  5626. cmd->ac =
  5627. TID_TO_WME_AC(aggr_qos_rsp_msg->tspec[i].tsinfo.
  5628. traffic.userPrio);
  5629. cmd->medium_time_us =
  5630. aggr_qos_rsp_msg->tspec[i].mediumTime * 32;
  5631. cmd->downgrade_type = WMM_AC_DOWNGRADE_DEPRIO;
  5632. WMA_LOGD("%s:%d: Addts vdev:%d, ac:%d, mediumTime:%d downgrade_type:%d",
  5633. __func__, __LINE__, cmd->vdev_id, cmd->ac,
  5634. cmd->medium_time_us, cmd->downgrade_type);
  5635. if (wmi_unified_cmd_send
  5636. (wmi_handle, buf, len,
  5637. WMI_VDEV_WMM_ADDTS_CMDID)) {
  5638. WMA_LOGP("%s: Failed to send vdev ADDTS command",
  5639. __func__);
  5640. aggr_qos_rsp_msg->status[i] =
  5641. CDF_STATUS_E_FAILURE;
  5642. cdf_nbuf_free(buf);
  5643. return CDF_STATUS_E_FAILURE;
  5644. }
  5645. }
  5646. }
  5647. return CDF_STATUS_SUCCESS;
  5648. }
  5649. /**
  5650. * send_add_ts_cmd_tlv() - send ADDTS request to fw
  5651. * @wmi_handle: wmi handle
  5652. * @msg: ADDTS params
  5653. *
  5654. * Return: CDF status
  5655. */
  5656. CDF_STATUS send_add_ts_cmd_tlv(wmi_unified_t wmi_handle,
  5657. struct add_ts_param *msg)
  5658. {
  5659. wmi_vdev_wmm_addts_cmd_fixed_param *cmd;
  5660. wmi_buf_t buf;
  5661. int32_t len = sizeof(*cmd);
  5662. msg->status = CDF_STATUS_SUCCESS;
  5663. buf = wmi_buf_alloc(wmi_handle, len);
  5664. if (!buf) {
  5665. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  5666. return CDF_STATUS_E_NOMEM;
  5667. }
  5668. cmd = (wmi_vdev_wmm_addts_cmd_fixed_param *) wmi_buf_data(buf);
  5669. WMITLV_SET_HDR(&cmd->tlv_header,
  5670. WMITLV_TAG_STRUC_wmi_vdev_wmm_addts_cmd_fixed_param,
  5671. WMITLV_GET_STRUCT_TLVLEN
  5672. (wmi_vdev_wmm_addts_cmd_fixed_param));
  5673. cmd->vdev_id = msg->sme_session_id;
  5674. cmd->ac = msg->tspec.tsinfo.traffic.userPrio;
  5675. cmd->medium_time_us = msg->tspec.mediumTime * 32;
  5676. cmd->downgrade_type = WMM_AC_DOWNGRADE_DROP;
  5677. WMA_LOGD("Addts vdev:%d, ac:%d, mediumTime:%d, downgrade_type:%d %s:%d",
  5678. cmd->vdev_id, cmd->ac, cmd->medium_time_us,
  5679. cmd->downgrade_type, __func__, __LINE__);
  5680. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5681. WMI_VDEV_WMM_ADDTS_CMDID)) {
  5682. WMA_LOGP("%s: Failed to send vdev ADDTS command", __func__);
  5683. msg->status = CDF_STATUS_E_FAILURE;
  5684. cdf_nbuf_free(buf);
  5685. return CDF_STATUS_E_FAILURE;
  5686. }
  5687. return CDF_STATUS_SUCCESS;
  5688. }
  5689. /**
  5690. * send_enable_disable_packet_filter_cmd_tlv() - enable/disable packet filter in target
  5691. * @wmi_handle: wmi handle
  5692. * @vdev_id: vdev id
  5693. * @enable: Flag to enable/disable packet filter
  5694. *
  5695. * Return: 0 for success or error code
  5696. */
  5697. CDF_STATUS send_enable_disable_packet_filter_cmd_tlv(wmi_unified_t wmi_handle,
  5698. uint8_t vdev_id, bool enable)
  5699. {
  5700. int32_t len;
  5701. int ret = 0;
  5702. wmi_buf_t buf;
  5703. WMI_PACKET_FILTER_ENABLE_CMD_fixed_param *cmd;
  5704. len = sizeof(WMI_PACKET_FILTER_ENABLE_CMD_fixed_param);
  5705. buf = wmi_buf_alloc(wmi_handle, len);
  5706. if (!buf) {
  5707. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  5708. return -ENOMEM;
  5709. }
  5710. cmd = (WMI_PACKET_FILTER_ENABLE_CMD_fixed_param *) wmi_buf_data(buf);
  5711. WMITLV_SET_HDR(&cmd->tlv_header,
  5712. WMITLV_TAG_STRUC_wmi_packet_filter_enable_fixed_param,
  5713. WMITLV_GET_STRUCT_TLVLEN(
  5714. WMI_PACKET_FILTER_ENABLE_CMD_fixed_param));
  5715. cmd->vdev_id = vdev_id;
  5716. if (enable)
  5717. cmd->enable = PACKET_FILTER_SET_ENABLE;
  5718. else
  5719. cmd->enable = PACKET_FILTER_SET_DISABLE;
  5720. WMA_LOGE("%s: Packet filter enable %d for vdev_id %d",
  5721. __func__, cmd->enable, vdev_id);
  5722. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5723. WMI_PACKET_FILTER_ENABLE_CMDID);
  5724. if (ret)
  5725. WMA_LOGE("Failed to send packet filter wmi cmd to fw");
  5726. return ret;
  5727. }
  5728. /**
  5729. * send_config_packet_filter_cmd_tlv() - configure packet filter in target
  5730. * @wmi_handle: wmi handle
  5731. * @vdev_id: vdev id
  5732. * @rcv_filter_param: Packet filter parameters
  5733. * @filter_id: Filter id
  5734. * @enable: Flag to add/delete packet filter configuration
  5735. *
  5736. * Return: 0 for success or error code
  5737. */
  5738. CDF_STATUS send_config_packet_filter_cmd_tlv(wmi_unified_t wmi_handle,
  5739. uint8_t vdev_id, struct rcv_pkt_filter_config *rcv_filter_param,
  5740. uint8_t filter_id, bool enable)
  5741. {
  5742. int len, i;
  5743. int err = 0;
  5744. wmi_buf_t buf;
  5745. WMI_PACKET_FILTER_CONFIG_CMD_fixed_param *cmd;
  5746. /* allocate the memory */
  5747. len = sizeof(*cmd);
  5748. buf = wmi_buf_alloc(wmi_handle, len);
  5749. if (!buf) {
  5750. WMA_LOGE("Failed to allocate buffer to send set_param cmd");
  5751. return -ENOMEM;
  5752. }
  5753. cmd = (WMI_PACKET_FILTER_CONFIG_CMD_fixed_param *)wmi_buf_data(buf);
  5754. WMITLV_SET_HDR(&cmd->tlv_header,
  5755. WMITLV_TAG_STRUC_wmi_packet_filter_config_fixed_param,
  5756. WMITLV_GET_STRUCT_TLVLEN
  5757. (WMI_PACKET_FILTER_CONFIG_CMD_fixed_param));
  5758. cmd->vdev_id = vdev_id;
  5759. cmd->filter_id = filter_id;
  5760. if (enable)
  5761. cmd->filter_action = PACKET_FILTER_SET_ACTIVE;
  5762. else
  5763. cmd->filter_action = PACKET_FILTER_SET_INACTIVE;
  5764. if (enable) {
  5765. cmd->num_params = CDF_MIN(
  5766. WMI_PACKET_FILTER_MAX_CMP_PER_PACKET_FILTER,
  5767. rcv_filter_param->numFieldParams);
  5768. cmd->filter_type = rcv_filter_param->filterType;
  5769. cmd->coalesce_time = rcv_filter_param->coalesceTime;
  5770. for (i = 0; i < cmd->num_params; i++) {
  5771. cmd->paramsData[i].proto_type =
  5772. rcv_filter_param->paramsData[i].protocolLayer;
  5773. cmd->paramsData[i].cmp_type =
  5774. rcv_filter_param->paramsData[i].cmpFlag;
  5775. cmd->paramsData[i].data_length =
  5776. rcv_filter_param->paramsData[i].dataLength;
  5777. cmd->paramsData[i].data_offset =
  5778. rcv_filter_param->paramsData[i].dataOffset;
  5779. memcpy(&cmd->paramsData[i].compareData,
  5780. rcv_filter_param->paramsData[i].compareData,
  5781. sizeof(cmd->paramsData[i].compareData));
  5782. memcpy(&cmd->paramsData[i].dataMask,
  5783. rcv_filter_param->paramsData[i].dataMask,
  5784. sizeof(cmd->paramsData[i].dataMask));
  5785. }
  5786. }
  5787. WMA_LOGE("Packet filter action %d filter with id: %d, num_params=%d",
  5788. cmd->filter_action, cmd->filter_id, cmd->num_params);
  5789. /* send the command along with data */
  5790. err = wmi_unified_cmd_send(wmi_handle, buf, len,
  5791. WMI_PACKET_FILTER_CONFIG_CMDID);
  5792. if (err) {
  5793. WMA_LOGE("Failed to send pkt_filter cmd");
  5794. wmi_buf_free(buf);
  5795. return -EIO;
  5796. }
  5797. return 0;
  5798. }
  5799. /**
  5800. * send_add_clear_mcbc_filter_cmd_tlv() - set mcast filter command to fw
  5801. * @wmi_handle: wmi handle
  5802. * @vdev_id: vdev id
  5803. * @multicastAddr: mcast address
  5804. * @clearList: clear list flag
  5805. *
  5806. * Return: 0 for success or error code
  5807. */
  5808. CDF_STATUS send_add_clear_mcbc_filter_cmd_tlv(wmi_unified_t wmi_handle,
  5809. uint8_t vdev_id,
  5810. struct cdf_mac_addr multicast_addr,
  5811. bool clearList)
  5812. {
  5813. WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param *cmd;
  5814. wmi_buf_t buf;
  5815. int err;
  5816. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  5817. if (!buf) {
  5818. WMA_LOGE("Failed to allocate buffer to send set_param cmd");
  5819. return -ENOMEM;
  5820. }
  5821. cmd = (WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param *) wmi_buf_data(buf);
  5822. cdf_mem_zero(cmd, sizeof(*cmd));
  5823. WMITLV_SET_HDR(&cmd->tlv_header,
  5824. WMITLV_TAG_STRUC_WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param,
  5825. WMITLV_GET_STRUCT_TLVLEN
  5826. (WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param));
  5827. cmd->action =
  5828. (clearList ? WMI_MCAST_FILTER_DELETE : WMI_MCAST_FILTER_SET);
  5829. cmd->vdev_id = vdev_id;
  5830. WMI_CHAR_ARRAY_TO_MAC_ADDR(multicast_addr.bytes, &cmd->mcastbdcastaddr);
  5831. err = wmi_unified_cmd_send(wmi_handle, buf,
  5832. sizeof(*cmd),
  5833. WMI_SET_MCASTBCAST_FILTER_CMDID);
  5834. if (err) {
  5835. WMA_LOGE("Failed to send set_param cmd");
  5836. cdf_mem_free(buf);
  5837. return -EIO;
  5838. }
  5839. WMA_LOGD("Action:%d; vdev_id:%d; clearList:%d",
  5840. cmd->action, vdev_id, clearList);
  5841. WMA_LOGD("MCBC MAC Addr: "MAC_ADDRESS_STR,
  5842. MAC_ADDR_ARRAY(multicast_addr.bytes));
  5843. return 0;
  5844. }
  5845. /**
  5846. * send_gtk_offload_cmd_tlv() - send GTK offload command to fw
  5847. * @wmi_handle: wmi handle
  5848. * @vdev_id: vdev id
  5849. * @params: GTK offload parameters
  5850. *
  5851. * Return: CDF status
  5852. */
  5853. CDF_STATUS send_gtk_offload_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
  5854. struct gtk_offload_params *params,
  5855. bool enable_offload,
  5856. uint32_t gtk_offload_opcode)
  5857. {
  5858. int len;
  5859. wmi_buf_t buf;
  5860. WMI_GTK_OFFLOAD_CMD_fixed_param *cmd;
  5861. CDF_STATUS status = CDF_STATUS_SUCCESS;
  5862. WMA_LOGD("%s Enter", __func__);
  5863. len = sizeof(*cmd);
  5864. /* alloc wmi buffer */
  5865. buf = wmi_buf_alloc(wmi_handle, len);
  5866. if (!buf) {
  5867. WMA_LOGE("wmi_buf_alloc failed for WMI_GTK_OFFLOAD_CMD");
  5868. status = CDF_STATUS_E_NOMEM;
  5869. goto out;
  5870. }
  5871. cmd = (WMI_GTK_OFFLOAD_CMD_fixed_param *) wmi_buf_data(buf);
  5872. WMITLV_SET_HDR(&cmd->tlv_header,
  5873. WMITLV_TAG_STRUC_WMI_GTK_OFFLOAD_CMD_fixed_param,
  5874. WMITLV_GET_STRUCT_TLVLEN
  5875. (WMI_GTK_OFFLOAD_CMD_fixed_param));
  5876. cmd->vdev_id = vdev_id;
  5877. /* Request target to enable GTK offload */
  5878. if (enable_offload) {
  5879. cmd->flags = gtk_offload_opcode;
  5880. /* Copy the keys and replay counter */
  5881. cdf_mem_copy(cmd->KCK, params->aKCK, WMI_GTK_OFFLOAD_KCK_BYTES);
  5882. cdf_mem_copy(cmd->KEK, params->aKEK, WMI_GTK_OFFLOAD_KEK_BYTES);
  5883. cdf_mem_copy(cmd->replay_counter, &params->ullKeyReplayCounter,
  5884. GTK_REPLAY_COUNTER_BYTES);
  5885. } else {
  5886. cmd->flags = gtk_offload_opcode;
  5887. }
  5888. /* send the wmi command */
  5889. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5890. WMI_GTK_OFFLOAD_CMDID)) {
  5891. WMA_LOGE("Failed to send WMI_GTK_OFFLOAD_CMDID");
  5892. wmi_buf_free(buf);
  5893. status = CDF_STATUS_E_FAILURE;
  5894. }
  5895. WMA_LOGD("VDEVID: %d, GTK_FLAGS: x%x", vdev_id, cmd->flags);
  5896. out:
  5897. WMA_LOGD("%s Exit", __func__);
  5898. return status;
  5899. }
  5900. /**
  5901. * send_process_gtk_offload_getinfo_cmd_tlv() - send GTK offload cmd to fw
  5902. * @wmi_handle: wmi handle
  5903. * @params: GTK offload params
  5904. *
  5905. * Return: CDF status
  5906. */
  5907. CDF_STATUS send_process_gtk_offload_getinfo_cmd_tlv(wmi_unified_t wmi_handle,
  5908. uint8_t vdev_id,
  5909. uint64_t offload_req_opcode)
  5910. {
  5911. int len;
  5912. wmi_buf_t buf;
  5913. WMI_GTK_OFFLOAD_CMD_fixed_param *cmd;
  5914. CDF_STATUS status = CDF_STATUS_SUCCESS;
  5915. len = sizeof(*cmd);
  5916. /* alloc wmi buffer */
  5917. buf = wmi_buf_alloc(wmi_handle, len);
  5918. if (!buf) {
  5919. WMA_LOGE("wmi_buf_alloc failed for WMI_GTK_OFFLOAD_CMD");
  5920. status = CDF_STATUS_E_NOMEM;
  5921. goto out;
  5922. }
  5923. cmd = (WMI_GTK_OFFLOAD_CMD_fixed_param *) wmi_buf_data(buf);
  5924. WMITLV_SET_HDR(&cmd->tlv_header,
  5925. WMITLV_TAG_STRUC_WMI_GTK_OFFLOAD_CMD_fixed_param,
  5926. WMITLV_GET_STRUCT_TLVLEN
  5927. (WMI_GTK_OFFLOAD_CMD_fixed_param));
  5928. /* Request for GTK offload status */
  5929. cmd->flags = offload_req_opcode;
  5930. cmd->vdev_id = vdev_id;
  5931. /* send the wmi command */
  5932. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5933. WMI_GTK_OFFLOAD_CMDID)) {
  5934. WMA_LOGE("Failed to send WMI_GTK_OFFLOAD_CMDID for req info");
  5935. wmi_buf_free(buf);
  5936. status = CDF_STATUS_E_FAILURE;
  5937. }
  5938. out:
  5939. return status;
  5940. }
  5941. /**
  5942. * send_process_add_periodic_tx_ptrn_cmd_tlv - add periodic tx ptrn
  5943. * @wmi_handle: wmi handle
  5944. * @pAddPeriodicTxPtrnParams: tx ptrn params
  5945. *
  5946. * Retrun: CDF status
  5947. */
  5948. CDF_STATUS send_process_add_periodic_tx_ptrn_cmd_tlv(wmi_unified_t wmi_handle,
  5949. struct periodic_tx_pattern *
  5950. pAddPeriodicTxPtrnParams,
  5951. uint8_t vdev_id)
  5952. {
  5953. WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *cmd;
  5954. wmi_buf_t wmi_buf;
  5955. uint32_t len;
  5956. uint8_t *buf_ptr;
  5957. uint32_t ptrn_len, ptrn_len_aligned;
  5958. int j;
  5959. ptrn_len = pAddPeriodicTxPtrnParams->ucPtrnSize;
  5960. ptrn_len_aligned = roundup(ptrn_len, sizeof(uint32_t));
  5961. len = sizeof(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param) +
  5962. WMI_TLV_HDR_SIZE + ptrn_len_aligned;
  5963. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  5964. if (!wmi_buf) {
  5965. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  5966. return CDF_STATUS_E_NOMEM;
  5967. }
  5968. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  5969. cmd = (WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *) buf_ptr;
  5970. WMITLV_SET_HDR(&cmd->tlv_header,
  5971. WMITLV_TAG_STRUC_WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param,
  5972. WMITLV_GET_STRUCT_TLVLEN
  5973. (WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param));
  5974. /* Pass the pattern id to delete for the corresponding vdev id */
  5975. cmd->vdev_id = vdev_id;
  5976. cmd->pattern_id = pAddPeriodicTxPtrnParams->ucPtrnId;
  5977. cmd->timeout = pAddPeriodicTxPtrnParams->usPtrnIntervalMs;
  5978. cmd->length = pAddPeriodicTxPtrnParams->ucPtrnSize;
  5979. /* Pattern info */
  5980. buf_ptr += sizeof(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param);
  5981. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ptrn_len_aligned);
  5982. buf_ptr += WMI_TLV_HDR_SIZE;
  5983. cdf_mem_copy(buf_ptr, pAddPeriodicTxPtrnParams->ucPattern, ptrn_len);
  5984. for (j = 0; j < pAddPeriodicTxPtrnParams->ucPtrnSize; j++)
  5985. WMA_LOGD("%s: Add Ptrn: %02x", __func__, buf_ptr[j] & 0xff);
  5986. WMA_LOGD("%s: Add ptrn id: %d vdev_id: %d",
  5987. __func__, cmd->pattern_id, cmd->vdev_id);
  5988. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  5989. WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID)) {
  5990. WMA_LOGE("%s: failed to add pattern set state command",
  5991. __func__);
  5992. cdf_nbuf_free(wmi_buf);
  5993. return CDF_STATUS_E_FAILURE;
  5994. }
  5995. return CDF_STATUS_SUCCESS;
  5996. }
  5997. /**
  5998. * send_process_del_periodic_tx_ptrn_cmd_tlv - del periodic tx ptrn
  5999. * @wmi_handle: wmi handle
  6000. * @vdev_id: vdev id
  6001. * @pattern_id: pattern id
  6002. *
  6003. * Retrun: CDF status
  6004. */
  6005. CDF_STATUS send_process_del_periodic_tx_ptrn_cmd_tlv(wmi_unified_t wmi_handle,
  6006. uint8_t vdev_id,
  6007. uint8_t pattern_id)
  6008. {
  6009. WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *cmd;
  6010. wmi_buf_t wmi_buf;
  6011. uint32_t len =
  6012. sizeof(WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param);
  6013. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  6014. if (!wmi_buf) {
  6015. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  6016. return CDF_STATUS_E_NOMEM;
  6017. }
  6018. cmd = (WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *)
  6019. wmi_buf_data(wmi_buf);
  6020. WMITLV_SET_HDR(&cmd->tlv_header,
  6021. WMITLV_TAG_STRUC_WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param,
  6022. WMITLV_GET_STRUCT_TLVLEN
  6023. (WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param));
  6024. /* Pass the pattern id to delete for the corresponding vdev id */
  6025. cmd->vdev_id = vdev_id;
  6026. cmd->pattern_id = pattern_id;
  6027. WMA_LOGD("%s: Del ptrn id: %d vdev_id: %d",
  6028. __func__, cmd->pattern_id, cmd->vdev_id);
  6029. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  6030. WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID)) {
  6031. WMA_LOGE("%s: failed to send del pattern command", __func__);
  6032. cdf_nbuf_free(wmi_buf);
  6033. return CDF_STATUS_E_FAILURE;
  6034. }
  6035. return CDF_STATUS_SUCCESS;
  6036. }
  6037. /**
  6038. * send_stats_ext_req_cmd_tlv() - request ext stats from fw
  6039. * @wmi_handle: wmi handle
  6040. * @preq: stats ext params
  6041. *
  6042. * Return: CDF status
  6043. */
  6044. CDF_STATUS send_stats_ext_req_cmd_tlv(wmi_unified_t wmi_handle,
  6045. struct stats_ext_params *preq)
  6046. {
  6047. int32_t ret;
  6048. wmi_req_stats_ext_cmd_fixed_param *cmd;
  6049. wmi_buf_t buf;
  6050. uint16_t len;
  6051. uint8_t *buf_ptr;
  6052. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + preq->request_data_len;
  6053. buf = wmi_buf_alloc(wmi_handle, len);
  6054. if (!buf) {
  6055. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  6056. return -ENOMEM;
  6057. }
  6058. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  6059. cmd = (wmi_req_stats_ext_cmd_fixed_param *) buf_ptr;
  6060. WMITLV_SET_HDR(&cmd->tlv_header,
  6061. WMITLV_TAG_STRUC_wmi_req_stats_ext_cmd_fixed_param,
  6062. WMITLV_GET_STRUCT_TLVLEN
  6063. (wmi_req_stats_ext_cmd_fixed_param));
  6064. cmd->vdev_id = preq->vdev_id;
  6065. cmd->data_len = preq->request_data_len;
  6066. WMA_LOGD("%s: The data len value is %u and vdev id set is %u ",
  6067. __func__, preq->request_data_len, preq->vdev_id);
  6068. buf_ptr += sizeof(wmi_req_stats_ext_cmd_fixed_param);
  6069. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, cmd->data_len);
  6070. buf_ptr += WMI_TLV_HDR_SIZE;
  6071. cdf_mem_copy(buf_ptr, preq->request_data, cmd->data_len);
  6072. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6073. WMI_REQUEST_STATS_EXT_CMDID);
  6074. if (ret != EOK) {
  6075. WMA_LOGE("%s: Failed to send notify cmd ret = %d", __func__,
  6076. ret);
  6077. wmi_buf_free(buf);
  6078. }
  6079. return ret;
  6080. }
  6081. /**
  6082. * send_enable_ext_wow_cmd_tlv() - enable ext wow in fw
  6083. * @wmi_handle: wmi handle
  6084. * @params: ext wow params
  6085. *
  6086. * Return:0 for success or error code
  6087. */
  6088. CDF_STATUS send_enable_ext_wow_cmd_tlv(wmi_unified_t wmi_handle,
  6089. struct ext_wow_params *params)
  6090. {
  6091. wmi_extwow_enable_cmd_fixed_param *cmd;
  6092. wmi_buf_t buf;
  6093. int32_t len;
  6094. int ret;
  6095. len = sizeof(wmi_extwow_enable_cmd_fixed_param);
  6096. buf = wmi_buf_alloc(wmi_handle, len);
  6097. if (!buf) {
  6098. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  6099. return CDF_STATUS_E_NOMEM;
  6100. }
  6101. cmd = (wmi_extwow_enable_cmd_fixed_param *) wmi_buf_data(buf);
  6102. WMITLV_SET_HDR(&cmd->tlv_header,
  6103. WMITLV_TAG_STRUC_wmi_extwow_enable_cmd_fixed_param,
  6104. WMITLV_GET_STRUCT_TLVLEN
  6105. (wmi_extwow_enable_cmd_fixed_param));
  6106. cmd->vdev_id = params->vdev_id;
  6107. cmd->type = params->type;
  6108. cmd->wakeup_pin_num = params->wakeup_pin_num;
  6109. WMA_LOGD("%s: vdev_id %d type %d Wakeup_pin_num %x",
  6110. __func__, cmd->vdev_id, cmd->type, cmd->wakeup_pin_num);
  6111. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6112. WMI_EXTWOW_ENABLE_CMDID);
  6113. if (ret) {
  6114. WMA_LOGE("%s: Failed to set EXTWOW Enable", __func__);
  6115. wmi_buf_free(buf);
  6116. return CDF_STATUS_E_FAILURE;
  6117. }
  6118. return CDF_STATUS_SUCCESS;
  6119. }
  6120. /**
  6121. * send_app_type1_params_in_fw_cmd_tlv() - set app type1 params in fw
  6122. * @wmi_handle: wmi handle
  6123. * @app_type1_params: app type1 params
  6124. *
  6125. * Return: CDF status
  6126. */
  6127. CDF_STATUS send_app_type1_params_in_fw_cmd_tlv(wmi_unified_t wmi_handle,
  6128. struct app_type1_params *app_type1_params)
  6129. {
  6130. wmi_extwow_set_app_type1_params_cmd_fixed_param *cmd;
  6131. wmi_buf_t buf;
  6132. int32_t len;
  6133. int ret;
  6134. len = sizeof(wmi_extwow_set_app_type1_params_cmd_fixed_param);
  6135. buf = wmi_buf_alloc(wmi_handle, len);
  6136. if (!buf) {
  6137. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  6138. return CDF_STATUS_E_NOMEM;
  6139. }
  6140. cmd = (wmi_extwow_set_app_type1_params_cmd_fixed_param *)
  6141. wmi_buf_data(buf);
  6142. WMITLV_SET_HDR(&cmd->tlv_header,
  6143. WMITLV_TAG_STRUC_wmi_extwow_set_app_type1_params_cmd_fixed_param,
  6144. WMITLV_GET_STRUCT_TLVLEN
  6145. (wmi_extwow_set_app_type1_params_cmd_fixed_param));
  6146. cmd->vdev_id = app_type1_params->vdev_id;
  6147. WMI_CHAR_ARRAY_TO_MAC_ADDR(app_type1_params->wakee_mac_addr.bytes,
  6148. &cmd->wakee_mac);
  6149. cdf_mem_copy(cmd->ident, app_type1_params->identification_id, 8);
  6150. cmd->ident_len = app_type1_params->id_length;
  6151. cdf_mem_copy(cmd->passwd, app_type1_params->password, 16);
  6152. cmd->passwd_len = app_type1_params->pass_length;
  6153. WMA_LOGD("%s: vdev_id %d wakee_mac_addr %pM "
  6154. "identification_id %.8s id_length %u "
  6155. "password %.16s pass_length %u",
  6156. __func__, cmd->vdev_id, app_type1_params->wakee_mac_addr.bytes,
  6157. cmd->ident, cmd->ident_len, cmd->passwd, cmd->passwd_len);
  6158. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6159. WMI_EXTWOW_SET_APP_TYPE1_PARAMS_CMDID);
  6160. if (ret) {
  6161. WMA_LOGE("%s: Failed to set APP TYPE1 PARAMS", __func__);
  6162. wmi_buf_free(buf);
  6163. return CDF_STATUS_E_FAILURE;
  6164. }
  6165. return CDF_STATUS_SUCCESS;
  6166. }
  6167. /**
  6168. * send_set_app_type2_params_in_fw_cmd_tlv() - set app type2 params in fw
  6169. * @wmi_handle: wmi handle
  6170. * @appType2Params: app type2 params
  6171. *
  6172. * Return: CDF status
  6173. */
  6174. CDF_STATUS send_set_app_type2_params_in_fw_cmd_tlv(wmi_unified_t wmi_handle,
  6175. struct app_type2_params *appType2Params)
  6176. {
  6177. wmi_extwow_set_app_type2_params_cmd_fixed_param *cmd;
  6178. wmi_buf_t buf;
  6179. int32_t len;
  6180. int ret;
  6181. len = sizeof(wmi_extwow_set_app_type2_params_cmd_fixed_param);
  6182. buf = wmi_buf_alloc(wmi_handle, len);
  6183. if (!buf) {
  6184. WMA_LOGE("%s: Failed allocate wmi buffer", __func__);
  6185. return CDF_STATUS_E_NOMEM;
  6186. }
  6187. cmd = (wmi_extwow_set_app_type2_params_cmd_fixed_param *)
  6188. wmi_buf_data(buf);
  6189. WMITLV_SET_HDR(&cmd->tlv_header,
  6190. WMITLV_TAG_STRUC_wmi_extwow_set_app_type2_params_cmd_fixed_param,
  6191. WMITLV_GET_STRUCT_TLVLEN
  6192. (wmi_extwow_set_app_type2_params_cmd_fixed_param));
  6193. cmd->vdev_id = appType2Params->vdev_id;
  6194. cdf_mem_copy(cmd->rc4_key, appType2Params->rc4_key, 16);
  6195. cmd->rc4_key_len = appType2Params->rc4_key_len;
  6196. cmd->ip_id = appType2Params->ip_id;
  6197. cmd->ip_device_ip = appType2Params->ip_device_ip;
  6198. cmd->ip_server_ip = appType2Params->ip_server_ip;
  6199. cmd->tcp_src_port = appType2Params->tcp_src_port;
  6200. cmd->tcp_dst_port = appType2Params->tcp_dst_port;
  6201. cmd->tcp_seq = appType2Params->tcp_seq;
  6202. cmd->tcp_ack_seq = appType2Params->tcp_ack_seq;
  6203. cmd->keepalive_init = appType2Params->keepalive_init;
  6204. cmd->keepalive_min = appType2Params->keepalive_min;
  6205. cmd->keepalive_max = appType2Params->keepalive_max;
  6206. cmd->keepalive_inc = appType2Params->keepalive_inc;
  6207. WMI_CHAR_ARRAY_TO_MAC_ADDR(appType2Params->gateway_mac.bytes,
  6208. &cmd->gateway_mac);
  6209. cmd->tcp_tx_timeout_val = appType2Params->tcp_tx_timeout_val;
  6210. cmd->tcp_rx_timeout_val = appType2Params->tcp_rx_timeout_val;
  6211. WMA_LOGD("%s: vdev_id %d gateway_mac %pM "
  6212. "rc4_key %.16s rc4_key_len %u "
  6213. "ip_id %x ip_device_ip %x ip_server_ip %x "
  6214. "tcp_src_port %u tcp_dst_port %u tcp_seq %u "
  6215. "tcp_ack_seq %u keepalive_init %u keepalive_min %u "
  6216. "keepalive_max %u keepalive_inc %u "
  6217. "tcp_tx_timeout_val %u tcp_rx_timeout_val %u",
  6218. __func__, cmd->vdev_id, appType2Params->gateway_mac.bytes,
  6219. cmd->rc4_key, cmd->rc4_key_len,
  6220. cmd->ip_id, cmd->ip_device_ip, cmd->ip_server_ip,
  6221. cmd->tcp_src_port, cmd->tcp_dst_port, cmd->tcp_seq,
  6222. cmd->tcp_ack_seq, cmd->keepalive_init, cmd->keepalive_min,
  6223. cmd->keepalive_max, cmd->keepalive_inc,
  6224. cmd->tcp_tx_timeout_val, cmd->tcp_rx_timeout_val);
  6225. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6226. WMI_EXTWOW_SET_APP_TYPE2_PARAMS_CMDID);
  6227. if (ret) {
  6228. WMA_LOGE("%s: Failed to set APP TYPE2 PARAMS", __func__);
  6229. wmi_buf_free(buf);
  6230. return CDF_STATUS_E_FAILURE;
  6231. }
  6232. return CDF_STATUS_SUCCESS;
  6233. }
  6234. /**
  6235. * send_set_auto_shutdown_timer_cmd_tlv() - sets auto shutdown timer in firmware
  6236. * @wmi_handle: wmi handle
  6237. * @timer_val: auto shutdown timer value
  6238. *
  6239. * Return: CDF status
  6240. */
  6241. CDF_STATUS send_set_auto_shutdown_timer_cmd_tlv(wmi_unified_t wmi_handle,
  6242. uint32_t timer_val)
  6243. {
  6244. int status = 0;
  6245. wmi_buf_t buf = NULL;
  6246. uint8_t *buf_ptr;
  6247. wmi_host_auto_shutdown_cfg_cmd_fixed_param *wmi_auto_sh_cmd;
  6248. int len = sizeof(wmi_host_auto_shutdown_cfg_cmd_fixed_param);
  6249. WMA_LOGD("%s: Set WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID:TIMER_VAL=%d",
  6250. __func__, timer_val);
  6251. buf = wmi_buf_alloc(wmi_handle, len);
  6252. if (!buf) {
  6253. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  6254. return CDF_STATUS_E_NOMEM;
  6255. }
  6256. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  6257. wmi_auto_sh_cmd =
  6258. (wmi_host_auto_shutdown_cfg_cmd_fixed_param *) buf_ptr;
  6259. wmi_auto_sh_cmd->timer_value = timer_val;
  6260. WMITLV_SET_HDR(&wmi_auto_sh_cmd->tlv_header,
  6261. WMITLV_TAG_STRUC_wmi_host_auto_shutdown_cfg_cmd_fixed_param,
  6262. WMITLV_GET_STRUCT_TLVLEN
  6263. (wmi_host_auto_shutdown_cfg_cmd_fixed_param));
  6264. status = wmi_unified_cmd_send(wmi_handle, buf,
  6265. len, WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID);
  6266. if (status != EOK) {
  6267. WMA_LOGE("%s: WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID Err %d",
  6268. __func__, status);
  6269. wmi_buf_free(buf);
  6270. return CDF_STATUS_E_FAILURE;
  6271. }
  6272. return CDF_STATUS_SUCCESS;
  6273. }
  6274. /**
  6275. * send_nan_req_cmd_tlv() - to send nan request to target
  6276. * @wmi_handle: wmi handle
  6277. * @nan_req: request data which will be non-null
  6278. *
  6279. * Return: CDF status
  6280. */
  6281. CDF_STATUS send_nan_req_cmd_tlv(wmi_unified_t wmi_handle,
  6282. struct nan_req_params *nan_req)
  6283. {
  6284. int ret;
  6285. wmi_nan_cmd_param *cmd;
  6286. wmi_buf_t buf;
  6287. uint16_t len = sizeof(*cmd);
  6288. uint16_t nan_data_len, nan_data_len_aligned;
  6289. uint8_t *buf_ptr;
  6290. /*
  6291. * <----- cmd ------------><-- WMI_TLV_HDR_SIZE --><--- data ---->
  6292. * +------------+----------+-----------------------+--------------+
  6293. * | tlv_header | data_len | WMITLV_TAG_ARRAY_BYTE | nan_req_data |
  6294. * +------------+----------+-----------------------+--------------+
  6295. */
  6296. if (!nan_req) {
  6297. WMA_LOGE("%s:nan req is not valid", __func__);
  6298. return CDF_STATUS_E_FAILURE;
  6299. }
  6300. nan_data_len = nan_req->request_data_len;
  6301. nan_data_len_aligned = roundup(nan_req->request_data_len,
  6302. sizeof(uint32_t));
  6303. len += WMI_TLV_HDR_SIZE + nan_data_len_aligned;
  6304. buf = wmi_buf_alloc(wmi_handle, len);
  6305. if (!buf) {
  6306. WMA_LOGE("%s:wmi_buf_alloc failed", __func__);
  6307. return CDF_STATUS_E_NOMEM;
  6308. }
  6309. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  6310. cmd = (wmi_nan_cmd_param *) buf_ptr;
  6311. WMITLV_SET_HDR(&cmd->tlv_header,
  6312. WMITLV_TAG_STRUC_wmi_nan_cmd_param,
  6313. WMITLV_GET_STRUCT_TLVLEN(wmi_nan_cmd_param));
  6314. cmd->data_len = nan_req->request_data_len;
  6315. WMA_LOGD("%s: The data len value is %u",
  6316. __func__, nan_req->request_data_len);
  6317. buf_ptr += sizeof(wmi_nan_cmd_param);
  6318. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, nan_data_len_aligned);
  6319. buf_ptr += WMI_TLV_HDR_SIZE;
  6320. cdf_mem_copy(buf_ptr, nan_req->request_data, cmd->data_len);
  6321. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6322. WMI_NAN_CMDID);
  6323. if (ret != EOK) {
  6324. WMA_LOGE("%s Failed to send set param command ret = %d",
  6325. __func__, ret);
  6326. wmi_buf_free(buf);
  6327. }
  6328. return ret;
  6329. }
  6330. /**
  6331. * send_process_dhcpserver_offload_cmd_tlv() - enable DHCP server offload
  6332. * @wmi_handle: wmi handle
  6333. * @pDhcpSrvOffloadInfo: DHCP server offload info
  6334. *
  6335. * Return: 0 for success or error code
  6336. */
  6337. CDF_STATUS send_process_dhcpserver_offload_cmd_tlv(wmi_unified_t wmi_handle,
  6338. struct dhcp_offload_info_params *pDhcpSrvOffloadInfo)
  6339. {
  6340. wmi_set_dhcp_server_offload_cmd_fixed_param *cmd;
  6341. wmi_buf_t buf;
  6342. int err;
  6343. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  6344. if (!buf) {
  6345. WMA_LOGE("Failed to allocate buffer to send "
  6346. "set_dhcp_server_offload cmd");
  6347. return -ENOMEM;
  6348. }
  6349. cmd = (wmi_set_dhcp_server_offload_cmd_fixed_param *) wmi_buf_data(buf);
  6350. cdf_mem_zero(cmd, sizeof(*cmd));
  6351. WMITLV_SET_HDR(&cmd->tlv_header,
  6352. WMITLV_TAG_STRUC_wmi_set_dhcp_server_offload_cmd_fixed_param,
  6353. WMITLV_GET_STRUCT_TLVLEN
  6354. (wmi_set_dhcp_server_offload_cmd_fixed_param));
  6355. cmd->vdev_id = pDhcpSrvOffloadInfo->vdev_id;
  6356. cmd->enable = pDhcpSrvOffloadInfo->dhcpSrvOffloadEnabled;
  6357. cmd->num_client = pDhcpSrvOffloadInfo->dhcpClientNum;
  6358. cmd->srv_ipv4 = pDhcpSrvOffloadInfo->dhcpSrvIP;
  6359. cmd->start_lsb = 0;
  6360. err = wmi_unified_cmd_send(wmi_handle, buf,
  6361. sizeof(*cmd),
  6362. WMI_SET_DHCP_SERVER_OFFLOAD_CMDID);
  6363. if (err) {
  6364. WMA_LOGE("Failed to send set_dhcp_server_offload cmd");
  6365. wmi_buf_free(buf);
  6366. return -EIO;
  6367. }
  6368. WMA_LOGD("Set dhcp server offload to vdevId %d",
  6369. pDhcpSrvOffloadInfo->vdev_id);
  6370. return 0;
  6371. }
  6372. /**
  6373. * send_set_led_flashing_cmd_tlv() - set led flashing in fw
  6374. * @wmi_handle: wmi handle
  6375. * @flashing: flashing request
  6376. *
  6377. * Return: CDF status
  6378. */
  6379. CDF_STATUS send_set_led_flashing_cmd_tlv(wmi_unified_t wmi_handle,
  6380. struct flashing_req_params *flashing)
  6381. {
  6382. wmi_set_led_flashing_cmd_fixed_param *cmd;
  6383. int status = 0;
  6384. wmi_buf_t buf;
  6385. uint8_t *buf_ptr;
  6386. int32_t len = sizeof(wmi_set_led_flashing_cmd_fixed_param);
  6387. buf = wmi_buf_alloc(wmi_handle, len);
  6388. if (!buf) {
  6389. WMA_LOGP(FL("wmi_buf_alloc failed"));
  6390. return -ENOMEM;
  6391. }
  6392. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  6393. cmd = (wmi_set_led_flashing_cmd_fixed_param *) buf_ptr;
  6394. WMITLV_SET_HDR(&cmd->tlv_header,
  6395. WMITLV_TAG_STRUC_wmi_set_led_flashing_cmd_fixed_param,
  6396. WMITLV_GET_STRUCT_TLVLEN
  6397. (wmi_set_led_flashing_cmd_fixed_param));
  6398. cmd->pattern_id = flashing->pattern_id;
  6399. cmd->led_x0 = flashing->led_x0;
  6400. cmd->led_x1 = flashing->led_x1;
  6401. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  6402. WMI_PDEV_SET_LED_FLASHING_CMDID);
  6403. if (status != EOK) {
  6404. WMA_LOGE("%s: wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
  6405. " returned Error %d", __func__, status);
  6406. return CDF_STATUS_E_FAILURE;
  6407. }
  6408. return CDF_STATUS_SUCCESS;
  6409. }
  6410. /**
  6411. * send_process_ch_avoid_update_cmd_tlv() - handles channel avoid update request
  6412. * @wmi_handle: wmi handle
  6413. * @ch_avoid_update_req: channel avoid update params
  6414. *
  6415. * Return: CDF status
  6416. */
  6417. CDF_STATUS send_process_ch_avoid_update_cmd_tlv(wmi_unified_t wmi_handle)
  6418. {
  6419. int status = 0;
  6420. wmi_buf_t buf = NULL;
  6421. uint8_t *buf_ptr;
  6422. wmi_chan_avoid_update_cmd_param *ch_avoid_update_fp;
  6423. int len = sizeof(wmi_chan_avoid_update_cmd_param);
  6424. buf = wmi_buf_alloc(wmi_handle, len);
  6425. if (!buf) {
  6426. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  6427. return CDF_STATUS_E_NOMEM;
  6428. }
  6429. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  6430. ch_avoid_update_fp = (wmi_chan_avoid_update_cmd_param *) buf_ptr;
  6431. WMITLV_SET_HDR(&ch_avoid_update_fp->tlv_header,
  6432. WMITLV_TAG_STRUC_wmi_chan_avoid_update_cmd_param,
  6433. WMITLV_GET_STRUCT_TLVLEN
  6434. (wmi_chan_avoid_update_cmd_param));
  6435. status = wmi_unified_cmd_send(wmi_handle, buf,
  6436. len, WMI_CHAN_AVOID_UPDATE_CMDID);
  6437. if (status != EOK) {
  6438. WMA_LOGE("wmi_unified_cmd_send"
  6439. " WMITLV_TABLE_WMI_CHAN_AVOID_UPDATE"
  6440. " returned Error %d", status);
  6441. wmi_buf_free(buf);
  6442. return CDF_STATUS_E_FAILURE;
  6443. }
  6444. return CDF_STATUS_SUCCESS;
  6445. }
  6446. /**
  6447. * send_regdomain_info_to_fw_cmd_tlv() - send regdomain info to fw
  6448. * @wmi_handle: wmi handle
  6449. * @reg_dmn: reg domain
  6450. * @regdmn2G: 2G reg domain
  6451. * @regdmn5G: 5G reg domain
  6452. * @ctl2G: 2G test limit
  6453. * @ctl5G: 5G test limit
  6454. *
  6455. * Return: none
  6456. */
  6457. CDF_STATUS send_regdomain_info_to_fw_cmd_tlv(wmi_unified_t wmi_handle,
  6458. uint32_t reg_dmn, uint16_t regdmn2G,
  6459. uint16_t regdmn5G, int8_t ctl2G,
  6460. int8_t ctl5G)
  6461. {
  6462. wmi_buf_t buf;
  6463. wmi_pdev_set_regdomain_cmd_fixed_param *cmd;
  6464. int32_t len = sizeof(*cmd);
  6465. buf = wmi_buf_alloc(wmi_handle, len);
  6466. if (!buf) {
  6467. WMA_LOGP("%s: wmi_buf_alloc failed", __func__);
  6468. return CDF_STATUS_E_NOMEM;
  6469. }
  6470. cmd = (wmi_pdev_set_regdomain_cmd_fixed_param *) wmi_buf_data(buf);
  6471. WMITLV_SET_HDR(&cmd->tlv_header,
  6472. WMITLV_TAG_STRUC_wmi_pdev_set_regdomain_cmd_fixed_param,
  6473. WMITLV_GET_STRUCT_TLVLEN
  6474. (wmi_pdev_set_regdomain_cmd_fixed_param));
  6475. cmd->reg_domain = reg_dmn;
  6476. cmd->reg_domain_2G = regdmn2G;
  6477. cmd->reg_domain_5G = regdmn5G;
  6478. cmd->conformance_test_limit_2G = ctl2G;
  6479. cmd->conformance_test_limit_5G = ctl5G;
  6480. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  6481. WMI_PDEV_SET_REGDOMAIN_CMDID)) {
  6482. WMA_LOGP("%s: Failed to send pdev set regdomain command",
  6483. __func__);
  6484. cdf_nbuf_free(buf);
  6485. return CDF_STATUS_E_FAILURE;
  6486. }
  6487. return CDF_STATUS_SUCCESS;
  6488. }
  6489. /**
  6490. * send_set_tdls_offchan_mode_cmd_tlv() - set tdls off channel mode
  6491. * @wmi_handle: wmi handle
  6492. * @chan_switch_params: Pointer to tdls channel switch parameter structure
  6493. *
  6494. * This function sets tdls off channel mode
  6495. *
  6496. * Return: 0 on success; Negative errno otherwise
  6497. */
  6498. CDF_STATUS send_set_tdls_offchan_mode_cmd_tlv(wmi_unified_t wmi_handle,
  6499. struct tdls_channel_switch_params *chan_switch_params)
  6500. {
  6501. wmi_tdls_set_offchan_mode_cmd_fixed_param *cmd;
  6502. wmi_buf_t wmi_buf;
  6503. u_int16_t len = sizeof(wmi_tdls_set_offchan_mode_cmd_fixed_param);
  6504. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  6505. if (!wmi_buf) {
  6506. WMA_LOGE(FL("wmi_buf_alloc failed"));
  6507. return CDF_STATUS_E_FAILURE;
  6508. }
  6509. cmd = (wmi_tdls_set_offchan_mode_cmd_fixed_param *)
  6510. wmi_buf_data(wmi_buf);
  6511. WMITLV_SET_HDR(&cmd->tlv_header,
  6512. WMITLV_TAG_STRUC_wmi_tdls_set_offchan_mode_cmd_fixed_param,
  6513. WMITLV_GET_STRUCT_TLVLEN(
  6514. wmi_tdls_set_offchan_mode_cmd_fixed_param));
  6515. WMI_CHAR_ARRAY_TO_MAC_ADDR(chan_switch_params->peer_mac_addr,
  6516. &cmd->peer_macaddr);
  6517. cmd->vdev_id = chan_switch_params->vdev_id;
  6518. cmd->offchan_mode = chan_switch_params->tdls_sw_mode;
  6519. cmd->is_peer_responder = chan_switch_params->is_responder;
  6520. cmd->offchan_num = chan_switch_params->tdls_off_ch;
  6521. cmd->offchan_bw_bitmap = chan_switch_params->tdls_off_ch_bw_offset;
  6522. cmd->offchan_oper_class = chan_switch_params->oper_class;
  6523. WMA_LOGD(FL("Peer MAC Addr mac_addr31to0: 0x%x, mac_addr47to32: 0x%x"),
  6524. cmd->peer_macaddr.mac_addr31to0,
  6525. cmd->peer_macaddr.mac_addr47to32);
  6526. WMA_LOGD(FL(
  6527. "vdev_id: %d, off channel mode: %d, off channel Num: %d, "
  6528. "off channel offset: 0x%x, is_peer_responder: %d, operating class: %d"
  6529. ),
  6530. cmd->vdev_id,
  6531. cmd->offchan_mode,
  6532. cmd->offchan_num,
  6533. cmd->offchan_bw_bitmap,
  6534. cmd->is_peer_responder,
  6535. cmd->offchan_oper_class);
  6536. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  6537. WMI_TDLS_SET_OFFCHAN_MODE_CMDID)) {
  6538. WMA_LOGP(FL("failed to send tdls off chan command"));
  6539. cdf_nbuf_free(wmi_buf);
  6540. return CDF_STATUS_E_FAILURE;
  6541. }
  6542. return CDF_STATUS_SUCCESS;
  6543. }
  6544. /**
  6545. * send_update_fw_tdls_state_cmd_tlv() - send enable/disable tdls for a vdev
  6546. * @wmi_handle: wmi handle
  6547. * @pwmaTdlsparams: TDLS params
  6548. *
  6549. * Return: 0 for sucess or error code
  6550. */
  6551. CDF_STATUS send_update_fw_tdls_state_cmd_tlv(wmi_unified_t wmi_handle,
  6552. void *tdls_param, uint8_t tdls_state)
  6553. {
  6554. wmi_tdls_set_state_cmd_fixed_param *cmd;
  6555. wmi_buf_t wmi_buf;
  6556. struct wmi_tdls_params *wmi_tdls = (struct wmi_tdls_params *) tdls_param;
  6557. uint16_t len = sizeof(wmi_tdls_set_state_cmd_fixed_param);
  6558. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  6559. if (!wmi_buf) {
  6560. WMA_LOGE("%s: wmai_buf_alloc failed", __func__);
  6561. return CDF_STATUS_E_FAILURE;
  6562. }
  6563. cmd = (wmi_tdls_set_state_cmd_fixed_param *) wmi_buf_data(wmi_buf);
  6564. WMITLV_SET_HDR(&cmd->tlv_header,
  6565. WMITLV_TAG_STRUC_wmi_tdls_set_state_cmd_fixed_param,
  6566. WMITLV_GET_STRUCT_TLVLEN
  6567. (wmi_tdls_set_state_cmd_fixed_param));
  6568. cmd->vdev_id = wmi_tdls->vdev_id;
  6569. cmd->state = tdls_state;
  6570. cmd->notification_interval_ms = wmi_tdls->notification_interval_ms;
  6571. cmd->tx_discovery_threshold = wmi_tdls->tx_discovery_threshold;
  6572. cmd->tx_teardown_threshold = wmi_tdls->tx_teardown_threshold;
  6573. cmd->rssi_teardown_threshold = wmi_tdls->rssi_teardown_threshold;
  6574. cmd->rssi_delta = wmi_tdls->rssi_delta;
  6575. cmd->tdls_options = wmi_tdls->tdls_options;
  6576. cmd->tdls_peer_traffic_ind_window = wmi_tdls->peer_traffic_ind_window;
  6577. cmd->tdls_peer_traffic_response_timeout_ms =
  6578. wmi_tdls->peer_traffic_response_timeout;
  6579. cmd->tdls_puapsd_mask = wmi_tdls->puapsd_mask;
  6580. cmd->tdls_puapsd_inactivity_time_ms = wmi_tdls->puapsd_inactivity_time;
  6581. cmd->tdls_puapsd_rx_frame_threshold =
  6582. wmi_tdls->puapsd_rx_frame_threshold;
  6583. cmd->teardown_notification_ms =
  6584. wmi_tdls->teardown_notification_ms;
  6585. cmd->tdls_peer_kickout_threshold =
  6586. wmi_tdls->tdls_peer_kickout_threshold;
  6587. WMA_LOGD("%s: tdls_state: %d, state: %d, "
  6588. "notification_interval_ms: %d, "
  6589. "tx_discovery_threshold: %d, "
  6590. "tx_teardown_threshold: %d, "
  6591. "rssi_teardown_threshold: %d, "
  6592. "rssi_delta: %d, "
  6593. "tdls_options: 0x%x, "
  6594. "tdls_peer_traffic_ind_window: %d, "
  6595. "tdls_peer_traffic_response_timeout: %d, "
  6596. "tdls_puapsd_mask: 0x%x, "
  6597. "tdls_puapsd_inactivity_time: %d, "
  6598. "tdls_puapsd_rx_frame_threshold: %d, "
  6599. "teardown_notification_ms: %d, "
  6600. "tdls_peer_kickout_threshold: %d",
  6601. __func__, tdls_state, cmd->state,
  6602. cmd->notification_interval_ms,
  6603. cmd->tx_discovery_threshold,
  6604. cmd->tx_teardown_threshold,
  6605. cmd->rssi_teardown_threshold,
  6606. cmd->rssi_delta,
  6607. cmd->tdls_options,
  6608. cmd->tdls_peer_traffic_ind_window,
  6609. cmd->tdls_peer_traffic_response_timeout_ms,
  6610. cmd->tdls_puapsd_mask,
  6611. cmd->tdls_puapsd_inactivity_time_ms,
  6612. cmd->tdls_puapsd_rx_frame_threshold,
  6613. cmd->teardown_notification_ms,
  6614. cmd->tdls_peer_kickout_threshold);
  6615. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  6616. WMI_TDLS_SET_STATE_CMDID)) {
  6617. WMA_LOGP("%s: failed to send tdls set state command", __func__);
  6618. cdf_nbuf_free(wmi_buf);
  6619. return CDF_STATUS_E_FAILURE;
  6620. }
  6621. WMA_LOGD("%s: vdev_id %d", __func__, wmi_tdls->vdev_id);
  6622. return CDF_STATUS_SUCCESS;
  6623. }
  6624. /**
  6625. * send_update_tdls_peer_state_cmd_tlv() - update TDLS peer state
  6626. * @wmi_handle: wmi handle
  6627. * @peerStateParams: TDLS peer state params
  6628. *
  6629. * Return: 0 for success or error code
  6630. */
  6631. CDF_STATUS send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
  6632. struct tdls_peer_state_params *peerStateParams,
  6633. uint32_t *ch_mhz)
  6634. {
  6635. wmi_tdls_peer_update_cmd_fixed_param *cmd;
  6636. wmi_tdls_peer_capabilities *peer_cap;
  6637. wmi_channel *chan_info;
  6638. wmi_buf_t wmi_buf;
  6639. uint8_t *buf_ptr;
  6640. uint32_t i;
  6641. int32_t len = sizeof(wmi_tdls_peer_update_cmd_fixed_param) +
  6642. sizeof(wmi_tdls_peer_capabilities);
  6643. len += WMI_TLV_HDR_SIZE +
  6644. sizeof(wmi_channel) * peerStateParams->peerCap.peerChanLen;
  6645. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  6646. if (!wmi_buf) {
  6647. WMA_LOGE("%s: wmi_buf_alloc failed", __func__);
  6648. return CDF_STATUS_E_FAILURE;
  6649. }
  6650. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  6651. cmd = (wmi_tdls_peer_update_cmd_fixed_param *) buf_ptr;
  6652. WMITLV_SET_HDR(&cmd->tlv_header,
  6653. WMITLV_TAG_STRUC_wmi_tdls_peer_update_cmd_fixed_param,
  6654. WMITLV_GET_STRUCT_TLVLEN
  6655. (wmi_tdls_peer_update_cmd_fixed_param));
  6656. cmd->vdev_id = peerStateParams->vdevId;
  6657. WMI_CHAR_ARRAY_TO_MAC_ADDR(peerStateParams->peerMacAddr,
  6658. &cmd->peer_macaddr);
  6659. cmd->peer_state = peerStateParams->peerState;
  6660. WMA_LOGD("%s: vdev_id: %d, peerStateParams->peerMacAddr: %pM, "
  6661. "peer_macaddr.mac_addr31to0: 0x%x, "
  6662. "peer_macaddr.mac_addr47to32: 0x%x, peer_state: %d",
  6663. __func__, cmd->vdev_id, peerStateParams->peerMacAddr,
  6664. cmd->peer_macaddr.mac_addr31to0,
  6665. cmd->peer_macaddr.mac_addr47to32, cmd->peer_state);
  6666. buf_ptr += sizeof(wmi_tdls_peer_update_cmd_fixed_param);
  6667. peer_cap = (wmi_tdls_peer_capabilities *) buf_ptr;
  6668. WMITLV_SET_HDR(&peer_cap->tlv_header,
  6669. WMITLV_TAG_STRUC_wmi_tdls_peer_capabilities,
  6670. WMITLV_GET_STRUCT_TLVLEN(wmi_tdls_peer_capabilities));
  6671. if ((peerStateParams->peerCap.peerUapsdQueue & 0x08) >> 3)
  6672. WMI_SET_TDLS_PEER_VO_UAPSD(peer_cap);
  6673. if ((peerStateParams->peerCap.peerUapsdQueue & 0x04) >> 2)
  6674. WMI_SET_TDLS_PEER_VI_UAPSD(peer_cap);
  6675. if ((peerStateParams->peerCap.peerUapsdQueue & 0x02) >> 1)
  6676. WMI_SET_TDLS_PEER_BK_UAPSD(peer_cap);
  6677. if (peerStateParams->peerCap.peerUapsdQueue & 0x01)
  6678. WMI_SET_TDLS_PEER_BE_UAPSD(peer_cap);
  6679. /* Ack and More Data Ack are sent as 0, so no need to set
  6680. * but fill SP
  6681. */
  6682. WMI_SET_TDLS_PEER_SP_UAPSD(peer_cap,
  6683. peerStateParams->peerCap.peerMaxSp);
  6684. peer_cap->buff_sta_support =
  6685. peerStateParams->peerCap.peerBuffStaSupport;
  6686. peer_cap->off_chan_support =
  6687. peerStateParams->peerCap.peerOffChanSupport;
  6688. peer_cap->peer_curr_operclass =
  6689. peerStateParams->peerCap.peerCurrOperClass;
  6690. /* self curr operclass is not being used and so pass op class for
  6691. * preferred off chan in it.
  6692. */
  6693. peer_cap->self_curr_operclass =
  6694. peerStateParams->peerCap.opClassForPrefOffChan;
  6695. peer_cap->peer_chan_len = peerStateParams->peerCap.peerChanLen;
  6696. peer_cap->peer_operclass_len =
  6697. peerStateParams->peerCap.peerOperClassLen;
  6698. WMA_LOGD("%s: peer_operclass_len: %d",
  6699. __func__, peer_cap->peer_operclass_len);
  6700. for (i = 0; i < WMI_TDLS_MAX_SUPP_OPER_CLASSES; i++) {
  6701. peer_cap->peer_operclass[i] =
  6702. peerStateParams->peerCap.peerOperClass[i];
  6703. WMA_LOGD("%s: peer_operclass[%d]: %d",
  6704. __func__, i, peer_cap->peer_operclass[i]);
  6705. }
  6706. peer_cap->is_peer_responder = peerStateParams->peerCap.isPeerResponder;
  6707. peer_cap->pref_offchan_num = peerStateParams->peerCap.prefOffChanNum;
  6708. peer_cap->pref_offchan_bw =
  6709. peerStateParams->peerCap.prefOffChanBandwidth;
  6710. WMA_LOGD
  6711. ("%s: peer_qos: 0x%x, buff_sta_support: %d, off_chan_support: %d, "
  6712. "peer_curr_operclass: %d, self_curr_operclass: %d, peer_chan_len: "
  6713. "%d, peer_operclass_len: %d, is_peer_responder: %d, pref_offchan_num:"
  6714. " %d, pref_offchan_bw: %d",
  6715. __func__, peer_cap->peer_qos, peer_cap->buff_sta_support,
  6716. peer_cap->off_chan_support, peer_cap->peer_curr_operclass,
  6717. peer_cap->self_curr_operclass, peer_cap->peer_chan_len,
  6718. peer_cap->peer_operclass_len, peer_cap->is_peer_responder,
  6719. peer_cap->pref_offchan_num, peer_cap->pref_offchan_bw);
  6720. /* next fill variable size array of peer chan info */
  6721. buf_ptr += sizeof(wmi_tdls_peer_capabilities);
  6722. WMITLV_SET_HDR(buf_ptr,
  6723. WMITLV_TAG_ARRAY_STRUC,
  6724. sizeof(wmi_channel) *
  6725. peerStateParams->peerCap.peerChanLen);
  6726. chan_info = (wmi_channel *) (buf_ptr + WMI_TLV_HDR_SIZE);
  6727. for (i = 0; i < peerStateParams->peerCap.peerChanLen; ++i) {
  6728. WMITLV_SET_HDR(&chan_info->tlv_header,
  6729. WMITLV_TAG_STRUC_wmi_channel,
  6730. WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
  6731. chan_info->mhz = ch_mhz[i];
  6732. chan_info->band_center_freq1 = chan_info->mhz;
  6733. chan_info->band_center_freq2 = 0;
  6734. WMA_LOGD("%s: chan[%d] = %u", __func__, i, chan_info->mhz);
  6735. if (peerStateParams->peerCap.peerChan[i].dfsSet) {
  6736. WMI_SET_CHANNEL_FLAG(chan_info, WMI_CHAN_FLAG_PASSIVE);
  6737. WMA_LOGI("chan[%d] DFS[%d]\n",
  6738. peerStateParams->peerCap.peerChan[i].chanId,
  6739. peerStateParams->peerCap.peerChan[i].dfsSet);
  6740. }
  6741. if (chan_info->mhz < WMI_2_4_GHZ_MAX_FREQ)
  6742. WMI_SET_CHANNEL_MODE(chan_info, MODE_11G);
  6743. else
  6744. WMI_SET_CHANNEL_MODE(chan_info, MODE_11A);
  6745. WMI_SET_CHANNEL_MAX_TX_POWER(chan_info,
  6746. peerStateParams->peerCap.
  6747. peerChan[i].pwr);
  6748. WMI_SET_CHANNEL_REG_POWER(chan_info,
  6749. peerStateParams->peerCap.peerChan[i].
  6750. pwr);
  6751. WMA_LOGD("Channel TX power[%d] = %u: %d", i, chan_info->mhz,
  6752. peerStateParams->peerCap.peerChan[i].pwr);
  6753. chan_info++;
  6754. }
  6755. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  6756. WMI_TDLS_PEER_UPDATE_CMDID)) {
  6757. WMA_LOGE("%s: failed to send tdls peer update state command",
  6758. __func__);
  6759. cdf_nbuf_free(wmi_buf);
  6760. return CDF_STATUS_E_FAILURE;
  6761. }
  6762. return CDF_STATUS_SUCCESS;
  6763. }
  6764. /*
  6765. * send_process_fw_mem_dump_cmd_tlv() - Function to request fw memory dump from
  6766. * firmware
  6767. * @wmi_handle: Pointer to wmi handle
  6768. * @mem_dump_req: Pointer for mem_dump_req
  6769. *
  6770. * This function sends memory dump request to firmware
  6771. *
  6772. * Return: CDF_STATUS_SUCCESS for success otherwise failure
  6773. *
  6774. */
  6775. CDF_STATUS send_process_fw_mem_dump_cmd_tlv(wmi_unified_t wmi_handle,
  6776. struct fw_dump_req_param *mem_dump_req)
  6777. {
  6778. wmi_get_fw_mem_dump_fixed_param *cmd;
  6779. wmi_fw_mem_dump *dump_params;
  6780. struct fw_dump_seg_req *seg_req;
  6781. int32_t len;
  6782. wmi_buf_t buf;
  6783. u_int8_t *buf_ptr;
  6784. int ret, loop;
  6785. /*
  6786. * len = sizeof(fixed param) that includes tlv header +
  6787. * tlv header for array of struc +
  6788. * sizeof (each struct)
  6789. */
  6790. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
  6791. len += mem_dump_req->num_seg * sizeof(wmi_fw_mem_dump);
  6792. buf = wmi_buf_alloc(wmi_handle, len);
  6793. if (!buf) {
  6794. WMA_LOGE(FL("Failed allocate wmi buffer"));
  6795. return CDF_STATUS_E_NOMEM;
  6796. }
  6797. buf_ptr = (u_int8_t *) wmi_buf_data(buf);
  6798. cdf_mem_zero(buf_ptr, len);
  6799. cmd = (wmi_get_fw_mem_dump_fixed_param *) buf_ptr;
  6800. WMITLV_SET_HDR(&cmd->tlv_header,
  6801. WMITLV_TAG_STRUC_wmi_get_fw_mem_dump_fixed_param,
  6802. WMITLV_GET_STRUCT_TLVLEN(wmi_get_fw_mem_dump_fixed_param));
  6803. cmd->request_id = mem_dump_req->request_id;
  6804. cmd->num_fw_mem_dump_segs = mem_dump_req->num_seg;
  6805. /* TLV indicating array of structures to follow */
  6806. buf_ptr += sizeof(wmi_get_fw_mem_dump_fixed_param);
  6807. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  6808. sizeof(wmi_fw_mem_dump) *
  6809. cmd->num_fw_mem_dump_segs);
  6810. buf_ptr += WMI_TLV_HDR_SIZE;
  6811. dump_params = (wmi_fw_mem_dump *) buf_ptr;
  6812. WMA_LOGI(FL("request_id:%d num_seg:%d"),
  6813. mem_dump_req->request_id, mem_dump_req->num_seg);
  6814. for (loop = 0; loop < cmd->num_fw_mem_dump_segs; loop++) {
  6815. seg_req = (struct fw_dump_seg_req *)
  6816. ((uint8_t *)(mem_dump_req->segment) +
  6817. loop * sizeof(*seg_req));
  6818. WMITLV_SET_HDR(&dump_params->tlv_header,
  6819. WMITLV_TAG_STRUC_wmi_fw_mem_dump_params,
  6820. WMITLV_GET_STRUCT_TLVLEN(wmi_fw_mem_dump));
  6821. dump_params->seg_id = seg_req->seg_id;
  6822. dump_params->seg_start_addr_lo = seg_req->seg_start_addr_lo;
  6823. dump_params->seg_start_addr_hi = seg_req->seg_start_addr_hi;
  6824. dump_params->seg_length = seg_req->seg_length;
  6825. dump_params->dest_addr_lo = seg_req->dst_addr_lo;
  6826. dump_params->dest_addr_hi = seg_req->dst_addr_hi;
  6827. WMA_LOGI(FL("seg_number:%d"), loop);
  6828. WMA_LOGI(FL("seg_id:%d start_addr_lo:0x%x start_addr_hi:0x%x"),
  6829. dump_params->seg_id, dump_params->seg_start_addr_lo,
  6830. dump_params->seg_start_addr_hi);
  6831. WMA_LOGI(FL("seg_length:%d dst_addr_lo:0x%x dst_addr_hi:0x%x"),
  6832. dump_params->seg_length, dump_params->dest_addr_lo,
  6833. dump_params->dest_addr_hi);
  6834. dump_params++;
  6835. }
  6836. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6837. WMI_GET_FW_MEM_DUMP_CMDID);
  6838. if (ret) {
  6839. WMA_LOGE(FL("Failed to send get firmware mem dump request"));
  6840. wmi_buf_free(buf);
  6841. return CDF_STATUS_E_FAILURE;
  6842. }
  6843. WMA_LOGI(FL("Get firmware mem dump request sent successfully"));
  6844. return CDF_STATUS_SUCCESS;
  6845. }
  6846. /*
  6847. * send_process_set_ie_info_cmd_tlv() - Function to send IE info to firmware
  6848. * @wmi_handle: Pointer to WMi handle
  6849. * @ie_data: Pointer for ie data
  6850. *
  6851. * This function sends IE information to firmware
  6852. *
  6853. * Return: CDF_STATUS_SUCCESS for success otherwise failure
  6854. *
  6855. */
  6856. CDF_STATUS send_process_set_ie_info_cmd_tlv(wmi_unified_t wmi_handle,
  6857. struct vdev_ie_info_param *ie_info)
  6858. {
  6859. wmi_vdev_set_ie_cmd_fixed_param *cmd;
  6860. wmi_buf_t buf;
  6861. uint8_t *buf_ptr;
  6862. uint32_t len, ie_len_aligned;
  6863. int ret;
  6864. ie_len_aligned = roundup(ie_info->length, sizeof(uint32_t));
  6865. /* Allocate memory for the WMI command */
  6866. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + ie_len_aligned;
  6867. buf = wmi_buf_alloc(wmi_handle, len);
  6868. if (!buf) {
  6869. WMA_LOGE(FL("wmi_buf_alloc failed"));
  6870. return CDF_STATUS_E_NOMEM;
  6871. }
  6872. buf_ptr = wmi_buf_data(buf);
  6873. cdf_mem_zero(buf_ptr, len);
  6874. /* Populate the WMI command */
  6875. cmd = (wmi_vdev_set_ie_cmd_fixed_param *)buf_ptr;
  6876. WMITLV_SET_HDR(&cmd->tlv_header,
  6877. WMITLV_TAG_STRUC_wmi_vdev_set_ie_cmd_fixed_param,
  6878. WMITLV_GET_STRUCT_TLVLEN(
  6879. wmi_vdev_set_ie_cmd_fixed_param));
  6880. cmd->vdev_id = ie_info->vdev_id;
  6881. cmd->ie_id = ie_info->ie_id;
  6882. cmd->ie_len = ie_info->length;
  6883. WMA_LOGD(FL("IE:%d of size:%d sent for vdev:%d"), ie_info->ie_id,
  6884. ie_info->length, ie_info->vdev_id);
  6885. buf_ptr += sizeof(*cmd);
  6886. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ie_len_aligned);
  6887. buf_ptr += WMI_TLV_HDR_SIZE;
  6888. cdf_mem_copy(buf_ptr, ie_info->data, cmd->ie_len);
  6889. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6890. WMI_VDEV_SET_IE_CMDID);
  6891. if (ret != EOK) {
  6892. WMA_LOGE(FL("Failed to send set IE command ret = %d"), ret);
  6893. wmi_buf_free(buf);
  6894. }
  6895. return ret;
  6896. }
  6897. void wmi_copy_resource_config(wmi_resource_config *resource_cfg,
  6898. wmi_resource_config *tgt_res_cfg)
  6899. {
  6900. resource_cfg->num_peers = tgt_res_cfg->num_peers;
  6901. resource_cfg->num_offload_peers = tgt_res_cfg->num_offload_peers;
  6902. resource_cfg->num_offload_reorder_buffs =
  6903. tgt_res_cfg->num_offload_reorder_buffs;
  6904. resource_cfg->num_peer_keys = tgt_res_cfg->num_peer_keys;
  6905. resource_cfg->num_tids = tgt_res_cfg->num_tids;
  6906. resource_cfg->ast_skid_limit = tgt_res_cfg->ast_skid_limit;
  6907. resource_cfg->tx_chain_mask = tgt_res_cfg->tx_chain_mask;
  6908. resource_cfg->rx_chain_mask = tgt_res_cfg->rx_chain_mask;
  6909. resource_cfg->rx_timeout_pri[0] = tgt_res_cfg->rx_timeout_pri[0];
  6910. resource_cfg->rx_timeout_pri[1] = tgt_res_cfg->rx_timeout_pri[1];
  6911. resource_cfg->rx_timeout_pri[2] = tgt_res_cfg->rx_timeout_pri[2];
  6912. resource_cfg->rx_timeout_pri[3] = tgt_res_cfg->rx_timeout_pri[3];
  6913. resource_cfg->rx_decap_mode = tgt_res_cfg->rx_decap_mode;
  6914. resource_cfg->scan_max_pending_req =
  6915. tgt_res_cfg->scan_max_pending_req;
  6916. resource_cfg->bmiss_offload_max_vdev =
  6917. tgt_res_cfg->bmiss_offload_max_vdev;
  6918. resource_cfg->roam_offload_max_vdev =
  6919. tgt_res_cfg->roam_offload_max_vdev;
  6920. resource_cfg->roam_offload_max_ap_profiles =
  6921. tgt_res_cfg->roam_offload_max_ap_profiles;
  6922. resource_cfg->num_mcast_groups = tgt_res_cfg->num_mcast_groups;
  6923. resource_cfg->num_mcast_table_elems =
  6924. tgt_res_cfg->num_mcast_table_elems;
  6925. resource_cfg->mcast2ucast_mode = tgt_res_cfg->mcast2ucast_mode;
  6926. resource_cfg->tx_dbg_log_size = tgt_res_cfg->tx_dbg_log_size;
  6927. resource_cfg->num_wds_entries = tgt_res_cfg->num_wds_entries;
  6928. resource_cfg->dma_burst_size = tgt_res_cfg->dma_burst_size;
  6929. resource_cfg->mac_aggr_delim = tgt_res_cfg->mac_aggr_delim;
  6930. resource_cfg->rx_skip_defrag_timeout_dup_detection_check =
  6931. tgt_res_cfg->rx_skip_defrag_timeout_dup_detection_check;
  6932. resource_cfg->vow_config = tgt_res_cfg->vow_config;
  6933. resource_cfg->gtk_offload_max_vdev = tgt_res_cfg->gtk_offload_max_vdev;
  6934. resource_cfg->num_msdu_desc = tgt_res_cfg->num_msdu_desc;
  6935. resource_cfg->max_frag_entries = tgt_res_cfg->max_frag_entries;
  6936. resource_cfg->num_tdls_vdevs = tgt_res_cfg->num_tdls_vdevs;
  6937. resource_cfg->num_tdls_conn_table_entries =
  6938. tgt_res_cfg->num_tdls_conn_table_entries;
  6939. resource_cfg->beacon_tx_offload_max_vdev =
  6940. tgt_res_cfg->beacon_tx_offload_max_vdev;
  6941. resource_cfg->num_multicast_filter_entries =
  6942. tgt_res_cfg->num_multicast_filter_entries;
  6943. resource_cfg->num_wow_filters =
  6944. tgt_res_cfg->num_wow_filters;
  6945. resource_cfg->num_keep_alive_pattern =
  6946. tgt_res_cfg->num_keep_alive_pattern;
  6947. resource_cfg->keep_alive_pattern_size =
  6948. tgt_res_cfg->keep_alive_pattern_size;
  6949. resource_cfg->max_tdls_concurrent_sleep_sta =
  6950. tgt_res_cfg->max_tdls_concurrent_sleep_sta;
  6951. resource_cfg->max_tdls_concurrent_buffer_sta =
  6952. tgt_res_cfg->max_tdls_concurrent_buffer_sta;
  6953. resource_cfg->wmi_send_separate =
  6954. tgt_res_cfg->wmi_send_separate;
  6955. resource_cfg->num_ocb_vdevs =
  6956. tgt_res_cfg->num_ocb_vdevs;
  6957. resource_cfg->num_ocb_channels =
  6958. tgt_res_cfg->num_ocb_channels;
  6959. resource_cfg->num_ocb_schedules =
  6960. tgt_res_cfg->num_ocb_schedules;
  6961. }
  6962. /**
  6963. * send_init_cmd_tlv() - wmi init command
  6964. * @wmi_handle: pointer to wmi handle
  6965. * @res_cfg: resource config
  6966. * @num_mem_chunks: no of mem chunck
  6967. * @mem_chunk: pointer to mem chunck structure
  6968. *
  6969. * This function sends IE information to firmware
  6970. *
  6971. * Return: CDF_STATUS_SUCCESS for success otherwise failure
  6972. *
  6973. */
  6974. CDF_STATUS send_init_cmd_tlv(wmi_unified_t wmi_handle,
  6975. wmi_resource_config *tgt_res_cfg,
  6976. uint8_t num_mem_chunks, struct wmi_host_mem_chunk *mem_chunks,
  6977. bool action)
  6978. {
  6979. wmi_buf_t buf;
  6980. wmi_init_cmd_fixed_param *cmd;
  6981. wmi_abi_version my_vers;
  6982. int num_whitelist;
  6983. uint8_t *buf_ptr;
  6984. wmi_resource_config *resource_cfg;
  6985. wlan_host_memory_chunk *host_mem_chunks;
  6986. uint32_t mem_chunk_len = 0;
  6987. uint16_t idx;
  6988. int len;
  6989. int ret;
  6990. len = sizeof(*cmd) + sizeof(wmi_resource_config) + WMI_TLV_HDR_SIZE;
  6991. mem_chunk_len = (sizeof(wlan_host_memory_chunk) * MAX_MEM_CHUNKS);
  6992. buf = wmi_buf_alloc(wmi_handle, len + mem_chunk_len);
  6993. if (!buf) {
  6994. WMA_LOGD("%s: wmi_buf_alloc failed\n", __func__);
  6995. return CDF_STATUS_E_FAILURE;
  6996. }
  6997. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  6998. cmd = (wmi_init_cmd_fixed_param *) buf_ptr;
  6999. resource_cfg = (wmi_resource_config *) (buf_ptr + sizeof(*cmd));
  7000. host_mem_chunks = (wlan_host_memory_chunk *)
  7001. (buf_ptr + sizeof(*cmd) + sizeof(wmi_resource_config)
  7002. + WMI_TLV_HDR_SIZE);
  7003. WMITLV_SET_HDR(&cmd->tlv_header,
  7004. WMITLV_TAG_STRUC_wmi_init_cmd_fixed_param,
  7005. WMITLV_GET_STRUCT_TLVLEN(wmi_init_cmd_fixed_param));
  7006. cdf_mem_copy(resource_cfg, tgt_res_cfg, sizeof(wmi_resource_config));
  7007. WMITLV_SET_HDR(&resource_cfg->tlv_header,
  7008. WMITLV_TAG_STRUC_wmi_resource_config,
  7009. WMITLV_GET_STRUCT_TLVLEN(wmi_resource_config));
  7010. for (idx = 0; idx < num_mem_chunks; ++idx) {
  7011. WMITLV_SET_HDR(&(host_mem_chunks[idx].tlv_header),
  7012. WMITLV_TAG_STRUC_wlan_host_memory_chunk,
  7013. WMITLV_GET_STRUCT_TLVLEN
  7014. (wlan_host_memory_chunk));
  7015. host_mem_chunks[idx].ptr = mem_chunks[idx].paddr;
  7016. host_mem_chunks[idx].size = mem_chunks[idx].len;
  7017. host_mem_chunks[idx].req_id = mem_chunks[idx].req_id;
  7018. WMA_LOGD("chunk %d len %d requested ,ptr 0x%x ",
  7019. idx, host_mem_chunks[idx].size,
  7020. host_mem_chunks[idx].ptr);
  7021. }
  7022. cmd->num_host_mem_chunks = num_mem_chunks;
  7023. len += (num_mem_chunks * sizeof(wlan_host_memory_chunk));
  7024. WMITLV_SET_HDR((buf_ptr + sizeof(*cmd) + sizeof(wmi_resource_config)),
  7025. WMITLV_TAG_ARRAY_STRUC,
  7026. (sizeof(wlan_host_memory_chunk) *
  7027. num_mem_chunks));
  7028. num_whitelist = sizeof(version_whitelist) /
  7029. sizeof(wmi_whitelist_version_info);
  7030. my_vers.abi_version_0 = WMI_ABI_VERSION_0;
  7031. my_vers.abi_version_1 = WMI_ABI_VERSION_1;
  7032. my_vers.abi_version_ns_0 = WMI_ABI_VERSION_NS_0;
  7033. my_vers.abi_version_ns_1 = WMI_ABI_VERSION_NS_1;
  7034. my_vers.abi_version_ns_2 = WMI_ABI_VERSION_NS_2;
  7035. my_vers.abi_version_ns_3 = WMI_ABI_VERSION_NS_3;
  7036. wmi_cmp_and_set_abi_version(num_whitelist, version_whitelist,
  7037. &my_vers,
  7038. &wmi_handle->fw_abi_version,
  7039. &cmd->host_abi_vers);
  7040. WMA_LOGD("%s: INIT_CMD version: %d, %d, 0x%x, 0x%x, 0x%x, 0x%x",
  7041. __func__, WMI_VER_GET_MAJOR(cmd->host_abi_vers.abi_version_0),
  7042. WMI_VER_GET_MINOR(cmd->host_abi_vers.abi_version_0),
  7043. cmd->host_abi_vers.abi_version_ns_0,
  7044. cmd->host_abi_vers.abi_version_ns_1,
  7045. cmd->host_abi_vers.abi_version_ns_2,
  7046. cmd->host_abi_vers.abi_version_ns_3);
  7047. /* Save version sent from host -
  7048. * Will be used to check ready event
  7049. */
  7050. cdf_mem_copy(&wmi_handle->final_abi_vers, &cmd->host_abi_vers,
  7051. sizeof(wmi_abi_version));
  7052. if (action) {
  7053. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  7054. WMI_INIT_CMDID);
  7055. if (ret) {
  7056. WMA_LOGE(FL("Failed to send set WMI INIT command ret = %d"), ret);
  7057. wmi_buf_free(buf);
  7058. return CDF_STATUS_E_FAILURE;
  7059. }
  7060. } else {
  7061. wmi_handle->saved_wmi_init_cmd.buf = buf;
  7062. wmi_handle->saved_wmi_init_cmd.buf_len = len;
  7063. }
  7064. return CDF_STATUS_SUCCESS;
  7065. }
  7066. /**
  7067. * send_saved_init_cmd_tlv() - wmi init command
  7068. * @wmi_handle: pointer to wmi handle
  7069. *
  7070. * This function sends IE information to firmware
  7071. *
  7072. * Return: CDF_STATUS_SUCCESS for success otherwise failure
  7073. *
  7074. */
  7075. CDF_STATUS send_saved_init_cmd_tlv(wmi_unified_t wmi_handle)
  7076. {
  7077. int status;
  7078. if (!wmi_handle->saved_wmi_init_cmd.buf ||
  7079. !wmi_handle->saved_wmi_init_cmd.buf_len) {
  7080. WMA_LOGP("Service ready ext event w/o WMI_SERVICE_EXT_MSG!");
  7081. return CDF_STATUS_E_FAILURE;
  7082. }
  7083. status = wmi_unified_cmd_send(wmi_handle,
  7084. wmi_handle->saved_wmi_init_cmd.buf,
  7085. wmi_handle->saved_wmi_init_cmd.buf_len,
  7086. WMI_INIT_CMDID);
  7087. if (status) {
  7088. WMA_LOGE(FL("Failed to send set WMI INIT command ret = %d"), status);
  7089. wmi_buf_free(wmi_handle->saved_wmi_init_cmd.buf);
  7090. return CDF_STATUS_E_FAILURE;
  7091. }
  7092. wmi_handle->saved_wmi_init_cmd.buf = NULL;
  7093. wmi_handle->saved_wmi_init_cmd.buf_len = 0;
  7094. return CDF_STATUS_SUCCESS;
  7095. }
  7096. CDF_STATUS save_fw_version_cmd_tlv(wmi_unified_t wmi_handle, void *evt_buf)
  7097. {
  7098. WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf;
  7099. wmi_service_ready_event_fixed_param *ev;
  7100. param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *) evt_buf;
  7101. ev = (wmi_service_ready_event_fixed_param *) param_buf->fixed_param;
  7102. if (!ev)
  7103. cdf_assert(0);
  7104. /*Save fw version from service ready message */
  7105. /*This will be used while sending INIT message */
  7106. cdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers,
  7107. sizeof(wmi_handle->fw_abi_version));
  7108. return CDF_STATUS_SUCCESS;
  7109. }
  7110. /**
  7111. * wmi_unified_save_fw_version_cmd() - save fw version
  7112. * @wmi_handle: pointer to wmi handle
  7113. * @res_cfg: resource config
  7114. * @num_mem_chunks: no of mem chunck
  7115. * @mem_chunk: pointer to mem chunck structure
  7116. *
  7117. * This function sends IE information to firmware
  7118. *
  7119. * Return: CDF_STATUS_SUCCESS for success otherwise failure
  7120. *
  7121. */
  7122. CDF_STATUS check_and_update_fw_version_cmd_tlv(wmi_unified_t wmi_handle,
  7123. void *evt_buf)
  7124. {
  7125. WMI_READY_EVENTID_param_tlvs *param_buf = NULL;
  7126. wmi_ready_event_fixed_param *ev = NULL;
  7127. param_buf = (WMI_READY_EVENTID_param_tlvs *) evt_buf;
  7128. ev = param_buf->fixed_param;
  7129. if (!wmi_versions_are_compatible(&wmi_handle->final_abi_vers,
  7130. &ev->fw_abi_vers)) {
  7131. /*
  7132. * Error: Our host version and the given firmware version
  7133. * are incompatible.
  7134. **/
  7135. WMA_LOGD("%s: Error: Incompatible WMI version."
  7136. "Host: %d,%d,0x%x 0x%x 0x%x 0x%x, FW: %d,%d,0x%x 0x%x 0x%x 0x%x\n",
  7137. __func__,
  7138. WMI_VER_GET_MAJOR(wmi_handle->final_abi_vers.
  7139. abi_version_0),
  7140. WMI_VER_GET_MINOR(wmi_handle->final_abi_vers.
  7141. abi_version_0),
  7142. wmi_handle->final_abi_vers.abi_version_ns_0,
  7143. wmi_handle->final_abi_vers.abi_version_ns_1,
  7144. wmi_handle->final_abi_vers.abi_version_ns_2,
  7145. wmi_handle->final_abi_vers.abi_version_ns_3,
  7146. WMI_VER_GET_MAJOR(ev->fw_abi_vers.abi_version_0),
  7147. WMI_VER_GET_MINOR(ev->fw_abi_vers.abi_version_0),
  7148. ev->fw_abi_vers.abi_version_ns_0,
  7149. ev->fw_abi_vers.abi_version_ns_1,
  7150. ev->fw_abi_vers.abi_version_ns_2,
  7151. ev->fw_abi_vers.abi_version_ns_3);
  7152. return CDF_STATUS_E_FAILURE;
  7153. }
  7154. cdf_mem_copy(&wmi_handle->final_abi_vers, &ev->fw_abi_vers,
  7155. sizeof(wmi_abi_version));
  7156. cdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers,
  7157. sizeof(wmi_abi_version));
  7158. return CDF_STATUS_SUCCESS;
  7159. }
  7160. struct wmi_ops tlv_ops = {
  7161. .send_vdev_create_cmd = send_vdev_create_cmd_tlv,
  7162. .send_vdev_delete_cmd = send_vdev_delete_cmd_tlv,
  7163. .send_vdev_down_cmd = send_vdev_down_cmd_tlv,
  7164. .send_peer_flush_tids_cmd = send_peer_flush_tids_cmd_tlv,
  7165. .send_peer_param_cmd = send_peer_param_cmd_tlv,
  7166. .send_vdev_up_cmd = send_vdev_up_cmd_tlv,
  7167. .send_vdev_stop_cmd = send_vdev_stop_cmd_tlv,
  7168. .send_peer_create_cmd = send_peer_create_cmd_tlv,
  7169. .send_peer_delete_cmd = send_peer_delete_cmd_tlv,
  7170. .send_green_ap_ps_cmd = send_green_ap_ps_cmd_tlv,
  7171. .send_pdev_utf_cmd = send_pdev_utf_cmd_tlv,
  7172. .send_pdev_param_cmd = send_pdev_param_cmd_tlv,
  7173. .send_suspend_cmd = send_suspend_cmd_tlv,
  7174. .send_resume_cmd = send_resume_cmd_tlv,
  7175. .send_wow_enable_cmd = send_wow_enable_cmd_tlv,
  7176. .send_set_ap_ps_param_cmd = send_set_ap_ps_param_cmd_tlv,
  7177. .send_set_sta_ps_param_cmd = send_set_sta_ps_param_cmd_tlv,
  7178. .send_crash_inject_cmd = send_crash_inject_cmd_tlv,
  7179. .send_dbglog_cmd = send_dbglog_cmd_tlv,
  7180. .send_vdev_set_param_cmd = send_vdev_set_param_cmd_tlv,
  7181. .send_stats_request_cmd = send_stats_request_cmd_tlv,
  7182. .send_packet_log_enable_cmd = send_packet_log_enable_cmd_tlv,
  7183. .send_beacon_send_cmd = send_beacon_send_cmd_tlv,
  7184. .send_peer_assoc_cmd = send_peer_assoc_cmd_tlv,
  7185. .send_scan_start_cmd = send_scan_start_cmd_tlv,
  7186. .send_scan_stop_cmd = send_scan_stop_cmd_tlv,
  7187. .send_scan_chan_list_cmd = send_scan_chan_list_cmd_tlv,
  7188. .send_mgmt_cmd = send_mgmt_cmd_tlv,
  7189. .send_modem_power_state_cmd = send_modem_power_state_cmd_tlv,
  7190. .send_set_sta_ps_mode_cmd = send_set_sta_ps_mode_cmd_tlv,
  7191. .send_set_sta_uapsd_auto_trig_cmd =
  7192. send_set_sta_uapsd_auto_trig_cmd_tlv,
  7193. .send_get_temperature_cmd = send_get_temperature_cmd_tlv,
  7194. .send_set_p2pgo_oppps_req_cmd = send_set_p2pgo_oppps_req_cmd_tlv,
  7195. .send_set_p2pgo_noa_req_cmd = send_set_p2pgo_noa_req_cmd_tlv,
  7196. .send_set_smps_params_cmd = send_set_smps_params_cmd_tlv,
  7197. .send_set_mimops_cmd = send_set_mimops_cmd_tlv,
  7198. .send_ocb_set_utc_time_cmd = send_ocb_set_utc_time_cmd_tlv,
  7199. .send_ocb_get_tsf_timer_cmd = send_ocb_get_tsf_timer_cmd_tlv,
  7200. .send_dcc_clear_stats_cmd = send_dcc_clear_stats_cmd_tlv,
  7201. .send_dcc_get_stats_cmd = send_dcc_get_stats_cmd_tlv,
  7202. .send_dcc_update_ndl_cmd = send_dcc_update_ndl_cmd_tlv,
  7203. .send_ocb_set_config_cmd = send_ocb_set_config_cmd_tlv,
  7204. .send_ocb_stop_timing_advert_cmd = send_ocb_stop_timing_advert_cmd_tlv,
  7205. .send_ocb_start_timing_advert_cmd =
  7206. send_ocb_start_timing_advert_cmd_tlv,
  7207. .send_set_enable_disable_mcc_adaptive_scheduler_cmd =
  7208. send_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv,
  7209. .send_set_mcc_channel_time_latency_cmd =
  7210. send_set_mcc_channel_time_latency_cmd_tlv,
  7211. .send_set_mcc_channel_time_quota_cmd =
  7212. send_set_mcc_channel_time_quota_cmd_tlv,
  7213. .send_set_thermal_mgmt_cmd = send_set_thermal_mgmt_cmd_tlv,
  7214. .send_lro_config_cmd = send_lro_config_cmd_tlv,
  7215. .send_bcn_buf_ll_cmd = send_bcn_buf_ll_cmd_tlv,
  7216. .send_set_sta_sa_query_param_cmd = send_set_sta_sa_query_param_cmd_tlv,
  7217. .send_set_sta_keep_alive_cmd = send_set_sta_keep_alive_cmd_tlv,
  7218. .send_vdev_set_gtx_cfg_cmd = send_vdev_set_gtx_cfg_cmd_tlv,
  7219. .send_process_update_edca_param_cmd =
  7220. send_process_update_edca_param_cmd_tlv,
  7221. .send_probe_rsp_tmpl_send_cmd =
  7222. send_probe_rsp_tmpl_send_cmd_tlv,
  7223. .send_p2p_go_set_beacon_ie_cmd =
  7224. send_p2p_go_set_beacon_ie_cmd_tlv,
  7225. .send_set_gateway_params_cmd =
  7226. send_set_gateway_params_cmd_tlv,
  7227. .send_set_rssi_monitoring_cmd =
  7228. send_set_rssi_monitoring_cmd_tlv,
  7229. .send_scan_probe_setoui_cmd =
  7230. send_scan_probe_setoui_cmd_tlv,
  7231. .send_reset_passpoint_network_list_cmd =
  7232. send_reset_passpoint_network_list_cmd_tlv,
  7233. .send_set_passpoint_network_list_cmd =
  7234. send_set_passpoint_network_list_cmd_tlv,
  7235. .send_set_epno_network_list_cmd =
  7236. send_set_epno_network_list_cmd_tlv,
  7237. .send_ipa_offload_control_cmd =
  7238. send_ipa_offload_control_cmd_tlv,
  7239. .send_extscan_get_capabilities_cmd =
  7240. send_extscan_get_capabilities_cmd_tlv,
  7241. .send_extscan_get_cached_results_cmd =
  7242. send_extscan_get_cached_results_cmd_tlv,
  7243. .send_extscan_stop_change_monitor_cmd =
  7244. send_extscan_stop_change_monitor_cmd_tlv,
  7245. .send_extscan_start_change_monitor_cmd =
  7246. send_extscan_start_change_monitor_cmd_tlv,
  7247. .send_extscan_stop_hotlist_monitor_cmd =
  7248. send_extscan_stop_hotlist_monitor_cmd_tlv,
  7249. .send_stop_extscan_cmd = send_stop_extscan_cmd_tlv,
  7250. .send_start_extscan_cmd = send_start_extscan_cmd_tlv,
  7251. .send_plm_stop_cmd = send_plm_stop_cmd_tlv,
  7252. .send_plm_start_cmd = send_plm_start_cmd_tlv,
  7253. .send_pno_stop_cmd = send_pno_stop_cmd_tlv,
  7254. .send_pno_start_cmd = send_pno_start_cmd_tlv,
  7255. .send_set_ric_req_cmd = send_set_ric_req_cmd_tlv,
  7256. .send_process_ll_stats_clear_cmd = send_process_ll_stats_clear_cmd_tlv,
  7257. .send_process_ll_stats_set_cmd = send_process_ll_stats_set_cmd_tlv,
  7258. .send_process_ll_stats_get_cmd = send_process_ll_stats_get_cmd_tlv,
  7259. .send_get_stats_cmd = send_get_stats_cmd_tlv,
  7260. .send_snr_request_cmd = send_snr_request_cmd_tlv,
  7261. .send_snr_cmd = send_snr_cmd_tlv,
  7262. .send_link_status_req_cmd = send_link_status_req_cmd_tlv,
  7263. .send_lphb_config_hbenable_cmd = send_lphb_config_hbenable_cmd_tlv,
  7264. .send_lphb_config_tcp_params_cmd = send_lphb_config_tcp_params_cmd_tlv,
  7265. .send_lphb_config_udp_params_cmd = send_lphb_config_udp_params_cmd_tlv,
  7266. .send_lphb_config_udp_pkt_filter_cmd =
  7267. send_lphb_config_udp_pkt_filter_cmd_tlv,
  7268. .send_process_dhcp_ind_cmd = send_process_dhcp_ind_cmd_tlv,
  7269. .send_get_link_speed_cmd = send_get_link_speed_cmd_tlv,
  7270. .send_egap_conf_params_cmd = send_egap_conf_params_cmd_tlv,
  7271. .send_fw_profiling_cmd = send_fw_profiling_cmd_tlv,
  7272. .send_csa_offload_enable_cmd = send_csa_offload_enable_cmd_tlv,
  7273. .send_wow_sta_ra_filter_cmd = send_wow_sta_ra_filter_cmd_tlv,
  7274. .send_nat_keepalive_en_cmd = send_nat_keepalive_en_cmd_tlv,
  7275. .send_start_oem_data_cmd = send_start_oem_data_cmd_tlv,
  7276. .send_dfs_phyerr_filter_offload_en_cmd =
  7277. send_dfs_phyerr_filter_offload_en_cmd_tlv,
  7278. .send_pktlog_wmi_send_cmd = send_pktlog_wmi_send_cmd_tlv,
  7279. .send_add_wow_wakeup_event_cmd = send_add_wow_wakeup_event_cmd_tlv,
  7280. .send_wow_patterns_to_fw_cmd = send_wow_patterns_to_fw_cmd_tlv,
  7281. .send_wow_delete_pattern_cmd = send_wow_delete_pattern_cmd_tlv,
  7282. .send_host_wakeup_ind_to_fw_cmd = send_host_wakeup_ind_to_fw_cmd_tlv,
  7283. .send_del_ts_cmd = send_del_ts_cmd_tlv,
  7284. .send_aggr_qos_cmd = send_aggr_qos_cmd_tlv,
  7285. .send_add_ts_cmd = send_add_ts_cmd_tlv,
  7286. .send_enable_disable_packet_filter_cmd =
  7287. send_enable_disable_packet_filter_cmd_tlv,
  7288. .send_config_packet_filter_cmd = send_config_packet_filter_cmd_tlv,
  7289. .send_add_clear_mcbc_filter_cmd = send_add_clear_mcbc_filter_cmd_tlv,
  7290. .send_gtk_offload_cmd = send_gtk_offload_cmd_tlv,
  7291. .send_process_gtk_offload_getinfo_cmd =
  7292. send_process_gtk_offload_getinfo_cmd_tlv,
  7293. .send_process_add_periodic_tx_ptrn_cmd =
  7294. send_process_add_periodic_tx_ptrn_cmd_tlv,
  7295. .send_process_del_periodic_tx_ptrn_cmd =
  7296. send_process_del_periodic_tx_ptrn_cmd_tlv,
  7297. .send_stats_ext_req_cmd = send_stats_ext_req_cmd_tlv,
  7298. .send_enable_ext_wow_cmd = send_enable_ext_wow_cmd_tlv,
  7299. .send_set_app_type2_params_in_fw_cmd =
  7300. send_set_app_type2_params_in_fw_cmd_tlv,
  7301. .send_set_auto_shutdown_timer_cmd =
  7302. send_set_auto_shutdown_timer_cmd_tlv,
  7303. .send_nan_req_cmd = send_nan_req_cmd_tlv,
  7304. .send_process_dhcpserver_offload_cmd =
  7305. send_process_dhcpserver_offload_cmd_tlv,
  7306. .send_set_led_flashing_cmd = send_set_led_flashing_cmd_tlv,
  7307. .send_process_ch_avoid_update_cmd =
  7308. send_process_ch_avoid_update_cmd_tlv,
  7309. .send_regdomain_info_to_fw_cmd = send_regdomain_info_to_fw_cmd_tlv,
  7310. .send_set_tdls_offchan_mode_cmd = send_set_tdls_offchan_mode_cmd_tlv,
  7311. .send_update_fw_tdls_state_cmd = send_update_fw_tdls_state_cmd_tlv,
  7312. .send_update_tdls_peer_state_cmd = send_update_tdls_peer_state_cmd_tlv,
  7313. .send_process_fw_mem_dump_cmd = send_process_fw_mem_dump_cmd_tlv,
  7314. .send_process_set_ie_info_cmd = send_process_set_ie_info_cmd_tlv,
  7315. .send_init_cmd = send_init_cmd_tlv,
  7316. .save_fw_version_cmd = save_fw_version_cmd_tlv,
  7317. .check_and_update_fw_version_cmd =
  7318. check_and_update_fw_version_cmd_tlv,
  7319. .send_saved_init_cmd = send_saved_init_cmd_tlv,
  7320. /* TODO - Add other tlv apis here */
  7321. };
  7322. /**
  7323. * wmi_get_tlv_ops() - gives pointer to wmi tlv ops
  7324. *
  7325. * Return: pointer to wmi tlv ops
  7326. */
  7327. struct wmi_ops *wmi_get_tlv_ops(void)
  7328. {
  7329. return &tlv_ops;
  7330. }