wmi_unified_tlv.c 318 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814381538163817381838193820382138223823382438253826382738283829383038313832383338343835383638373838383938403841384238433844384538463847384838493850385138523853385438553856385738583859386038613862386338643865386638673868386938703871387238733874387538763877387838793880388138823883388438853886388738883889389038913892389338943895389638973898389939003901390239033904390539063907390839093910391139123913391439153916391739183919392039213922392339243925392639273928392939303931393239333934393539363937393839393940394139423943394439453946394739483949395039513952395339543955395639573958395939603961396239633964396539663967396839693970397139723973397439753976397739783979398039813982398339843985398639873988398939903991399239933994399539963997399839994000400140024003400440054006400740084009401040114012401340144015401640174018401940204021402240234024402540264027402840294030403140324033403440354036403740384039404040414042404340444045404640474048404940504051405240534054405540564057405840594060406140624063406440654066406740684069407040714072407340744075407640774078407940804081408240834084408540864087408840894090409140924093409440954096409740984099410041014102410341044105410641074108410941104111411241134114411541164117411841194120412141224123412441254126412741284129413041314132413341344135413641374138413941404141414241434144414541464147414841494150415141524153415441554156415741584159416041614162416341644165416641674168416941704171417241734174417541764177417841794180418141824183418441854186418741884189419041914192419341944195419641974198419942004201420242034204420542064207420842094210421142124213421442154216421742184219422042214222422342244225422642274228422942304231423242334234423542364237423842394240424142424243424442454246424742484249425042514252425342544255425642574258425942604261426242634264426542664267426842694270427142724273427442754276427742784279428042814282428342844285428642874288428942904291429242934294429542964297429842994300430143024303430443054306430743084309431043114312431343144315431643174318431943204321432243234324432543264327432843294330433143324333433443354336433743384339434043414342434343444345434643474348434943504351435243534354435543564357435843594360436143624363436443654366436743684369437043714372437343744375437643774378437943804381438243834384438543864387438843894390439143924393439443954396439743984399440044014402440344044405440644074408440944104411441244134414441544164417441844194420442144224423442444254426442744284429443044314432443344344435443644374438443944404441444244434444444544464447444844494450445144524453445444554456445744584459446044614462446344644465446644674468446944704471447244734474447544764477447844794480448144824483448444854486448744884489449044914492449344944495449644974498449945004501450245034504450545064507450845094510451145124513451445154516451745184519452045214522452345244525452645274528452945304531453245334534453545364537453845394540454145424543454445454546454745484549455045514552455345544555455645574558455945604561456245634564456545664567456845694570457145724573457445754576457745784579458045814582458345844585458645874588458945904591459245934594459545964597459845994600460146024603460446054606460746084609461046114612461346144615461646174618461946204621462246234624462546264627462846294630463146324633463446354636463746384639464046414642464346444645464646474648464946504651465246534654465546564657465846594660466146624663466446654666466746684669467046714672467346744675467646774678467946804681468246834684468546864687468846894690469146924693469446954696469746984699470047014702470347044705470647074708470947104711471247134714471547164717471847194720472147224723472447254726472747284729473047314732473347344735473647374738473947404741474247434744474547464747474847494750475147524753475447554756475747584759476047614762476347644765476647674768476947704771477247734774477547764777477847794780478147824783478447854786478747884789479047914792479347944795479647974798479948004801480248034804480548064807480848094810481148124813481448154816481748184819482048214822482348244825482648274828482948304831483248334834483548364837483848394840484148424843484448454846484748484849485048514852485348544855485648574858485948604861486248634864486548664867486848694870487148724873487448754876487748784879488048814882488348844885488648874888488948904891489248934894489548964897489848994900490149024903490449054906490749084909491049114912491349144915491649174918491949204921492249234924492549264927492849294930493149324933493449354936493749384939494049414942494349444945494649474948494949504951495249534954495549564957495849594960496149624963496449654966496749684969497049714972497349744975497649774978497949804981498249834984498549864987498849894990499149924993499449954996499749984999500050015002500350045005500650075008500950105011501250135014501550165017501850195020502150225023502450255026502750285029503050315032503350345035503650375038503950405041504250435044504550465047504850495050505150525053505450555056505750585059506050615062506350645065506650675068506950705071507250735074507550765077507850795080508150825083508450855086508750885089509050915092509350945095509650975098509951005101510251035104510551065107510851095110511151125113511451155116511751185119512051215122512351245125512651275128512951305131513251335134513551365137513851395140514151425143514451455146514751485149515051515152515351545155515651575158515951605161516251635164516551665167516851695170517151725173517451755176517751785179518051815182518351845185518651875188518951905191519251935194519551965197519851995200520152025203520452055206520752085209521052115212521352145215521652175218521952205221522252235224522552265227522852295230523152325233523452355236523752385239524052415242524352445245524652475248524952505251525252535254525552565257525852595260526152625263526452655266526752685269527052715272527352745275527652775278527952805281528252835284528552865287528852895290529152925293529452955296529752985299530053015302530353045305530653075308530953105311531253135314531553165317531853195320532153225323532453255326532753285329533053315332533353345335533653375338533953405341534253435344534553465347534853495350535153525353535453555356535753585359536053615362536353645365536653675368536953705371537253735374537553765377537853795380538153825383538453855386538753885389539053915392539353945395539653975398539954005401540254035404540554065407540854095410541154125413541454155416541754185419542054215422542354245425542654275428542954305431543254335434543554365437543854395440544154425443544454455446544754485449545054515452545354545455545654575458545954605461546254635464546554665467546854695470547154725473547454755476547754785479548054815482548354845485548654875488548954905491549254935494549554965497549854995500550155025503550455055506550755085509551055115512551355145515551655175518551955205521552255235524552555265527552855295530553155325533553455355536553755385539554055415542554355445545554655475548554955505551555255535554555555565557555855595560556155625563556455655566556755685569557055715572557355745575557655775578557955805581558255835584558555865587558855895590559155925593559455955596559755985599560056015602560356045605560656075608560956105611561256135614561556165617561856195620562156225623562456255626562756285629563056315632563356345635563656375638563956405641564256435644564556465647564856495650565156525653565456555656565756585659566056615662566356645665566656675668566956705671567256735674567556765677567856795680568156825683568456855686568756885689569056915692569356945695569656975698569957005701570257035704570557065707570857095710571157125713571457155716571757185719572057215722572357245725572657275728572957305731573257335734573557365737573857395740574157425743574457455746574757485749575057515752575357545755575657575758575957605761576257635764576557665767576857695770577157725773577457755776577757785779578057815782578357845785578657875788578957905791579257935794579557965797579857995800580158025803580458055806580758085809581058115812581358145815581658175818581958205821582258235824582558265827582858295830583158325833583458355836583758385839584058415842584358445845584658475848584958505851585258535854585558565857585858595860586158625863586458655866586758685869587058715872587358745875587658775878587958805881588258835884588558865887588858895890589158925893589458955896589758985899590059015902590359045905590659075908590959105911591259135914591559165917591859195920592159225923592459255926592759285929593059315932593359345935593659375938593959405941594259435944594559465947594859495950595159525953595459555956595759585959596059615962596359645965596659675968596959705971597259735974597559765977597859795980598159825983598459855986598759885989599059915992599359945995599659975998599960006001600260036004600560066007600860096010601160126013601460156016601760186019602060216022602360246025602660276028602960306031603260336034603560366037603860396040604160426043604460456046604760486049605060516052605360546055605660576058605960606061606260636064606560666067606860696070607160726073607460756076607760786079608060816082608360846085608660876088608960906091609260936094609560966097609860996100610161026103610461056106610761086109611061116112611361146115611661176118611961206121612261236124612561266127612861296130613161326133613461356136613761386139614061416142614361446145614661476148614961506151615261536154615561566157615861596160616161626163616461656166616761686169617061716172617361746175617661776178617961806181618261836184618561866187618861896190619161926193619461956196619761986199620062016202620362046205620662076208620962106211621262136214621562166217621862196220622162226223622462256226622762286229623062316232623362346235623662376238623962406241624262436244624562466247624862496250625162526253625462556256625762586259626062616262626362646265626662676268626962706271627262736274627562766277627862796280628162826283628462856286628762886289629062916292629362946295629662976298629963006301630263036304630563066307630863096310631163126313631463156316631763186319632063216322632363246325632663276328632963306331633263336334633563366337633863396340634163426343634463456346634763486349635063516352635363546355635663576358635963606361636263636364636563666367636863696370637163726373637463756376637763786379638063816382638363846385638663876388638963906391639263936394639563966397639863996400640164026403640464056406640764086409641064116412641364146415641664176418641964206421642264236424642564266427642864296430643164326433643464356436643764386439644064416442644364446445644664476448644964506451645264536454645564566457645864596460646164626463646464656466646764686469647064716472647364746475647664776478647964806481648264836484648564866487648864896490649164926493649464956496649764986499650065016502650365046505650665076508650965106511651265136514651565166517651865196520652165226523652465256526652765286529653065316532653365346535653665376538653965406541654265436544654565466547654865496550655165526553655465556556655765586559656065616562656365646565656665676568656965706571657265736574657565766577657865796580658165826583658465856586658765886589659065916592659365946595659665976598659966006601660266036604660566066607660866096610661166126613661466156616661766186619662066216622662366246625662666276628662966306631663266336634663566366637663866396640664166426643664466456646664766486649665066516652665366546655665666576658665966606661666266636664666566666667666866696670667166726673667466756676667766786679668066816682668366846685668666876688668966906691669266936694669566966697669866996700670167026703670467056706670767086709671067116712671367146715671667176718671967206721672267236724672567266727672867296730673167326733673467356736673767386739674067416742674367446745674667476748674967506751675267536754675567566757675867596760676167626763676467656766676767686769677067716772677367746775677667776778677967806781678267836784678567866787678867896790679167926793679467956796679767986799680068016802680368046805680668076808680968106811681268136814681568166817681868196820682168226823682468256826682768286829683068316832683368346835683668376838683968406841684268436844684568466847684868496850685168526853685468556856685768586859686068616862686368646865686668676868686968706871687268736874687568766877687868796880688168826883688468856886688768886889689068916892689368946895689668976898689969006901690269036904690569066907690869096910691169126913691469156916691769186919692069216922692369246925692669276928692969306931693269336934693569366937693869396940694169426943694469456946694769486949695069516952695369546955695669576958695969606961696269636964696569666967696869696970697169726973697469756976697769786979698069816982698369846985698669876988698969906991699269936994699569966997699869997000700170027003700470057006700770087009701070117012701370147015701670177018701970207021702270237024702570267027702870297030703170327033703470357036703770387039704070417042704370447045704670477048704970507051705270537054705570567057705870597060706170627063706470657066706770687069707070717072707370747075707670777078707970807081708270837084708570867087708870897090709170927093709470957096709770987099710071017102710371047105710671077108710971107111711271137114711571167117711871197120712171227123712471257126712771287129713071317132713371347135713671377138713971407141714271437144714571467147714871497150715171527153715471557156715771587159716071617162716371647165716671677168716971707171717271737174717571767177717871797180718171827183718471857186718771887189719071917192719371947195719671977198719972007201720272037204720572067207720872097210721172127213721472157216721772187219722072217222722372247225722672277228722972307231723272337234723572367237723872397240724172427243724472457246724772487249725072517252725372547255725672577258725972607261726272637264726572667267726872697270727172727273727472757276727772787279728072817282728372847285728672877288728972907291729272937294729572967297729872997300730173027303730473057306730773087309731073117312731373147315731673177318731973207321732273237324732573267327732873297330733173327333733473357336733773387339734073417342734373447345734673477348734973507351735273537354735573567357735873597360736173627363736473657366736773687369737073717372737373747375737673777378737973807381738273837384738573867387738873897390739173927393739473957396739773987399740074017402740374047405740674077408740974107411741274137414741574167417741874197420742174227423742474257426742774287429743074317432743374347435743674377438743974407441744274437444744574467447744874497450745174527453745474557456745774587459746074617462746374647465746674677468746974707471747274737474747574767477747874797480748174827483748474857486748774887489749074917492749374947495749674977498749975007501750275037504750575067507750875097510751175127513751475157516751775187519752075217522752375247525752675277528752975307531753275337534753575367537753875397540754175427543754475457546754775487549755075517552755375547555755675577558755975607561756275637564756575667567756875697570757175727573757475757576757775787579758075817582758375847585758675877588758975907591759275937594759575967597759875997600760176027603760476057606760776087609761076117612761376147615761676177618761976207621762276237624762576267627762876297630763176327633763476357636763776387639764076417642764376447645764676477648764976507651765276537654765576567657765876597660766176627663766476657666766776687669767076717672767376747675767676777678767976807681768276837684768576867687768876897690769176927693769476957696769776987699770077017702770377047705770677077708770977107711771277137714771577167717771877197720772177227723772477257726772777287729773077317732773377347735773677377738773977407741774277437744774577467747774877497750775177527753775477557756775777587759776077617762776377647765776677677768776977707771777277737774777577767777777877797780778177827783778477857786778777887789779077917792779377947795779677977798779978007801780278037804780578067807780878097810781178127813781478157816781778187819782078217822782378247825782678277828782978307831783278337834783578367837783878397840784178427843784478457846784778487849785078517852785378547855785678577858785978607861786278637864786578667867786878697870787178727873787478757876787778787879788078817882788378847885788678877888788978907891789278937894789578967897789878997900790179027903790479057906790779087909791079117912791379147915791679177918791979207921792279237924792579267927792879297930793179327933793479357936793779387939794079417942794379447945794679477948794979507951795279537954795579567957795879597960796179627963796479657966796779687969797079717972797379747975797679777978797979807981798279837984798579867987798879897990799179927993799479957996799779987999800080018002800380048005800680078008800980108011801280138014801580168017801880198020802180228023802480258026802780288029803080318032803380348035803680378038803980408041804280438044804580468047804880498050805180528053805480558056805780588059806080618062806380648065806680678068806980708071807280738074807580768077807880798080808180828083808480858086808780888089809080918092809380948095809680978098809981008101810281038104810581068107810881098110811181128113811481158116811781188119812081218122812381248125812681278128812981308131813281338134813581368137813881398140814181428143814481458146814781488149815081518152815381548155815681578158815981608161816281638164816581668167816881698170817181728173817481758176817781788179818081818182818381848185818681878188818981908191819281938194819581968197819881998200820182028203820482058206820782088209821082118212821382148215821682178218821982208221822282238224822582268227822882298230823182328233823482358236823782388239824082418242824382448245824682478248824982508251825282538254825582568257825882598260826182628263826482658266826782688269827082718272827382748275827682778278827982808281828282838284828582868287828882898290829182928293829482958296829782988299830083018302830383048305830683078308830983108311831283138314831583168317831883198320832183228323832483258326832783288329833083318332833383348335833683378338833983408341834283438344834583468347834883498350835183528353835483558356835783588359836083618362836383648365836683678368836983708371837283738374837583768377837883798380838183828383838483858386838783888389839083918392839383948395839683978398839984008401840284038404840584068407840884098410841184128413841484158416841784188419842084218422842384248425842684278428842984308431843284338434843584368437843884398440844184428443844484458446844784488449845084518452845384548455845684578458845984608461846284638464846584668467846884698470847184728473847484758476847784788479848084818482848384848485848684878488848984908491849284938494849584968497849884998500850185028503850485058506850785088509851085118512851385148515851685178518851985208521852285238524852585268527852885298530853185328533853485358536853785388539854085418542854385448545854685478548854985508551855285538554855585568557855885598560856185628563856485658566856785688569857085718572857385748575857685778578857985808581858285838584858585868587858885898590859185928593859485958596859785988599860086018602860386048605860686078608860986108611861286138614861586168617861886198620862186228623862486258626862786288629863086318632863386348635863686378638863986408641864286438644864586468647864886498650865186528653865486558656865786588659866086618662866386648665866686678668866986708671867286738674867586768677867886798680868186828683868486858686868786888689869086918692869386948695869686978698869987008701870287038704870587068707870887098710871187128713871487158716871787188719872087218722872387248725872687278728872987308731873287338734873587368737873887398740874187428743874487458746874787488749875087518752875387548755875687578758875987608761876287638764876587668767876887698770877187728773877487758776877787788779878087818782878387848785878687878788878987908791879287938794879587968797879887998800880188028803880488058806880788088809881088118812881388148815881688178818881988208821882288238824882588268827882888298830883188328833883488358836883788388839884088418842884388448845884688478848884988508851885288538854885588568857885888598860886188628863886488658866886788688869887088718872887388748875887688778878887988808881888288838884888588868887888888898890889188928893889488958896889788988899890089018902890389048905890689078908890989108911891289138914891589168917891889198920892189228923892489258926892789288929893089318932893389348935893689378938893989408941894289438944894589468947894889498950895189528953895489558956895789588959896089618962896389648965896689678968896989708971897289738974897589768977897889798980898189828983898489858986898789888989899089918992899389948995899689978998899990009001900290039004900590069007900890099010901190129013901490159016901790189019902090219022902390249025902690279028902990309031903290339034903590369037903890399040904190429043904490459046904790489049905090519052905390549055905690579058905990609061906290639064906590669067906890699070907190729073907490759076907790789079908090819082908390849085908690879088908990909091909290939094909590969097909890999100910191029103910491059106910791089109911091119112911391149115911691179118911991209121912291239124912591269127912891299130913191329133913491359136913791389139914091419142914391449145914691479148914991509151915291539154915591569157915891599160916191629163916491659166916791689169917091719172917391749175917691779178917991809181918291839184918591869187918891899190919191929193919491959196919791989199920092019202920392049205920692079208920992109211921292139214921592169217921892199220922192229223922492259226922792289229923092319232923392349235923692379238923992409241924292439244924592469247924892499250925192529253925492559256925792589259926092619262926392649265926692679268926992709271927292739274927592769277927892799280928192829283928492859286928792889289929092919292929392949295929692979298929993009301930293039304930593069307930893099310931193129313931493159316931793189319932093219322932393249325932693279328932993309331933293339334933593369337933893399340934193429343934493459346934793489349935093519352935393549355935693579358935993609361936293639364936593669367936893699370937193729373937493759376937793789379938093819382938393849385938693879388938993909391939293939394939593969397939893999400940194029403940494059406940794089409941094119412941394149415941694179418941994209421942294239424942594269427942894299430943194329433943494359436943794389439944094419442944394449445944694479448944994509451945294539454945594569457945894599460946194629463946494659466946794689469947094719472947394749475947694779478947994809481948294839484948594869487948894899490949194929493949494959496949794989499950095019502950395049505950695079508950995109511951295139514951595169517951895199520952195229523952495259526952795289529953095319532953395349535953695379538953995409541954295439544954595469547954895499550955195529553955495559556955795589559956095619562956395649565956695679568956995709571957295739574957595769577957895799580958195829583958495859586958795889589959095919592959395949595959695979598959996009601960296039604960596069607960896099610961196129613961496159616961796189619962096219622962396249625962696279628962996309631963296339634963596369637963896399640964196429643964496459646964796489649965096519652965396549655965696579658965996609661966296639664966596669667966896699670967196729673967496759676967796789679968096819682968396849685968696879688968996909691969296939694969596969697969896999700970197029703970497059706970797089709971097119712971397149715971697179718971997209721972297239724972597269727972897299730973197329733973497359736973797389739974097419742974397449745974697479748974997509751975297539754975597569757975897599760976197629763976497659766976797689769977097719772977397749775977697779778977997809781978297839784978597869787978897899790979197929793979497959796979797989799980098019802980398049805980698079808980998109811981298139814981598169817981898199820982198229823982498259826982798289829983098319832983398349835983698379838983998409841984298439844984598469847984898499850985198529853985498559856985798589859986098619862986398649865986698679868986998709871987298739874987598769877987898799880988198829883988498859886988798889889989098919892989398949895989698979898989999009901990299039904990599069907990899099910991199129913991499159916991799189919992099219922992399249925992699279928992999309931993299339934993599369937993899399940994199429943994499459946994799489949995099519952995399549955995699579958995999609961996299639964996599669967996899699970997199729973997499759976997799789979998099819982998399849985998699879988998999909991999299939994999599969997999899991000010001100021000310004100051000610007100081000910010100111001210013100141001510016100171001810019100201002110022100231002410025100261002710028100291003010031100321003310034100351003610037100381003910040100411004210043100441004510046100471004810049100501005110052100531005410055100561005710058100591006010061100621006310064100651006610067100681006910070100711007210073100741007510076100771007810079100801008110082100831008410085100861008710088100891009010091100921009310094100951009610097100981009910100101011010210103101041010510106101071010810109101101011110112101131011410115101161011710118101191012010121101221012310124101251012610127101281012910130101311013210133101341013510136101371013810139101401014110142101431014410145101461014710148101491015010151101521015310154101551015610157101581015910160101611016210163101641016510166101671016810169101701017110172101731017410175101761017710178101791018010181101821018310184101851018610187101881018910190101911019210193101941019510196101971019810199102001020110202102031020410205102061020710208102091021010211102121021310214102151021610217102181021910220102211022210223102241022510226102271022810229102301023110232102331023410235102361023710238102391024010241102421024310244102451024610247102481024910250102511025210253102541025510256102571025810259102601026110262102631026410265102661026710268102691027010271102721027310274102751027610277102781027910280102811028210283102841028510286102871028810289102901029110292102931029410295102961029710298102991030010301103021030310304103051030610307103081030910310103111031210313103141031510316103171031810319103201032110322103231032410325103261032710328103291033010331103321033310334103351033610337103381033910340103411034210343103441034510346103471034810349103501035110352103531035410355103561035710358103591036010361103621036310364103651036610367103681036910370103711037210373103741037510376103771037810379103801038110382103831038410385103861038710388103891039010391103921039310394103951039610397103981039910400104011040210403104041040510406104071040810409104101041110412104131041410415104161041710418104191042010421104221042310424104251042610427104281042910430104311043210433104341043510436104371043810439104401044110442104431044410445104461044710448104491045010451104521045310454104551045610457104581045910460104611046210463104641046510466104671046810469104701047110472104731047410475104761047710478104791048010481104821048310484104851048610487104881048910490104911049210493104941049510496104971049810499105001050110502105031050410505105061050710508
  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. #include "wmi_version_whitelist.h"
  33. /**
  34. * send_vdev_create_cmd_tlv() - send VDEV create command to fw
  35. * @wmi_handle: wmi handle
  36. * @param: pointer to hold vdev create parameter
  37. * @macaddr: vdev mac address
  38. *
  39. * Return: 0 for success or error code
  40. */
  41. QDF_STATUS send_vdev_create_cmd_tlv(wmi_unified_t wmi_handle,
  42. uint8_t macaddr[IEEE80211_ADDR_LEN],
  43. struct vdev_create_params *param)
  44. {
  45. wmi_vdev_create_cmd_fixed_param *cmd;
  46. wmi_buf_t buf;
  47. int32_t len = sizeof(*cmd);
  48. int32_t ret;
  49. buf = wmi_buf_alloc(wmi_handle, len);
  50. if (!buf) {
  51. WMI_LOGP("%s:wmi_buf_alloc failed", __func__);
  52. return -ENOMEM;
  53. }
  54. cmd = (wmi_vdev_create_cmd_fixed_param *) wmi_buf_data(buf);
  55. WMITLV_SET_HDR(&cmd->tlv_header,
  56. WMITLV_TAG_STRUC_wmi_vdev_create_cmd_fixed_param,
  57. WMITLV_GET_STRUCT_TLVLEN
  58. (wmi_vdev_create_cmd_fixed_param));
  59. cmd->vdev_id = param->if_id;
  60. cmd->vdev_type = param->type;
  61. cmd->vdev_subtype = param->subtype;
  62. WMI_CHAR_ARRAY_TO_MAC_ADDR(macaddr, &cmd->vdev_macaddr);
  63. WMI_LOGD("%s: ID = %d VAP Addr = %02x:%02x:%02x:%02x:%02x:%02x",
  64. __func__, param->if_id,
  65. macaddr[0], macaddr[1], macaddr[2],
  66. macaddr[3], macaddr[4], macaddr[5]);
  67. ret = wmi_unified_cmd_send(wmi_handle, buf, len, WMI_VDEV_CREATE_CMDID);
  68. if (ret != EOK) {
  69. WMI_LOGE("Failed to send WMI_VDEV_CREATE_CMDID");
  70. wmi_buf_free(buf);
  71. }
  72. return ret;
  73. }
  74. /**
  75. * send_vdev_delete_cmd_tlv() - send VDEV delete command to fw
  76. * @wmi_handle: wmi handle
  77. * @if_id: vdev id
  78. *
  79. * Return: 0 for success or error code
  80. */
  81. QDF_STATUS send_vdev_delete_cmd_tlv(wmi_unified_t wmi_handle,
  82. uint8_t if_id)
  83. {
  84. wmi_vdev_delete_cmd_fixed_param *cmd;
  85. wmi_buf_t buf;
  86. int32_t ret;
  87. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  88. if (!buf) {
  89. WMI_LOGP("%s:wmi_buf_alloc failed", __func__);
  90. return -ENOMEM;
  91. }
  92. cmd = (wmi_vdev_delete_cmd_fixed_param *) wmi_buf_data(buf);
  93. WMITLV_SET_HDR(&cmd->tlv_header,
  94. WMITLV_TAG_STRUC_wmi_vdev_delete_cmd_fixed_param,
  95. WMITLV_GET_STRUCT_TLVLEN
  96. (wmi_vdev_delete_cmd_fixed_param));
  97. cmd->vdev_id = if_id;
  98. ret = wmi_unified_cmd_send(wmi_handle, buf,
  99. sizeof(wmi_vdev_delete_cmd_fixed_param),
  100. WMI_VDEV_DELETE_CMDID);
  101. if (ret != EOK) {
  102. WMI_LOGE("Failed to send WMI_VDEV_DELETE_CMDID");
  103. wmi_buf_free(buf);
  104. }
  105. WMI_LOGD("%s:vdev id = %d", __func__, if_id);
  106. return ret;
  107. }
  108. /**
  109. * send_vdev_stop_cmd_tlv() - send vdev stop command to fw
  110. * @wmi: wmi handle
  111. * @vdev_id: vdev id
  112. *
  113. * Return: 0 for success or erro code
  114. */
  115. QDF_STATUS send_vdev_stop_cmd_tlv(wmi_unified_t wmi,
  116. uint8_t vdev_id)
  117. {
  118. wmi_vdev_stop_cmd_fixed_param *cmd;
  119. wmi_buf_t buf;
  120. int32_t len = sizeof(*cmd);
  121. buf = wmi_buf_alloc(wmi, len);
  122. if (!buf) {
  123. WMI_LOGP("%s : wmi_buf_alloc failed", __func__);
  124. return -ENOMEM;
  125. }
  126. cmd = (wmi_vdev_stop_cmd_fixed_param *) wmi_buf_data(buf);
  127. WMITLV_SET_HDR(&cmd->tlv_header,
  128. WMITLV_TAG_STRUC_wmi_vdev_stop_cmd_fixed_param,
  129. WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_stop_cmd_fixed_param));
  130. cmd->vdev_id = vdev_id;
  131. if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_STOP_CMDID)) {
  132. WMI_LOGP("%s: Failed to send vdev stop command", __func__);
  133. qdf_nbuf_free(buf);
  134. return -EIO;
  135. }
  136. return 0;
  137. }
  138. /**
  139. * send_vdev_down_cmd_tlv() - send vdev down command to fw
  140. * @wmi: wmi handle
  141. * @vdev_id: vdev id
  142. *
  143. * Return: 0 for success or error code
  144. */
  145. QDF_STATUS send_vdev_down_cmd_tlv(wmi_unified_t wmi, uint8_t vdev_id)
  146. {
  147. wmi_vdev_down_cmd_fixed_param *cmd;
  148. wmi_buf_t buf;
  149. int32_t len = sizeof(*cmd);
  150. buf = wmi_buf_alloc(wmi, len);
  151. if (!buf) {
  152. WMI_LOGP("%s : wmi_buf_alloc failed", __func__);
  153. return -ENOMEM;
  154. }
  155. cmd = (wmi_vdev_down_cmd_fixed_param *) wmi_buf_data(buf);
  156. WMITLV_SET_HDR(&cmd->tlv_header,
  157. WMITLV_TAG_STRUC_wmi_vdev_down_cmd_fixed_param,
  158. WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_down_cmd_fixed_param));
  159. cmd->vdev_id = vdev_id;
  160. if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_DOWN_CMDID)) {
  161. WMI_LOGP("%s: Failed to send vdev down", __func__);
  162. qdf_nbuf_free(buf);
  163. return -EIO;
  164. }
  165. WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
  166. return 0;
  167. }
  168. /**
  169. * send_vdev_start_cmd_tlv() - send vdev start request to fw
  170. * @wmi_handle: wmi handle
  171. * @req: vdev start params
  172. *
  173. * Return: QDF status
  174. */
  175. QDF_STATUS send_vdev_start_cmd_tlv(wmi_unified_t wmi_handle,
  176. struct vdev_start_params *req)
  177. {
  178. wmi_vdev_start_request_cmd_fixed_param *cmd;
  179. wmi_buf_t buf;
  180. wmi_channel *chan;
  181. int32_t len, ret;
  182. uint8_t *buf_ptr;
  183. len = sizeof(*cmd) + sizeof(wmi_channel) + WMI_TLV_HDR_SIZE;
  184. buf = wmi_buf_alloc(wmi_handle, len);
  185. if (!buf) {
  186. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  187. return QDF_STATUS_E_NOMEM;
  188. }
  189. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  190. cmd = (wmi_vdev_start_request_cmd_fixed_param *) buf_ptr;
  191. chan = (wmi_channel *) (buf_ptr + sizeof(*cmd));
  192. WMITLV_SET_HDR(&cmd->tlv_header,
  193. WMITLV_TAG_STRUC_wmi_vdev_start_request_cmd_fixed_param,
  194. WMITLV_GET_STRUCT_TLVLEN
  195. (wmi_vdev_start_request_cmd_fixed_param));
  196. WMITLV_SET_HDR(&chan->tlv_header, WMITLV_TAG_STRUC_wmi_channel,
  197. WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
  198. cmd->vdev_id = req->vdev_id;
  199. /* Fill channel info */
  200. chan->mhz = req->chan_freq;
  201. WMI_SET_CHANNEL_MODE(chan, req->chan_mode);
  202. chan->band_center_freq1 = req->band_center_freq1;
  203. chan->band_center_freq2 = req->band_center_freq2;
  204. if (req->is_half_rate)
  205. WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_HALF_RATE);
  206. else if (req->is_quarter_rate)
  207. WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_QUARTER_RATE);
  208. if (req->is_dfs) {
  209. WMI_SET_CHANNEL_FLAG(chan, req->flag_dfs);
  210. cmd->disable_hw_ack = req->dis_hw_ack;
  211. }
  212. cmd->beacon_interval = req->beacon_intval;
  213. cmd->dtim_period = req->dtim_period;
  214. /* FIXME: Find out min, max and regulatory power levels */
  215. WMI_SET_CHANNEL_REG_POWER(chan, req->max_txpow);
  216. WMI_SET_CHANNEL_MAX_TX_POWER(chan, req->max_txpow);
  217. if (!req->is_restart) {
  218. cmd->beacon_interval = req->beacon_intval;
  219. cmd->dtim_period = req->dtim_period;
  220. /* Copy the SSID */
  221. if (req->ssid.length) {
  222. if (req->ssid.length < sizeof(cmd->ssid.ssid))
  223. cmd->ssid.ssid_len = req->ssid.length;
  224. else
  225. cmd->ssid.ssid_len = sizeof(cmd->ssid.ssid);
  226. qdf_mem_copy(cmd->ssid.ssid, req->ssid.mac_ssid,
  227. cmd->ssid.ssid_len);
  228. }
  229. if (req->hidden_ssid)
  230. cmd->flags |= WMI_UNIFIED_VDEV_START_HIDDEN_SSID;
  231. if (req->pmf_enabled)
  232. cmd->flags |= WMI_UNIFIED_VDEV_START_PMF_ENABLED;
  233. }
  234. cmd->num_noa_descriptors = req->num_noa_descriptors;
  235. cmd->preferred_rx_streams = req->preferred_rx_streams;
  236. cmd->preferred_tx_streams = req->preferred_tx_streams;
  237. buf_ptr = (uint8_t *) (((uintptr_t) cmd) + sizeof(*cmd) +
  238. sizeof(wmi_channel));
  239. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  240. cmd->num_noa_descriptors *
  241. sizeof(wmi_p2p_noa_descriptor));
  242. WMI_LOGA("\n%s: vdev_id %d freq %d chanmode %d is_dfs %d "
  243. "beacon interval %d dtim %d center_chan %d center_freq2 %d "
  244. "reg_info_1: 0x%x reg_info_2: 0x%x, req->max_txpow: 0x%x "
  245. "Tx SS %d, Rx SS %d",
  246. __func__, req->vdev_id, chan->mhz, req->chan_mode,
  247. req->is_dfs, req->beacon_intval, cmd->dtim_period,
  248. chan->band_center_freq1, chan->band_center_freq2,
  249. chan->reg_info_1, chan->reg_info_2, req->max_txpow,
  250. req->preferred_tx_streams, req->preferred_rx_streams);
  251. if (req->is_restart)
  252. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  253. WMI_VDEV_RESTART_REQUEST_CMDID);
  254. else
  255. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  256. WMI_VDEV_START_REQUEST_CMDID);
  257. if (ret) {
  258. WMI_LOGP("%s: Failed to send vdev start command", __func__);
  259. qdf_nbuf_free(buf);
  260. return QDF_STATUS_E_FAILURE;
  261. }
  262. return QDF_STATUS_SUCCESS;
  263. }
  264. /**
  265. * send_hidden_ssid_vdev_restart_cmd_tlv() - restart vdev to set hidden ssid
  266. * @wmi_handle: wmi handle
  267. * @restart_params: vdev restart params
  268. *
  269. * Return: 0 for success or error code
  270. */
  271. QDF_STATUS send_hidden_ssid_vdev_restart_cmd_tlv(wmi_unified_t wmi_handle,
  272. struct hidden_ssid_vdev_restart_params *restart_params)
  273. {
  274. wmi_vdev_start_request_cmd_fixed_param *cmd;
  275. wmi_buf_t buf;
  276. wmi_channel *chan;
  277. int32_t len;
  278. uint8_t *buf_ptr;
  279. int32_t ret = 0;
  280. len = sizeof(*cmd) + sizeof(wmi_channel) + WMI_TLV_HDR_SIZE;
  281. buf = wmi_buf_alloc(wmi_handle, len);
  282. if (!buf) {
  283. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  284. return QDF_STATUS_E_NOMEM;
  285. }
  286. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  287. cmd = (wmi_vdev_start_request_cmd_fixed_param *) buf_ptr;
  288. chan = (wmi_channel *) (buf_ptr + sizeof(*cmd));
  289. WMITLV_SET_HDR(&cmd->tlv_header,
  290. WMITLV_TAG_STRUC_wmi_vdev_start_request_cmd_fixed_param,
  291. WMITLV_GET_STRUCT_TLVLEN
  292. (wmi_vdev_start_request_cmd_fixed_param));
  293. WMITLV_SET_HDR(&chan->tlv_header,
  294. WMITLV_TAG_STRUC_wmi_channel,
  295. WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
  296. cmd->vdev_id = restart_params->session_id;
  297. cmd->ssid.ssid_len = restart_params->ssid_len;
  298. qdf_mem_copy(cmd->ssid.ssid,
  299. restart_params->ssid,
  300. cmd->ssid.ssid_len);
  301. cmd->flags = restart_params->flags;
  302. cmd->requestor_id = restart_params->requestor_id;
  303. cmd->disable_hw_ack = restart_params->disable_hw_ack;
  304. chan->mhz = restart_params->mhz;
  305. chan->band_center_freq1 =
  306. restart_params->band_center_freq1;
  307. chan->band_center_freq2 =
  308. restart_params->band_center_freq2;
  309. chan->info = restart_params->info;
  310. chan->reg_info_1 = restart_params->reg_info_1;
  311. chan->reg_info_2 = restart_params->reg_info_2;
  312. cmd->num_noa_descriptors = 0;
  313. buf_ptr = (uint8_t *) (((uint8_t *) cmd) + sizeof(*cmd) +
  314. sizeof(wmi_channel));
  315. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  316. cmd->num_noa_descriptors *
  317. sizeof(wmi_p2p_noa_descriptor));
  318. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  319. WMI_VDEV_RESTART_REQUEST_CMDID);
  320. if (ret < 0) {
  321. wmi_buf_free(buf);
  322. return QDF_STATUS_E_FAILURE;
  323. }
  324. return QDF_STATUS_SUCCESS;
  325. }
  326. /**
  327. * send_peer_flush_tids_cmd_tlv() - flush peer tids packets in fw
  328. * @wmi: wmi handle
  329. * @peer_addr: peer mac address
  330. * @param: pointer to hold peer flush tid parameter
  331. *
  332. * Return: 0 for sucess or error code
  333. */
  334. QDF_STATUS send_peer_flush_tids_cmd_tlv(wmi_unified_t wmi,
  335. uint8_t peer_addr[IEEE80211_ADDR_LEN],
  336. struct peer_flush_params *param)
  337. {
  338. wmi_peer_flush_tids_cmd_fixed_param *cmd;
  339. wmi_buf_t buf;
  340. int32_t len = sizeof(*cmd);
  341. buf = wmi_buf_alloc(wmi, len);
  342. if (!buf) {
  343. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  344. return -ENOMEM;
  345. }
  346. cmd = (wmi_peer_flush_tids_cmd_fixed_param *) wmi_buf_data(buf);
  347. WMITLV_SET_HDR(&cmd->tlv_header,
  348. WMITLV_TAG_STRUC_wmi_peer_flush_tids_cmd_fixed_param,
  349. WMITLV_GET_STRUCT_TLVLEN
  350. (wmi_peer_flush_tids_cmd_fixed_param));
  351. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  352. cmd->peer_tid_bitmap = param->peer_tid_bitmap;
  353. cmd->vdev_id = param->vdev_id;
  354. WMI_LOGD("%s: peer_addr %pM vdev_id %d and peer bitmap %d", __func__,
  355. peer_addr, param->vdev_id,
  356. param->peer_tid_bitmap);
  357. if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_FLUSH_TIDS_CMDID)) {
  358. WMI_LOGP("%s: Failed to send flush tid command", __func__);
  359. qdf_nbuf_free(buf);
  360. return -EIO;
  361. }
  362. return 0;
  363. }
  364. /**
  365. * send_peer_delete_cmd_tlv() - send PEER delete command to fw
  366. * @wmi: wmi handle
  367. * @peer_addr: peer mac addr
  368. * @vdev_id: vdev id
  369. *
  370. * Return: 0 for success or error code
  371. */
  372. QDF_STATUS send_peer_delete_cmd_tlv(wmi_unified_t wmi,
  373. uint8_t peer_addr[IEEE80211_ADDR_LEN],
  374. uint8_t vdev_id)
  375. {
  376. wmi_peer_delete_cmd_fixed_param *cmd;
  377. wmi_buf_t buf;
  378. int32_t len = sizeof(*cmd);
  379. buf = wmi_buf_alloc(wmi, len);
  380. if (!buf) {
  381. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  382. return -ENOMEM;
  383. }
  384. cmd = (wmi_peer_delete_cmd_fixed_param *) wmi_buf_data(buf);
  385. WMITLV_SET_HDR(&cmd->tlv_header,
  386. WMITLV_TAG_STRUC_wmi_peer_delete_cmd_fixed_param,
  387. WMITLV_GET_STRUCT_TLVLEN
  388. (wmi_peer_delete_cmd_fixed_param));
  389. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  390. cmd->vdev_id = vdev_id;
  391. if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_DELETE_CMDID)) {
  392. WMI_LOGP("%s: Failed to send peer delete command", __func__);
  393. qdf_nbuf_free(buf);
  394. return -EIO;
  395. }
  396. WMI_LOGD("%s: peer_addr %pM vdev_id %d", __func__, peer_addr, vdev_id);
  397. return 0;
  398. }
  399. /**
  400. * send_peer_param_cmd_tlv() - set peer parameter in fw
  401. * @wmi: wmi handle
  402. * @peer_addr: peer mac address
  403. * @param : pointer to hold peer set parameter
  404. *
  405. * Return: 0 for success or error code
  406. */
  407. QDF_STATUS send_peer_param_cmd_tlv(wmi_unified_t wmi,
  408. uint8_t peer_addr[IEEE80211_ADDR_LEN],
  409. struct peer_set_params *param)
  410. {
  411. wmi_peer_set_param_cmd_fixed_param *cmd;
  412. wmi_buf_t buf;
  413. int32_t err;
  414. buf = wmi_buf_alloc(wmi, sizeof(*cmd));
  415. if (!buf) {
  416. WMI_LOGE("Failed to allocate buffer to send set_param cmd");
  417. return -ENOMEM;
  418. }
  419. cmd = (wmi_peer_set_param_cmd_fixed_param *) wmi_buf_data(buf);
  420. WMITLV_SET_HDR(&cmd->tlv_header,
  421. WMITLV_TAG_STRUC_wmi_peer_set_param_cmd_fixed_param,
  422. WMITLV_GET_STRUCT_TLVLEN
  423. (wmi_peer_set_param_cmd_fixed_param));
  424. cmd->vdev_id = param->vdev_id;
  425. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  426. cmd->param_id = param->param_id;
  427. cmd->param_value = param->param_value;
  428. err = wmi_unified_cmd_send(wmi, buf,
  429. sizeof(wmi_peer_set_param_cmd_fixed_param),
  430. WMI_PEER_SET_PARAM_CMDID);
  431. if (err) {
  432. WMI_LOGE("Failed to send set_param cmd");
  433. qdf_mem_free(buf);
  434. return -EIO;
  435. }
  436. return 0;
  437. }
  438. /**
  439. * send_vdev_up_cmd_tlv() - send vdev up command in fw
  440. * @wmi: wmi handle
  441. * @bssid: bssid
  442. * @vdev_up_params: pointer to hold vdev up parameter
  443. *
  444. * Return: 0 for success or error code
  445. */
  446. QDF_STATUS send_vdev_up_cmd_tlv(wmi_unified_t wmi,
  447. uint8_t bssid[IEEE80211_ADDR_LEN],
  448. struct vdev_up_params *params)
  449. {
  450. wmi_vdev_up_cmd_fixed_param *cmd;
  451. wmi_buf_t buf;
  452. int32_t len = sizeof(*cmd);
  453. WMI_LOGD("%s: VDEV_UP", __func__);
  454. WMI_LOGD("%s: vdev_id %d aid %d bssid %pM", __func__,
  455. params->vdev_id, params->assoc_id, bssid);
  456. buf = wmi_buf_alloc(wmi, len);
  457. if (!buf) {
  458. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  459. return -ENOMEM;
  460. }
  461. cmd = (wmi_vdev_up_cmd_fixed_param *) wmi_buf_data(buf);
  462. WMITLV_SET_HDR(&cmd->tlv_header,
  463. WMITLV_TAG_STRUC_wmi_vdev_up_cmd_fixed_param,
  464. WMITLV_GET_STRUCT_TLVLEN(wmi_vdev_up_cmd_fixed_param));
  465. cmd->vdev_id = params->vdev_id;
  466. cmd->vdev_assoc_id = params->assoc_id;
  467. WMI_CHAR_ARRAY_TO_MAC_ADDR(bssid, &cmd->vdev_bssid);
  468. if (wmi_unified_cmd_send(wmi, buf, len, WMI_VDEV_UP_CMDID)) {
  469. WMI_LOGP("%s: Failed to send vdev up command", __func__);
  470. qdf_nbuf_free(buf);
  471. return -EIO;
  472. }
  473. return 0;
  474. }
  475. /**
  476. * send_peer_create_cmd_tlv() - send peer create command to fw
  477. * @wmi: wmi handle
  478. * @peer_addr: peer mac address
  479. * @peer_type: peer type
  480. * @vdev_id: vdev id
  481. *
  482. * Return: 0 for success or error code
  483. */
  484. QDF_STATUS send_peer_create_cmd_tlv(wmi_unified_t wmi,
  485. struct peer_create_params *param)
  486. {
  487. wmi_peer_create_cmd_fixed_param *cmd;
  488. wmi_buf_t buf;
  489. int32_t len = sizeof(*cmd);
  490. buf = wmi_buf_alloc(wmi, len);
  491. if (!buf) {
  492. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  493. return -ENOMEM;
  494. }
  495. cmd = (wmi_peer_create_cmd_fixed_param *) wmi_buf_data(buf);
  496. WMITLV_SET_HDR(&cmd->tlv_header,
  497. WMITLV_TAG_STRUC_wmi_peer_create_cmd_fixed_param,
  498. WMITLV_GET_STRUCT_TLVLEN
  499. (wmi_peer_create_cmd_fixed_param));
  500. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr);
  501. cmd->peer_type = param->peer_type;
  502. cmd->vdev_id = param->vdev_id;
  503. if (wmi_unified_cmd_send(wmi, buf, len, WMI_PEER_CREATE_CMDID)) {
  504. WMI_LOGP("%s: failed to send WMI_PEER_CREATE_CMDID", __func__);
  505. qdf_nbuf_free(buf);
  506. return -EIO;
  507. }
  508. WMI_LOGD("%s: peer_addr %pM vdev_id %d", __func__, param->peer_addr,
  509. param->vdev_id);
  510. return 0;
  511. }
  512. /**
  513. * send_green_ap_ps_cmd_tlv() - enable green ap powersave command
  514. * @wmi_handle: wmi handle
  515. * @value: value
  516. * @mac_id: mac id to have radio context
  517. *
  518. * Return: 0 for success or error code
  519. */
  520. QDF_STATUS send_green_ap_ps_cmd_tlv(wmi_unified_t wmi_handle,
  521. uint32_t value, uint8_t mac_id)
  522. {
  523. wmi_pdev_green_ap_ps_enable_cmd_fixed_param *cmd;
  524. wmi_buf_t buf;
  525. int32_t len = sizeof(*cmd);
  526. WMI_LOGD("Set Green AP PS val %d", value);
  527. buf = wmi_buf_alloc(wmi_handle, len);
  528. if (!buf) {
  529. WMI_LOGP("%s: Green AP PS Mem Alloc Failed", __func__);
  530. return -ENOMEM;
  531. }
  532. cmd = (wmi_pdev_green_ap_ps_enable_cmd_fixed_param *) wmi_buf_data(buf);
  533. WMITLV_SET_HDR(&cmd->tlv_header,
  534. WMITLV_TAG_STRUC_wmi_pdev_green_ap_ps_enable_cmd_fixed_param,
  535. WMITLV_GET_STRUCT_TLVLEN
  536. (wmi_pdev_green_ap_ps_enable_cmd_fixed_param));
  537. cmd->pdev_id = 0;
  538. cmd->enable = value;
  539. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  540. WMI_PDEV_GREEN_AP_PS_ENABLE_CMDID)) {
  541. WMI_LOGE("Set Green AP PS param Failed val %d", value);
  542. qdf_nbuf_free(buf);
  543. return -EIO;
  544. }
  545. return 0;
  546. }
  547. /**
  548. * send_pdev_utf_cmd_tlv() - send utf command to fw
  549. * @wmi_handle: wmi handle
  550. * @param: pointer to pdev_utf_params
  551. * @mac_id: mac id to have radio context
  552. *
  553. * Return: 0 for success or error code
  554. */
  555. QDF_STATUS
  556. send_pdev_utf_cmd_tlv(wmi_unified_t wmi_handle,
  557. struct pdev_utf_params *param,
  558. uint8_t mac_id)
  559. {
  560. wmi_buf_t buf;
  561. uint8_t *cmd;
  562. int32_t ret = 0;
  563. static uint8_t msgref = 1;
  564. uint8_t segNumber = 0, segInfo, numSegments;
  565. uint16_t chunk_len, total_bytes;
  566. uint8_t *bufpos;
  567. struct seg_hdr_info segHdrInfo;
  568. bufpos = param->utf_payload;
  569. total_bytes = param->len;
  570. ASSERT(total_bytes / MAX_WMI_UTF_LEN ==
  571. (uint8_t) (total_bytes / MAX_WMI_UTF_LEN));
  572. numSegments = (uint8_t) (total_bytes / MAX_WMI_UTF_LEN);
  573. if (param->len - (numSegments * MAX_WMI_UTF_LEN))
  574. numSegments++;
  575. while (param->len) {
  576. if (param->len > MAX_WMI_UTF_LEN)
  577. chunk_len = MAX_WMI_UTF_LEN; /* MAX messsage */
  578. else
  579. chunk_len = param->len;
  580. buf = wmi_buf_alloc(wmi_handle,
  581. (chunk_len + sizeof(segHdrInfo) +
  582. WMI_TLV_HDR_SIZE));
  583. if (!buf) {
  584. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  585. return -ENOMEM;
  586. }
  587. cmd = (uint8_t *) wmi_buf_data(buf);
  588. segHdrInfo.len = total_bytes;
  589. segHdrInfo.msgref = msgref;
  590. segInfo = ((numSegments << 4) & 0xF0) | (segNumber & 0xF);
  591. segHdrInfo.segmentInfo = segInfo;
  592. segHdrInfo.pad = 0;
  593. WMI_LOGD("%s:segHdrInfo.len = %d, segHdrInfo.msgref = %d,"
  594. " segHdrInfo.segmentInfo = %d",
  595. __func__, segHdrInfo.len, segHdrInfo.msgref,
  596. segHdrInfo.segmentInfo);
  597. WMI_LOGD("%s:total_bytes %d segNumber %d totalSegments %d"
  598. "chunk len %d", __func__, total_bytes, segNumber,
  599. numSegments, chunk_len);
  600. segNumber++;
  601. WMITLV_SET_HDR(cmd, WMITLV_TAG_ARRAY_BYTE,
  602. (chunk_len + sizeof(segHdrInfo)));
  603. cmd += WMI_TLV_HDR_SIZE;
  604. memcpy(cmd, &segHdrInfo, sizeof(segHdrInfo)); /* 4 bytes */
  605. memcpy(&cmd[sizeof(segHdrInfo)], bufpos, chunk_len);
  606. ret = wmi_unified_cmd_send(wmi_handle, buf,
  607. (chunk_len + sizeof(segHdrInfo) +
  608. WMI_TLV_HDR_SIZE),
  609. WMI_PDEV_UTF_CMDID);
  610. if (ret != EOK) {
  611. WMI_LOGE("Failed to send WMI_PDEV_UTF_CMDID command");
  612. wmi_buf_free(buf);
  613. break;
  614. }
  615. param->len -= chunk_len;
  616. bufpos += chunk_len;
  617. }
  618. msgref++;
  619. return ret;
  620. }
  621. /**
  622. * send_pdev_param_cmd_tlv() - set pdev parameters
  623. * @wmi_handle: wmi handle
  624. * @param: pointer to pdev parameter
  625. * @mac_id: radio context
  626. *
  627. * Return: 0 on success, errno on failure
  628. */
  629. QDF_STATUS
  630. send_pdev_param_cmd_tlv(wmi_unified_t wmi_handle,
  631. struct pdev_params *param,
  632. uint8_t mac_id)
  633. {
  634. int32_t ret;
  635. wmi_pdev_set_param_cmd_fixed_param *cmd;
  636. wmi_buf_t buf;
  637. uint16_t len = sizeof(*cmd);
  638. buf = wmi_buf_alloc(wmi_handle, len);
  639. if (!buf) {
  640. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  641. return -ENOMEM;
  642. }
  643. cmd = (wmi_pdev_set_param_cmd_fixed_param *) wmi_buf_data(buf);
  644. WMITLV_SET_HDR(&cmd->tlv_header,
  645. WMITLV_TAG_STRUC_wmi_pdev_set_param_cmd_fixed_param,
  646. WMITLV_GET_STRUCT_TLVLEN
  647. (wmi_pdev_set_param_cmd_fixed_param));
  648. cmd->pdev_id = 0;
  649. cmd->param_id = param->param_id;
  650. cmd->param_value = param->param_value;
  651. WMI_LOGD("Setting pdev param = %x, value = %u", param->param_id,
  652. param->param_value);
  653. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  654. WMI_PDEV_SET_PARAM_CMDID);
  655. if (ret != EOK) {
  656. WMI_LOGE("Failed to send set param command ret = %d", ret);
  657. wmi_buf_free(buf);
  658. }
  659. return ret;
  660. }
  661. /**
  662. * send_suspend_cmd_tlv() - WMI suspend function
  663. * @param wmi_handle : handle to WMI.
  664. * @param param : pointer to hold suspend parameter
  665. * @mac_id: radio context
  666. *
  667. * Return 0 on success and -ve on failure.
  668. */
  669. QDF_STATUS send_suspend_cmd_tlv(wmi_unified_t wmi_handle,
  670. struct suspend_params *param,
  671. uint8_t mac_id)
  672. {
  673. wmi_pdev_suspend_cmd_fixed_param *cmd;
  674. wmi_buf_t wmibuf;
  675. uint32_t len = sizeof(*cmd);
  676. int32_t ret;
  677. /*
  678. * send the comand to Target to ignore the
  679. * PCIE reset so as to ensure that Host and target
  680. * states are in sync
  681. */
  682. wmibuf = wmi_buf_alloc(wmi_handle, len);
  683. if (wmibuf == NULL)
  684. return -ENOMEM;
  685. cmd = (wmi_pdev_suspend_cmd_fixed_param *) wmi_buf_data(wmibuf);
  686. WMITLV_SET_HDR(&cmd->tlv_header,
  687. WMITLV_TAG_STRUC_wmi_pdev_suspend_cmd_fixed_param,
  688. WMITLV_GET_STRUCT_TLVLEN
  689. (wmi_pdev_suspend_cmd_fixed_param));
  690. if (param->disable_target_intr)
  691. cmd->suspend_opt = WMI_PDEV_SUSPEND_AND_DISABLE_INTR;
  692. else
  693. cmd->suspend_opt = WMI_PDEV_SUSPEND;
  694. ret = wmi_unified_cmd_send(wmi_handle, wmibuf, len,
  695. WMI_PDEV_SUSPEND_CMDID);
  696. if (ret) {
  697. qdf_nbuf_free(wmibuf);
  698. WMA_LOGE("Failed to send WMI_PDEV_SUSPEND_CMDID command");
  699. }
  700. return ret;
  701. }
  702. /**
  703. * send_resume_cmd_tlv() - WMI resume function
  704. * @param wmi_handle : handle to WMI.
  705. * @mac_id: radio context
  706. *
  707. * Return: 0 on success and -ve on failure.
  708. */
  709. QDF_STATUS send_resume_cmd_tlv(wmi_unified_t wmi_handle,
  710. uint8_t mac_id)
  711. {
  712. wmi_buf_t wmibuf;
  713. wmi_pdev_resume_cmd_fixed_param *cmd;
  714. int32_t ret;
  715. wmibuf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  716. if (wmibuf == NULL)
  717. return -ENOMEM;
  718. cmd = (wmi_pdev_resume_cmd_fixed_param *) wmi_buf_data(wmibuf);
  719. WMITLV_SET_HDR(&cmd->tlv_header,
  720. WMITLV_TAG_STRUC_wmi_pdev_resume_cmd_fixed_param,
  721. WMITLV_GET_STRUCT_TLVLEN
  722. (wmi_pdev_resume_cmd_fixed_param));
  723. cmd->reserved0 = 0;
  724. ret = wmi_unified_cmd_send(wmi_handle, wmibuf, sizeof(*cmd),
  725. WMI_PDEV_RESUME_CMDID);
  726. if (ret != EOK) {
  727. WMI_LOGE("Failed to send WMI_PDEV_RESUME_CMDID command");
  728. wmi_buf_free(wmibuf);
  729. }
  730. return ret;
  731. }
  732. /**
  733. * send_wow_enable_cmd_tlv() - WMI wow enable function
  734. * @param wmi_handle : handle to WMI.
  735. * @param param : pointer to hold wow enable parameter
  736. * @mac_id: radio context
  737. *
  738. * Return: 0 on success and -ve on failure.
  739. */
  740. QDF_STATUS send_wow_enable_cmd_tlv(wmi_unified_t wmi_handle,
  741. struct wow_cmd_params *param,
  742. uint8_t mac_id)
  743. {
  744. wmi_wow_enable_cmd_fixed_param *cmd;
  745. wmi_buf_t buf;
  746. int32_t len;
  747. int32_t ret;
  748. len = sizeof(wmi_wow_enable_cmd_fixed_param);
  749. buf = wmi_buf_alloc(wmi_handle, len);
  750. if (!buf) {
  751. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  752. return QDF_STATUS_E_NOMEM;
  753. }
  754. cmd = (wmi_wow_enable_cmd_fixed_param *) wmi_buf_data(buf);
  755. WMITLV_SET_HDR(&cmd->tlv_header,
  756. WMITLV_TAG_STRUC_wmi_wow_enable_cmd_fixed_param,
  757. WMITLV_GET_STRUCT_TLVLEN
  758. (wmi_wow_enable_cmd_fixed_param));
  759. cmd->enable = param->enable;
  760. if (param->can_suspend_link)
  761. cmd->pause_iface_config = WOW_IFACE_PAUSE_ENABLED;
  762. else
  763. cmd->pause_iface_config = WOW_IFACE_PAUSE_DISABLED;
  764. WMI_LOGI("suspend type: %s",
  765. cmd->pause_iface_config == WOW_IFACE_PAUSE_ENABLED ?
  766. "WOW_IFACE_PAUSE_ENABLED" : "WOW_IFACE_PAUSE_DISABLED");
  767. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  768. WMI_WOW_ENABLE_CMDID);
  769. if (ret)
  770. wmi_buf_free(buf);
  771. return ret;
  772. }
  773. /**
  774. * send_set_ap_ps_param_cmd_tlv() - set ap powersave parameters
  775. * @wmi_handle: wmi handle
  776. * @peer_addr: peer mac address
  777. * @param: pointer to ap_ps parameter structure
  778. *
  779. * Return: 0 for success or error code
  780. */
  781. QDF_STATUS send_set_ap_ps_param_cmd_tlv(wmi_unified_t wmi_handle,
  782. uint8_t *peer_addr,
  783. struct ap_ps_params *param)
  784. {
  785. wmi_ap_ps_peer_cmd_fixed_param *cmd;
  786. wmi_buf_t buf;
  787. int32_t err;
  788. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  789. if (!buf) {
  790. WMI_LOGE("Failed to allocate buffer to send set_ap_ps_param cmd");
  791. return -ENOMEM;
  792. }
  793. cmd = (wmi_ap_ps_peer_cmd_fixed_param *) wmi_buf_data(buf);
  794. WMITLV_SET_HDR(&cmd->tlv_header,
  795. WMITLV_TAG_STRUC_wmi_ap_ps_peer_cmd_fixed_param,
  796. WMITLV_GET_STRUCT_TLVLEN
  797. (wmi_ap_ps_peer_cmd_fixed_param));
  798. cmd->vdev_id = param->vdev_id;
  799. WMI_CHAR_ARRAY_TO_MAC_ADDR(peer_addr, &cmd->peer_macaddr);
  800. cmd->param = param->param;
  801. cmd->value = param->value;
  802. err = wmi_unified_cmd_send(wmi_handle, buf,
  803. sizeof(*cmd), WMI_AP_PS_PEER_PARAM_CMDID);
  804. if (err) {
  805. WMI_LOGE("Failed to send set_ap_ps_param cmd");
  806. qdf_mem_free(buf);
  807. return -EIO;
  808. }
  809. return 0;
  810. }
  811. /**
  812. * send_set_sta_ps_param_cmd_tlv() - set sta powersave parameters
  813. * @wmi_handle: wmi handle
  814. * @peer_addr: peer mac address
  815. * @param: pointer to sta_ps parameter structure
  816. *
  817. * Return: 0 for success or error code
  818. */
  819. QDF_STATUS send_set_sta_ps_param_cmd_tlv(wmi_unified_t wmi_handle,
  820. struct sta_ps_params *param)
  821. {
  822. wmi_sta_powersave_param_cmd_fixed_param *cmd;
  823. wmi_buf_t buf;
  824. int32_t len = sizeof(*cmd);
  825. buf = wmi_buf_alloc(wmi_handle, len);
  826. if (!buf) {
  827. WMI_LOGP("%s: Set Sta Ps param Mem Alloc Failed", __func__);
  828. return -ENOMEM;
  829. }
  830. cmd = (wmi_sta_powersave_param_cmd_fixed_param *) wmi_buf_data(buf);
  831. WMITLV_SET_HDR(&cmd->tlv_header,
  832. WMITLV_TAG_STRUC_wmi_sta_powersave_param_cmd_fixed_param,
  833. WMITLV_GET_STRUCT_TLVLEN
  834. (wmi_sta_powersave_param_cmd_fixed_param));
  835. cmd->vdev_id = param->vdev_id;
  836. cmd->param = param->param;
  837. cmd->value = param->value;
  838. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  839. WMI_STA_POWERSAVE_PARAM_CMDID)) {
  840. WMI_LOGE("Set Sta Ps param Failed vdevId %d Param %d val %d",
  841. param->vdev_id, param->param, param->value);
  842. qdf_nbuf_free(buf);
  843. return -EIO;
  844. }
  845. return 0;
  846. }
  847. /**
  848. * send_crash_inject_cmd_tlv() - inject fw crash
  849. * @wmi_handle: wmi handle
  850. * @param: ponirt to crash inject paramter structure
  851. *
  852. * Return: 0 for success or return error
  853. */
  854. QDF_STATUS send_crash_inject_cmd_tlv(wmi_unified_t wmi_handle,
  855. struct crash_inject *param)
  856. {
  857. int32_t ret = 0;
  858. WMI_FORCE_FW_HANG_CMD_fixed_param *cmd;
  859. uint16_t len = sizeof(*cmd);
  860. wmi_buf_t buf;
  861. buf = wmi_buf_alloc(wmi_handle, len);
  862. if (!buf) {
  863. WMI_LOGE("%s: wmi_buf_alloc failed!", __func__);
  864. return -ENOMEM;
  865. }
  866. cmd = (WMI_FORCE_FW_HANG_CMD_fixed_param *) wmi_buf_data(buf);
  867. WMITLV_SET_HDR(&cmd->tlv_header,
  868. WMITLV_TAG_STRUC_WMI_FORCE_FW_HANG_CMD_fixed_param,
  869. WMITLV_GET_STRUCT_TLVLEN
  870. (WMI_FORCE_FW_HANG_CMD_fixed_param));
  871. cmd->type = param->type;
  872. cmd->delay_time_ms = param->delay_time_ms;
  873. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  874. WMI_FORCE_FW_HANG_CMDID);
  875. if (ret) {
  876. WMI_LOGE("%s: Failed to send set param command, ret = %d",
  877. __func__, ret);
  878. wmi_buf_free(buf);
  879. }
  880. return ret;
  881. }
  882. /**
  883. * send_dbglog_cmd_tlv() - set debug log level
  884. * @param wmi_handle : handle to WMI.
  885. * @param param : pointer to hold dbglog level parameter
  886. *
  887. * Return: 0 on success and -ve on failure.
  888. */
  889. QDF_STATUS
  890. send_dbglog_cmd_tlv(wmi_unified_t wmi_handle,
  891. struct dbglog_params *dbglog_param)
  892. {
  893. wmi_buf_t buf;
  894. wmi_debug_log_config_cmd_fixed_param *configmsg;
  895. A_STATUS status = A_OK;
  896. int32_t i;
  897. int32_t len;
  898. int8_t *buf_ptr;
  899. int32_t *module_id_bitmap_array; /* Used to fomr the second tlv */
  900. ASSERT(bitmap_len < MAX_MODULE_ID_BITMAP_WORDS);
  901. /* Allocate size for 2 tlvs - including tlv hdr space for second tlv */
  902. len = sizeof(wmi_debug_log_config_cmd_fixed_param) + WMI_TLV_HDR_SIZE +
  903. (sizeof(int32_t) * MAX_MODULE_ID_BITMAP_WORDS);
  904. buf = wmi_buf_alloc(wmi_handle, len);
  905. if (buf == NULL)
  906. return A_NO_MEMORY;
  907. configmsg =
  908. (wmi_debug_log_config_cmd_fixed_param *) (wmi_buf_data(buf));
  909. buf_ptr = (int8_t *) configmsg;
  910. WMITLV_SET_HDR(&configmsg->tlv_header,
  911. WMITLV_TAG_STRUC_wmi_debug_log_config_cmd_fixed_param,
  912. WMITLV_GET_STRUCT_TLVLEN
  913. (wmi_debug_log_config_cmd_fixed_param));
  914. configmsg->dbg_log_param = dbglog_param->param;
  915. configmsg->value = dbglog_param->val;
  916. /* Filling in the data part of second tlv -- should
  917. * follow first tlv _ WMI_TLV_HDR_SIZE */
  918. module_id_bitmap_array = (A_UINT32 *) (buf_ptr +
  919. sizeof
  920. (wmi_debug_log_config_cmd_fixed_param)
  921. + WMI_TLV_HDR_SIZE);
  922. WMITLV_SET_HDR(buf_ptr + sizeof(wmi_debug_log_config_cmd_fixed_param),
  923. WMITLV_TAG_ARRAY_UINT32,
  924. sizeof(A_UINT32) * MAX_MODULE_ID_BITMAP_WORDS);
  925. if (dbglog_param->module_id_bitmap) {
  926. for (i = 0; i < dbglog_param->bitmap_len; ++i) {
  927. module_id_bitmap_array[i] =
  928. dbglog_param->module_id_bitmap[i];
  929. }
  930. }
  931. status = wmi_unified_cmd_send(wmi_handle, buf,
  932. len, WMI_DBGLOG_CFG_CMDID);
  933. if (status != A_OK)
  934. qdf_nbuf_free(buf);
  935. return status;
  936. }
  937. /**
  938. * send_vdev_set_param_cmd_tlv() - WMI vdev set parameter function
  939. * @param wmi_handle : handle to WMI.
  940. * @param macaddr : MAC address
  941. * @param param : pointer to hold vdev set parameter
  942. *
  943. * Return: 0 on success and -ve on failure.
  944. */
  945. QDF_STATUS send_vdev_set_param_cmd_tlv(wmi_unified_t wmi_handle,
  946. struct vdev_set_params *param)
  947. {
  948. int32_t ret;
  949. wmi_vdev_set_param_cmd_fixed_param *cmd;
  950. wmi_buf_t buf;
  951. uint16_t len = sizeof(*cmd);
  952. buf = wmi_buf_alloc(wmi_handle, len);
  953. if (!buf) {
  954. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  955. return -ENOMEM;
  956. }
  957. cmd = (wmi_vdev_set_param_cmd_fixed_param *) wmi_buf_data(buf);
  958. WMITLV_SET_HDR(&cmd->tlv_header,
  959. WMITLV_TAG_STRUC_wmi_vdev_set_param_cmd_fixed_param,
  960. WMITLV_GET_STRUCT_TLVLEN
  961. (wmi_vdev_set_param_cmd_fixed_param));
  962. cmd->vdev_id = param->if_id;
  963. cmd->param_id = param->param_id;
  964. cmd->param_value = param->param_value;
  965. WMI_LOGD("Setting vdev %d param = %x, value = %u",
  966. param->if_id, param->param_id, param->param_value);
  967. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  968. WMI_VDEV_SET_PARAM_CMDID);
  969. if (ret < 0) {
  970. WMI_LOGE("Failed to send set param command ret = %d", ret);
  971. wmi_buf_free(buf);
  972. }
  973. return ret;
  974. }
  975. /**
  976. * send_stats_request_cmd_tlv() - WMI request stats function
  977. * @param wmi_handle : handle to WMI.
  978. * @param macaddr : MAC address
  979. * @param param : pointer to hold stats request parameter
  980. *
  981. * Return: 0 on success and -ve on failure.
  982. */
  983. QDF_STATUS send_stats_request_cmd_tlv(wmi_unified_t wmi_handle,
  984. uint8_t macaddr[IEEE80211_ADDR_LEN],
  985. struct stats_request_params *param)
  986. {
  987. int32_t ret;
  988. wmi_request_stats_cmd_fixed_param *cmd;
  989. wmi_buf_t buf;
  990. uint16_t len = sizeof(wmi_request_stats_cmd_fixed_param);
  991. buf = wmi_buf_alloc(wmi_handle, len);
  992. if (!buf) {
  993. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  994. return -QDF_STATUS_E_NOMEM;
  995. }
  996. cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
  997. WMITLV_SET_HDR(&cmd->tlv_header,
  998. WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
  999. WMITLV_GET_STRUCT_TLVLEN
  1000. (wmi_request_stats_cmd_fixed_param));
  1001. cmd->stats_id = param->stats_id;
  1002. cmd->vdev_id = param->vdev_id;
  1003. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1004. WMI_REQUEST_STATS_CMDID);
  1005. if (ret) {
  1006. WMI_LOGE("Failed to send status request to fw =%d", ret);
  1007. wmi_buf_free(buf);
  1008. }
  1009. return ret;
  1010. }
  1011. /**
  1012. * send_packet_log_enable_cmd_tlv() - WMI request stats function
  1013. * @param wmi_handle : handle to WMI.
  1014. * @param macaddr : MAC address
  1015. * @param param : pointer to hold stats request parameter
  1016. *
  1017. * Return: 0 on success and -ve on failure.
  1018. */
  1019. QDF_STATUS send_packet_log_enable_cmd_tlv(wmi_unified_t wmi_handle,
  1020. uint8_t macaddr[IEEE80211_ADDR_LEN],
  1021. struct packet_enable_params *param)
  1022. {
  1023. return 0;
  1024. }
  1025. /**
  1026. * send_beacon_send_cmd_tlv() - WMI beacon send function
  1027. * @param wmi_handle : handle to WMI.
  1028. * @param param : pointer to hold beacon send cmd parameter
  1029. *
  1030. * Return: 0 on success and -ve on failure.
  1031. */
  1032. QDF_STATUS send_beacon_send_cmd_tlv(wmi_unified_t wmi_handle,
  1033. struct beacon_params *param)
  1034. {
  1035. int32_t ret;
  1036. wmi_bcn_tmpl_cmd_fixed_param *cmd;
  1037. wmi_bcn_prb_info *bcn_prb_info;
  1038. wmi_buf_t wmi_buf;
  1039. uint8_t *buf_ptr;
  1040. uint32_t wmi_buf_len;
  1041. wmi_buf_len = sizeof(wmi_bcn_tmpl_cmd_fixed_param) +
  1042. sizeof(wmi_bcn_prb_info) + WMI_TLV_HDR_SIZE +
  1043. param->tmpl_len_aligned;
  1044. wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len);
  1045. if (!wmi_buf) {
  1046. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  1047. return -ENOMEM;
  1048. }
  1049. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  1050. cmd = (wmi_bcn_tmpl_cmd_fixed_param *) buf_ptr;
  1051. WMITLV_SET_HDR(&cmd->tlv_header,
  1052. WMITLV_TAG_STRUC_wmi_bcn_tmpl_cmd_fixed_param,
  1053. WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_tmpl_cmd_fixed_param));
  1054. cmd->vdev_id = param->vdev_id;
  1055. cmd->tim_ie_offset = param->tim_ie_offset;
  1056. cmd->buf_len = param->tmpl_len;
  1057. buf_ptr += sizeof(wmi_bcn_tmpl_cmd_fixed_param);
  1058. bcn_prb_info = (wmi_bcn_prb_info *) buf_ptr;
  1059. WMITLV_SET_HDR(&bcn_prb_info->tlv_header,
  1060. WMITLV_TAG_STRUC_wmi_bcn_prb_info,
  1061. WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_prb_info));
  1062. bcn_prb_info->caps = 0;
  1063. bcn_prb_info->erp = 0;
  1064. buf_ptr += sizeof(wmi_bcn_prb_info);
  1065. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, param->tmpl_len_aligned);
  1066. buf_ptr += WMI_TLV_HDR_SIZE;
  1067. qdf_mem_copy(buf_ptr, param->frm, param->tmpl_len);
  1068. ret = wmi_unified_cmd_send(wmi_handle,
  1069. wmi_buf, wmi_buf_len, WMI_BCN_TMPL_CMDID);
  1070. if (ret) {
  1071. WMI_LOGE("%s: Failed to send bcn tmpl: %d", __func__, ret);
  1072. wmi_buf_free(wmi_buf);
  1073. }
  1074. return 0;
  1075. }
  1076. /**
  1077. * send_peer_assoc_cmd_tlv() - WMI peer assoc function
  1078. * @param wmi_handle : handle to WMI.
  1079. * @param param : pointer to peer assoc parameter
  1080. *
  1081. * Return: 0 on success and -ve on failure.
  1082. */
  1083. QDF_STATUS send_peer_assoc_cmd_tlv(wmi_unified_t wmi_handle,
  1084. struct peer_assoc_params *param)
  1085. {
  1086. wmi_peer_assoc_complete_cmd_fixed_param *cmd;
  1087. wmi_vht_rate_set *mcs;
  1088. wmi_buf_t buf;
  1089. int32_t len;
  1090. uint8_t *buf_ptr;
  1091. int ret;
  1092. uint32_t peer_legacy_rates_align;
  1093. uint32_t peer_ht_rates_align;
  1094. peer_legacy_rates_align = wmi_align(param->peer_legacy_rates.num_rates);
  1095. peer_ht_rates_align = wmi_align(param->peer_ht_rates.num_rates);
  1096. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
  1097. (peer_legacy_rates_align * sizeof(uint8_t)) +
  1098. WMI_TLV_HDR_SIZE +
  1099. (peer_ht_rates_align * sizeof(uint8_t)) +
  1100. sizeof(wmi_vht_rate_set);
  1101. buf = wmi_buf_alloc(wmi_handle, len);
  1102. if (!buf) {
  1103. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  1104. return -ENOMEM;
  1105. }
  1106. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1107. cmd = (wmi_peer_assoc_complete_cmd_fixed_param *) buf_ptr;
  1108. WMITLV_SET_HDR(&cmd->tlv_header,
  1109. WMITLV_TAG_STRUC_wmi_peer_assoc_complete_cmd_fixed_param,
  1110. WMITLV_GET_STRUCT_TLVLEN
  1111. (wmi_peer_assoc_complete_cmd_fixed_param));
  1112. cmd->vdev_id = param->vdev_id;
  1113. qdf_mem_copy(&cmd->peer_macaddr, &param->peer_macaddr,
  1114. sizeof(param->peer_macaddr));
  1115. cmd->peer_new_assoc = param->peer_new_assoc;
  1116. cmd->peer_associd = param->peer_associd;
  1117. cmd->peer_flags = param->peer_flags;
  1118. cmd->peer_rate_caps = param->peer_rate_caps;
  1119. cmd->peer_caps = param->peer_caps;
  1120. cmd->peer_listen_intval = param->peer_listen_intval;
  1121. cmd->peer_ht_caps = param->peer_ht_caps;
  1122. cmd->peer_max_mpdu = param->peer_max_mpdu;
  1123. cmd->peer_mpdu_density = param->peer_mpdu_density;
  1124. cmd->peer_vht_caps = param->peer_vht_caps;
  1125. cmd->peer_phymode = param->peer_phymode;
  1126. /* Update peer legacy rate information */
  1127. buf_ptr += sizeof(*cmd);
  1128. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  1129. peer_legacy_rates_align);
  1130. buf_ptr += WMI_TLV_HDR_SIZE;
  1131. cmd->num_peer_legacy_rates = param->peer_legacy_rates.num_rates;
  1132. qdf_mem_copy(buf_ptr, param->peer_legacy_rates.rates,
  1133. param->peer_legacy_rates.num_rates);
  1134. /* Update peer HT rate information */
  1135. buf_ptr += param->peer_legacy_rates.num_rates;
  1136. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  1137. peer_ht_rates_align);
  1138. buf_ptr += WMI_TLV_HDR_SIZE;
  1139. cmd->num_peer_ht_rates = param->peer_ht_rates.num_rates;
  1140. qdf_mem_copy(buf_ptr, param->peer_ht_rates.rates,
  1141. param->peer_ht_rates.num_rates);
  1142. /* VHT Rates */
  1143. buf_ptr += param->peer_ht_rates.num_rates;
  1144. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_STRUC_wmi_vht_rate_set,
  1145. WMITLV_GET_STRUCT_TLVLEN(wmi_vht_rate_set));
  1146. cmd->peer_nss = param->peer_nss;
  1147. mcs = (wmi_vht_rate_set *) buf_ptr;
  1148. if (param->vht_capable) {
  1149. mcs->rx_max_rate = param->rx_max_rate;
  1150. mcs->rx_mcs_set = param->rx_mcs_set;
  1151. mcs->tx_max_rate = param->tx_max_rate;
  1152. mcs->tx_mcs_set = param->tx_mcs_set;
  1153. }
  1154. WMI_LOGD("%s: vdev_id %d associd %d peer_flags %x rate_caps %x "
  1155. "peer_caps %x listen_intval %d ht_caps %x max_mpdu %d "
  1156. "nss %d phymode %d peer_mpdu_density %d "
  1157. "cmd->peer_vht_caps %x", __func__,
  1158. cmd->vdev_id, cmd->peer_associd, cmd->peer_flags,
  1159. cmd->peer_rate_caps, cmd->peer_caps,
  1160. cmd->peer_listen_intval, cmd->peer_ht_caps,
  1161. cmd->peer_max_mpdu, cmd->peer_nss, cmd->peer_phymode,
  1162. cmd->peer_mpdu_density,
  1163. cmd->peer_vht_caps);
  1164. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1165. WMI_PEER_ASSOC_CMDID);
  1166. if (ret != EOK) {
  1167. WMI_LOGP("%s: Failed to send peer assoc command ret = %d",
  1168. __func__, ret);
  1169. qdf_nbuf_free(buf);
  1170. }
  1171. return ret;
  1172. }
  1173. /**
  1174. * send_scan_start_cmd_tlv() - WMI scan start function
  1175. * @param wmi_handle : handle to WMI.
  1176. * @param param : pointer to hold scan start cmd parameter
  1177. *
  1178. * Return: 0 on success and -ve on failure.
  1179. */
  1180. QDF_STATUS send_scan_start_cmd_tlv(wmi_unified_t wmi_handle,
  1181. struct scan_start_params *params)
  1182. {
  1183. int32_t ret = 0;
  1184. int32_t i;
  1185. wmi_buf_t wmi_buf;
  1186. wmi_start_scan_cmd_fixed_param *cmd;
  1187. uint8_t *buf_ptr;
  1188. uint32_t *tmp_ptr;
  1189. wmi_ssid *ssid = NULL;
  1190. wmi_mac_addr *bssid;
  1191. int len = sizeof(*cmd);
  1192. /* Length TLV placeholder for array of uint32_t */
  1193. len += WMI_TLV_HDR_SIZE;
  1194. /* calculate the length of buffer required */
  1195. if (params->num_chan)
  1196. len += params->num_chan * sizeof(uint32_t);
  1197. /* Length TLV placeholder for array of wmi_ssid structures */
  1198. len += WMI_TLV_HDR_SIZE;
  1199. if (params->num_ssids)
  1200. len += params->num_ssids * sizeof(wmi_ssid);
  1201. /* Length TLV placeholder for array of wmi_mac_addr structures */
  1202. len += WMI_TLV_HDR_SIZE;
  1203. len += sizeof(wmi_mac_addr);
  1204. /* Length TLV placeholder for array of bytes */
  1205. len += WMI_TLV_HDR_SIZE;
  1206. if (params->ie_len)
  1207. len += roundup(params->ie_len, sizeof(uint32_t));
  1208. /* Allocate the memory */
  1209. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  1210. if (!wmi_buf) {
  1211. WMI_LOGP("%s: failed to allocate memory for start scan cmd",
  1212. __func__);
  1213. return QDF_STATUS_E_FAILURE;
  1214. }
  1215. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  1216. cmd = (wmi_start_scan_cmd_fixed_param *) buf_ptr;
  1217. WMITLV_SET_HDR(&cmd->tlv_header,
  1218. WMITLV_TAG_STRUC_wmi_start_scan_cmd_fixed_param,
  1219. WMITLV_GET_STRUCT_TLVLEN
  1220. (wmi_start_scan_cmd_fixed_param));
  1221. cmd->scan_id = params->scan_id;
  1222. cmd->scan_req_id = params->scan_req_id;
  1223. cmd->vdev_id = params->vdev_id;
  1224. cmd->scan_priority = params->scan_priority;
  1225. cmd->notify_scan_events = params->notify_scan_events;
  1226. cmd->dwell_time_active = params->dwell_time_active;
  1227. cmd->dwell_time_passive = params->dwell_time_passive;
  1228. cmd->min_rest_time = params->min_rest_time;
  1229. cmd->max_rest_time = params->max_rest_time;
  1230. cmd->repeat_probe_time = params->repeat_probe_time;
  1231. cmd->probe_spacing_time = params->probe_spacing_time;
  1232. cmd->idle_time = params->idle_time;
  1233. cmd->max_scan_time = params->max_scan_time;
  1234. cmd->probe_delay = params->probe_delay;
  1235. cmd->scan_ctrl_flags = params->scan_ctrl_flags;
  1236. cmd->burst_duration = params->burst_duration;
  1237. cmd->num_chan = params->num_chan;
  1238. cmd->num_bssid = params->num_bssid;
  1239. cmd->num_ssids = params->num_ssids;
  1240. cmd->ie_len = params->ie_len;
  1241. cmd->n_probes = params->n_probes;
  1242. buf_ptr += sizeof(*cmd);
  1243. tmp_ptr = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE);
  1244. for (i = 0; i < params->num_chan; ++i)
  1245. tmp_ptr[i] = params->chan_list[i];
  1246. WMITLV_SET_HDR(buf_ptr,
  1247. WMITLV_TAG_ARRAY_UINT32,
  1248. (params->num_chan * sizeof(uint32_t)));
  1249. buf_ptr += WMI_TLV_HDR_SIZE + (params->num_chan * sizeof(uint32_t));
  1250. if (params->num_ssids > WMI_SCAN_MAX_NUM_SSID) {
  1251. WMI_LOGE("Invalid value for numSsid");
  1252. goto error;
  1253. }
  1254. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC,
  1255. (params->num_ssids * sizeof(wmi_ssid)));
  1256. if (params->num_ssids) {
  1257. ssid = (wmi_ssid *) (buf_ptr + WMI_TLV_HDR_SIZE);
  1258. for (i = 0; i < params->num_ssids; ++i) {
  1259. ssid->ssid_len = params->ssid[i].length;
  1260. qdf_mem_copy(ssid->ssid, params->ssid[i].mac_ssid,
  1261. params->ssid[i].length);
  1262. ssid++;
  1263. }
  1264. }
  1265. buf_ptr += WMI_TLV_HDR_SIZE + (params->num_ssids * sizeof(wmi_ssid));
  1266. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC,
  1267. (params->num_bssid * sizeof(wmi_mac_addr)));
  1268. bssid = (wmi_mac_addr *) (buf_ptr + WMI_TLV_HDR_SIZE);
  1269. WMI_CHAR_ARRAY_TO_MAC_ADDR(params->mac_add_bytes, bssid);
  1270. buf_ptr += WMI_TLV_HDR_SIZE + (params->num_bssid * sizeof(wmi_mac_addr));
  1271. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, params->ie_len_with_pad);
  1272. if (params->ie_len) {
  1273. qdf_mem_copy(buf_ptr + WMI_TLV_HDR_SIZE,
  1274. (uint8_t *) params->ie_base +
  1275. (params->uie_fieldOffset), params->ie_len);
  1276. }
  1277. buf_ptr += WMI_TLV_HDR_SIZE + params->ie_len_with_pad;
  1278. ret = wmi_unified_cmd_send(wmi_handle, wmi_buf,
  1279. len, WMI_START_SCAN_CMDID);
  1280. if (ret) {
  1281. WMI_LOGE("%s: Failed to start scan: %d", __func__, ret);
  1282. wmi_buf_free(wmi_buf);
  1283. }
  1284. return ret;
  1285. error:
  1286. qdf_nbuf_free(wmi_buf);
  1287. return QDF_STATUS_E_FAILURE;
  1288. }
  1289. /**
  1290. * send_scan_stop_cmd_tlv() - WMI scan start function
  1291. * @param wmi_handle : handle to WMI.
  1292. * @param param : pointer to hold scan start cmd parameter
  1293. *
  1294. * Return: 0 on success and -ve on failure.
  1295. */
  1296. QDF_STATUS send_scan_stop_cmd_tlv(wmi_unified_t wmi_handle,
  1297. struct scan_stop_params *param)
  1298. {
  1299. wmi_stop_scan_cmd_fixed_param *cmd;
  1300. int ret;
  1301. int len = sizeof(*cmd);
  1302. wmi_buf_t wmi_buf;
  1303. /* Allocate the memory */
  1304. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  1305. if (!wmi_buf) {
  1306. WMI_LOGP("%s: failed to allocate memory for stop scan cmd",
  1307. __func__);
  1308. ret = -ENOMEM;
  1309. goto error;
  1310. }
  1311. cmd = (wmi_stop_scan_cmd_fixed_param *) wmi_buf_data(wmi_buf);
  1312. WMITLV_SET_HDR(&cmd->tlv_header,
  1313. WMITLV_TAG_STRUC_wmi_stop_scan_cmd_fixed_param,
  1314. WMITLV_GET_STRUCT_TLVLEN(wmi_stop_scan_cmd_fixed_param));
  1315. cmd->vdev_id = param->vdev_id;
  1316. cmd->requestor = param->requestor;
  1317. cmd->scan_id = param->scan_id;
  1318. /* stop the scan with the corresponding scan_id */
  1319. cmd->req_type = param->req_type;
  1320. ret = wmi_unified_cmd_send(wmi_handle, wmi_buf,
  1321. len, WMI_STOP_SCAN_CMDID);
  1322. if (ret) {
  1323. WMI_LOGE("%s: Failed to send stop scan: %d", __func__, ret);
  1324. wmi_buf_free(wmi_buf);
  1325. }
  1326. error:
  1327. return ret;
  1328. }
  1329. /**
  1330. * send_scan_chan_list_cmd_tlv() - WMI scan channel list function
  1331. * @param wmi_handle : handle to WMI.
  1332. * @param param : pointer to hold scan channel list parameter
  1333. *
  1334. * Return: 0 on success and -ve on failure.
  1335. */
  1336. QDF_STATUS send_scan_chan_list_cmd_tlv(wmi_unified_t wmi_handle,
  1337. struct scan_chan_list_params *chan_list)
  1338. {
  1339. wmi_buf_t buf;
  1340. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  1341. wmi_scan_chan_list_cmd_fixed_param *cmd;
  1342. int status, i;
  1343. uint8_t *buf_ptr;
  1344. wmi_channel *chan_info, *tchan_info;
  1345. uint16_t len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
  1346. len += sizeof(wmi_channel) * chan_list->num_scan_chans;
  1347. buf = wmi_buf_alloc(wmi_handle, len);
  1348. if (!buf) {
  1349. WMI_LOGE("Failed to allocate memory");
  1350. qdf_status = QDF_STATUS_E_NOMEM;
  1351. goto end;
  1352. }
  1353. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1354. cmd = (wmi_scan_chan_list_cmd_fixed_param *) buf_ptr;
  1355. WMITLV_SET_HDR(&cmd->tlv_header,
  1356. WMITLV_TAG_STRUC_wmi_scan_chan_list_cmd_fixed_param,
  1357. WMITLV_GET_STRUCT_TLVLEN
  1358. (wmi_scan_chan_list_cmd_fixed_param));
  1359. WMI_LOGD("no of channels = %d, len = %d", chan_list->num_scan_chans, len);
  1360. cmd->num_scan_chans = chan_list->num_scan_chans;
  1361. WMITLV_SET_HDR((buf_ptr + sizeof(wmi_scan_chan_list_cmd_fixed_param)),
  1362. WMITLV_TAG_ARRAY_STRUC,
  1363. sizeof(wmi_channel) * chan_list->num_scan_chans);
  1364. chan_info = (wmi_channel *) (buf_ptr + sizeof(*cmd) + WMI_TLV_HDR_SIZE);
  1365. tchan_info = chan_list->chan_info;
  1366. for (i = 0; i < chan_list->num_scan_chans; ++i) {
  1367. WMITLV_SET_HDR(&chan_info->tlv_header,
  1368. WMITLV_TAG_STRUC_wmi_channel,
  1369. WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
  1370. chan_info->mhz = tchan_info->mhz;
  1371. chan_info->band_center_freq1 =
  1372. tchan_info->band_center_freq1;
  1373. chan_info->band_center_freq2 =
  1374. tchan_info->band_center_freq2;
  1375. chan_info->info = tchan_info->info;
  1376. chan_info->reg_info_1 = tchan_info->reg_info_1;
  1377. chan_info->reg_info_2 = tchan_info->reg_info_2;
  1378. WMI_LOGD("chan[%d] = %u", i, chan_info->mhz);
  1379. /*TODO: Set WMI_SET_CHANNEL_MIN_POWER */
  1380. /*TODO: Set WMI_SET_CHANNEL_ANTENNA_MAX */
  1381. /*TODO: WMI_SET_CHANNEL_REG_CLASSID */
  1382. tchan_info++;
  1383. chan_info++;
  1384. }
  1385. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  1386. WMI_SCAN_CHAN_LIST_CMDID);
  1387. if (status != EOK) {
  1388. qdf_status = QDF_STATUS_E_FAILURE;
  1389. WMI_LOGE("Failed to send WMI_SCAN_CHAN_LIST_CMDID");
  1390. wmi_buf_free(buf);
  1391. }
  1392. end:
  1393. return qdf_status;
  1394. }
  1395. /**
  1396. * send_mgmt_cmd_tlv() - WMI scan start function
  1397. * @wmi_handle : handle to WMI.
  1398. * @param : pointer to hold mgmt cmd parameter
  1399. *
  1400. * Return: 0 on success and -ve on failure.
  1401. */
  1402. QDF_STATUS send_mgmt_cmd_tlv(wmi_unified_t wmi_handle,
  1403. struct wmi_mgmt_params *param)
  1404. {
  1405. wmi_buf_t buf;
  1406. wmi_mgmt_tx_send_cmd_fixed_param *cmd;
  1407. int32_t cmd_len;
  1408. uint64_t dma_addr;
  1409. struct wmi_desc_t *wmi_desc = NULL;
  1410. void *qdf_ctx = param->qdf_ctx;
  1411. uint8_t *bufp;
  1412. int32_t bufp_len = (param->frm_len < mgmt_tx_dl_frm_len) ? param->frm_len :
  1413. mgmt_tx_dl_frm_len;
  1414. cmd_len = sizeof(wmi_mgmt_tx_send_cmd_fixed_param) +
  1415. WMI_TLV_HDR_SIZE + roundup(bufp_len, sizeof(uint32_t));
  1416. buf = wmi_buf_alloc(wmi_handle, cmd_len);
  1417. if (!buf) {
  1418. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  1419. return QDF_STATUS_E_NOMEM;
  1420. }
  1421. cmd = (wmi_mgmt_tx_send_cmd_fixed_param *)wmi_buf_data(buf);
  1422. bufp = (uint8_t *) cmd;
  1423. WMITLV_SET_HDR(&cmd->tlv_header,
  1424. WMITLV_TAG_STRUC_wmi_mgmt_tx_send_cmd_fixed_param,
  1425. WMITLV_GET_STRUCT_TLVLEN
  1426. (wmi_mgmt_tx_send_cmd_fixed_param));
  1427. cmd->vdev_id = param->vdev_id;
  1428. wmi_desc = param->wmi_desc;
  1429. if (!wmi_desc) {
  1430. WMI_LOGE("%s: Failed to get wmi_desc", __func__);
  1431. goto err1;
  1432. }
  1433. wmi_desc->nbuf = param->tx_frame;
  1434. wmi_desc->tx_cmpl_cb = param->tx_complete_cb;
  1435. wmi_desc->ota_post_proc_cb = param->tx_ota_post_proc_cb;
  1436. cmd->desc_id = wmi_desc->desc_id;
  1437. cmd->chanfreq = param->chanfreq;
  1438. bufp += sizeof(wmi_mgmt_tx_send_cmd_fixed_param);
  1439. WMITLV_SET_HDR(bufp, WMITLV_TAG_ARRAY_BYTE, roundup(bufp_len,
  1440. sizeof(uint32_t)));
  1441. bufp += WMI_TLV_HDR_SIZE;
  1442. qdf_mem_copy(bufp, param->pdata, bufp_len);
  1443. qdf_nbuf_map_single(qdf_ctx, param->tx_frame, QDF_DMA_TO_DEVICE);
  1444. dma_addr = qdf_nbuf_get_frag_paddr(param->tx_frame, 0);
  1445. cmd->paddr_lo = (uint32_t)(dma_addr & 0xffffffff);
  1446. #if defined(HELIUMPLUS_PADDR64)
  1447. cmd->paddr_hi = (uint32_t)((dma_addr >> 32) & 0x1F);
  1448. #endif
  1449. cmd->frame_len = param->frm_len;
  1450. cmd->buf_len = bufp_len;
  1451. if (wmi_unified_cmd_send(wmi_handle, buf, cmd_len,
  1452. WMI_MGMT_TX_SEND_CMDID)) {
  1453. WMI_LOGE("%s: Failed to send mgmt Tx", __func__);
  1454. goto err1;
  1455. }
  1456. return QDF_STATUS_SUCCESS;
  1457. err1:
  1458. wmi_buf_free(buf);
  1459. return QDF_STATUS_E_FAILURE;
  1460. }
  1461. /**
  1462. * send_modem_power_state_cmd_tlv() - set modem power state to fw
  1463. * @wmi_handle: wmi handle
  1464. * @param_value: parameter value
  1465. *
  1466. * Return: 0 for success or error code
  1467. */
  1468. QDF_STATUS send_modem_power_state_cmd_tlv(wmi_unified_t wmi_handle,
  1469. uint32_t param_value)
  1470. {
  1471. int ret;
  1472. wmi_modem_power_state_cmd_param *cmd;
  1473. wmi_buf_t buf;
  1474. uint16_t len = sizeof(*cmd);
  1475. buf = wmi_buf_alloc(wmi_handle, len);
  1476. if (!buf) {
  1477. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  1478. return -ENOMEM;
  1479. }
  1480. cmd = (wmi_modem_power_state_cmd_param *) wmi_buf_data(buf);
  1481. WMITLV_SET_HDR(&cmd->tlv_header,
  1482. WMITLV_TAG_STRUC_wmi_modem_power_state_cmd_param,
  1483. WMITLV_GET_STRUCT_TLVLEN
  1484. (wmi_modem_power_state_cmd_param));
  1485. cmd->modem_power_state = param_value;
  1486. WMI_LOGD("%s: Setting cmd->modem_power_state = %u", __func__,
  1487. param_value);
  1488. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1489. WMI_MODEM_POWER_STATE_CMDID);
  1490. if (ret != EOK) {
  1491. WMI_LOGE("Failed to send notify cmd ret = %d", ret);
  1492. wmi_buf_free(buf);
  1493. }
  1494. return ret;
  1495. }
  1496. /**
  1497. * send_set_sta_ps_mode_cmd_tlv() - set sta powersave mode in fw
  1498. * @wmi_handle: wmi handle
  1499. * @vdev_id: vdev id
  1500. * @val: value
  1501. *
  1502. * Return: 0 for success or error code.
  1503. */
  1504. QDF_STATUS send_set_sta_ps_mode_cmd_tlv(wmi_unified_t wmi_handle,
  1505. uint32_t vdev_id, uint8_t val)
  1506. {
  1507. wmi_sta_powersave_mode_cmd_fixed_param *cmd;
  1508. wmi_buf_t buf;
  1509. int32_t len = sizeof(*cmd);
  1510. WMI_LOGD("Set Sta Mode Ps vdevId %d val %d", vdev_id, val);
  1511. buf = wmi_buf_alloc(wmi_handle, len);
  1512. if (!buf) {
  1513. WMI_LOGP("%s: Set Sta Mode Ps Mem Alloc Failed", __func__);
  1514. return -ENOMEM;
  1515. }
  1516. cmd = (wmi_sta_powersave_mode_cmd_fixed_param *) wmi_buf_data(buf);
  1517. WMITLV_SET_HDR(&cmd->tlv_header,
  1518. WMITLV_TAG_STRUC_wmi_sta_powersave_mode_cmd_fixed_param,
  1519. WMITLV_GET_STRUCT_TLVLEN
  1520. (wmi_sta_powersave_mode_cmd_fixed_param));
  1521. cmd->vdev_id = vdev_id;
  1522. if (val)
  1523. cmd->sta_ps_mode = WMI_STA_PS_MODE_ENABLED;
  1524. else
  1525. cmd->sta_ps_mode = WMI_STA_PS_MODE_DISABLED;
  1526. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  1527. WMI_STA_POWERSAVE_MODE_CMDID)) {
  1528. WMI_LOGE("Set Sta Mode Ps Failed vdevId %d val %d",
  1529. vdev_id, val);
  1530. qdf_nbuf_free(buf);
  1531. return -EIO;
  1532. }
  1533. return 0;
  1534. }
  1535. /**
  1536. * send_set_mimops_cmd_tlv() - set MIMO powersave
  1537. * @wmi_handle: wmi handle
  1538. * @vdev_id: vdev id
  1539. * @value: value
  1540. *
  1541. * Return: QDF_STATUS_SUCCESS for success or error code.
  1542. */
  1543. QDF_STATUS send_set_mimops_cmd_tlv(wmi_unified_t wmi_handle,
  1544. uint8_t vdev_id, int value)
  1545. {
  1546. int ret = QDF_STATUS_SUCCESS;
  1547. wmi_sta_smps_force_mode_cmd_fixed_param *cmd;
  1548. wmi_buf_t buf;
  1549. uint16_t len = sizeof(*cmd);
  1550. buf = wmi_buf_alloc(wmi_handle, len);
  1551. if (!buf) {
  1552. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  1553. return -ENOMEM;
  1554. }
  1555. cmd = (wmi_sta_smps_force_mode_cmd_fixed_param *) wmi_buf_data(buf);
  1556. WMITLV_SET_HDR(&cmd->tlv_header,
  1557. WMITLV_TAG_STRUC_wmi_sta_smps_force_mode_cmd_fixed_param,
  1558. WMITLV_GET_STRUCT_TLVLEN
  1559. (wmi_sta_smps_force_mode_cmd_fixed_param));
  1560. cmd->vdev_id = vdev_id;
  1561. switch (value) {
  1562. case 0:
  1563. cmd->forced_mode = WMI_SMPS_FORCED_MODE_NONE;
  1564. break;
  1565. case 1:
  1566. cmd->forced_mode = WMI_SMPS_FORCED_MODE_DISABLED;
  1567. break;
  1568. case 2:
  1569. cmd->forced_mode = WMI_SMPS_FORCED_MODE_STATIC;
  1570. break;
  1571. case 3:
  1572. cmd->forced_mode = WMI_SMPS_FORCED_MODE_DYNAMIC;
  1573. break;
  1574. default:
  1575. WMI_LOGE("%s:INVALID Mimo PS CONFIG", __func__);
  1576. return QDF_STATUS_E_FAILURE;
  1577. }
  1578. WMI_LOGD("Setting vdev %d value = %u", vdev_id, value);
  1579. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1580. WMI_STA_SMPS_FORCE_MODE_CMDID);
  1581. if (ret < 0) {
  1582. WMI_LOGE("Failed to send set Mimo PS ret = %d", ret);
  1583. wmi_buf_free(buf);
  1584. }
  1585. return ret;
  1586. }
  1587. /**
  1588. * send_set_smps_params_cmd_tlv() - set smps params
  1589. * @wmi_handle: wmi handle
  1590. * @vdev_id: vdev id
  1591. * @value: value
  1592. *
  1593. * Return: QDF_STATUS_SUCCESS for success or error code.
  1594. */
  1595. QDF_STATUS send_set_smps_params_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
  1596. int value)
  1597. {
  1598. int ret = QDF_STATUS_SUCCESS;
  1599. wmi_sta_smps_param_cmd_fixed_param *cmd;
  1600. wmi_buf_t buf;
  1601. uint16_t len = sizeof(*cmd);
  1602. buf = wmi_buf_alloc(wmi_handle, len);
  1603. if (!buf) {
  1604. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  1605. return -ENOMEM;
  1606. }
  1607. cmd = (wmi_sta_smps_param_cmd_fixed_param *) wmi_buf_data(buf);
  1608. WMITLV_SET_HDR(&cmd->tlv_header,
  1609. WMITLV_TAG_STRUC_wmi_sta_smps_param_cmd_fixed_param,
  1610. WMITLV_GET_STRUCT_TLVLEN
  1611. (wmi_sta_smps_param_cmd_fixed_param));
  1612. cmd->vdev_id = vdev_id;
  1613. cmd->value = value & WMI_SMPS_MASK_LOWER_16BITS;
  1614. cmd->param =
  1615. (value >> WMI_SMPS_PARAM_VALUE_S) & WMI_SMPS_MASK_UPPER_3BITS;
  1616. WMI_LOGD("Setting vdev %d value = %x param %x", vdev_id, cmd->value,
  1617. cmd->param);
  1618. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1619. WMI_STA_SMPS_PARAM_CMDID);
  1620. if (ret < 0) {
  1621. WMI_LOGE("Failed to send set Mimo PS ret = %d", ret);
  1622. wmi_buf_free(buf);
  1623. }
  1624. return ret;
  1625. }
  1626. /**
  1627. * send_set_p2pgo_noa_req_cmd_tlv() - send p2p go noa request to fw
  1628. * @wmi_handle: wmi handle
  1629. * @noa: p2p power save parameters
  1630. *
  1631. * Return: CDF status
  1632. */
  1633. QDF_STATUS send_set_p2pgo_noa_req_cmd_tlv(wmi_unified_t wmi_handle,
  1634. struct p2p_ps_params *noa)
  1635. {
  1636. wmi_p2p_set_noa_cmd_fixed_param *cmd;
  1637. wmi_p2p_noa_descriptor *noa_discriptor;
  1638. wmi_buf_t buf;
  1639. uint8_t *buf_ptr;
  1640. uint16_t len;
  1641. int32_t status;
  1642. uint32_t duration;
  1643. WMI_LOGD("%s: Enter", __func__);
  1644. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + sizeof(*noa_discriptor);
  1645. buf = wmi_buf_alloc(wmi_handle, len);
  1646. if (!buf) {
  1647. WMI_LOGE("Failed to allocate memory");
  1648. status = QDF_STATUS_E_FAILURE;
  1649. goto end;
  1650. }
  1651. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1652. cmd = (wmi_p2p_set_noa_cmd_fixed_param *) buf_ptr;
  1653. WMITLV_SET_HDR(&cmd->tlv_header,
  1654. WMITLV_TAG_STRUC_wmi_p2p_set_noa_cmd_fixed_param,
  1655. WMITLV_GET_STRUCT_TLVLEN
  1656. (wmi_p2p_set_noa_cmd_fixed_param));
  1657. duration = (noa->count == 1) ? noa->single_noa_duration : noa->duration;
  1658. cmd->vdev_id = noa->session_id;
  1659. cmd->enable = (duration) ? true : false;
  1660. cmd->num_noa = 1;
  1661. WMITLV_SET_HDR((buf_ptr + sizeof(wmi_p2p_set_noa_cmd_fixed_param)),
  1662. WMITLV_TAG_ARRAY_STRUC, sizeof(wmi_p2p_noa_descriptor));
  1663. noa_discriptor = (wmi_p2p_noa_descriptor *) (buf_ptr +
  1664. sizeof
  1665. (wmi_p2p_set_noa_cmd_fixed_param)
  1666. + WMI_TLV_HDR_SIZE);
  1667. WMITLV_SET_HDR(&noa_discriptor->tlv_header,
  1668. WMITLV_TAG_STRUC_wmi_p2p_noa_descriptor,
  1669. WMITLV_GET_STRUCT_TLVLEN(wmi_p2p_noa_descriptor));
  1670. noa_discriptor->type_count = noa->count;
  1671. noa_discriptor->duration = duration;
  1672. noa_discriptor->interval = noa->interval;
  1673. noa_discriptor->start_time = 0;
  1674. WMI_LOGI("SET P2P GO NOA:vdev_id:%d count:%d duration:%d interval:%d",
  1675. cmd->vdev_id, noa->count, noa_discriptor->duration,
  1676. noa->interval);
  1677. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  1678. WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID);
  1679. if (status != EOK) {
  1680. WMI_LOGE("Failed to send WMI_FWTEST_P2P_SET_NOA_PARAM_CMDID");
  1681. wmi_buf_free(buf);
  1682. }
  1683. end:
  1684. WMI_LOGD("%s: Exit", __func__);
  1685. return status;
  1686. }
  1687. /**
  1688. * send_set_p2pgo_oppps_req_cmd_tlv() - send p2p go opp power save request to fw
  1689. * @wmi_handle: wmi handle
  1690. * @noa: p2p opp power save parameters
  1691. *
  1692. * Return: CDF status
  1693. */
  1694. QDF_STATUS send_set_p2pgo_oppps_req_cmd_tlv(wmi_unified_t wmi_handle,
  1695. struct p2p_ps_params *oppps)
  1696. {
  1697. wmi_p2p_set_oppps_cmd_fixed_param *cmd;
  1698. wmi_buf_t buf;
  1699. int32_t status;
  1700. WMI_LOGD("%s: Enter", __func__);
  1701. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  1702. if (!buf) {
  1703. WMI_LOGE("Failed to allocate memory");
  1704. status = QDF_STATUS_E_FAILURE;
  1705. goto end;
  1706. }
  1707. cmd = (wmi_p2p_set_oppps_cmd_fixed_param *) wmi_buf_data(buf);
  1708. WMITLV_SET_HDR(&cmd->tlv_header,
  1709. WMITLV_TAG_STRUC_wmi_p2p_set_oppps_cmd_fixed_param,
  1710. WMITLV_GET_STRUCT_TLVLEN
  1711. (wmi_p2p_set_oppps_cmd_fixed_param));
  1712. cmd->vdev_id = oppps->session_id;
  1713. if (oppps->ctwindow)
  1714. WMI_UNIFIED_OPPPS_ATTR_ENABLED_SET(cmd);
  1715. WMI_UNIFIED_OPPPS_ATTR_CTWIN_SET(cmd, oppps->ctwindow);
  1716. WMI_LOGI("SET P2P GO OPPPS:vdev_id:%d ctwindow:%d",
  1717. cmd->vdev_id, oppps->ctwindow);
  1718. status = wmi_unified_cmd_send(wmi_handle, buf, sizeof(*cmd),
  1719. WMI_P2P_SET_OPPPS_PARAM_CMDID);
  1720. if (status != EOK) {
  1721. WMI_LOGE("Failed to send WMI_P2P_SET_OPPPS_PARAM_CMDID");
  1722. wmi_buf_free(buf);
  1723. }
  1724. end:
  1725. WMI_LOGD("%s: Exit", __func__);
  1726. return status;
  1727. }
  1728. /**
  1729. * send_get_temperature_cmd_tlv() - get pdev temperature req
  1730. * @wmi_handle: wmi handle
  1731. *
  1732. * Return: QDF_STATUS_SUCCESS for success or error code.
  1733. */
  1734. QDF_STATUS send_get_temperature_cmd_tlv(wmi_unified_t wmi_handle)
  1735. {
  1736. wmi_pdev_get_temperature_cmd_fixed_param *cmd;
  1737. wmi_buf_t wmi_buf;
  1738. uint32_t len = sizeof(wmi_pdev_get_temperature_cmd_fixed_param);
  1739. uint8_t *buf_ptr;
  1740. if (!wmi_handle) {
  1741. WMI_LOGE(FL("WMI is closed, can not issue cmd"));
  1742. return QDF_STATUS_E_INVAL;
  1743. }
  1744. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  1745. if (!wmi_buf) {
  1746. WMI_LOGE(FL("wmi_buf_alloc failed"));
  1747. return QDF_STATUS_E_NOMEM;
  1748. }
  1749. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  1750. cmd = (wmi_pdev_get_temperature_cmd_fixed_param *) buf_ptr;
  1751. WMITLV_SET_HDR(&cmd->tlv_header,
  1752. WMITLV_TAG_STRUC_wmi_pdev_get_temperature_cmd_fixed_param,
  1753. WMITLV_GET_STRUCT_TLVLEN
  1754. (wmi_pdev_get_temperature_cmd_fixed_param));
  1755. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  1756. WMI_PDEV_GET_TEMPERATURE_CMDID)) {
  1757. WMI_LOGE(FL("failed to send get temperature command"));
  1758. wmi_buf_free(wmi_buf);
  1759. return QDF_STATUS_E_FAILURE;
  1760. }
  1761. return QDF_STATUS_SUCCESS;
  1762. }
  1763. /**
  1764. * send_set_sta_uapsd_auto_trig_cmd_tlv() - set uapsd auto trigger command
  1765. * @wmi_handle: wmi handle
  1766. * @vdevid: vdev id
  1767. * @peer_addr: peer mac address
  1768. * @auto_triggerparam: auto trigger parameters
  1769. * @num_ac: number of access category
  1770. *
  1771. * This function sets the trigger
  1772. * uapsd params such as service interval, delay interval
  1773. * and suspend interval which will be used by the firmware
  1774. * to send trigger frames periodically when there is no
  1775. * traffic on the transmit side.
  1776. *
  1777. * Return: 0 for success or error code.
  1778. */
  1779. QDF_STATUS send_set_sta_uapsd_auto_trig_cmd_tlv(wmi_unified_t wmi_handle,
  1780. struct sta_uapsd_trig_params *param)
  1781. {
  1782. wmi_sta_uapsd_auto_trig_cmd_fixed_param *cmd;
  1783. int32_t ret;
  1784. uint32_t param_len = param->num_ac * sizeof(wmi_sta_uapsd_auto_trig_param);
  1785. uint32_t cmd_len = sizeof(*cmd) + param_len + WMI_TLV_HDR_SIZE;
  1786. uint32_t i;
  1787. wmi_buf_t buf;
  1788. uint8_t *buf_ptr;
  1789. buf = wmi_buf_alloc(wmi_handle, cmd_len);
  1790. if (!buf) {
  1791. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  1792. return -ENOMEM;
  1793. }
  1794. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  1795. cmd = (wmi_sta_uapsd_auto_trig_cmd_fixed_param *) buf_ptr;
  1796. WMITLV_SET_HDR(&cmd->tlv_header,
  1797. WMITLV_TAG_STRUC_wmi_sta_uapsd_auto_trig_cmd_fixed_param,
  1798. WMITLV_GET_STRUCT_TLVLEN
  1799. (wmi_sta_uapsd_auto_trig_cmd_fixed_param));
  1800. cmd->vdev_id = param->vdevid;
  1801. cmd->num_ac = param->num_ac;
  1802. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->peer_addr, &cmd->peer_macaddr);
  1803. /* TLV indicating array of structures to follow */
  1804. buf_ptr += sizeof(*cmd);
  1805. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, param_len);
  1806. buf_ptr += WMI_TLV_HDR_SIZE;
  1807. qdf_mem_copy(buf_ptr, param->auto_triggerparam, param_len);
  1808. /*
  1809. * Update tag and length for uapsd auto trigger params (this will take
  1810. * care of updating tag and length if it is not pre-filled by caller).
  1811. */
  1812. for (i = 0; i < param->num_ac; i++) {
  1813. WMITLV_SET_HDR((buf_ptr +
  1814. (i * sizeof(wmi_sta_uapsd_auto_trig_param))),
  1815. WMITLV_TAG_STRUC_wmi_sta_uapsd_auto_trig_param,
  1816. WMITLV_GET_STRUCT_TLVLEN
  1817. (wmi_sta_uapsd_auto_trig_param));
  1818. }
  1819. ret = wmi_unified_cmd_send(wmi_handle, buf, cmd_len,
  1820. WMI_STA_UAPSD_AUTO_TRIG_CMDID);
  1821. if (ret != EOK) {
  1822. WMI_LOGE("Failed to send set uapsd param ret = %d", ret);
  1823. wmi_buf_free(buf);
  1824. }
  1825. return ret;
  1826. }
  1827. /**
  1828. * send_ocb_set_utc_time_cmd() - send the UTC time to the firmware
  1829. * @wmi_handle: pointer to the wmi handle
  1830. * @utc: pointer to the UTC time struct
  1831. *
  1832. * Return: 0 on succes
  1833. */
  1834. QDF_STATUS send_ocb_set_utc_time_cmd_tlv(wmi_unified_t wmi_handle,
  1835. struct ocb_utc_param *utc)
  1836. {
  1837. int32_t ret;
  1838. wmi_ocb_set_utc_time_cmd_fixed_param *cmd;
  1839. uint8_t *buf_ptr;
  1840. uint32_t len, i;
  1841. wmi_buf_t buf;
  1842. len = sizeof(*cmd);
  1843. buf = wmi_buf_alloc(wmi_handle, len);
  1844. if (!buf) {
  1845. WMI_LOGE(FL("wmi_buf_alloc failed"));
  1846. return -ENOMEM;
  1847. }
  1848. buf_ptr = (uint8_t *)wmi_buf_data(buf);
  1849. cmd = (wmi_ocb_set_utc_time_cmd_fixed_param *)buf_ptr;
  1850. WMITLV_SET_HDR(&cmd->tlv_header,
  1851. WMITLV_TAG_STRUC_wmi_ocb_set_utc_time_cmd_fixed_param,
  1852. WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_set_utc_time_cmd_fixed_param));
  1853. cmd->vdev_id = utc->vdev_id;
  1854. for (i = 0; i < SIZE_UTC_TIME; i++)
  1855. WMI_UTC_TIME_SET(cmd, i, utc->utc_time[i]);
  1856. for (i = 0; i < SIZE_UTC_TIME_ERROR; i++)
  1857. WMI_TIME_ERROR_SET(cmd, i, utc->time_error[i]);
  1858. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1859. WMI_OCB_SET_UTC_TIME_CMDID);
  1860. if (ret != EOK) {
  1861. WMI_LOGE(FL("Failed to set OCB UTC time"));
  1862. wmi_buf_free(buf);
  1863. return -EIO;
  1864. }
  1865. return QDF_STATUS_SUCCESS;
  1866. }
  1867. /**
  1868. * send_ocb_start_timing_advert_cmd_tlv() - start sending the timing advertisement
  1869. * frames on a channel
  1870. * @wmi_handle: pointer to the wmi handle
  1871. * @timing_advert: pointer to the timing advertisement struct
  1872. *
  1873. * Return: 0 on succes
  1874. */
  1875. QDF_STATUS send_ocb_start_timing_advert_cmd_tlv(wmi_unified_t wmi_handle,
  1876. struct ocb_timing_advert_param *timing_advert)
  1877. {
  1878. int32_t ret;
  1879. wmi_ocb_start_timing_advert_cmd_fixed_param *cmd;
  1880. uint8_t *buf_ptr;
  1881. uint32_t len, len_template;
  1882. wmi_buf_t buf;
  1883. len = sizeof(*cmd) +
  1884. WMI_TLV_HDR_SIZE;
  1885. len_template = timing_advert->template_length;
  1886. /* Add padding to the template if needed */
  1887. if (len_template % 4 != 0)
  1888. len_template += 4 - (len_template % 4);
  1889. len += len_template;
  1890. buf = wmi_buf_alloc(wmi_handle, len);
  1891. if (!buf) {
  1892. WMI_LOGE(FL("wmi_buf_alloc failed"));
  1893. return -ENOMEM;
  1894. }
  1895. buf_ptr = (uint8_t *)wmi_buf_data(buf);
  1896. cmd = (wmi_ocb_start_timing_advert_cmd_fixed_param *)buf_ptr;
  1897. WMITLV_SET_HDR(&cmd->tlv_header,
  1898. WMITLV_TAG_STRUC_wmi_ocb_start_timing_advert_cmd_fixed_param,
  1899. WMITLV_GET_STRUCT_TLVLEN(
  1900. wmi_ocb_start_timing_advert_cmd_fixed_param));
  1901. cmd->vdev_id = timing_advert->vdev_id;
  1902. cmd->repeat_rate = timing_advert->repeat_rate;
  1903. cmd->channel_freq = timing_advert->chan_freq;
  1904. cmd->timestamp_offset = timing_advert->timestamp_offset;
  1905. cmd->time_value_offset = timing_advert->time_value_offset;
  1906. cmd->timing_advert_template_length = timing_advert->template_length;
  1907. buf_ptr += sizeof(*cmd);
  1908. /* Add the timing advert template */
  1909. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  1910. len_template);
  1911. qdf_mem_copy(buf_ptr + WMI_TLV_HDR_SIZE,
  1912. (uint8_t *)timing_advert->template_value,
  1913. timing_advert->template_length);
  1914. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1915. WMI_OCB_START_TIMING_ADVERT_CMDID);
  1916. if (ret != EOK) {
  1917. WMI_LOGE(FL("Failed to start OCB timing advert"));
  1918. wmi_buf_free(buf);
  1919. return -EIO;
  1920. }
  1921. return QDF_STATUS_SUCCESS;
  1922. }
  1923. /**
  1924. * send_ocb_stop_timing_advert_cmd_tlv() - stop sending the timing advertisement frames
  1925. * on a channel
  1926. * @wmi_handle: pointer to the wmi handle
  1927. * @timing_advert: pointer to the timing advertisement struct
  1928. *
  1929. * Return: 0 on succes
  1930. */
  1931. QDF_STATUS send_ocb_stop_timing_advert_cmd_tlv(wmi_unified_t wmi_handle,
  1932. struct ocb_timing_advert_param *timing_advert)
  1933. {
  1934. int32_t ret;
  1935. wmi_ocb_stop_timing_advert_cmd_fixed_param *cmd;
  1936. uint8_t *buf_ptr;
  1937. uint32_t len;
  1938. wmi_buf_t buf;
  1939. len = sizeof(*cmd);
  1940. buf = wmi_buf_alloc(wmi_handle, len);
  1941. if (!buf) {
  1942. WMI_LOGE(FL("wmi_buf_alloc failed"));
  1943. return -ENOMEM;
  1944. }
  1945. buf_ptr = (uint8_t *)wmi_buf_data(buf);
  1946. cmd = (wmi_ocb_stop_timing_advert_cmd_fixed_param *)buf_ptr;
  1947. WMITLV_SET_HDR(&cmd->tlv_header,
  1948. WMITLV_TAG_STRUC_wmi_ocb_stop_timing_advert_cmd_fixed_param,
  1949. WMITLV_GET_STRUCT_TLVLEN(
  1950. wmi_ocb_stop_timing_advert_cmd_fixed_param));
  1951. cmd->vdev_id = timing_advert->vdev_id;
  1952. cmd->channel_freq = timing_advert->chan_freq;
  1953. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1954. WMI_OCB_STOP_TIMING_ADVERT_CMDID);
  1955. if (ret != EOK) {
  1956. WMI_LOGE(FL("Failed to stop OCB timing advert"));
  1957. wmi_buf_free(buf);
  1958. return -EIO;
  1959. }
  1960. return QDF_STATUS_SUCCESS;
  1961. }
  1962. /**
  1963. * send_ocb_get_tsf_timer_cmd_tlv() - get ocb tsf timer val
  1964. * @wmi_handle: pointer to the wmi handle
  1965. * @request: pointer to the request
  1966. *
  1967. * Return: 0 on succes
  1968. */
  1969. QDF_STATUS send_ocb_get_tsf_timer_cmd_tlv(wmi_unified_t wmi_handle,
  1970. uint8_t vdev_id)
  1971. {
  1972. QDF_STATUS ret;
  1973. wmi_ocb_get_tsf_timer_cmd_fixed_param *cmd;
  1974. uint8_t *buf_ptr;
  1975. wmi_buf_t buf;
  1976. int32_t len;
  1977. len = sizeof(*cmd);
  1978. buf = wmi_buf_alloc(wmi_handle, len);
  1979. if (!buf) {
  1980. WMI_LOGE(FL("wmi_buf_alloc failed"));
  1981. return -ENOMEM;
  1982. }
  1983. buf_ptr = (uint8_t *)wmi_buf_data(buf);
  1984. cmd = (wmi_ocb_get_tsf_timer_cmd_fixed_param *)buf_ptr;
  1985. qdf_mem_zero(cmd, len);
  1986. WMITLV_SET_HDR(&cmd->tlv_header,
  1987. WMITLV_TAG_STRUC_wmi_ocb_get_tsf_timer_cmd_fixed_param,
  1988. WMITLV_GET_STRUCT_TLVLEN(
  1989. wmi_ocb_get_tsf_timer_cmd_fixed_param));
  1990. cmd->vdev_id = vdev_id;
  1991. /* Send the WMI command */
  1992. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  1993. WMI_OCB_GET_TSF_TIMER_CMDID);
  1994. /* If there is an error, set the completion event */
  1995. if (ret != EOK) {
  1996. WMI_LOGE(FL("Failed to send WMI message: %d"), ret);
  1997. wmi_buf_free(buf);
  1998. return -EIO;
  1999. }
  2000. return QDF_STATUS_SUCCESS;
  2001. }
  2002. /**
  2003. * send_dcc_get_stats_cmd_tlv() - get the DCC channel stats
  2004. * @wmi_handle: pointer to the wmi handle
  2005. * @get_stats_param: pointer to the dcc stats
  2006. *
  2007. * Return: 0 on succes
  2008. */
  2009. QDF_STATUS send_dcc_get_stats_cmd_tlv(wmi_unified_t wmi_handle,
  2010. struct dcc_get_stats_param *get_stats_param)
  2011. {
  2012. int32_t ret;
  2013. wmi_dcc_get_stats_cmd_fixed_param *cmd;
  2014. wmi_dcc_channel_stats_request *channel_stats_array;
  2015. wmi_buf_t buf;
  2016. uint8_t *buf_ptr;
  2017. uint32_t len;
  2018. uint32_t i;
  2019. /* Validate the input */
  2020. if (get_stats_param->request_array_len !=
  2021. get_stats_param->channel_count * sizeof(*channel_stats_array)) {
  2022. WMI_LOGE(FL("Invalid parameter"));
  2023. return -EINVAL;
  2024. }
  2025. /* Allocate memory for the WMI command */
  2026. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
  2027. get_stats_param->request_array_len;
  2028. buf = wmi_buf_alloc(wmi_handle, len);
  2029. if (!buf) {
  2030. WMI_LOGE(FL("wmi_buf_alloc failed"));
  2031. return QDF_STATUS_E_NOMEM;
  2032. }
  2033. buf_ptr = wmi_buf_data(buf);
  2034. qdf_mem_zero(buf_ptr, len);
  2035. /* Populate the WMI command */
  2036. cmd = (wmi_dcc_get_stats_cmd_fixed_param *)buf_ptr;
  2037. buf_ptr += sizeof(*cmd);
  2038. WMITLV_SET_HDR(&cmd->tlv_header,
  2039. WMITLV_TAG_STRUC_wmi_dcc_get_stats_cmd_fixed_param,
  2040. WMITLV_GET_STRUCT_TLVLEN(
  2041. wmi_dcc_get_stats_cmd_fixed_param));
  2042. cmd->vdev_id = get_stats_param->vdev_id;
  2043. cmd->num_channels = get_stats_param->channel_count;
  2044. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2045. get_stats_param->request_array_len);
  2046. buf_ptr += WMI_TLV_HDR_SIZE;
  2047. channel_stats_array = (wmi_dcc_channel_stats_request *)buf_ptr;
  2048. qdf_mem_copy(channel_stats_array, get_stats_param->request_array,
  2049. get_stats_param->request_array_len);
  2050. for (i = 0; i < cmd->num_channels; i++)
  2051. WMITLV_SET_HDR(&channel_stats_array[i].tlv_header,
  2052. WMITLV_TAG_STRUC_wmi_dcc_channel_stats_request,
  2053. WMITLV_GET_STRUCT_TLVLEN(
  2054. wmi_dcc_channel_stats_request));
  2055. /* Send the WMI command */
  2056. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2057. WMI_DCC_GET_STATS_CMDID);
  2058. if (ret != EOK) {
  2059. WMI_LOGE(FL("Failed to send WMI message: %d"), ret);
  2060. wmi_buf_free(buf);
  2061. return -EIO;
  2062. }
  2063. return QDF_STATUS_SUCCESS;
  2064. }
  2065. /**
  2066. * send_dcc_clear_stats_cmd_tlv() - command to clear the DCC stats
  2067. * @wmi_handle: pointer to the wmi handle
  2068. * @vdev_id: vdev id
  2069. * @dcc_stats_bitmap: dcc status bitmap
  2070. *
  2071. * Return: 0 on succes
  2072. */
  2073. QDF_STATUS send_dcc_clear_stats_cmd_tlv(wmi_unified_t wmi_handle,
  2074. uint32_t vdev_id, uint32_t dcc_stats_bitmap)
  2075. {
  2076. int32_t ret;
  2077. wmi_dcc_clear_stats_cmd_fixed_param *cmd;
  2078. wmi_buf_t buf;
  2079. uint8_t *buf_ptr;
  2080. uint32_t len;
  2081. /* Allocate memory for the WMI command */
  2082. len = sizeof(*cmd);
  2083. buf = wmi_buf_alloc(wmi_handle, len);
  2084. if (!buf) {
  2085. WMI_LOGE(FL("wmi_buf_alloc failed"));
  2086. return -ENOMEM;
  2087. }
  2088. buf_ptr = wmi_buf_data(buf);
  2089. qdf_mem_zero(buf_ptr, len);
  2090. /* Populate the WMI command */
  2091. cmd = (wmi_dcc_clear_stats_cmd_fixed_param *)buf_ptr;
  2092. WMITLV_SET_HDR(&cmd->tlv_header,
  2093. WMITLV_TAG_STRUC_wmi_dcc_clear_stats_cmd_fixed_param,
  2094. WMITLV_GET_STRUCT_TLVLEN(
  2095. wmi_dcc_clear_stats_cmd_fixed_param));
  2096. cmd->vdev_id = vdev_id;
  2097. cmd->dcc_stats_bitmap = dcc_stats_bitmap;
  2098. /* Send the WMI command */
  2099. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2100. WMI_DCC_CLEAR_STATS_CMDID);
  2101. if (ret != EOK) {
  2102. WMI_LOGE(FL("Failed to send the WMI command"));
  2103. wmi_buf_free(buf);
  2104. return -EIO;
  2105. }
  2106. return QDF_STATUS_SUCCESS;
  2107. }
  2108. /**
  2109. * send_dcc_update_ndl_cmd_tlv() - command to update the NDL data
  2110. * @wmi_handle: pointer to the wmi handle
  2111. * @update_ndl_param: pointer to the request parameters
  2112. *
  2113. * Return: 0 on success
  2114. */
  2115. QDF_STATUS send_dcc_update_ndl_cmd_tlv(wmi_unified_t wmi_handle,
  2116. struct dcc_update_ndl_param *update_ndl_param)
  2117. {
  2118. QDF_STATUS qdf_status;
  2119. wmi_dcc_update_ndl_cmd_fixed_param *cmd;
  2120. wmi_dcc_ndl_chan *ndl_chan_array;
  2121. wmi_dcc_ndl_active_state_config *ndl_active_state_array;
  2122. uint32_t active_state_count;
  2123. wmi_buf_t buf;
  2124. uint8_t *buf_ptr;
  2125. uint32_t len;
  2126. uint32_t i;
  2127. /* validate the input */
  2128. if (update_ndl_param->dcc_ndl_chan_list_len !=
  2129. update_ndl_param->channel_count * sizeof(*ndl_chan_array)) {
  2130. WMI_LOGE(FL("Invalid parameter"));
  2131. return QDF_STATUS_E_INVAL;
  2132. }
  2133. active_state_count = 0;
  2134. ndl_chan_array = update_ndl_param->dcc_ndl_chan_list;
  2135. for (i = 0; i < update_ndl_param->channel_count; i++)
  2136. active_state_count +=
  2137. WMI_NDL_NUM_ACTIVE_STATE_GET(&ndl_chan_array[i]);
  2138. if (update_ndl_param->dcc_ndl_active_state_list_len !=
  2139. active_state_count * sizeof(*ndl_active_state_array)) {
  2140. WMI_LOGE(FL("Invalid parameter"));
  2141. return QDF_STATUS_E_INVAL;
  2142. }
  2143. /* Allocate memory for the WMI command */
  2144. len = sizeof(*cmd) +
  2145. WMI_TLV_HDR_SIZE + update_ndl_param->dcc_ndl_chan_list_len +
  2146. WMI_TLV_HDR_SIZE +
  2147. update_ndl_param->dcc_ndl_active_state_list_len;
  2148. buf = wmi_buf_alloc(wmi_handle, len);
  2149. if (!buf) {
  2150. WMI_LOGE(FL("wmi_buf_alloc failed"));
  2151. return -ENOMEM;
  2152. }
  2153. buf_ptr = wmi_buf_data(buf);
  2154. qdf_mem_zero(buf_ptr, len);
  2155. /* Populate the WMI command */
  2156. cmd = (wmi_dcc_update_ndl_cmd_fixed_param *)buf_ptr;
  2157. buf_ptr += sizeof(*cmd);
  2158. WMITLV_SET_HDR(&cmd->tlv_header,
  2159. WMITLV_TAG_STRUC_wmi_dcc_update_ndl_cmd_fixed_param,
  2160. WMITLV_GET_STRUCT_TLVLEN(
  2161. wmi_dcc_update_ndl_cmd_fixed_param));
  2162. cmd->vdev_id = update_ndl_param->vdev_id;
  2163. cmd->num_channel = update_ndl_param->channel_count;
  2164. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2165. update_ndl_param->dcc_ndl_chan_list_len);
  2166. buf_ptr += WMI_TLV_HDR_SIZE;
  2167. ndl_chan_array = (wmi_dcc_ndl_chan *)buf_ptr;
  2168. qdf_mem_copy(ndl_chan_array, update_ndl_param->dcc_ndl_chan_list,
  2169. update_ndl_param->dcc_ndl_chan_list_len);
  2170. for (i = 0; i < cmd->num_channel; i++)
  2171. WMITLV_SET_HDR(&ndl_chan_array[i].tlv_header,
  2172. WMITLV_TAG_STRUC_wmi_dcc_ndl_chan,
  2173. WMITLV_GET_STRUCT_TLVLEN(
  2174. wmi_dcc_ndl_chan));
  2175. buf_ptr += update_ndl_param->dcc_ndl_chan_list_len;
  2176. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2177. update_ndl_param->dcc_ndl_active_state_list_len);
  2178. buf_ptr += WMI_TLV_HDR_SIZE;
  2179. ndl_active_state_array = (wmi_dcc_ndl_active_state_config *) buf_ptr;
  2180. qdf_mem_copy(ndl_active_state_array,
  2181. update_ndl_param->dcc_ndl_active_state_list,
  2182. update_ndl_param->dcc_ndl_active_state_list_len);
  2183. for (i = 0; i < active_state_count; i++) {
  2184. WMITLV_SET_HDR(&ndl_active_state_array[i].tlv_header,
  2185. WMITLV_TAG_STRUC_wmi_dcc_ndl_active_state_config,
  2186. WMITLV_GET_STRUCT_TLVLEN(
  2187. wmi_dcc_ndl_active_state_config));
  2188. }
  2189. buf_ptr += update_ndl_param->dcc_ndl_active_state_list_len;
  2190. /* Send the WMI command */
  2191. qdf_status = wmi_unified_cmd_send(wmi_handle, buf, len,
  2192. WMI_DCC_UPDATE_NDL_CMDID);
  2193. /* If there is an error, set the completion event */
  2194. if (qdf_status) {
  2195. WMI_LOGE(FL("Failed to send WMI message: %d"), qdf_status);
  2196. wmi_buf_free(buf);
  2197. return -EIO;
  2198. }
  2199. return 0;
  2200. }
  2201. /**
  2202. * send_ocb_set_config_cmd_tlv() - send the OCB config to the FW
  2203. * @wmi_handle: pointer to the wmi handle
  2204. * @config: the OCB configuration
  2205. *
  2206. * Return: 0 on success
  2207. */
  2208. QDF_STATUS send_ocb_set_config_cmd_tlv(wmi_unified_t wmi_handle,
  2209. struct ocb_config_param *config, uint32_t *ch_mhz)
  2210. {
  2211. int32_t ret;
  2212. wmi_ocb_set_config_cmd_fixed_param *cmd;
  2213. wmi_channel *chan;
  2214. wmi_ocb_channel *ocb_chan;
  2215. wmi_qos_parameter *qos_param;
  2216. wmi_dcc_ndl_chan *ndl_chan;
  2217. wmi_dcc_ndl_active_state_config *ndl_active_config;
  2218. wmi_ocb_schedule_element *sched_elem;
  2219. uint8_t *buf_ptr;
  2220. wmi_buf_t buf;
  2221. int32_t len;
  2222. int32_t i, j, active_state_count;
  2223. /*
  2224. * Validate the dcc_ndl_chan_list_len and count the number of active
  2225. * states. Validate dcc_ndl_active_state_list_len.
  2226. */
  2227. active_state_count = 0;
  2228. if (config->dcc_ndl_chan_list_len) {
  2229. if (!config->dcc_ndl_chan_list ||
  2230. config->dcc_ndl_chan_list_len !=
  2231. config->channel_count * sizeof(wmi_dcc_ndl_chan)) {
  2232. WMI_LOGE(FL("NDL channel is invalid. List len: %d"),
  2233. config->dcc_ndl_chan_list_len);
  2234. return -EINVAL;
  2235. }
  2236. for (i = 0, ndl_chan = config->dcc_ndl_chan_list;
  2237. i < config->channel_count; ++i, ++ndl_chan)
  2238. active_state_count +=
  2239. WMI_NDL_NUM_ACTIVE_STATE_GET(ndl_chan);
  2240. if (active_state_count) {
  2241. if (!config->dcc_ndl_active_state_list ||
  2242. config->dcc_ndl_active_state_list_len !=
  2243. active_state_count *
  2244. sizeof(wmi_dcc_ndl_active_state_config)) {
  2245. WMI_LOGE(FL("NDL active state is invalid."));
  2246. return -EINVAL;
  2247. }
  2248. }
  2249. }
  2250. len = sizeof(*cmd) +
  2251. WMI_TLV_HDR_SIZE + config->channel_count *
  2252. sizeof(wmi_channel) +
  2253. WMI_TLV_HDR_SIZE + config->channel_count *
  2254. sizeof(wmi_ocb_channel) +
  2255. WMI_TLV_HDR_SIZE + config->channel_count *
  2256. sizeof(wmi_qos_parameter) * WMI_MAX_NUM_AC +
  2257. WMI_TLV_HDR_SIZE + config->dcc_ndl_chan_list_len +
  2258. WMI_TLV_HDR_SIZE + active_state_count *
  2259. sizeof(wmi_dcc_ndl_active_state_config) +
  2260. WMI_TLV_HDR_SIZE + config->schedule_size *
  2261. sizeof(wmi_ocb_schedule_element);
  2262. buf = wmi_buf_alloc(wmi_handle, len);
  2263. if (!buf) {
  2264. WMI_LOGE(FL("wmi_buf_alloc failed"));
  2265. return -ENOMEM;
  2266. }
  2267. buf_ptr = (uint8_t *)wmi_buf_data(buf);
  2268. cmd = (wmi_ocb_set_config_cmd_fixed_param *)buf_ptr;
  2269. WMITLV_SET_HDR(&cmd->tlv_header,
  2270. WMITLV_TAG_STRUC_wmi_ocb_set_config_cmd_fixed_param,
  2271. WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_set_config_cmd_fixed_param));
  2272. cmd->vdev_id = config->session_id;
  2273. cmd->channel_count = config->channel_count;
  2274. cmd->schedule_size = config->schedule_size;
  2275. cmd->flags = config->flags;
  2276. buf_ptr += sizeof(*cmd);
  2277. /* Add the wmi_channel info */
  2278. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2279. config->channel_count*sizeof(wmi_channel));
  2280. buf_ptr += WMI_TLV_HDR_SIZE;
  2281. for (i = 0; i < config->channel_count; i++) {
  2282. chan = (wmi_channel *)buf_ptr;
  2283. WMITLV_SET_HDR(&chan->tlv_header,
  2284. WMITLV_TAG_STRUC_wmi_channel,
  2285. WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
  2286. chan->mhz = config->channels[i].chan_freq;
  2287. chan->band_center_freq1 = config->channels[i].chan_freq;
  2288. chan->band_center_freq2 = 0;
  2289. chan->info = 0;
  2290. WMI_SET_CHANNEL_MODE(chan, ch_mhz[i]);
  2291. WMI_SET_CHANNEL_MAX_POWER(chan, config->channels[i].max_pwr);
  2292. WMI_SET_CHANNEL_MIN_POWER(chan, config->channels[i].min_pwr);
  2293. WMI_SET_CHANNEL_MAX_TX_POWER(chan, config->channels[i].max_pwr);
  2294. WMI_SET_CHANNEL_REG_POWER(chan, config->channels[i].reg_pwr);
  2295. WMI_SET_CHANNEL_ANTENNA_MAX(chan,
  2296. config->channels[i].antenna_max);
  2297. if (config->channels[i].bandwidth < 10)
  2298. WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_QUARTER_RATE);
  2299. else if (config->channels[i].bandwidth < 20)
  2300. WMI_SET_CHANNEL_FLAG(chan, WMI_CHAN_FLAG_HALF_RATE);
  2301. buf_ptr += sizeof(*chan);
  2302. }
  2303. /* Add the wmi_ocb_channel info */
  2304. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2305. config->channel_count*sizeof(wmi_ocb_channel));
  2306. buf_ptr += WMI_TLV_HDR_SIZE;
  2307. for (i = 0; i < config->channel_count; i++) {
  2308. ocb_chan = (wmi_ocb_channel *)buf_ptr;
  2309. WMITLV_SET_HDR(&ocb_chan->tlv_header,
  2310. WMITLV_TAG_STRUC_wmi_ocb_channel,
  2311. WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_channel));
  2312. ocb_chan->bandwidth = config->channels[i].bandwidth;
  2313. WMI_CHAR_ARRAY_TO_MAC_ADDR(
  2314. config->channels[i].mac_address.bytes,
  2315. &ocb_chan->mac_address);
  2316. buf_ptr += sizeof(*ocb_chan);
  2317. }
  2318. /* Add the wmi_qos_parameter info */
  2319. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2320. config->channel_count * sizeof(wmi_qos_parameter)*WMI_MAX_NUM_AC);
  2321. buf_ptr += WMI_TLV_HDR_SIZE;
  2322. /* WMI_MAX_NUM_AC parameters for each channel */
  2323. for (i = 0; i < config->channel_count; i++) {
  2324. for (j = 0; j < WMI_MAX_NUM_AC; j++) {
  2325. qos_param = (wmi_qos_parameter *)buf_ptr;
  2326. WMITLV_SET_HDR(&qos_param->tlv_header,
  2327. WMITLV_TAG_STRUC_wmi_qos_parameter,
  2328. WMITLV_GET_STRUCT_TLVLEN(wmi_qos_parameter));
  2329. qos_param->aifsn =
  2330. config->channels[i].qos_params[j].aifsn;
  2331. qos_param->cwmin =
  2332. config->channels[i].qos_params[j].cwmin;
  2333. qos_param->cwmax =
  2334. config->channels[i].qos_params[j].cwmax;
  2335. buf_ptr += sizeof(*qos_param);
  2336. }
  2337. }
  2338. /* Add the wmi_dcc_ndl_chan (per channel) */
  2339. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2340. config->dcc_ndl_chan_list_len);
  2341. buf_ptr += WMI_TLV_HDR_SIZE;
  2342. if (config->dcc_ndl_chan_list_len) {
  2343. ndl_chan = (wmi_dcc_ndl_chan *)buf_ptr;
  2344. qdf_mem_copy(ndl_chan, config->dcc_ndl_chan_list,
  2345. config->dcc_ndl_chan_list_len);
  2346. for (i = 0; i < config->channel_count; i++)
  2347. WMITLV_SET_HDR(&(ndl_chan[i].tlv_header),
  2348. WMITLV_TAG_STRUC_wmi_dcc_ndl_chan,
  2349. WMITLV_GET_STRUCT_TLVLEN(wmi_dcc_ndl_chan));
  2350. buf_ptr += config->dcc_ndl_chan_list_len;
  2351. }
  2352. /* Add the wmi_dcc_ndl_active_state_config */
  2353. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, active_state_count *
  2354. sizeof(wmi_dcc_ndl_active_state_config));
  2355. buf_ptr += WMI_TLV_HDR_SIZE;
  2356. if (active_state_count) {
  2357. ndl_active_config = (wmi_dcc_ndl_active_state_config *)buf_ptr;
  2358. qdf_mem_copy(ndl_active_config,
  2359. config->dcc_ndl_active_state_list,
  2360. active_state_count * sizeof(*ndl_active_config));
  2361. for (i = 0; i < active_state_count; ++i)
  2362. WMITLV_SET_HDR(&(ndl_active_config[i].tlv_header),
  2363. WMITLV_TAG_STRUC_wmi_dcc_ndl_active_state_config,
  2364. WMITLV_GET_STRUCT_TLVLEN(
  2365. wmi_dcc_ndl_active_state_config));
  2366. buf_ptr += active_state_count *
  2367. sizeof(*ndl_active_config);
  2368. }
  2369. /* Add the wmi_ocb_schedule_element info */
  2370. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  2371. config->schedule_size * sizeof(wmi_ocb_schedule_element));
  2372. buf_ptr += WMI_TLV_HDR_SIZE;
  2373. for (i = 0; i < config->schedule_size; i++) {
  2374. sched_elem = (wmi_ocb_schedule_element *)buf_ptr;
  2375. WMITLV_SET_HDR(&sched_elem->tlv_header,
  2376. WMITLV_TAG_STRUC_wmi_ocb_schedule_element,
  2377. WMITLV_GET_STRUCT_TLVLEN(wmi_ocb_schedule_element));
  2378. sched_elem->channel_freq = config->schedule[i].chan_freq;
  2379. sched_elem->total_duration = config->schedule[i].total_duration;
  2380. sched_elem->guard_interval = config->schedule[i].guard_interval;
  2381. buf_ptr += sizeof(*sched_elem);
  2382. }
  2383. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2384. WMI_OCB_SET_CONFIG_CMDID);
  2385. if (ret != EOK) {
  2386. WMI_LOGE("Failed to set OCB config");
  2387. wmi_buf_free(buf);
  2388. return -EIO;
  2389. }
  2390. return 0;
  2391. }
  2392. /**
  2393. * send_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv() -enable/disable mcc scheduler
  2394. * @wmi_handle: wmi handle
  2395. * @mcc_adaptive_scheduler: enable/disable
  2396. *
  2397. * This function enable/disable mcc adaptive scheduler in fw.
  2398. *
  2399. * Return: QDF_STATUS_SUCCESS for sucess or error code
  2400. */
  2401. QDF_STATUS send_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv(
  2402. wmi_unified_t wmi_handle, uint32_t mcc_adaptive_scheduler)
  2403. {
  2404. int ret = -1;
  2405. wmi_buf_t buf = 0;
  2406. wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param *cmd = NULL;
  2407. uint16_t len =
  2408. sizeof(wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param);
  2409. buf = wmi_buf_alloc(wmi_handle, len);
  2410. if (!buf) {
  2411. WMI_LOGP("%s : wmi_buf_alloc failed", __func__);
  2412. return QDF_STATUS_E_NOMEM;
  2413. }
  2414. cmd = (wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param *)
  2415. wmi_buf_data(buf);
  2416. WMITLV_SET_HDR(&cmd->tlv_header,
  2417. WMITLV_TAG_STRUC_wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param,
  2418. WMITLV_GET_STRUCT_TLVLEN
  2419. (wmi_resmgr_adaptive_ocs_enable_disable_cmd_fixed_param));
  2420. cmd->enable = mcc_adaptive_scheduler;
  2421. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2422. WMI_RESMGR_ADAPTIVE_OCS_ENABLE_DISABLE_CMDID);
  2423. if (ret) {
  2424. WMI_LOGP("%s: Failed to send enable/disable MCC"
  2425. " adaptive scheduler command", __func__);
  2426. qdf_nbuf_free(buf);
  2427. }
  2428. return QDF_STATUS_SUCCESS;
  2429. }
  2430. /**
  2431. * send_set_mcc_channel_time_latency_cmd_tlv() -set MCC channel time latency
  2432. * @wmi: wmi handle
  2433. * @mcc_channel: mcc channel
  2434. * @mcc_channel_time_latency: MCC channel time latency.
  2435. *
  2436. * Currently used to set time latency for an MCC vdev/adapter using operating
  2437. * channel of it and channel number. The info is provided run time using
  2438. * iwpriv command: iwpriv <wlan0 | p2p0> setMccLatency <latency in ms>.
  2439. *
  2440. * Return: CDF status
  2441. */
  2442. QDF_STATUS send_set_mcc_channel_time_latency_cmd_tlv(wmi_unified_t wmi_handle,
  2443. uint32_t mcc_channel_freq, uint32_t mcc_channel_time_latency)
  2444. {
  2445. int ret = -1;
  2446. wmi_buf_t buf = 0;
  2447. wmi_resmgr_set_chan_latency_cmd_fixed_param *cmdTL = NULL;
  2448. uint16_t len = 0;
  2449. uint8_t *buf_ptr = NULL;
  2450. wmi_resmgr_chan_latency chan_latency;
  2451. /* Note: we only support MCC time latency for a single channel */
  2452. uint32_t num_channels = 1;
  2453. uint32_t chan1_freq = mcc_channel_freq;
  2454. uint32_t latency_chan1 = mcc_channel_time_latency;
  2455. /* If 0ms latency is provided, then FW will set to a default.
  2456. * Otherwise, latency must be at least 30ms.
  2457. */
  2458. if ((latency_chan1 > 0) &&
  2459. (latency_chan1 < WMI_MCC_MIN_NON_ZERO_CHANNEL_LATENCY)) {
  2460. WMI_LOGE("%s: Invalid time latency for Channel #1 = %dms "
  2461. "Minimum is 30ms (or 0 to use default value by "
  2462. "firmware)", __func__, latency_chan1);
  2463. return QDF_STATUS_E_INVAL;
  2464. }
  2465. /* Set WMI CMD for channel time latency here */
  2466. len = sizeof(wmi_resmgr_set_chan_latency_cmd_fixed_param) +
  2467. WMI_TLV_HDR_SIZE + /*Place holder for chan_time_latency array */
  2468. num_channels * sizeof(wmi_resmgr_chan_latency);
  2469. buf = wmi_buf_alloc(wmi_handle, len);
  2470. if (!buf) {
  2471. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  2472. return QDF_STATUS_E_NOMEM;
  2473. }
  2474. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  2475. cmdTL = (wmi_resmgr_set_chan_latency_cmd_fixed_param *)
  2476. wmi_buf_data(buf);
  2477. WMITLV_SET_HDR(&cmdTL->tlv_header,
  2478. WMITLV_TAG_STRUC_wmi_resmgr_set_chan_latency_cmd_fixed_param,
  2479. WMITLV_GET_STRUCT_TLVLEN
  2480. (wmi_resmgr_set_chan_latency_cmd_fixed_param));
  2481. cmdTL->num_chans = num_channels;
  2482. /* Update channel time latency information for home channel(s) */
  2483. buf_ptr += sizeof(*cmdTL);
  2484. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  2485. num_channels * sizeof(wmi_resmgr_chan_latency));
  2486. buf_ptr += WMI_TLV_HDR_SIZE;
  2487. chan_latency.chan_mhz = chan1_freq;
  2488. chan_latency.latency = latency_chan1;
  2489. qdf_mem_copy(buf_ptr, &chan_latency, sizeof(chan_latency));
  2490. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2491. WMI_RESMGR_SET_CHAN_LATENCY_CMDID);
  2492. if (ret) {
  2493. WMI_LOGE("%s: Failed to send MCC Channel Time Latency command",
  2494. __func__);
  2495. qdf_nbuf_free(buf);
  2496. QDF_ASSERT(0);
  2497. return QDF_STATUS_E_FAILURE;
  2498. }
  2499. return QDF_STATUS_SUCCESS;
  2500. }
  2501. /**
  2502. * send_set_mcc_channel_time_quota_cmd_tlv() -set MCC channel time quota
  2503. * @wmi: wmi handle
  2504. * @adapter_1_chan_number: adapter 1 channel number
  2505. * @adapter_1_quota: adapter 1 quota
  2506. * @adapter_2_chan_number: adapter 2 channel number
  2507. *
  2508. * Return: CDF status
  2509. */
  2510. QDF_STATUS send_set_mcc_channel_time_quota_cmd_tlv(wmi_unified_t wmi_handle,
  2511. uint32_t adapter_1_chan_freq,
  2512. uint32_t adapter_1_quota, uint32_t adapter_2_chan_freq)
  2513. {
  2514. int ret = -1;
  2515. wmi_buf_t buf = 0;
  2516. uint16_t len = 0;
  2517. uint8_t *buf_ptr = NULL;
  2518. wmi_resmgr_set_chan_time_quota_cmd_fixed_param *cmdTQ = NULL;
  2519. wmi_resmgr_chan_time_quota chan_quota;
  2520. uint32_t quota_chan1 = adapter_1_quota;
  2521. /* Knowing quota of 1st chan., derive quota for 2nd chan. */
  2522. uint32_t quota_chan2 = 100 - quota_chan1;
  2523. /* Note: setting time quota for MCC requires info for 2 channels */
  2524. uint32_t num_channels = 2;
  2525. uint32_t chan1_freq = adapter_1_chan_freq;
  2526. uint32_t chan2_freq = adapter_2_chan_freq;
  2527. WMI_LOGD("%s: freq1:%dMHz, Quota1:%dms, "
  2528. "freq2:%dMHz, Quota2:%dms", __func__,
  2529. chan1_freq, quota_chan1, chan2_freq,
  2530. quota_chan2);
  2531. /*
  2532. * Perform sanity check on time quota values provided.
  2533. */
  2534. if (quota_chan1 < WMI_MCC_MIN_CHANNEL_QUOTA ||
  2535. quota_chan1 > WMI_MCC_MAX_CHANNEL_QUOTA) {
  2536. WMI_LOGE("%s: Invalid time quota for Channel #1=%dms. Minimum "
  2537. "is 20ms & maximum is 80ms", __func__, quota_chan1);
  2538. return QDF_STATUS_E_INVAL;
  2539. }
  2540. /* Set WMI CMD for channel time quota here */
  2541. len = sizeof(wmi_resmgr_set_chan_time_quota_cmd_fixed_param) +
  2542. WMI_TLV_HDR_SIZE + /* Place holder for chan_time_quota array */
  2543. num_channels * sizeof(wmi_resmgr_chan_time_quota);
  2544. buf = wmi_buf_alloc(wmi_handle, len);
  2545. if (!buf) {
  2546. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  2547. QDF_ASSERT(0);
  2548. return QDF_STATUS_E_NOMEM;
  2549. }
  2550. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  2551. cmdTQ = (wmi_resmgr_set_chan_time_quota_cmd_fixed_param *)
  2552. wmi_buf_data(buf);
  2553. WMITLV_SET_HDR(&cmdTQ->tlv_header,
  2554. WMITLV_TAG_STRUC_wmi_resmgr_set_chan_time_quota_cmd_fixed_param,
  2555. WMITLV_GET_STRUCT_TLVLEN
  2556. (wmi_resmgr_set_chan_time_quota_cmd_fixed_param));
  2557. cmdTQ->num_chans = num_channels;
  2558. /* Update channel time quota information for home channel(s) */
  2559. buf_ptr += sizeof(*cmdTQ);
  2560. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  2561. num_channels * sizeof(wmi_resmgr_chan_time_quota));
  2562. buf_ptr += WMI_TLV_HDR_SIZE;
  2563. chan_quota.chan_mhz = chan1_freq;
  2564. chan_quota.channel_time_quota = quota_chan1;
  2565. qdf_mem_copy(buf_ptr, &chan_quota, sizeof(chan_quota));
  2566. /* Construct channel and quota record for the 2nd MCC mode. */
  2567. buf_ptr += sizeof(chan_quota);
  2568. chan_quota.chan_mhz = chan2_freq;
  2569. chan_quota.channel_time_quota = quota_chan2;
  2570. qdf_mem_copy(buf_ptr, &chan_quota, sizeof(chan_quota));
  2571. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  2572. WMI_RESMGR_SET_CHAN_TIME_QUOTA_CMDID);
  2573. if (ret) {
  2574. WMI_LOGE("Failed to send MCC Channel Time Quota command");
  2575. qdf_nbuf_free(buf);
  2576. QDF_ASSERT(0);
  2577. return QDF_STATUS_E_FAILURE;
  2578. }
  2579. return QDF_STATUS_SUCCESS;
  2580. }
  2581. /**
  2582. * send_set_thermal_mgmt_cmd_tlv() - set thermal mgmt command to fw
  2583. * @wmi_handle: Pointer to wmi handle
  2584. * @thermal_info: Thermal command information
  2585. *
  2586. * This function sends the thermal management command
  2587. * to the firmware
  2588. *
  2589. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  2590. */
  2591. QDF_STATUS send_set_thermal_mgmt_cmd_tlv(wmi_unified_t wmi_handle,
  2592. struct thermal_cmd_params *thermal_info)
  2593. {
  2594. wmi_thermal_mgmt_cmd_fixed_param *cmd = NULL;
  2595. wmi_buf_t buf = NULL;
  2596. int status = 0;
  2597. uint32_t len = 0;
  2598. len = sizeof(*cmd);
  2599. buf = wmi_buf_alloc(wmi_handle, len);
  2600. if (!buf) {
  2601. WMI_LOGE("Failed to allocate buffer to send set key cmd");
  2602. return QDF_STATUS_E_FAILURE;
  2603. }
  2604. cmd = (wmi_thermal_mgmt_cmd_fixed_param *) wmi_buf_data(buf);
  2605. WMITLV_SET_HDR(&cmd->tlv_header,
  2606. WMITLV_TAG_STRUC_wmi_thermal_mgmt_cmd_fixed_param,
  2607. WMITLV_GET_STRUCT_TLVLEN
  2608. (wmi_thermal_mgmt_cmd_fixed_param));
  2609. cmd->lower_thresh_degreeC = thermal_info->min_temp;
  2610. cmd->upper_thresh_degreeC = thermal_info->max_temp;
  2611. cmd->enable = thermal_info->thermal_enable;
  2612. WMI_LOGE("TM Sending thermal mgmt cmd: low temp %d, upper temp %d, enabled %d",
  2613. cmd->lower_thresh_degreeC, cmd->upper_thresh_degreeC, cmd->enable);
  2614. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  2615. WMI_THERMAL_MGMT_CMDID);
  2616. if (status) {
  2617. qdf_nbuf_free(buf);
  2618. WMI_LOGE("%s:Failed to send thermal mgmt command", __func__);
  2619. return QDF_STATUS_E_FAILURE;
  2620. }
  2621. return QDF_STATUS_SUCCESS;
  2622. }
  2623. /**
  2624. * send_lro_config_cmd_tlv() - process the LRO config command
  2625. * @wmi_handle: Pointer to WMI handle
  2626. * @wmi_lro_cmd: Pointer to LRO configuration parameters
  2627. *
  2628. * This function sends down the LRO configuration parameters to
  2629. * the firmware to enable LRO, sets the TCP flags and sets the
  2630. * seed values for the toeplitz hash generation
  2631. *
  2632. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  2633. */
  2634. QDF_STATUS send_lro_config_cmd_tlv(wmi_unified_t wmi_handle,
  2635. struct wmi_lro_config_cmd_t *wmi_lro_cmd)
  2636. {
  2637. wmi_lro_info_cmd_fixed_param *cmd;
  2638. wmi_buf_t buf;
  2639. int status;
  2640. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  2641. if (!buf) {
  2642. WMI_LOGE("Failed to allocate buffer to send set key cmd");
  2643. return QDF_STATUS_E_FAILURE;
  2644. }
  2645. cmd = (wmi_lro_info_cmd_fixed_param *) wmi_buf_data(buf);
  2646. WMITLV_SET_HDR(&cmd->tlv_header,
  2647. WMITLV_TAG_STRUC_wmi_lro_info_cmd_fixed_param,
  2648. WMITLV_GET_STRUCT_TLVLEN(wmi_lro_info_cmd_fixed_param));
  2649. cmd->lro_enable = wmi_lro_cmd->lro_enable;
  2650. WMI_LRO_INFO_TCP_FLAG_VALS_SET(cmd->tcp_flag_u32,
  2651. wmi_lro_cmd->tcp_flag);
  2652. WMI_LRO_INFO_TCP_FLAGS_MASK_SET(cmd->tcp_flag_u32,
  2653. wmi_lro_cmd->tcp_flag_mask);
  2654. cmd->toeplitz_hash_ipv4_0_3 =
  2655. wmi_lro_cmd->toeplitz_hash_ipv4[0];
  2656. cmd->toeplitz_hash_ipv4_4_7 =
  2657. wmi_lro_cmd->toeplitz_hash_ipv4[1];
  2658. cmd->toeplitz_hash_ipv4_8_11 =
  2659. wmi_lro_cmd->toeplitz_hash_ipv4[2];
  2660. cmd->toeplitz_hash_ipv4_12_15 =
  2661. wmi_lro_cmd->toeplitz_hash_ipv4[3];
  2662. cmd->toeplitz_hash_ipv4_16 =
  2663. wmi_lro_cmd->toeplitz_hash_ipv4[4];
  2664. cmd->toeplitz_hash_ipv6_0_3 =
  2665. wmi_lro_cmd->toeplitz_hash_ipv6[0];
  2666. cmd->toeplitz_hash_ipv6_4_7 =
  2667. wmi_lro_cmd->toeplitz_hash_ipv6[1];
  2668. cmd->toeplitz_hash_ipv6_8_11 =
  2669. wmi_lro_cmd->toeplitz_hash_ipv6[2];
  2670. cmd->toeplitz_hash_ipv6_12_15 =
  2671. wmi_lro_cmd->toeplitz_hash_ipv6[3];
  2672. cmd->toeplitz_hash_ipv6_16_19 =
  2673. wmi_lro_cmd->toeplitz_hash_ipv6[4];
  2674. cmd->toeplitz_hash_ipv6_20_23 =
  2675. wmi_lro_cmd->toeplitz_hash_ipv6[5];
  2676. cmd->toeplitz_hash_ipv6_24_27 =
  2677. wmi_lro_cmd->toeplitz_hash_ipv6[6];
  2678. cmd->toeplitz_hash_ipv6_28_31 =
  2679. wmi_lro_cmd->toeplitz_hash_ipv6[7];
  2680. cmd->toeplitz_hash_ipv6_32_35 =
  2681. wmi_lro_cmd->toeplitz_hash_ipv6[8];
  2682. cmd->toeplitz_hash_ipv6_36_39 =
  2683. wmi_lro_cmd->toeplitz_hash_ipv6[9];
  2684. cmd->toeplitz_hash_ipv6_40 =
  2685. wmi_lro_cmd->toeplitz_hash_ipv6[10];
  2686. WMI_LOGD("WMI_LRO_CONFIG: lro_enable %d, tcp_flag 0x%x",
  2687. cmd->lro_enable, cmd->tcp_flag_u32);
  2688. status = wmi_unified_cmd_send(wmi_handle, buf,
  2689. sizeof(*cmd), WMI_LRO_CONFIG_CMDID);
  2690. if (status) {
  2691. qdf_nbuf_free(buf);
  2692. WMI_LOGE("%s:Failed to send WMI_LRO_CONFIG_CMDID", __func__);
  2693. return QDF_STATUS_E_FAILURE;
  2694. }
  2695. return QDF_STATUS_SUCCESS;
  2696. }
  2697. /**
  2698. * send_bcn_buf_ll_cmd_tlv() - prepare and send beacon buffer to fw for LL
  2699. * @wmi_handle: wmi handle
  2700. * @param: bcn ll cmd parameter
  2701. *
  2702. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  2703. */
  2704. QDF_STATUS send_bcn_buf_ll_cmd_tlv(wmi_unified_t wmi_handle,
  2705. wmi_bcn_send_from_host_cmd_fixed_param *param)
  2706. {
  2707. wmi_bcn_send_from_host_cmd_fixed_param *cmd;
  2708. wmi_buf_t wmi_buf;
  2709. QDF_STATUS ret;
  2710. wmi_buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  2711. if (!wmi_buf) {
  2712. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  2713. return QDF_STATUS_E_FAILURE;
  2714. }
  2715. cmd = (wmi_bcn_send_from_host_cmd_fixed_param *) wmi_buf_data(wmi_buf);
  2716. WMITLV_SET_HDR(&cmd->tlv_header,
  2717. WMITLV_TAG_STRUC_wmi_bcn_send_from_host_cmd_fixed_param,
  2718. WMITLV_GET_STRUCT_TLVLEN
  2719. (wmi_bcn_send_from_host_cmd_fixed_param));
  2720. cmd->vdev_id = param->vdev_id;
  2721. cmd->data_len = param->data_len;
  2722. cmd->frame_ctrl = param->frame_ctrl;
  2723. cmd->frag_ptr = param->frag_ptr;
  2724. cmd->dtim_flag = param->dtim_flag;
  2725. ret = wmi_unified_cmd_send(wmi_handle, wmi_buf, sizeof(*cmd),
  2726. WMI_PDEV_SEND_BCN_CMDID);
  2727. if (ret != EOK) {
  2728. WMI_LOGE("Failed to send WMI_PDEV_SEND_BCN_CMDID command");
  2729. wmi_buf_free(wmi_buf);
  2730. }
  2731. return ret;
  2732. }
  2733. /**
  2734. * send_set_sta_sa_query_param_cmd_tlv() - set sta sa query parameters
  2735. * @wmi_handle: wmi handle
  2736. * @vdev_id: vdev id
  2737. * @max_retries: max retries
  2738. * @retry_interval: retry interval
  2739. * This function sets sta query related parameters in fw.
  2740. *
  2741. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  2742. */
  2743. QDF_STATUS send_set_sta_sa_query_param_cmd_tlv(wmi_unified_t wmi_handle,
  2744. uint8_t vdev_id, uint32_t max_retries,
  2745. uint32_t retry_interval)
  2746. {
  2747. wmi_buf_t buf;
  2748. WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param *cmd;
  2749. int len;
  2750. len = sizeof(*cmd);
  2751. buf = wmi_buf_alloc(wmi_handle, len);
  2752. if (!buf) {
  2753. WMI_LOGE(FL("wmi_buf_alloc failed"));
  2754. return QDF_STATUS_E_FAILURE;
  2755. }
  2756. cmd = (WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param *)wmi_buf_data(buf);
  2757. WMITLV_SET_HDR(&cmd->tlv_header,
  2758. WMITLV_TAG_STRUC_WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param,
  2759. WMITLV_GET_STRUCT_TLVLEN
  2760. (WMI_PMF_OFFLOAD_SET_SA_QUERY_CMD_fixed_param));
  2761. cmd->vdev_id = vdev_id;
  2762. cmd->sa_query_max_retry_count = max_retries;
  2763. cmd->sa_query_retry_interval = retry_interval;
  2764. WMI_LOGD(FL("STA sa query: vdev_id:%d interval:%u retry count:%d"),
  2765. vdev_id, retry_interval, max_retries);
  2766. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  2767. WMI_PMF_OFFLOAD_SET_SA_QUERY_CMDID)) {
  2768. WMI_LOGE(FL("Failed to offload STA SA Query"));
  2769. qdf_nbuf_free(buf);
  2770. return QDF_STATUS_E_FAILURE;
  2771. }
  2772. WMI_LOGD(FL("Exit :"));
  2773. return 0;
  2774. }
  2775. /**
  2776. * send_set_sta_keep_alive_cmd_tlv() - set sta keep alive parameters
  2777. * @wmi_handle: wmi handle
  2778. * @params: sta keep alive parameter
  2779. *
  2780. * This function sets keep alive related parameters in fw.
  2781. *
  2782. * Return: CDF status
  2783. */
  2784. QDF_STATUS send_set_sta_keep_alive_cmd_tlv(wmi_unified_t wmi_handle,
  2785. struct sta_params *params)
  2786. {
  2787. wmi_buf_t buf;
  2788. WMI_STA_KEEPALIVE_CMD_fixed_param *cmd;
  2789. WMI_STA_KEEPALVE_ARP_RESPONSE *arp_rsp;
  2790. uint8_t *buf_ptr;
  2791. int len;
  2792. WMI_LOGD("%s: Enter", __func__);
  2793. if (params->timeperiod > WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD_STAMAX) {
  2794. WMI_LOGE("Invalid period %d Max limit %d", params->timeperiod,
  2795. WNI_CFG_INFRA_STA_KEEP_ALIVE_PERIOD_STAMAX);
  2796. return QDF_STATUS_E_FAILURE;
  2797. }
  2798. len = sizeof(*cmd) + sizeof(*arp_rsp);
  2799. buf = wmi_buf_alloc(wmi_handle, len);
  2800. if (!buf) {
  2801. WMI_LOGE("wmi_buf_alloc failed");
  2802. return QDF_STATUS_E_FAILURE;
  2803. }
  2804. cmd = (WMI_STA_KEEPALIVE_CMD_fixed_param *) wmi_buf_data(buf);
  2805. buf_ptr = (uint8_t *) cmd;
  2806. WMITLV_SET_HDR(&cmd->tlv_header,
  2807. WMITLV_TAG_STRUC_WMI_STA_KEEPALIVE_CMD_fixed_param,
  2808. WMITLV_GET_STRUCT_TLVLEN
  2809. (WMI_STA_KEEPALIVE_CMD_fixed_param));
  2810. cmd->interval = params->timeperiod;
  2811. cmd->enable = (params->timeperiod) ? 1 : 0;
  2812. cmd->vdev_id = params->vdev_id;
  2813. WMI_LOGD("Keep Alive: vdev_id:%d interval:%u method:%d", params->vdev_id,
  2814. params->timeperiod, params->method);
  2815. arp_rsp = (WMI_STA_KEEPALVE_ARP_RESPONSE *) (buf_ptr + sizeof(*cmd));
  2816. WMITLV_SET_HDR(&arp_rsp->tlv_header,
  2817. WMITLV_TAG_STRUC_WMI_STA_KEEPALVE_ARP_RESPONSE,
  2818. WMITLV_GET_STRUCT_TLVLEN(WMI_STA_KEEPALVE_ARP_RESPONSE));
  2819. if (params->method == WMI_KEEP_ALIVE_UNSOLICIT_ARP_RSP) {
  2820. if ((NULL == params->hostv4addr) ||
  2821. (NULL == params->destv4addr) ||
  2822. (NULL == params->destmac)) {
  2823. WMI_LOGE("%s: received null pointer, hostv4addr:%p "
  2824. "destv4addr:%p destmac:%p ", __func__,
  2825. params->hostv4addr, params->destv4addr, params->destmac);
  2826. qdf_nbuf_free(buf);
  2827. return QDF_STATUS_E_FAILURE;
  2828. }
  2829. cmd->method = WMI_STA_KEEPALIVE_METHOD_UNSOLICITED_ARP_RESPONSE;
  2830. qdf_mem_copy(&arp_rsp->sender_prot_addr, params->hostv4addr,
  2831. WMI_IPV4_ADDR_LEN);
  2832. qdf_mem_copy(&arp_rsp->target_prot_addr, params->destv4addr,
  2833. WMI_IPV4_ADDR_LEN);
  2834. WMI_CHAR_ARRAY_TO_MAC_ADDR(params->destmac, &arp_rsp->dest_mac_addr);
  2835. } else {
  2836. cmd->method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;
  2837. }
  2838. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  2839. WMI_STA_KEEPALIVE_CMDID)) {
  2840. WMI_LOGE("Failed to set KeepAlive");
  2841. qdf_nbuf_free(buf);
  2842. }
  2843. WMI_LOGD("%s: Exit", __func__);
  2844. return 0;
  2845. }
  2846. /**
  2847. * send_vdev_set_gtx_cfg_cmd_tlv() - set GTX params
  2848. * @wmi_handle: wmi handle
  2849. * @if_id: vdev id
  2850. * @gtx_info: GTX config params
  2851. *
  2852. * This function set GTX related params in firmware.
  2853. *
  2854. * Return: 0 for success or error code
  2855. */
  2856. QDF_STATUS send_vdev_set_gtx_cfg_cmd_tlv(wmi_unified_t wmi_handle, uint32_t if_id,
  2857. struct wmi_gtx_config *gtx_info)
  2858. {
  2859. wmi_vdev_set_gtx_params_cmd_fixed_param *cmd;
  2860. wmi_buf_t buf;
  2861. int len = sizeof(wmi_vdev_set_gtx_params_cmd_fixed_param);
  2862. buf = wmi_buf_alloc(wmi_handle, len);
  2863. if (!buf) {
  2864. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  2865. return -ENOMEM;
  2866. }
  2867. cmd = (wmi_vdev_set_gtx_params_cmd_fixed_param *) wmi_buf_data(buf);
  2868. WMITLV_SET_HDR(&cmd->tlv_header,
  2869. WMITLV_TAG_STRUC_wmi_vdev_set_gtx_params_cmd_fixed_param,
  2870. WMITLV_GET_STRUCT_TLVLEN
  2871. (wmi_vdev_set_gtx_params_cmd_fixed_param));
  2872. cmd->vdev_id = if_id;
  2873. cmd->gtxRTMask[0] = gtx_info->gtx_rt_mask[0];
  2874. cmd->gtxRTMask[1] = gtx_info->gtx_rt_mask[1];
  2875. cmd->userGtxMask = gtx_info->gtx_usrcfg;
  2876. cmd->gtxPERThreshold = gtx_info->gtx_threshold;
  2877. cmd->gtxPERMargin = gtx_info->gtx_margin;
  2878. cmd->gtxTPCstep = gtx_info->gtx_tpcstep;
  2879. cmd->gtxTPCMin = gtx_info->gtx_tpcmin;
  2880. cmd->gtxBWMask = gtx_info->gtx_bwmask;
  2881. WMI_LOGD("Setting vdev%d GTX values:htmcs 0x%x, vhtmcs 0x%x, usermask 0x%x, \
  2882. gtxPERThreshold %d, gtxPERMargin %d, gtxTPCstep %d, gtxTPCMin %d, \
  2883. gtxBWMask 0x%x.", if_id, cmd->gtxRTMask[0], cmd->gtxRTMask[1],
  2884. cmd->userGtxMask, cmd->gtxPERThreshold, cmd->gtxPERMargin,
  2885. cmd->gtxTPCstep, cmd->gtxTPCMin, cmd->gtxBWMask);
  2886. return wmi_unified_cmd_send(wmi_handle, buf, len,
  2887. WMI_VDEV_SET_GTX_PARAMS_CMDID);
  2888. }
  2889. /**
  2890. * send_process_update_edca_param_cmd_tlv() - update EDCA params
  2891. * @wmi_handle: wmi handle
  2892. * @edca_params: edca parameters
  2893. *
  2894. * This function updates EDCA parameters to the target
  2895. *
  2896. * Return: CDF Status
  2897. */
  2898. QDF_STATUS send_process_update_edca_param_cmd_tlv(wmi_unified_t wmi_handle,
  2899. uint8_t vdev_id,
  2900. wmi_wmm_vparams gwmm_param[WMI_MAX_NUM_AC])
  2901. {
  2902. uint8_t *buf_ptr;
  2903. wmi_buf_t buf;
  2904. wmi_vdev_set_wmm_params_cmd_fixed_param *cmd;
  2905. wmi_wmm_vparams *wmm_param, *twmm_param;
  2906. int len = sizeof(*cmd);
  2907. int ac;
  2908. buf = wmi_buf_alloc(wmi_handle, len);
  2909. if (!buf) {
  2910. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  2911. return QDF_STATUS_E_NOMEM;
  2912. }
  2913. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  2914. cmd = (wmi_vdev_set_wmm_params_cmd_fixed_param *) buf_ptr;
  2915. WMITLV_SET_HDR(&cmd->tlv_header,
  2916. WMITLV_TAG_STRUC_wmi_vdev_set_wmm_params_cmd_fixed_param,
  2917. WMITLV_GET_STRUCT_TLVLEN
  2918. (wmi_vdev_set_wmm_params_cmd_fixed_param));
  2919. cmd->vdev_id = vdev_id;
  2920. for (ac = 0; ac < WMI_MAX_NUM_AC; ac++) {
  2921. wmm_param = (wmi_wmm_vparams *) (&cmd->wmm_params[ac]);
  2922. twmm_param = (wmi_wmm_vparams *) (&gwmm_param[ac]);
  2923. WMITLV_SET_HDR(&wmm_param->tlv_header,
  2924. WMITLV_TAG_STRUC_wmi_vdev_set_wmm_params_cmd_fixed_param,
  2925. WMITLV_GET_STRUCT_TLVLEN(wmi_wmm_vparams));
  2926. wmm_param->cwmin = twmm_param->cwmin;
  2927. wmm_param->cwmax = twmm_param->cwmax;
  2928. wmm_param->aifs = twmm_param->aifs;
  2929. wmm_param->txoplimit = twmm_param->txoplimit;
  2930. wmm_param->acm = twmm_param->acm;
  2931. wmm_param->no_ack = twmm_param->no_ack;
  2932. }
  2933. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  2934. WMI_VDEV_SET_WMM_PARAMS_CMDID))
  2935. goto fail;
  2936. return QDF_STATUS_SUCCESS;
  2937. fail:
  2938. wmi_buf_free(buf);
  2939. WMI_LOGE("%s: Failed to set WMM Paremeters", __func__);
  2940. return QDF_STATUS_E_FAILURE;
  2941. }
  2942. /**
  2943. * send_probe_rsp_tmpl_send_cmd_tlv() - send probe response template to fw
  2944. * @wmi_handle: wmi handle
  2945. * @vdev_id: vdev id
  2946. * @probe_rsp_info: probe response info
  2947. *
  2948. * Return: 0 for success or error code
  2949. */
  2950. QDF_STATUS send_probe_rsp_tmpl_send_cmd_tlv(wmi_unified_t wmi_handle,
  2951. uint8_t vdev_id,
  2952. struct wmi_probe_resp_params *probe_rsp_info,
  2953. uint8_t *frm)
  2954. {
  2955. wmi_prb_tmpl_cmd_fixed_param *cmd;
  2956. wmi_bcn_prb_info *bcn_prb_info;
  2957. wmi_buf_t wmi_buf;
  2958. uint32_t tmpl_len, tmpl_len_aligned, wmi_buf_len;
  2959. uint8_t *buf_ptr;
  2960. int ret;
  2961. WMI_LOGD(FL("Send probe response template for vdev %d"), vdev_id);
  2962. tmpl_len = probe_rsp_info->probeRespTemplateLen;
  2963. tmpl_len_aligned = roundup(tmpl_len, sizeof(A_UINT32));
  2964. wmi_buf_len = sizeof(wmi_prb_tmpl_cmd_fixed_param) +
  2965. sizeof(wmi_bcn_prb_info) + WMI_TLV_HDR_SIZE +
  2966. tmpl_len_aligned;
  2967. if (wmi_buf_len > WMI_BEACON_TX_BUFFER_SIZE) {
  2968. WMI_LOGE(FL("wmi_buf_len: %d > %d. Can't send wmi cmd"),
  2969. wmi_buf_len, WMI_BEACON_TX_BUFFER_SIZE);
  2970. return -EINVAL;
  2971. }
  2972. wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len);
  2973. if (!wmi_buf) {
  2974. WMI_LOGE(FL("wmi_buf_alloc failed"));
  2975. return -ENOMEM;
  2976. }
  2977. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  2978. cmd = (wmi_prb_tmpl_cmd_fixed_param *) buf_ptr;
  2979. WMITLV_SET_HDR(&cmd->tlv_header,
  2980. WMITLV_TAG_STRUC_wmi_prb_tmpl_cmd_fixed_param,
  2981. WMITLV_GET_STRUCT_TLVLEN(wmi_prb_tmpl_cmd_fixed_param));
  2982. cmd->vdev_id = vdev_id;
  2983. cmd->buf_len = tmpl_len;
  2984. buf_ptr += sizeof(wmi_prb_tmpl_cmd_fixed_param);
  2985. bcn_prb_info = (wmi_bcn_prb_info *) buf_ptr;
  2986. WMITLV_SET_HDR(&bcn_prb_info->tlv_header,
  2987. WMITLV_TAG_STRUC_wmi_bcn_prb_info,
  2988. WMITLV_GET_STRUCT_TLVLEN(wmi_bcn_prb_info));
  2989. bcn_prb_info->caps = 0;
  2990. bcn_prb_info->erp = 0;
  2991. buf_ptr += sizeof(wmi_bcn_prb_info);
  2992. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, tmpl_len_aligned);
  2993. buf_ptr += WMI_TLV_HDR_SIZE;
  2994. qdf_mem_copy(buf_ptr, frm, tmpl_len);
  2995. ret = wmi_unified_cmd_send(wmi_handle,
  2996. wmi_buf, wmi_buf_len, WMI_PRB_TMPL_CMDID);
  2997. if (ret) {
  2998. WMI_LOGE(FL("Failed to send PRB RSP tmpl: %d"), ret);
  2999. wmi_buf_free(wmi_buf);
  3000. }
  3001. return ret;
  3002. }
  3003. #ifdef FEATURE_WLAN_WAPI
  3004. #define WPI_IV_LEN 16
  3005. /**
  3006. * wmi_update_wpi_key_counter() - update WAPI tsc and rsc key counters
  3007. *
  3008. * @dest_tx: destination address of tsc key counter
  3009. * @src_tx: source address of tsc key counter
  3010. * @dest_rx: destination address of rsc key counter
  3011. * @src_rx: source address of rsc key counter
  3012. *
  3013. * This function copies WAPI tsc and rsc key counters in the wmi buffer.
  3014. *
  3015. * Return: None
  3016. *
  3017. */
  3018. static void wmi_update_wpi_key_counter(uint8_t *dest_tx, uint8_t *src_tx,
  3019. uint8_t *dest_rx, uint8_t *src_rx)
  3020. {
  3021. qdf_mem_copy(dest_tx, src_tx, WPI_IV_LEN);
  3022. qdf_mem_copy(dest_rx, src_rx, WPI_IV_LEN);
  3023. }
  3024. #else
  3025. static void wmi_update_wpi_key_counter(uint8_t *dest_tx, uint8_t *src_tx,
  3026. uint8_t *dest_rx, uint8_t *src_rx)
  3027. {
  3028. return;
  3029. }
  3030. #endif
  3031. /**
  3032. * send_setup_install_key_cmd_tlv() - set key parameters
  3033. * @wmi_handle: wmi handle
  3034. * @key_params: key parameters
  3035. *
  3036. * This function fills structure from information
  3037. * passed in key_params.
  3038. *
  3039. * Return: QDF_STATUS_SUCCESS - success
  3040. * QDF_STATUS_E_FAILURE - failure
  3041. * QDF_STATUS_E_NOMEM - not able to allocate buffer
  3042. */
  3043. QDF_STATUS send_setup_install_key_cmd_tlv(wmi_unified_t wmi_handle,
  3044. struct set_key_params *key_params)
  3045. {
  3046. wmi_vdev_install_key_cmd_fixed_param *cmd;
  3047. wmi_buf_t buf;
  3048. uint8_t *buf_ptr;
  3049. uint32_t len;
  3050. uint8_t *key_data;
  3051. uint8_t status;
  3052. len = sizeof(*cmd) + roundup(key_params->key_len, sizeof(uint32_t)) +
  3053. WMI_TLV_HDR_SIZE;
  3054. buf = wmi_buf_alloc(wmi_handle, len);
  3055. if (!buf) {
  3056. WMA_LOGE("Failed to allocate buffer to send set key cmd");
  3057. return QDF_STATUS_E_NOMEM;
  3058. }
  3059. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  3060. cmd = (wmi_vdev_install_key_cmd_fixed_param *) buf_ptr;
  3061. WMITLV_SET_HDR(&cmd->tlv_header,
  3062. WMITLV_TAG_STRUC_wmi_vdev_install_key_cmd_fixed_param,
  3063. WMITLV_GET_STRUCT_TLVLEN
  3064. (wmi_vdev_install_key_cmd_fixed_param));
  3065. cmd->vdev_id = key_params->vdev_id;
  3066. cmd->key_ix = key_params->key_idx;
  3067. WMI_CHAR_ARRAY_TO_MAC_ADDR(key_params->peer_mac, &cmd->peer_macaddr);
  3068. cmd->key_flags |= key_params->key_flags;
  3069. cmd->key_cipher = key_params->key_cipher;
  3070. if ((key_params->key_txmic_len) &&
  3071. (key_params->key_rxmic_len)) {
  3072. cmd->key_txmic_len = key_params->key_txmic_len;
  3073. cmd->key_rxmic_len = key_params->key_rxmic_len;
  3074. }
  3075. wmi_update_wpi_key_counter(cmd->wpi_key_tsc_counter,
  3076. key_params->tx_iv,
  3077. cmd->wpi_key_rsc_counter,
  3078. key_params->rx_iv);
  3079. buf_ptr += sizeof(wmi_vdev_install_key_cmd_fixed_param);
  3080. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  3081. roundup(key_params->key_len, sizeof(uint32_t)));
  3082. key_data = (A_UINT8 *) (buf_ptr + WMI_TLV_HDR_SIZE);
  3083. qdf_mem_copy((void *)key_data,
  3084. (const void *)key_params->key_data, key_params->key_len);
  3085. cmd->key_len = key_params->key_len;
  3086. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  3087. WMI_VDEV_INSTALL_KEY_CMDID);
  3088. if (status) {
  3089. qdf_nbuf_free(buf);
  3090. return QDF_STATUS_E_FAILURE;
  3091. }
  3092. return QDF_STATUS_SUCCESS;
  3093. }
  3094. /**
  3095. * send_p2p_go_set_beacon_ie_cmd_tlv() - set beacon IE for p2p go
  3096. * @wmi_handle: wmi handle
  3097. * @vdev_id: vdev id
  3098. * @p2p_ie: p2p IE
  3099. *
  3100. * Return: 0 for success or error code
  3101. */
  3102. QDF_STATUS send_p2p_go_set_beacon_ie_cmd_tlv(wmi_unified_t wmi_handle,
  3103. A_UINT32 vdev_id, uint8_t *p2p_ie)
  3104. {
  3105. int ret;
  3106. wmi_p2p_go_set_beacon_ie_fixed_param *cmd;
  3107. wmi_buf_t wmi_buf;
  3108. uint32_t ie_len, ie_len_aligned, wmi_buf_len;
  3109. uint8_t *buf_ptr;
  3110. ie_len = (uint32_t) (p2p_ie[1] + 2);
  3111. /* More than one P2P IE may be included in a single frame.
  3112. If multiple P2P IEs are present, the complete P2P attribute
  3113. data consists of the concatenation of the P2P Attribute
  3114. fields of the P2P IEs. The P2P Attributes field of each
  3115. P2P IE may be any length up to the maximum (251 octets).
  3116. In this case host sends one P2P IE to firmware so the length
  3117. should not exceed more than 251 bytes
  3118. */
  3119. if (ie_len > 251) {
  3120. WMI_LOGE("%s : invalid p2p ie length %u", __func__, ie_len);
  3121. return -EINVAL;
  3122. }
  3123. ie_len_aligned = roundup(ie_len, sizeof(A_UINT32));
  3124. wmi_buf_len =
  3125. sizeof(wmi_p2p_go_set_beacon_ie_fixed_param) + ie_len_aligned +
  3126. WMI_TLV_HDR_SIZE;
  3127. wmi_buf = wmi_buf_alloc(wmi_handle, wmi_buf_len);
  3128. if (!wmi_buf) {
  3129. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  3130. return -ENOMEM;
  3131. }
  3132. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  3133. cmd = (wmi_p2p_go_set_beacon_ie_fixed_param *) buf_ptr;
  3134. WMITLV_SET_HDR(&cmd->tlv_header,
  3135. WMITLV_TAG_STRUC_wmi_p2p_go_set_beacon_ie_fixed_param,
  3136. WMITLV_GET_STRUCT_TLVLEN
  3137. (wmi_p2p_go_set_beacon_ie_fixed_param));
  3138. cmd->vdev_id = vdev_id;
  3139. cmd->ie_buf_len = ie_len;
  3140. buf_ptr += sizeof(wmi_p2p_go_set_beacon_ie_fixed_param);
  3141. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ie_len_aligned);
  3142. buf_ptr += WMI_TLV_HDR_SIZE;
  3143. qdf_mem_copy(buf_ptr, p2p_ie, ie_len);
  3144. WMI_LOGI("%s: Sending WMI_P2P_GO_SET_BEACON_IE", __func__);
  3145. ret = wmi_unified_cmd_send(wmi_handle,
  3146. wmi_buf, wmi_buf_len,
  3147. WMI_P2P_GO_SET_BEACON_IE);
  3148. if (ret) {
  3149. WMI_LOGE("Failed to send bcn tmpl: %d", ret);
  3150. wmi_buf_free(wmi_buf);
  3151. }
  3152. WMI_LOGI("%s: Successfully sent WMI_P2P_GO_SET_BEACON_IE", __func__);
  3153. return ret;
  3154. }
  3155. /**
  3156. * send_set_gateway_params_cmd_tlv() - set gateway parameters
  3157. * @wmi_handle: wmi handle
  3158. * @req: gateway parameter update request structure
  3159. *
  3160. * This function reads the incoming @req and fill in the destination
  3161. * WMI structure and sends down the gateway configs down to the firmware
  3162. *
  3163. * Return: QDF_STATUS
  3164. */
  3165. QDF_STATUS send_set_gateway_params_cmd_tlv(wmi_unified_t wmi_handle,
  3166. struct gateway_update_req_param *req)
  3167. {
  3168. wmi_roam_subnet_change_config_fixed_param *cmd;
  3169. wmi_buf_t buf;
  3170. int ret;
  3171. int len = sizeof(*cmd);
  3172. buf = wmi_buf_alloc(wmi_handle, len);
  3173. if (!buf) {
  3174. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  3175. return QDF_STATUS_E_NOMEM;
  3176. }
  3177. cmd = (wmi_roam_subnet_change_config_fixed_param *) wmi_buf_data(buf);
  3178. WMITLV_SET_HDR(&cmd->tlv_header,
  3179. WMITLV_TAG_STRUC_wmi_roam_subnet_change_config_fixed_param,
  3180. WMITLV_GET_STRUCT_TLVLEN(
  3181. wmi_roam_subnet_change_config_fixed_param));
  3182. cmd->vdev_id = req->session_id;
  3183. qdf_mem_copy(&cmd->inet_gw_ip_v4_addr, req->ipv4_addr,
  3184. QDF_IPV4_ADDR_SIZE);
  3185. qdf_mem_copy(&cmd->inet_gw_ip_v6_addr, req->ipv6_addr,
  3186. QDF_IPV6_ADDR_SIZE);
  3187. WMI_CHAR_ARRAY_TO_MAC_ADDR(req->gw_mac_addr.bytes,
  3188. &cmd->inet_gw_mac_addr);
  3189. cmd->max_retries = req->max_retries;
  3190. cmd->timeout = req->timeout;
  3191. cmd->num_skip_subnet_change_detection_bssid_list = 0;
  3192. cmd->flag = 0;
  3193. if (req->ipv4_addr_type)
  3194. WMI_SET_ROAM_SUBNET_CHANGE_FLAG_IP4_ENABLED(cmd->flag);
  3195. if (req->ipv6_addr_type)
  3196. WMI_SET_ROAM_SUBNET_CHANGE_FLAG_IP6_ENABLED(cmd->flag);
  3197. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  3198. WMI_ROAM_SUBNET_CHANGE_CONFIG_CMDID);
  3199. if (ret != EOK) {
  3200. WMI_LOGE("Failed to send gw config parameter to fw, ret: %d",
  3201. ret);
  3202. wmi_buf_free(buf);
  3203. return QDF_STATUS_E_FAILURE;
  3204. }
  3205. return QDF_STATUS_SUCCESS;
  3206. }
  3207. /**
  3208. * send_set_rssi_monitoring_cmd_tlv() - set rssi monitoring
  3209. * @wmi_handle: wmi handle
  3210. * @req: rssi monitoring request structure
  3211. *
  3212. * This function reads the incoming @req and fill in the destination
  3213. * WMI structure and send down the rssi monitoring configs down to the firmware
  3214. *
  3215. * Return: 0 on success; error number otherwise
  3216. */
  3217. QDF_STATUS send_set_rssi_monitoring_cmd_tlv(wmi_unified_t wmi_handle,
  3218. struct rssi_monitor_param *req)
  3219. {
  3220. wmi_rssi_breach_monitor_config_fixed_param *cmd;
  3221. wmi_buf_t buf;
  3222. int ret, len = sizeof(*cmd);
  3223. buf = wmi_buf_alloc(wmi_handle, len);
  3224. if (!buf) {
  3225. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  3226. return QDF_STATUS_E_NOMEM;
  3227. }
  3228. cmd = (wmi_rssi_breach_monitor_config_fixed_param *) wmi_buf_data(buf);
  3229. WMITLV_SET_HDR(&cmd->tlv_header,
  3230. WMITLV_TAG_STRUC_wmi_rssi_breach_monitor_config_fixed_param,
  3231. WMITLV_GET_STRUCT_TLVLEN(
  3232. wmi_rssi_breach_monitor_config_fixed_param));
  3233. cmd->vdev_id = req->session_id;
  3234. cmd->request_id = req->request_id;
  3235. cmd->lo_rssi_reenable_hysteresis = 0;
  3236. cmd->hi_rssi_reenable_histeresis = 0;
  3237. cmd->min_report_interval = 0;
  3238. cmd->max_num_report = 1;
  3239. if (req->control) {
  3240. /* enable one threshold for each min/max */
  3241. cmd->enabled_bitmap = 0x09;
  3242. cmd->low_rssi_breach_threshold[0] = req->min_rssi;
  3243. cmd->hi_rssi_breach_threshold[0] = req->max_rssi;
  3244. } else {
  3245. cmd->enabled_bitmap = 0;
  3246. cmd->low_rssi_breach_threshold[0] = 0;
  3247. cmd->hi_rssi_breach_threshold[0] = 0;
  3248. }
  3249. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  3250. WMI_RSSI_BREACH_MONITOR_CONFIG_CMDID);
  3251. if (ret != EOK) {
  3252. WMI_LOGE("Failed to send WMI_RSSI_BREACH_MONITOR_CONFIG_CMDID");
  3253. wmi_buf_free(buf);
  3254. return QDF_STATUS_E_FAILURE;
  3255. }
  3256. WMI_LOGI("Sent WMI_RSSI_BREACH_MONITOR_CONFIG_CMDID to FW");
  3257. return QDF_STATUS_SUCCESS;
  3258. }
  3259. /**
  3260. * send_scan_probe_setoui_cmd_tlv() - set scan probe OUI
  3261. * @wmi_handle: wmi handle
  3262. * @psetoui: OUI parameters
  3263. *
  3264. * set scan probe OUI parameters in firmware
  3265. *
  3266. * Return: CDF status
  3267. */
  3268. QDF_STATUS send_scan_probe_setoui_cmd_tlv(wmi_unified_t wmi_handle,
  3269. struct scan_mac_oui *psetoui)
  3270. {
  3271. wmi_scan_prob_req_oui_cmd_fixed_param *cmd;
  3272. wmi_buf_t wmi_buf;
  3273. uint32_t len;
  3274. uint8_t *buf_ptr;
  3275. uint32_t *oui_buf;
  3276. len = sizeof(*cmd);
  3277. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  3278. if (!wmi_buf) {
  3279. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  3280. return QDF_STATUS_E_NOMEM;
  3281. }
  3282. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  3283. cmd = (wmi_scan_prob_req_oui_cmd_fixed_param *) buf_ptr;
  3284. WMITLV_SET_HDR(&cmd->tlv_header,
  3285. WMITLV_TAG_STRUC_wmi_scan_prob_req_oui_cmd_fixed_param,
  3286. WMITLV_GET_STRUCT_TLVLEN
  3287. (wmi_scan_prob_req_oui_cmd_fixed_param));
  3288. oui_buf = &cmd->prob_req_oui;
  3289. qdf_mem_zero(oui_buf, sizeof(cmd->prob_req_oui));
  3290. *oui_buf = psetoui->oui[0] << 16 | psetoui->oui[1] << 8
  3291. | psetoui->oui[2];
  3292. WMI_LOGD("%s: wmi:oui received from hdd %08x", __func__,
  3293. cmd->prob_req_oui);
  3294. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  3295. WMI_SCAN_PROB_REQ_OUI_CMDID)) {
  3296. WMI_LOGE("%s: failed to send command", __func__);
  3297. qdf_nbuf_free(wmi_buf);
  3298. return QDF_STATUS_E_FAILURE;
  3299. }
  3300. return QDF_STATUS_SUCCESS;
  3301. }
  3302. /**
  3303. * send_reset_passpoint_network_list_cmd_tlv() - reset passpoint network list
  3304. * @wmi_handle: wmi handle
  3305. * @req: passpoint network request structure
  3306. *
  3307. * This function sends down WMI command with network id set to wildcard id.
  3308. * firmware shall clear all the config entries
  3309. *
  3310. * Return: QDF_STATUS enumeration
  3311. */
  3312. QDF_STATUS send_reset_passpoint_network_list_cmd_tlv(wmi_unified_t wmi_handle,
  3313. struct wifi_passpoint_req_param *req)
  3314. {
  3315. wmi_passpoint_config_cmd_fixed_param *cmd;
  3316. wmi_buf_t buf;
  3317. uint32_t len;
  3318. int ret;
  3319. len = sizeof(*cmd);
  3320. buf = wmi_buf_alloc(wmi_handle, len);
  3321. if (!buf) {
  3322. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  3323. return QDF_STATUS_E_NOMEM;
  3324. }
  3325. cmd = (wmi_passpoint_config_cmd_fixed_param *) wmi_buf_data(buf);
  3326. WMITLV_SET_HDR(&cmd->tlv_header,
  3327. WMITLV_TAG_STRUC_wmi_passpoint_config_cmd_fixed_param,
  3328. WMITLV_GET_STRUCT_TLVLEN(
  3329. wmi_passpoint_config_cmd_fixed_param));
  3330. cmd->id = WMI_PASSPOINT_NETWORK_ID_WILDCARD;
  3331. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  3332. WMI_PASSPOINT_LIST_CONFIG_CMDID);
  3333. if (ret) {
  3334. WMI_LOGE("%s: Failed to send reset passpoint network list wmi cmd",
  3335. __func__);
  3336. wmi_buf_free(buf);
  3337. return QDF_STATUS_E_FAILURE;
  3338. }
  3339. return QDF_STATUS_SUCCESS;
  3340. }
  3341. /**
  3342. * send_set_passpoint_network_list_cmd_tlv() - set passpoint network list
  3343. * @wmi_handle: wmi handle
  3344. * @req: passpoint network request structure
  3345. *
  3346. * This function reads the incoming @req and fill in the destination
  3347. * WMI structure and send down the passpoint configs down to the firmware
  3348. *
  3349. * Return: QDF_STATUS enumeration
  3350. */
  3351. QDF_STATUS send_set_passpoint_network_list_cmd_tlv(wmi_unified_t wmi_handle,
  3352. struct wifi_passpoint_req_param *req)
  3353. {
  3354. wmi_passpoint_config_cmd_fixed_param *cmd;
  3355. u_int8_t i, j, *bytes;
  3356. wmi_buf_t buf;
  3357. uint32_t len;
  3358. int ret;
  3359. len = sizeof(*cmd);
  3360. for (i = 0; i < req->num_networks; i++) {
  3361. buf = wmi_buf_alloc(wmi_handle, len);
  3362. if (!buf) {
  3363. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  3364. return QDF_STATUS_E_NOMEM;
  3365. }
  3366. cmd = (wmi_passpoint_config_cmd_fixed_param *)
  3367. wmi_buf_data(buf);
  3368. WMITLV_SET_HDR(&cmd->tlv_header,
  3369. WMITLV_TAG_STRUC_wmi_passpoint_config_cmd_fixed_param,
  3370. WMITLV_GET_STRUCT_TLVLEN(
  3371. wmi_passpoint_config_cmd_fixed_param));
  3372. cmd->id = req->networks[i].id;
  3373. WMI_LOGD("%s: network id: %u", __func__, cmd->id);
  3374. qdf_mem_copy(cmd->realm, req->networks[i].realm,
  3375. strlen(req->networks[i].realm) + 1);
  3376. WMI_LOGD("%s: realm: %s", __func__, cmd->realm);
  3377. for (j = 0; j < PASSPOINT_ROAMING_CONSORTIUM_ID_NUM; j++) {
  3378. bytes = (uint8_t *) &req->networks[i].roaming_consortium_ids[j];
  3379. WMI_LOGD("index: %d rcids: %02x %02x %02x %02x %02x %02x %02x %02x",
  3380. j, bytes[0], bytes[1], bytes[2], bytes[3],
  3381. bytes[4], bytes[5], bytes[6], bytes[7]);
  3382. qdf_mem_copy(&cmd->roaming_consortium_ids[j],
  3383. &req->networks[i].roaming_consortium_ids[j],
  3384. PASSPOINT_ROAMING_CONSORTIUM_ID_LEN);
  3385. }
  3386. qdf_mem_copy(cmd->plmn, req->networks[i].plmn,
  3387. PASSPOINT_PLMN_ID_LEN);
  3388. WMI_LOGD("%s: plmn: %02x:%02x:%02x", __func__,
  3389. cmd->plmn[0], cmd->plmn[1], cmd->plmn[2]);
  3390. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  3391. WMI_PASSPOINT_LIST_CONFIG_CMDID);
  3392. if (ret) {
  3393. WMI_LOGE("%s: Failed to send set passpoint network list wmi cmd",
  3394. __func__);
  3395. wmi_buf_free(buf);
  3396. return QDF_STATUS_E_FAILURE;
  3397. }
  3398. }
  3399. return QDF_STATUS_SUCCESS;
  3400. }
  3401. /**
  3402. * send_roam_scan_offload_mode_cmd_tlv() - send roam scan mode request to fw
  3403. * @wmi_handle: wmi handle
  3404. * @scan_cmd_fp: start scan command ptr
  3405. * @roam_req: roam request param
  3406. *
  3407. * send WMI_ROAM_SCAN_MODE TLV to firmware. It has a piggyback
  3408. * of WMI_ROAM_SCAN_MODE.
  3409. *
  3410. * Return: QDF status
  3411. */
  3412. QDF_STATUS send_roam_scan_offload_mode_cmd_tlv(wmi_unified_t wmi_handle,
  3413. wmi_start_scan_cmd_fixed_param *
  3414. scan_cmd_fp,
  3415. struct roam_offload_scan_params *roam_req)
  3416. {
  3417. wmi_buf_t buf = NULL;
  3418. int status = 0;
  3419. int len;
  3420. uint8_t *buf_ptr;
  3421. wmi_roam_scan_mode_fixed_param *roam_scan_mode_fp;
  3422. #ifdef WLAN_FEATURE_ROAM_OFFLOAD
  3423. int auth_mode = roam_req->auth_mode;
  3424. wmi_roam_offload_tlv_param *roam_offload_params;
  3425. wmi_roam_11i_offload_tlv_param *roam_offload_11i;
  3426. wmi_roam_11r_offload_tlv_param *roam_offload_11r;
  3427. wmi_roam_ese_offload_tlv_param *roam_offload_ese;
  3428. #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
  3429. /* Need to create a buf with roam_scan command at
  3430. * front and piggyback with scan command */
  3431. len = sizeof(wmi_roam_scan_mode_fixed_param) +
  3432. #ifdef WLAN_FEATURE_ROAM_OFFLOAD
  3433. (2 * WMI_TLV_HDR_SIZE) +
  3434. #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
  3435. sizeof(wmi_start_scan_cmd_fixed_param);
  3436. #ifdef WLAN_FEATURE_ROAM_OFFLOAD
  3437. if (roam_req->is_roam_req_valid &&
  3438. roam_req->roam_offload_enabled) {
  3439. len += sizeof(wmi_roam_offload_tlv_param);
  3440. len += WMI_TLV_HDR_SIZE;
  3441. if ((auth_mode != WMI_AUTH_NONE) &&
  3442. ((auth_mode != WMI_AUTH_OPEN) ||
  3443. (auth_mode == WMI_AUTH_OPEN &&
  3444. roam_req->mdid.mdie_present) ||
  3445. roam_req->is_ese_assoc)) {
  3446. len += WMI_TLV_HDR_SIZE;
  3447. if (roam_req->is_ese_assoc)
  3448. len +=
  3449. sizeof(wmi_roam_ese_offload_tlv_param);
  3450. else if (auth_mode == WMI_AUTH_FT_RSNA ||
  3451. auth_mode == WMI_AUTH_FT_RSNA_PSK ||
  3452. (auth_mode == WMI_AUTH_OPEN &&
  3453. roam_req->mdid.mdie_present))
  3454. len +=
  3455. sizeof(wmi_roam_11r_offload_tlv_param);
  3456. else
  3457. len +=
  3458. sizeof(wmi_roam_11i_offload_tlv_param);
  3459. } else {
  3460. len += WMI_TLV_HDR_SIZE;
  3461. }
  3462. } else {
  3463. if (roam_req->is_roam_req_valid)
  3464. WMA_LOGD("%s : roam offload = %d",
  3465. __func__, roam_req->roam_offload_enabled);
  3466. else
  3467. WMA_LOGD("%s : roam_req is NULL", __func__);
  3468. len += (2 * WMI_TLV_HDR_SIZE);
  3469. }
  3470. if (roam_req->is_roam_req_valid &&
  3471. roam_req->roam_offload_enabled) {
  3472. roam_req->mode = roam_req->mode |
  3473. WMI_ROAM_SCAN_MODE_ROAMOFFLOAD;
  3474. }
  3475. #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
  3476. buf = wmi_buf_alloc(wmi_handle, len);
  3477. if (!buf) {
  3478. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  3479. return QDF_STATUS_E_NOMEM;
  3480. }
  3481. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  3482. roam_scan_mode_fp = (wmi_roam_scan_mode_fixed_param *) buf_ptr;
  3483. WMITLV_SET_HDR(&roam_scan_mode_fp->tlv_header,
  3484. WMITLV_TAG_STRUC_wmi_roam_scan_mode_fixed_param,
  3485. WMITLV_GET_STRUCT_TLVLEN
  3486. (wmi_roam_scan_mode_fixed_param));
  3487. roam_scan_mode_fp->roam_scan_mode = roam_req->mode;
  3488. roam_scan_mode_fp->vdev_id = roam_req->vdev_id;
  3489. /* Fill in scan parameters suitable for roaming scan */
  3490. buf_ptr += sizeof(wmi_roam_scan_mode_fixed_param);
  3491. qdf_mem_copy(buf_ptr, scan_cmd_fp,
  3492. sizeof(wmi_start_scan_cmd_fixed_param));
  3493. /* Ensure there is no additional IEs */
  3494. scan_cmd_fp->ie_len = 0;
  3495. WMITLV_SET_HDR(buf_ptr,
  3496. WMITLV_TAG_STRUC_wmi_start_scan_cmd_fixed_param,
  3497. WMITLV_GET_STRUCT_TLVLEN
  3498. (wmi_start_scan_cmd_fixed_param));
  3499. #ifdef WLAN_FEATURE_ROAM_OFFLOAD
  3500. buf_ptr += sizeof(wmi_start_scan_cmd_fixed_param);
  3501. if (roam_req->is_roam_req_valid && roam_req->roam_offload_enabled) {
  3502. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3503. sizeof(wmi_roam_offload_tlv_param));
  3504. buf_ptr += WMI_TLV_HDR_SIZE;
  3505. roam_offload_params = (wmi_roam_offload_tlv_param *) buf_ptr;
  3506. WMITLV_SET_HDR(buf_ptr,
  3507. WMITLV_TAG_STRUC_wmi_roam_offload_tlv_param,
  3508. WMITLV_GET_STRUCT_TLVLEN
  3509. (wmi_roam_offload_tlv_param));
  3510. roam_offload_params->prefer_5g = roam_req->prefer_5ghz;
  3511. roam_offload_params->rssi_cat_gap = roam_req->roam_rssi_cat_gap;
  3512. roam_offload_params->select_5g_margin =
  3513. roam_req->select_5ghz_margin;
  3514. roam_offload_params->reassoc_failure_timeout =
  3515. roam_req->reassoc_failure_timeout;
  3516. /* Fill the capabilities */
  3517. roam_offload_params->capability =
  3518. roam_req->roam_offload_params.capability;
  3519. roam_offload_params->ht_caps_info =
  3520. roam_req->roam_offload_params.ht_caps_info;
  3521. roam_offload_params->ampdu_param =
  3522. roam_req->roam_offload_params.ampdu_param;
  3523. roam_offload_params->ht_ext_cap =
  3524. roam_req->roam_offload_params.ht_ext_cap;
  3525. roam_offload_params->ht_txbf =
  3526. roam_req->roam_offload_params.ht_txbf;
  3527. roam_offload_params->asel_cap =
  3528. roam_req->roam_offload_params.asel_cap;
  3529. roam_offload_params->qos_caps =
  3530. roam_req->roam_offload_params.qos_caps;
  3531. roam_offload_params->wmm_caps =
  3532. roam_req->roam_offload_params.wmm_caps;
  3533. qdf_mem_copy((uint8_t *)roam_offload_params->mcsset,
  3534. (uint8_t *)roam_req->roam_offload_params.mcsset,
  3535. ROAM_OFFLOAD_NUM_MCS_SET);
  3536. buf_ptr += sizeof(wmi_roam_offload_tlv_param);
  3537. /* The TLV's are in the order of 11i, 11R, ESE. Hence,
  3538. * they are filled in the same order.Depending on the
  3539. * authentication type, the other mode TLV's are nullified
  3540. * and only headers are filled.*/
  3541. if ((auth_mode != WMI_AUTH_NONE) &&
  3542. ((auth_mode != WMI_AUTH_OPEN) ||
  3543. (auth_mode == WMI_AUTH_OPEN
  3544. && roam_req->mdid.mdie_present) ||
  3545. roam_req->is_ese_assoc)) {
  3546. if (roam_req->is_ese_assoc) {
  3547. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3548. WMITLV_GET_STRUCT_TLVLEN(0));
  3549. buf_ptr += WMI_TLV_HDR_SIZE;
  3550. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3551. WMITLV_GET_STRUCT_TLVLEN(0));
  3552. buf_ptr += WMI_TLV_HDR_SIZE;
  3553. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3554. sizeof(wmi_roam_ese_offload_tlv_param));
  3555. buf_ptr += WMI_TLV_HDR_SIZE;
  3556. roam_offload_ese =
  3557. (wmi_roam_ese_offload_tlv_param *) buf_ptr;
  3558. qdf_mem_copy(roam_offload_ese->krk,
  3559. roam_req->krk,
  3560. sizeof(roam_req->krk));
  3561. qdf_mem_copy(roam_offload_ese->btk,
  3562. roam_req->btk,
  3563. sizeof(roam_req->btk));
  3564. WMITLV_SET_HDR(&roam_offload_ese->tlv_header,
  3565. WMITLV_TAG_STRUC_wmi_roam_ese_offload_tlv_param,
  3566. WMITLV_GET_STRUCT_TLVLEN
  3567. (wmi_roam_ese_offload_tlv_param));
  3568. buf_ptr +=
  3569. sizeof(wmi_roam_ese_offload_tlv_param);
  3570. } else if (auth_mode == WMI_AUTH_FT_RSNA
  3571. || auth_mode == WMI_AUTH_FT_RSNA_PSK
  3572. || (auth_mode == WMI_AUTH_OPEN
  3573. && roam_req->mdid.mdie_present)) {
  3574. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3575. 0);
  3576. buf_ptr += WMI_TLV_HDR_SIZE;
  3577. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3578. sizeof(wmi_roam_11r_offload_tlv_param));
  3579. buf_ptr += WMI_TLV_HDR_SIZE;
  3580. roam_offload_11r =
  3581. (wmi_roam_11r_offload_tlv_param *) buf_ptr;
  3582. roam_offload_11r->r0kh_id_len =
  3583. roam_req->rokh_id_length;
  3584. qdf_mem_copy(roam_offload_11r->r0kh_id,
  3585. roam_req->rokh_id,
  3586. roam_offload_11r->r0kh_id_len);
  3587. qdf_mem_copy(roam_offload_11r->psk_msk,
  3588. roam_req->psk_pmk,
  3589. sizeof(roam_req->psk_pmk));
  3590. roam_offload_11r->psk_msk_len =
  3591. roam_req->pmk_len;
  3592. roam_offload_11r->mdie_present =
  3593. roam_req->mdid.mdie_present;
  3594. roam_offload_11r->mdid =
  3595. roam_req->mdid.mobility_domain;
  3596. if (auth_mode == WMI_AUTH_OPEN) {
  3597. /* If FT-Open ensure pmk length
  3598. and r0khid len are zero */
  3599. roam_offload_11r->r0kh_id_len = 0;
  3600. roam_offload_11r->psk_msk_len = 0;
  3601. }
  3602. WMITLV_SET_HDR(&roam_offload_11r->tlv_header,
  3603. WMITLV_TAG_STRUC_wmi_roam_11r_offload_tlv_param,
  3604. WMITLV_GET_STRUCT_TLVLEN
  3605. (wmi_roam_11r_offload_tlv_param));
  3606. buf_ptr +=
  3607. sizeof(wmi_roam_11r_offload_tlv_param);
  3608. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3609. WMITLV_GET_STRUCT_TLVLEN(0));
  3610. buf_ptr += WMI_TLV_HDR_SIZE;
  3611. } else {
  3612. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3613. sizeof(wmi_roam_11i_offload_tlv_param));
  3614. buf_ptr += WMI_TLV_HDR_SIZE;
  3615. roam_offload_11i =
  3616. (wmi_roam_11i_offload_tlv_param *) buf_ptr;
  3617. if (roam_req->roam_key_mgmt_offload_enabled) {
  3618. WMI_SET_ROAM_OFFLOAD_OKC_ENABLED
  3619. (roam_offload_11i->flags);
  3620. WMA_LOGE("LFR3:OKC Enabled");
  3621. } else {
  3622. WMI_SET_ROAM_OFFLOAD_OKC_DISABLED
  3623. (roam_offload_11i->flags);
  3624. WMA_LOGE("LFR3:OKC Disabled");
  3625. }
  3626. qdf_mem_copy(roam_offload_11i->pmk,
  3627. roam_req->psk_pmk,
  3628. sizeof(roam_req->psk_pmk));
  3629. roam_offload_11i->pmk_len = roam_req->pmk_len;
  3630. WMITLV_SET_HDR(&roam_offload_11i->tlv_header,
  3631. WMITLV_TAG_STRUC_wmi_roam_11i_offload_tlv_param,
  3632. WMITLV_GET_STRUCT_TLVLEN
  3633. (wmi_roam_11i_offload_tlv_param));
  3634. buf_ptr +=
  3635. sizeof(wmi_roam_11i_offload_tlv_param);
  3636. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3637. 0);
  3638. buf_ptr += WMI_TLV_HDR_SIZE;
  3639. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3640. 0);
  3641. buf_ptr += WMI_TLV_HDR_SIZE;
  3642. }
  3643. } else {
  3644. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3645. WMITLV_GET_STRUCT_TLVLEN(0));
  3646. buf_ptr += WMI_TLV_HDR_SIZE;
  3647. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3648. WMITLV_GET_STRUCT_TLVLEN(0));
  3649. buf_ptr += WMI_TLV_HDR_SIZE;
  3650. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3651. WMITLV_GET_STRUCT_TLVLEN(0));
  3652. }
  3653. } else {
  3654. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3655. WMITLV_GET_STRUCT_TLVLEN(0));
  3656. buf_ptr += WMI_TLV_HDR_SIZE;
  3657. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3658. WMITLV_GET_STRUCT_TLVLEN(0));
  3659. buf_ptr += WMI_TLV_HDR_SIZE;
  3660. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3661. WMITLV_GET_STRUCT_TLVLEN(0));
  3662. buf_ptr += WMI_TLV_HDR_SIZE;
  3663. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3664. WMITLV_GET_STRUCT_TLVLEN(0));
  3665. }
  3666. #endif /* WLAN_FEATURE_ROAM_OFFLOAD */
  3667. status = wmi_unified_cmd_send(wmi_handle, buf,
  3668. len, WMI_ROAM_SCAN_MODE);
  3669. if (status != EOK) {
  3670. WMA_LOGE(
  3671. "wmi_unified_cmd_send WMI_ROAM_SCAN_MODE returned Error %d",
  3672. status);
  3673. wmi_buf_free(buf);
  3674. return QDF_STATUS_E_FAILURE;
  3675. }
  3676. return QDF_STATUS_SUCCESS;
  3677. }
  3678. /**
  3679. * send_roam_scan_offload_rssi_thresh_cmd_tlv() - set scan offload
  3680. * rssi threashold
  3681. * @wmi_handle: wmi handle
  3682. * @roam_req: Roaming request buffer
  3683. *
  3684. * Send WMI_ROAM_SCAN_RSSI_THRESHOLD TLV to firmware
  3685. *
  3686. * Return: QDF status
  3687. */
  3688. QDF_STATUS send_roam_scan_offload_rssi_thresh_cmd_tlv(wmi_unified_t wmi_handle,
  3689. struct roam_offload_scan_rssi_params *roam_req)
  3690. {
  3691. wmi_buf_t buf = NULL;
  3692. int status = 0;
  3693. int len;
  3694. uint8_t *buf_ptr;
  3695. wmi_roam_scan_rssi_threshold_fixed_param *rssi_threshold_fp;
  3696. wmi_roam_scan_extended_threshold_param *ext_thresholds = NULL;
  3697. wmi_roam_earlystop_rssi_thres_param *early_stop_thresholds = NULL;
  3698. len = sizeof(wmi_roam_scan_rssi_threshold_fixed_param);
  3699. len += WMI_TLV_HDR_SIZE; /* TLV for ext_thresholds*/
  3700. len += sizeof(wmi_roam_scan_extended_threshold_param);
  3701. len += WMI_TLV_HDR_SIZE;
  3702. len += sizeof(wmi_roam_earlystop_rssi_thres_param);
  3703. buf = wmi_buf_alloc(wmi_handle, len);
  3704. if (!buf) {
  3705. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  3706. return QDF_STATUS_E_NOMEM;
  3707. }
  3708. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  3709. rssi_threshold_fp =
  3710. (wmi_roam_scan_rssi_threshold_fixed_param *) buf_ptr;
  3711. WMITLV_SET_HDR(&rssi_threshold_fp->tlv_header,
  3712. WMITLV_TAG_STRUC_wmi_roam_scan_rssi_threshold_fixed_param,
  3713. WMITLV_GET_STRUCT_TLVLEN
  3714. (wmi_roam_scan_rssi_threshold_fixed_param));
  3715. /* fill in threshold values */
  3716. rssi_threshold_fp->vdev_id = roam_req->session_id;
  3717. rssi_threshold_fp->roam_scan_rssi_thresh = roam_req->rssi_thresh;
  3718. rssi_threshold_fp->roam_rssi_thresh_diff = roam_req->rssi_thresh_diff;
  3719. rssi_threshold_fp->hirssi_scan_max_count =
  3720. roam_req->hi_rssi_scan_max_count;
  3721. rssi_threshold_fp->hirssi_scan_delta =
  3722. roam_req->hi_rssi_scan_rssi_delta;
  3723. rssi_threshold_fp->hirssi_upper_bound = roam_req->hi_rssi_scan_rssi_ub;
  3724. buf_ptr += sizeof(wmi_roam_scan_rssi_threshold_fixed_param);
  3725. WMITLV_SET_HDR(buf_ptr,
  3726. WMITLV_TAG_ARRAY_STRUC,
  3727. sizeof(wmi_roam_scan_extended_threshold_param));
  3728. buf_ptr += WMI_TLV_HDR_SIZE;
  3729. ext_thresholds = (wmi_roam_scan_extended_threshold_param *) buf_ptr;
  3730. ext_thresholds->penalty_threshold_5g = roam_req->penalty_threshold_5g;
  3731. if (roam_req->raise_rssi_thresh_5g >= WMI_NOISE_FLOOR_DBM_DEFAULT)
  3732. ext_thresholds->boost_threshold_5g =
  3733. roam_req->boost_threshold_5g;
  3734. ext_thresholds->boost_algorithm_5g =
  3735. WMI_ROAM_5G_BOOST_PENALIZE_ALGO_LINEAR;
  3736. ext_thresholds->boost_factor_5g = roam_req->raise_factor_5g;
  3737. ext_thresholds->penalty_algorithm_5g =
  3738. WMI_ROAM_5G_BOOST_PENALIZE_ALGO_LINEAR;
  3739. ext_thresholds->penalty_factor_5g = roam_req->drop_factor_5g;
  3740. ext_thresholds->max_boost_5g = roam_req->max_raise_rssi_5g;
  3741. ext_thresholds->max_penalty_5g = roam_req->max_drop_rssi_5g;
  3742. ext_thresholds->good_rssi_threshold = roam_req->good_rssi_threshold;
  3743. WMITLV_SET_HDR(&ext_thresholds->tlv_header,
  3744. WMITLV_TAG_STRUC_wmi_roam_scan_extended_threshold_param,
  3745. WMITLV_GET_STRUCT_TLVLEN
  3746. (wmi_roam_scan_extended_threshold_param));
  3747. buf_ptr += sizeof(wmi_roam_scan_extended_threshold_param);
  3748. WMITLV_SET_HDR(buf_ptr,
  3749. WMITLV_TAG_ARRAY_STRUC,
  3750. sizeof(wmi_roam_earlystop_rssi_thres_param));
  3751. buf_ptr += WMI_TLV_HDR_SIZE;
  3752. early_stop_thresholds = (wmi_roam_earlystop_rssi_thres_param *) buf_ptr;
  3753. early_stop_thresholds->roam_earlystop_thres_min =
  3754. roam_req->roam_earlystop_thres_min;
  3755. early_stop_thresholds->roam_earlystop_thres_max =
  3756. roam_req->roam_earlystop_thres_max;
  3757. WMITLV_SET_HDR(&early_stop_thresholds->tlv_header,
  3758. WMITLV_TAG_STRUC_wmi_roam_earlystop_rssi_thres_param,
  3759. WMITLV_GET_STRUCT_TLVLEN
  3760. (wmi_roam_earlystop_rssi_thres_param));
  3761. status = wmi_unified_cmd_send(wmi_handle, buf,
  3762. len, WMI_ROAM_SCAN_RSSI_THRESHOLD);
  3763. if (status != EOK) {
  3764. WMA_LOGE("cmd WMI_ROAM_SCAN_RSSI_THRESHOLD returned Error %d",
  3765. status);
  3766. wmi_buf_free(buf);
  3767. return QDF_STATUS_E_FAILURE;
  3768. }
  3769. return QDF_STATUS_SUCCESS;
  3770. }
  3771. /**
  3772. * send_roam_scan_filter_cmd_tlv() - Filter to be applied while roaming
  3773. * @wmi_handle: wmi handle
  3774. * @roam_req: Request which contains the filters
  3775. *
  3776. * There are filters such as whitelist, blacklist and preferred
  3777. * list that need to be applied to the scan results to form the
  3778. * probable candidates for roaming.
  3779. *
  3780. * Return: Return success upon succesfully passing the
  3781. * parameters to the firmware, otherwise failure.
  3782. */
  3783. QDF_STATUS send_roam_scan_filter_cmd_tlv(wmi_unified_t wmi_handle,
  3784. struct roam_scan_filter_params *roam_req)
  3785. {
  3786. wmi_buf_t buf = NULL;
  3787. int status = 0, i;
  3788. uint32_t len;
  3789. uint8_t *buf_ptr;
  3790. wmi_roam_filter_fixed_param *roam_filter;
  3791. uint8_t *bssid_src_ptr = NULL;
  3792. wmi_mac_addr *bssid_dst_ptr = NULL;
  3793. wmi_ssid *ssid_ptr = NULL;
  3794. uint32_t *bssid_preferred_factor_ptr = NULL;
  3795. len = sizeof(wmi_roam_filter_fixed_param);
  3796. len += WMI_TLV_HDR_SIZE;
  3797. len += roam_req->len;
  3798. buf = wmi_buf_alloc(wmi_handle, len);
  3799. if (!buf) {
  3800. WMA_LOGE("%s : wmi_buf_alloc failed", __func__);
  3801. return QDF_STATUS_E_NOMEM;
  3802. }
  3803. buf_ptr = (u_int8_t *) wmi_buf_data(buf);
  3804. roam_filter = (wmi_roam_filter_fixed_param *) buf_ptr;
  3805. WMITLV_SET_HDR(&roam_filter->tlv_header,
  3806. WMITLV_TAG_STRUC_wmi_roam_filter_fixed_param,
  3807. WMITLV_GET_STRUCT_TLVLEN(wmi_roam_filter_fixed_param));
  3808. /* fill in fixed values */
  3809. roam_filter->vdev_id = roam_req->session_id;
  3810. roam_filter->flags = 0;
  3811. roam_filter->op_bitmap = roam_req->op_bitmap;
  3812. roam_filter->num_bssid_black_list = roam_req->num_bssid_black_list;
  3813. roam_filter->num_ssid_white_list = roam_req->num_ssid_white_list;
  3814. roam_filter->num_bssid_preferred_list =
  3815. roam_req->num_bssid_preferred_list;
  3816. buf_ptr += sizeof(wmi_roam_filter_fixed_param);
  3817. WMITLV_SET_HDR((buf_ptr),
  3818. WMITLV_TAG_ARRAY_FIXED_STRUC,
  3819. (roam_req->num_bssid_black_list * sizeof(wmi_mac_addr)));
  3820. bssid_src_ptr = (uint8_t *)&roam_req->bssid_avoid_list;
  3821. bssid_dst_ptr = (wmi_mac_addr *)(buf_ptr + WMI_TLV_HDR_SIZE);
  3822. for (i = 0; i < roam_req->num_bssid_black_list; i++) {
  3823. WMI_CHAR_ARRAY_TO_MAC_ADDR(bssid_src_ptr, bssid_dst_ptr);
  3824. bssid_src_ptr += ATH_MAC_LEN;
  3825. bssid_dst_ptr++;
  3826. }
  3827. buf_ptr += WMI_TLV_HDR_SIZE +
  3828. (roam_req->num_bssid_black_list * sizeof(wmi_mac_addr));
  3829. WMITLV_SET_HDR((buf_ptr),
  3830. WMITLV_TAG_ARRAY_FIXED_STRUC,
  3831. (roam_req->num_ssid_white_list * sizeof(wmi_ssid)));
  3832. ssid_ptr = (wmi_ssid *)(buf_ptr + WMI_TLV_HDR_SIZE);
  3833. for (i = 0; i < roam_req->num_ssid_white_list; i++) {
  3834. qdf_mem_copy(&ssid_ptr->ssid,
  3835. &roam_req->ssid_allowed_list[i].mac_ssid,
  3836. roam_req->ssid_allowed_list[i].length);
  3837. ssid_ptr->ssid_len = roam_req->ssid_allowed_list[i].length;
  3838. ssid_ptr++;
  3839. }
  3840. buf_ptr += WMI_TLV_HDR_SIZE + (roam_req->num_ssid_white_list *
  3841. sizeof(wmi_ssid));
  3842. WMITLV_SET_HDR((buf_ptr),
  3843. WMITLV_TAG_ARRAY_FIXED_STRUC,
  3844. (roam_req->num_bssid_preferred_list * sizeof(wmi_mac_addr)));
  3845. bssid_src_ptr = (uint8_t *)&roam_req->bssid_favored;
  3846. bssid_dst_ptr = (wmi_mac_addr *)(buf_ptr + WMI_TLV_HDR_SIZE);
  3847. for (i = 0; i < roam_req->num_bssid_preferred_list; i++) {
  3848. WMI_CHAR_ARRAY_TO_MAC_ADDR(bssid_src_ptr,
  3849. (wmi_mac_addr *)bssid_dst_ptr);
  3850. bssid_src_ptr += ATH_MAC_LEN;
  3851. bssid_dst_ptr++;
  3852. }
  3853. buf_ptr += WMI_TLV_HDR_SIZE +
  3854. (roam_req->num_bssid_preferred_list * sizeof(wmi_mac_addr));
  3855. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  3856. (roam_req->num_bssid_preferred_list * sizeof(uint32_t)));
  3857. bssid_preferred_factor_ptr = (uint32_t *)(buf_ptr + WMI_TLV_HDR_SIZE);
  3858. for (i = 0; i < roam_req->num_bssid_preferred_list; i++) {
  3859. *bssid_preferred_factor_ptr =
  3860. roam_req->bssid_favored_factor[i];
  3861. bssid_preferred_factor_ptr++;
  3862. }
  3863. buf_ptr += WMI_TLV_HDR_SIZE +
  3864. (roam_req->num_bssid_preferred_list * sizeof(uint32_t));
  3865. status = wmi_unified_cmd_send(wmi_handle, buf,
  3866. len, WMI_ROAM_FILTER_CMDID);
  3867. if (status != EOK) {
  3868. WMA_LOGE("cmd WMI_ROAM_FILTER_CMDID returned Error %d",
  3869. status);
  3870. wmi_buf_free(buf);
  3871. return QDF_STATUS_E_FAILURE;
  3872. }
  3873. return QDF_STATUS_SUCCESS;
  3874. }
  3875. /** send_set_epno_network_list_cmd_tlv() - set epno network list
  3876. * @wmi_handle: wmi handle
  3877. * @req: epno config params request structure
  3878. *
  3879. * This function reads the incoming epno config request structure
  3880. * and constructs the WMI message to the firmware.
  3881. *
  3882. * Returns: 0 on success, error number otherwise
  3883. */
  3884. QDF_STATUS send_set_epno_network_list_cmd_tlv(wmi_unified_t wmi_handle,
  3885. struct wifi_enhanched_pno_params *req)
  3886. {
  3887. wmi_nlo_config_cmd_fixed_param *cmd;
  3888. nlo_configured_parameters *nlo_list;
  3889. u_int8_t i, *buf_ptr;
  3890. wmi_buf_t buf;
  3891. uint32_t len;
  3892. int ret;
  3893. /* TLV place holder for array of structures
  3894. * nlo_configured_parameters(nlo_list) */
  3895. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
  3896. len += sizeof(nlo_configured_parameters) *
  3897. QDF_MIN(req->num_networks, WMI_NLO_MAX_SSIDS);
  3898. len += WMI_TLV_HDR_SIZE; /* TLV for channel_list */
  3899. len += WMI_TLV_HDR_SIZE; /* TLV for channel prediction cfg*/
  3900. buf = wmi_buf_alloc(wmi_handle, len);
  3901. if (!buf) {
  3902. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  3903. return QDF_STATUS_E_NOMEM;
  3904. }
  3905. cmd = (wmi_nlo_config_cmd_fixed_param *) wmi_buf_data(buf);
  3906. buf_ptr = (u_int8_t *) cmd;
  3907. WMITLV_SET_HDR(&cmd->tlv_header,
  3908. WMITLV_TAG_STRUC_wmi_nlo_config_cmd_fixed_param,
  3909. WMITLV_GET_STRUCT_TLVLEN(
  3910. wmi_nlo_config_cmd_fixed_param));
  3911. cmd->vdev_id = req->session_id;
  3912. cmd->flags = WMI_NLO_CONFIG_ENLO;
  3913. buf_ptr += sizeof(wmi_nlo_config_cmd_fixed_param);
  3914. cmd->no_of_ssids = QDF_MIN(req->num_networks, WMI_NLO_MAX_SSIDS);
  3915. WMI_LOGD("SSID count: %d", cmd->no_of_ssids);
  3916. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  3917. cmd->no_of_ssids * sizeof(nlo_configured_parameters));
  3918. buf_ptr += WMI_TLV_HDR_SIZE;
  3919. nlo_list = (nlo_configured_parameters *) buf_ptr;
  3920. for (i = 0; i < cmd->no_of_ssids; i++) {
  3921. WMITLV_SET_HDR(&nlo_list[i].tlv_header,
  3922. WMITLV_TAG_ARRAY_BYTE,
  3923. WMITLV_GET_STRUCT_TLVLEN(nlo_configured_parameters));
  3924. /* Copy ssid and it's length */
  3925. nlo_list[i].ssid.valid = true;
  3926. nlo_list[i].ssid.ssid.ssid_len = req->networks[i].ssid.length;
  3927. qdf_mem_copy(nlo_list[i].ssid.ssid.ssid,
  3928. req->networks[i].ssid.mac_ssid,
  3929. nlo_list[i].ssid.ssid.ssid_len);
  3930. WMI_LOGD("index: %d ssid: %.*s len: %d", i,
  3931. nlo_list[i].ssid.ssid.ssid_len,
  3932. (char *) nlo_list[i].ssid.ssid.ssid,
  3933. nlo_list[i].ssid.ssid.ssid_len);
  3934. /* Copy rssi threshold */
  3935. nlo_list[i].rssi_cond.valid = true;
  3936. nlo_list[i].rssi_cond.rssi =
  3937. req->networks[i].rssi_threshold;
  3938. WMI_LOGD("RSSI threshold : %d dBm",
  3939. nlo_list[i].rssi_cond.rssi);
  3940. /* Copy pno flags */
  3941. nlo_list[i].bcast_nw_type.valid = true;
  3942. nlo_list[i].bcast_nw_type.bcast_nw_type =
  3943. req->networks[i].flags;
  3944. WMI_LOGD("PNO flags (%u)",
  3945. nlo_list[i].bcast_nw_type.bcast_nw_type);
  3946. /* Copy auth bit field */
  3947. nlo_list[i].auth_type.valid = true;
  3948. nlo_list[i].auth_type.auth_type =
  3949. req->networks[i].auth_bit_field;
  3950. WMI_LOGD("Auth bit field (%u)",
  3951. nlo_list[i].auth_type.auth_type);
  3952. }
  3953. buf_ptr += cmd->no_of_ssids * sizeof(nlo_configured_parameters);
  3954. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
  3955. buf_ptr += WMI_TLV_HDR_SIZE;
  3956. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  3957. buf_ptr += WMI_TLV_HDR_SIZE;
  3958. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  3959. WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
  3960. if (ret) {
  3961. WMI_LOGE("%s: Failed to send nlo wmi cmd", __func__);
  3962. wmi_buf_free(buf);
  3963. return QDF_STATUS_E_FAILURE;
  3964. }
  3965. WMI_LOGD("set ePNO list request sent successfully for vdev %d",
  3966. req->session_id);
  3967. return QDF_STATUS_SUCCESS;
  3968. }
  3969. /** send_ipa_offload_control_cmd_tlv() - ipa offload control parameter
  3970. * @wmi_handle: wmi handle
  3971. * @ipa_offload: ipa offload control parameter
  3972. *
  3973. * Returns: 0 on success, error number otherwise
  3974. */
  3975. QDF_STATUS send_ipa_offload_control_cmd_tlv(wmi_unified_t wmi_handle,
  3976. struct ipa_offload_control_params *ipa_offload)
  3977. {
  3978. wmi_ipa_offload_enable_disable_cmd_fixed_param *cmd;
  3979. wmi_buf_t wmi_buf;
  3980. uint32_t len;
  3981. u_int8_t *buf_ptr;
  3982. len = sizeof(*cmd);
  3983. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  3984. if (!wmi_buf) {
  3985. WMI_LOGE("%s: wmi_buf_alloc failed (len=%d)", __func__, len);
  3986. return QDF_STATUS_E_NOMEM;
  3987. }
  3988. WMI_LOGE("%s: offload_type=%d, enable=%d", __func__,
  3989. ipa_offload->offload_type, ipa_offload->enable);
  3990. buf_ptr = (u_int8_t *)wmi_buf_data(wmi_buf);
  3991. cmd = (wmi_ipa_offload_enable_disable_cmd_fixed_param *)buf_ptr;
  3992. WMITLV_SET_HDR(&cmd->tlv_header,
  3993. WMITLV_TAG_STRUCT_wmi_ipa_offload_enable_disable_cmd_fixed_param,
  3994. WMITLV_GET_STRUCT_TLVLEN(
  3995. wmi_ipa_offload_enable_disable_cmd_fixed_param));
  3996. cmd->offload_type = ipa_offload->offload_type;
  3997. cmd->vdev_id = ipa_offload->vdev_id;
  3998. cmd->enable = ipa_offload->enable;
  3999. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  4000. WMI_IPA_OFFLOAD_ENABLE_DISABLE_CMDID)) {
  4001. WMI_LOGE("%s: failed to command", __func__);
  4002. wmi_buf_free(wmi_buf);
  4003. return QDF_STATUS_E_FAILURE;
  4004. }
  4005. return QDF_STATUS_SUCCESS;
  4006. }
  4007. /**
  4008. * send_extscan_get_capabilities_cmd_tlv() - extscan get capabilities
  4009. * @wmi_handle: wmi handle
  4010. * @pgetcapab: get capabilities params
  4011. *
  4012. * This function send request to fw to get extscan capabilities.
  4013. *
  4014. * Return: CDF status
  4015. */
  4016. QDF_STATUS send_extscan_get_capabilities_cmd_tlv(wmi_unified_t wmi_handle,
  4017. struct extscan_capabilities_params *pgetcapab)
  4018. {
  4019. wmi_extscan_get_capabilities_cmd_fixed_param *cmd;
  4020. wmi_buf_t wmi_buf;
  4021. uint32_t len;
  4022. uint8_t *buf_ptr;
  4023. len = sizeof(*cmd);
  4024. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  4025. if (!wmi_buf) {
  4026. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  4027. return QDF_STATUS_E_NOMEM;
  4028. }
  4029. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  4030. cmd = (wmi_extscan_get_capabilities_cmd_fixed_param *) buf_ptr;
  4031. WMITLV_SET_HDR(&cmd->tlv_header,
  4032. WMITLV_TAG_STRUC_wmi_extscan_get_capabilities_cmd_fixed_param,
  4033. WMITLV_GET_STRUCT_TLVLEN
  4034. (wmi_extscan_get_capabilities_cmd_fixed_param));
  4035. cmd->request_id = pgetcapab->request_id;
  4036. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  4037. WMI_EXTSCAN_GET_CAPABILITIES_CMDID)) {
  4038. WMI_LOGE("%s: failed to command", __func__);
  4039. qdf_nbuf_free(wmi_buf);
  4040. return QDF_STATUS_E_FAILURE;
  4041. }
  4042. return QDF_STATUS_SUCCESS;
  4043. }
  4044. /**
  4045. * send_extscan_get_cached_results_cmd_tlv() - extscan get cached results
  4046. * @wmi_handle: wmi handle
  4047. * @pcached_results: cached results parameters
  4048. *
  4049. * This function send request to fw to get cached results.
  4050. *
  4051. * Return: CDF status
  4052. */
  4053. QDF_STATUS send_extscan_get_cached_results_cmd_tlv(wmi_unified_t wmi_handle,
  4054. struct extscan_cached_result_params *pcached_results)
  4055. {
  4056. wmi_extscan_get_cached_results_cmd_fixed_param *cmd;
  4057. wmi_buf_t wmi_buf;
  4058. uint32_t len;
  4059. uint8_t *buf_ptr;
  4060. len = sizeof(*cmd);
  4061. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  4062. if (!wmi_buf) {
  4063. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  4064. return QDF_STATUS_E_NOMEM;
  4065. }
  4066. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  4067. cmd = (wmi_extscan_get_cached_results_cmd_fixed_param *) buf_ptr;
  4068. WMITLV_SET_HDR(&cmd->tlv_header,
  4069. WMITLV_TAG_STRUC_wmi_extscan_get_cached_results_cmd_fixed_param,
  4070. WMITLV_GET_STRUCT_TLVLEN
  4071. (wmi_extscan_get_cached_results_cmd_fixed_param));
  4072. cmd->request_id = pcached_results->request_id;
  4073. cmd->vdev_id = pcached_results->session_id;
  4074. cmd->control_flags = pcached_results->flush;
  4075. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  4076. WMI_EXTSCAN_GET_CACHED_RESULTS_CMDID)) {
  4077. WMI_LOGE("%s: failed to command", __func__);
  4078. qdf_nbuf_free(wmi_buf);
  4079. return QDF_STATUS_E_FAILURE;
  4080. }
  4081. return QDF_STATUS_SUCCESS;
  4082. }
  4083. /**
  4084. * send_extscan_stop_change_monitor_cmd_tlv() - send stop change monitor cmd
  4085. * @wmi_handle: wmi handle
  4086. * @reset_req: Reset change request params
  4087. *
  4088. * This function sends stop change monitor request to fw.
  4089. *
  4090. * Return: CDF status
  4091. */
  4092. QDF_STATUS send_extscan_stop_change_monitor_cmd_tlv(wmi_unified_t wmi_handle,
  4093. struct extscan_capabilities_reset_params *reset_req)
  4094. {
  4095. wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param *cmd;
  4096. wmi_buf_t wmi_buf;
  4097. uint32_t len;
  4098. uint8_t *buf_ptr;
  4099. int change_list = 0;
  4100. len = sizeof(*cmd);
  4101. /* reset significant change tlv is set to 0 */
  4102. len += WMI_TLV_HDR_SIZE;
  4103. len += change_list * sizeof(wmi_extscan_wlan_change_bssid_param);
  4104. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  4105. if (!wmi_buf) {
  4106. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  4107. return QDF_STATUS_E_NOMEM;
  4108. }
  4109. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  4110. cmd = (wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param *)
  4111. buf_ptr;
  4112. WMITLV_SET_HDR(&cmd->tlv_header,
  4113. WMITLV_TAG_STRUC_wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param,
  4114. WMITLV_GET_STRUCT_TLVLEN
  4115. (wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param));
  4116. cmd->request_id = reset_req->request_id;
  4117. cmd->vdev_id = reset_req->session_id;
  4118. cmd->mode = 0;
  4119. buf_ptr += sizeof(*cmd);
  4120. WMITLV_SET_HDR(buf_ptr,
  4121. WMITLV_TAG_ARRAY_STRUC,
  4122. change_list *
  4123. sizeof(wmi_extscan_wlan_change_bssid_param));
  4124. buf_ptr += WMI_TLV_HDR_SIZE + (change_list *
  4125. sizeof
  4126. (wmi_extscan_wlan_change_bssid_param));
  4127. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  4128. WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID)) {
  4129. WMI_LOGE("%s: failed to command", __func__);
  4130. qdf_nbuf_free(wmi_buf);
  4131. return QDF_STATUS_E_FAILURE;
  4132. }
  4133. return QDF_STATUS_SUCCESS;
  4134. }
  4135. /**
  4136. * wmi_get_buf_extscan_change_monitor_cmd() - fill change monitor request
  4137. * @wmi_handle: wmi handle
  4138. * @psigchange: change monitor request params
  4139. * @buf: wmi buffer
  4140. * @buf_len: buffer length
  4141. *
  4142. * This function fills elements of change monitor request buffer.
  4143. *
  4144. * Return: CDF status
  4145. */
  4146. static QDF_STATUS wmi_get_buf_extscan_change_monitor_cmd(wmi_unified_t wmi_handle,
  4147. struct extscan_set_sig_changereq_params
  4148. *psigchange, wmi_buf_t *buf, int *buf_len)
  4149. {
  4150. wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param *cmd;
  4151. wmi_extscan_wlan_change_bssid_param *dest_chglist;
  4152. uint8_t *buf_ptr;
  4153. int j;
  4154. int len = sizeof(*cmd);
  4155. int numap = psigchange->num_ap;
  4156. struct ap_threshold_params *src_ap = psigchange->ap;
  4157. if (!numap) {
  4158. WMI_LOGE("%s: Invalid number of bssid's", __func__);
  4159. return QDF_STATUS_E_INVAL;
  4160. }
  4161. len += WMI_TLV_HDR_SIZE;
  4162. len += numap * sizeof(wmi_extscan_wlan_change_bssid_param);
  4163. *buf = wmi_buf_alloc(wmi_handle, len);
  4164. if (!*buf) {
  4165. WMI_LOGP("%s: failed to allocate memory for change monitor cmd",
  4166. __func__);
  4167. return QDF_STATUS_E_FAILURE;
  4168. }
  4169. buf_ptr = (uint8_t *) wmi_buf_data(*buf);
  4170. cmd =
  4171. (wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param *)
  4172. buf_ptr;
  4173. WMITLV_SET_HDR(&cmd->tlv_header,
  4174. WMITLV_TAG_STRUC_wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param,
  4175. WMITLV_GET_STRUCT_TLVLEN
  4176. (wmi_extscan_configure_wlan_change_monitor_cmd_fixed_param));
  4177. cmd->request_id = psigchange->request_id;
  4178. cmd->vdev_id = psigchange->session_id;
  4179. cmd->total_entries = numap;
  4180. cmd->mode = 1;
  4181. cmd->num_entries_in_page = numap;
  4182. cmd->lost_ap_scan_count = psigchange->lostap_sample_size;
  4183. cmd->max_rssi_samples = psigchange->rssi_sample_size;
  4184. cmd->rssi_averaging_samples = psigchange->rssi_sample_size;
  4185. cmd->max_out_of_range_count = psigchange->min_breaching;
  4186. buf_ptr += sizeof(*cmd);
  4187. WMITLV_SET_HDR(buf_ptr,
  4188. WMITLV_TAG_ARRAY_STRUC,
  4189. numap * sizeof(wmi_extscan_wlan_change_bssid_param));
  4190. dest_chglist = (wmi_extscan_wlan_change_bssid_param *)
  4191. (buf_ptr + WMI_TLV_HDR_SIZE);
  4192. for (j = 0; j < numap; j++) {
  4193. WMITLV_SET_HDR(dest_chglist,
  4194. WMITLV_TAG_STRUC_wmi_extscan_bucket_cmd_fixed_param,
  4195. WMITLV_GET_STRUCT_TLVLEN
  4196. (wmi_extscan_wlan_change_bssid_param));
  4197. dest_chglist->lower_rssi_limit = src_ap->low;
  4198. dest_chglist->upper_rssi_limit = src_ap->high;
  4199. WMI_CHAR_ARRAY_TO_MAC_ADDR(src_ap->bssid.bytes,
  4200. &dest_chglist->bssid);
  4201. WMI_LOGD("%s: min_rssi %d", __func__,
  4202. dest_chglist->lower_rssi_limit);
  4203. dest_chglist++;
  4204. src_ap++;
  4205. }
  4206. buf_ptr += WMI_TLV_HDR_SIZE +
  4207. (numap * sizeof(wmi_extscan_wlan_change_bssid_param));
  4208. *buf_len = len;
  4209. return QDF_STATUS_SUCCESS;
  4210. }
  4211. /**
  4212. * send_extscan_start_change_monitor_cmd_tlv() - send start change monitor cmd
  4213. * @wmi_handle: wmi handle
  4214. * @psigchange: change monitor request params
  4215. *
  4216. * This function sends start change monitor request to fw.
  4217. *
  4218. * Return: CDF status
  4219. */
  4220. QDF_STATUS send_extscan_start_change_monitor_cmd_tlv(wmi_unified_t wmi_handle,
  4221. struct extscan_set_sig_changereq_params *
  4222. psigchange)
  4223. {
  4224. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  4225. wmi_buf_t buf;
  4226. int len;
  4227. qdf_status = wmi_get_buf_extscan_change_monitor_cmd(wmi_handle,
  4228. psigchange, &buf,
  4229. &len);
  4230. if (qdf_status != QDF_STATUS_SUCCESS) {
  4231. WMI_LOGE("%s: Failed to get buffer for change monitor cmd",
  4232. __func__);
  4233. return QDF_STATUS_E_FAILURE;
  4234. }
  4235. if (!buf) {
  4236. WMI_LOGE("%s: Failed to get buffer", __func__);
  4237. return QDF_STATUS_E_FAILURE;
  4238. }
  4239. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  4240. WMI_EXTSCAN_CONFIGURE_WLAN_CHANGE_MONITOR_CMDID)) {
  4241. WMI_LOGE("%s: failed to send command", __func__);
  4242. qdf_nbuf_free(buf);
  4243. return QDF_STATUS_E_FAILURE;
  4244. }
  4245. return QDF_STATUS_SUCCESS;
  4246. }
  4247. /**
  4248. * send_extscan_stop_hotlist_monitor_cmd_tlv() - stop hotlist monitor
  4249. * @wmi_handle: wmi handle
  4250. * @photlist_reset: hotlist reset params
  4251. *
  4252. * This function configures hotlist monitor to stop in fw.
  4253. *
  4254. * Return: CDF status
  4255. */
  4256. QDF_STATUS send_extscan_stop_hotlist_monitor_cmd_tlv(wmi_unified_t wmi_handle,
  4257. struct extscan_bssid_hotlist_reset_params *photlist_reset)
  4258. {
  4259. wmi_extscan_configure_hotlist_monitor_cmd_fixed_param *cmd;
  4260. wmi_buf_t wmi_buf;
  4261. uint32_t len;
  4262. uint8_t *buf_ptr;
  4263. int hotlist_entries = 0;
  4264. len = sizeof(*cmd);
  4265. /* reset bssid hotlist with tlv set to 0 */
  4266. len += WMI_TLV_HDR_SIZE;
  4267. len += hotlist_entries * sizeof(wmi_extscan_hotlist_entry);
  4268. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  4269. if (!wmi_buf) {
  4270. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  4271. return QDF_STATUS_E_NOMEM;
  4272. }
  4273. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  4274. cmd = (wmi_extscan_configure_hotlist_monitor_cmd_fixed_param *)
  4275. buf_ptr;
  4276. WMITLV_SET_HDR(&cmd->tlv_header,
  4277. WMITLV_TAG_STRUC_wmi_extscan_configure_hotlist_monitor_cmd_fixed_param,
  4278. WMITLV_GET_STRUCT_TLVLEN
  4279. (wmi_extscan_configure_hotlist_monitor_cmd_fixed_param));
  4280. cmd->request_id = photlist_reset->request_id;
  4281. cmd->vdev_id = photlist_reset->session_id;
  4282. cmd->mode = 0;
  4283. buf_ptr += sizeof(*cmd);
  4284. WMITLV_SET_HDR(buf_ptr,
  4285. WMITLV_TAG_ARRAY_STRUC,
  4286. hotlist_entries * sizeof(wmi_extscan_hotlist_entry));
  4287. buf_ptr += WMI_TLV_HDR_SIZE +
  4288. (hotlist_entries * sizeof(wmi_extscan_hotlist_entry));
  4289. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  4290. WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID)) {
  4291. WMI_LOGE("%s: failed to command", __func__);
  4292. qdf_nbuf_free(wmi_buf);
  4293. return QDF_STATUS_E_FAILURE;
  4294. }
  4295. return QDF_STATUS_SUCCESS;
  4296. }
  4297. /**
  4298. * send_stop_extscan_cmd_tlv() - stop extscan command to fw.
  4299. * @wmi_handle: wmi handle
  4300. * @pstopcmd: stop scan command request params
  4301. *
  4302. * This function sends stop extscan request to fw.
  4303. *
  4304. * Return: CDF Status.
  4305. */
  4306. QDF_STATUS send_stop_extscan_cmd_tlv(wmi_unified_t wmi_handle,
  4307. struct extscan_stop_req_params *pstopcmd)
  4308. {
  4309. wmi_extscan_stop_cmd_fixed_param *cmd;
  4310. wmi_buf_t wmi_buf;
  4311. uint32_t len;
  4312. uint8_t *buf_ptr;
  4313. len = sizeof(*cmd);
  4314. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  4315. if (!wmi_buf) {
  4316. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  4317. return QDF_STATUS_E_NOMEM;
  4318. }
  4319. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  4320. cmd = (wmi_extscan_stop_cmd_fixed_param *) buf_ptr;
  4321. WMITLV_SET_HDR(&cmd->tlv_header,
  4322. WMITLV_TAG_STRUC_wmi_extscan_stop_cmd_fixed_param,
  4323. WMITLV_GET_STRUCT_TLVLEN
  4324. (wmi_extscan_stop_cmd_fixed_param));
  4325. cmd->request_id = pstopcmd->request_id;
  4326. cmd->vdev_id = pstopcmd->session_id;
  4327. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  4328. WMI_EXTSCAN_STOP_CMDID)) {
  4329. WMI_LOGE("%s: failed to command", __func__);
  4330. qdf_nbuf_free(wmi_buf);
  4331. return QDF_STATUS_E_FAILURE;
  4332. }
  4333. return QDF_STATUS_SUCCESS;
  4334. }
  4335. /**
  4336. * wmi_get_buf_extscan_start_cmd() - Fill extscan start request
  4337. * @wmi_handle: wmi handle
  4338. * @pstart: scan command request params
  4339. * @buf: event buffer
  4340. * @buf_len: length of buffer
  4341. *
  4342. * This function fills individual elements of extscan request and
  4343. * TLV for buckets, channel list.
  4344. *
  4345. * Return: CDF Status.
  4346. */
  4347. QDF_STATUS wmi_get_buf_extscan_start_cmd(wmi_unified_t wmi_handle,
  4348. struct wifi_scan_cmd_req_params *pstart,
  4349. wmi_buf_t *buf, int *buf_len)
  4350. {
  4351. wmi_extscan_start_cmd_fixed_param *cmd;
  4352. wmi_extscan_bucket *dest_blist;
  4353. wmi_extscan_bucket_channel *dest_clist;
  4354. struct wifi_scan_bucket_params *src_bucket = pstart->buckets;
  4355. struct wifi_scan_channelspec_params *src_channel = src_bucket->channels;
  4356. struct wifi_scan_channelspec_params save_channel[WMI_WLAN_EXTSCAN_MAX_CHANNELS];
  4357. uint8_t *buf_ptr;
  4358. int i, k, count = 0;
  4359. int len = sizeof(*cmd);
  4360. int nbuckets = pstart->numBuckets;
  4361. int nchannels = 0;
  4362. /* These TLV's are are NULL by default */
  4363. uint32_t ie_len_with_pad = 0;
  4364. int num_ssid = 0;
  4365. int num_bssid = 0;
  4366. int ie_len = 0;
  4367. uint32_t base_period = pstart->basePeriod;
  4368. /* TLV placeholder for ssid_list (NULL) */
  4369. len += WMI_TLV_HDR_SIZE;
  4370. len += num_ssid * sizeof(wmi_ssid);
  4371. /* TLV placeholder for bssid_list (NULL) */
  4372. len += WMI_TLV_HDR_SIZE;
  4373. len += num_bssid * sizeof(wmi_mac_addr);
  4374. /* TLV placeholder for ie_data (NULL) */
  4375. len += WMI_TLV_HDR_SIZE;
  4376. len += ie_len * sizeof(uint32_t);
  4377. /* TLV placeholder for bucket */
  4378. len += WMI_TLV_HDR_SIZE;
  4379. len += nbuckets * sizeof(wmi_extscan_bucket);
  4380. /* TLV channel placeholder */
  4381. len += WMI_TLV_HDR_SIZE;
  4382. for (i = 0; i < nbuckets; i++) {
  4383. nchannels += src_bucket->numChannels;
  4384. src_bucket++;
  4385. }
  4386. WMI_LOGD("%s: Total buckets: %d total #of channels is %d",
  4387. __func__, nbuckets, nchannels);
  4388. len += nchannels * sizeof(wmi_extscan_bucket_channel);
  4389. /* Allocate the memory */
  4390. *buf = wmi_buf_alloc(wmi_handle, len);
  4391. if (!*buf) {
  4392. WMI_LOGP("%s: failed to allocate memory"
  4393. " for start extscan cmd", __func__);
  4394. return QDF_STATUS_E_NOMEM;
  4395. }
  4396. buf_ptr = (uint8_t *) wmi_buf_data(*buf);
  4397. cmd = (wmi_extscan_start_cmd_fixed_param *) buf_ptr;
  4398. WMITLV_SET_HDR(&cmd->tlv_header,
  4399. WMITLV_TAG_STRUC_wmi_extscan_start_cmd_fixed_param,
  4400. WMITLV_GET_STRUCT_TLVLEN
  4401. (wmi_extscan_start_cmd_fixed_param));
  4402. cmd->request_id = pstart->requestId;
  4403. cmd->vdev_id = pstart->sessionId;
  4404. cmd->base_period = pstart->basePeriod;
  4405. cmd->num_buckets = nbuckets;
  4406. cmd->configuration_flags = 0;
  4407. if (pstart->configuration_flags & EXTSCAN_LP_EXTENDED_BATCHING)
  4408. cmd->configuration_flags |= WMI_EXTSCAN_EXTENDED_BATCHING_EN;
  4409. WMI_LOGI("%s: configuration_flags: 0x%x", __func__,
  4410. cmd->configuration_flags);
  4411. cmd->min_rest_time = WMI_EXTSCAN_REST_TIME;
  4412. cmd->max_rest_time = WMI_EXTSCAN_REST_TIME;
  4413. cmd->max_bssids_per_scan_cycle = pstart->maxAPperScan;
  4414. /* The max dwell time is retrieved from the first channel
  4415. * of the first bucket and kept common for all channels.
  4416. */
  4417. cmd->min_dwell_time_active = pstart->min_dwell_time_active;
  4418. cmd->max_dwell_time_active = pstart->max_dwell_time_active;
  4419. cmd->min_dwell_time_passive = pstart->min_dwell_time_passive;
  4420. cmd->max_dwell_time_passive = pstart->max_dwell_time_passive;
  4421. cmd->max_bssids_per_scan_cycle = pstart->maxAPperScan;
  4422. cmd->max_table_usage = pstart->report_threshold_percent;
  4423. cmd->report_threshold_num_scans = pstart->report_threshold_num_scans;
  4424. cmd->repeat_probe_time = cmd->max_dwell_time_active /
  4425. WMI_SCAN_NPROBES_DEFAULT;
  4426. cmd->max_scan_time = WMI_EXTSCAN_MAX_SCAN_TIME;
  4427. cmd->probe_delay = 0;
  4428. cmd->probe_spacing_time = 0;
  4429. cmd->idle_time = 0;
  4430. cmd->burst_duration = WMI_EXTSCAN_BURST_DURATION;
  4431. cmd->scan_ctrl_flags = WMI_SCAN_ADD_BCAST_PROBE_REQ |
  4432. WMI_SCAN_ADD_CCK_RATES |
  4433. WMI_SCAN_ADD_OFDM_RATES |
  4434. WMI_SCAN_ADD_SPOOFED_MAC_IN_PROBE_REQ |
  4435. WMI_SCAN_ADD_DS_IE_IN_PROBE_REQ;
  4436. cmd->scan_priority = WMI_SCAN_PRIORITY_HIGH;
  4437. cmd->num_ssids = 0;
  4438. cmd->num_bssid = 0;
  4439. cmd->ie_len = 0;
  4440. cmd->n_probes = (cmd->repeat_probe_time > 0) ?
  4441. cmd->max_dwell_time_active / cmd->repeat_probe_time : 0;
  4442. buf_ptr += sizeof(*cmd);
  4443. WMITLV_SET_HDR(buf_ptr,
  4444. WMITLV_TAG_ARRAY_FIXED_STRUC,
  4445. num_ssid * sizeof(wmi_ssid));
  4446. buf_ptr += WMI_TLV_HDR_SIZE + (num_ssid * sizeof(wmi_ssid));
  4447. WMITLV_SET_HDR(buf_ptr,
  4448. WMITLV_TAG_ARRAY_FIXED_STRUC,
  4449. num_bssid * sizeof(wmi_mac_addr));
  4450. buf_ptr += WMI_TLV_HDR_SIZE + (num_bssid * sizeof(wmi_mac_addr));
  4451. ie_len_with_pad = 0;
  4452. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE,
  4453. ie_len_with_pad);
  4454. buf_ptr += WMI_TLV_HDR_SIZE + ie_len_with_pad;
  4455. WMITLV_SET_HDR(buf_ptr,
  4456. WMITLV_TAG_ARRAY_STRUC,
  4457. nbuckets * sizeof(wmi_extscan_bucket));
  4458. dest_blist = (wmi_extscan_bucket *)
  4459. (buf_ptr + WMI_TLV_HDR_SIZE);
  4460. src_bucket = pstart->buckets;
  4461. /* Retrieve scanning information from each bucket and
  4462. * channels and send it to the target
  4463. */
  4464. for (i = 0; i < nbuckets; i++) {
  4465. WMITLV_SET_HDR(dest_blist,
  4466. WMITLV_TAG_STRUC_wmi_extscan_bucket_cmd_fixed_param,
  4467. WMITLV_GET_STRUCT_TLVLEN(wmi_extscan_bucket));
  4468. dest_blist->bucket_id = src_bucket->bucket;
  4469. dest_blist->base_period_multiplier =
  4470. src_bucket->period / base_period;
  4471. dest_blist->min_period = src_bucket->period;
  4472. dest_blist->max_period = src_bucket->max_period;
  4473. dest_blist->exp_backoff = src_bucket->exponent;
  4474. dest_blist->exp_max_step_count = src_bucket->step_count;
  4475. dest_blist->channel_band = src_bucket->band;
  4476. dest_blist->num_channels = src_bucket->numChannels;
  4477. dest_blist->notify_extscan_events = 0;
  4478. if (src_bucket->reportEvents & WMI_EXTSCAN_REPORT_EVENTS_EACH_SCAN)
  4479. dest_blist->notify_extscan_events =
  4480. WMI_EXTSCAN_BUCKET_COMPLETED_EVENT;
  4481. if (src_bucket->reportEvents &
  4482. WMI_EXTSCAN_REPORT_EVENTS_FULL_RESULTS) {
  4483. dest_blist->forwarding_flags =
  4484. WMI_EXTSCAN_FORWARD_FRAME_TO_HOST;
  4485. dest_blist->notify_extscan_events |=
  4486. WMI_EXTSCAN_BUCKET_COMPLETED_EVENT |
  4487. WMI_EXTSCAN_CYCLE_STARTED_EVENT |
  4488. WMI_EXTSCAN_CYCLE_COMPLETED_EVENT;
  4489. } else {
  4490. dest_blist->forwarding_flags =
  4491. WMI_EXTSCAN_NO_FORWARDING;
  4492. }
  4493. if (src_bucket->reportEvents & WMI_EXTSCAN_REPORT_EVENTS_NO_BATCH)
  4494. dest_blist->configuration_flags = 0;
  4495. else
  4496. dest_blist->configuration_flags =
  4497. WMI_EXTSCAN_BUCKET_CACHE_RESULTS;
  4498. WMI_LOGI("%s: ntfy_extscan_events:%u cfg_flags:%u fwd_flags:%u",
  4499. __func__, dest_blist->notify_extscan_events,
  4500. dest_blist->configuration_flags,
  4501. dest_blist->forwarding_flags);
  4502. dest_blist->min_dwell_time_active =
  4503. src_bucket->min_dwell_time_active;
  4504. dest_blist->max_dwell_time_active =
  4505. src_bucket->max_dwell_time_active;
  4506. dest_blist->min_dwell_time_passive =
  4507. src_bucket->min_dwell_time_passive;
  4508. dest_blist->max_dwell_time_passive =
  4509. src_bucket->max_dwell_time_passive;
  4510. src_channel = src_bucket->channels;
  4511. /* save the channel info to later populate
  4512. * the channel TLV
  4513. */
  4514. for (k = 0; k < src_bucket->numChannels; k++) {
  4515. save_channel[count++].channel = src_channel->channel;
  4516. src_channel++;
  4517. }
  4518. dest_blist++;
  4519. src_bucket++;
  4520. }
  4521. buf_ptr += WMI_TLV_HDR_SIZE + (nbuckets * sizeof(wmi_extscan_bucket));
  4522. WMITLV_SET_HDR(buf_ptr,
  4523. WMITLV_TAG_ARRAY_STRUC,
  4524. nchannels * sizeof(wmi_extscan_bucket_channel));
  4525. dest_clist = (wmi_extscan_bucket_channel *)
  4526. (buf_ptr + WMI_TLV_HDR_SIZE);
  4527. /* Active or passive scan is based on the bucket dwell time
  4528. * and channel specific active,passive scans are not
  4529. * supported yet
  4530. */
  4531. for (i = 0; i < nchannels; i++) {
  4532. WMITLV_SET_HDR(dest_clist,
  4533. WMITLV_TAG_STRUC_wmi_extscan_bucket_channel_event_fixed_param,
  4534. WMITLV_GET_STRUCT_TLVLEN
  4535. (wmi_extscan_bucket_channel));
  4536. dest_clist->channel = save_channel[i].channel;
  4537. dest_clist++;
  4538. }
  4539. buf_ptr += WMI_TLV_HDR_SIZE +
  4540. (nchannels * sizeof(wmi_extscan_bucket_channel));
  4541. *buf_len = len;
  4542. return QDF_STATUS_SUCCESS;
  4543. }
  4544. /**
  4545. * send_start_extscan_cmd_tlv() - start extscan command to fw.
  4546. * @wmi_handle: wmi handle
  4547. * @pstart: scan command request params
  4548. *
  4549. * This function sends start extscan request to fw.
  4550. *
  4551. * Return: CDF Status.
  4552. */
  4553. QDF_STATUS send_start_extscan_cmd_tlv(wmi_unified_t wmi_handle,
  4554. struct wifi_scan_cmd_req_params *pstart)
  4555. {
  4556. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  4557. wmi_buf_t buf;
  4558. int len;
  4559. /* Fill individual elements of extscan request and
  4560. * TLV for buckets, channel list.
  4561. */
  4562. qdf_status = wmi_get_buf_extscan_start_cmd(wmi_handle,
  4563. pstart, &buf, &len);
  4564. if (qdf_status != QDF_STATUS_SUCCESS) {
  4565. WMI_LOGE("%s: Failed to get buffer for ext scan cmd", __func__);
  4566. return QDF_STATUS_E_FAILURE;
  4567. }
  4568. if (!buf) {
  4569. WMI_LOGE("%s:Failed to get buffer"
  4570. "for current extscan info", __func__);
  4571. return QDF_STATUS_E_FAILURE;
  4572. }
  4573. if (wmi_unified_cmd_send(wmi_handle, buf,
  4574. len, WMI_EXTSCAN_START_CMDID)) {
  4575. WMI_LOGE("%s: failed to send command", __func__);
  4576. qdf_nbuf_free(buf);
  4577. return QDF_STATUS_E_FAILURE;
  4578. }
  4579. return QDF_STATUS_SUCCESS;
  4580. }
  4581. /**
  4582. * send_plm_stop_cmd_tlv() - plm stop request
  4583. * @wmi_handle: wmi handle
  4584. * @plm: plm request parameters
  4585. *
  4586. * This function request FW to stop PLM.
  4587. *
  4588. * Return: CDF status
  4589. */
  4590. QDF_STATUS send_plm_stop_cmd_tlv(wmi_unified_t wmi_handle,
  4591. const struct plm_req_params *plm)
  4592. {
  4593. wmi_vdev_plmreq_stop_cmd_fixed_param *cmd;
  4594. int32_t len;
  4595. wmi_buf_t buf;
  4596. uint8_t *buf_ptr;
  4597. int ret;
  4598. len = sizeof(*cmd);
  4599. buf = wmi_buf_alloc(wmi_handle, len);
  4600. if (!buf) {
  4601. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  4602. return QDF_STATUS_E_NOMEM;
  4603. }
  4604. cmd = (wmi_vdev_plmreq_stop_cmd_fixed_param *) wmi_buf_data(buf);
  4605. buf_ptr = (uint8_t *) cmd;
  4606. WMITLV_SET_HDR(&cmd->tlv_header,
  4607. WMITLV_TAG_STRUC_wmi_vdev_plmreq_stop_cmd_fixed_param,
  4608. WMITLV_GET_STRUCT_TLVLEN
  4609. (wmi_vdev_plmreq_stop_cmd_fixed_param));
  4610. cmd->vdev_id = plm->session_id;
  4611. cmd->meas_token = plm->meas_token;
  4612. WMI_LOGD("vdev %d meas token %d", cmd->vdev_id, cmd->meas_token);
  4613. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4614. WMI_VDEV_PLMREQ_STOP_CMDID);
  4615. if (ret) {
  4616. WMI_LOGE("%s: Failed to send plm stop wmi cmd", __func__);
  4617. wmi_buf_free(buf);
  4618. return QDF_STATUS_E_FAILURE;
  4619. }
  4620. return QDF_STATUS_SUCCESS;
  4621. }
  4622. /**
  4623. * send_plm_start_cmd_tlv() - plm start request
  4624. * @wmi_handle: wmi handle
  4625. * @plm: plm request parameters
  4626. *
  4627. * This function request FW to start PLM.
  4628. *
  4629. * Return: CDF status
  4630. */
  4631. QDF_STATUS send_plm_start_cmd_tlv(wmi_unified_t wmi_handle,
  4632. const struct plm_req_params *plm,
  4633. uint32_t *gchannel_list)
  4634. {
  4635. wmi_vdev_plmreq_start_cmd_fixed_param *cmd;
  4636. uint32_t *channel_list;
  4637. int32_t len;
  4638. wmi_buf_t buf;
  4639. uint8_t *buf_ptr;
  4640. uint8_t count;
  4641. int ret;
  4642. /* TLV place holder for channel_list */
  4643. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
  4644. len += sizeof(uint32_t) * plm->plm_num_ch;
  4645. buf = wmi_buf_alloc(wmi_handle, len);
  4646. if (!buf) {
  4647. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  4648. return QDF_STATUS_E_NOMEM;
  4649. }
  4650. cmd = (wmi_vdev_plmreq_start_cmd_fixed_param *) wmi_buf_data(buf);
  4651. buf_ptr = (uint8_t *) cmd;
  4652. WMITLV_SET_HDR(&cmd->tlv_header,
  4653. WMITLV_TAG_STRUC_wmi_vdev_plmreq_start_cmd_fixed_param,
  4654. WMITLV_GET_STRUCT_TLVLEN
  4655. (wmi_vdev_plmreq_start_cmd_fixed_param));
  4656. cmd->vdev_id = plm->session_id;
  4657. cmd->meas_token = plm->meas_token;
  4658. cmd->dialog_token = plm->diag_token;
  4659. cmd->number_bursts = plm->num_bursts;
  4660. cmd->burst_interval = WMI_SEC_TO_MSEC(plm->burst_int);
  4661. cmd->off_duration = plm->meas_duration;
  4662. cmd->burst_cycle = plm->burst_len;
  4663. cmd->tx_power = plm->desired_tx_pwr;
  4664. WMI_CHAR_ARRAY_TO_MAC_ADDR(plm->mac_addr.bytes, &cmd->dest_mac);
  4665. cmd->num_chans = plm->plm_num_ch;
  4666. buf_ptr += sizeof(wmi_vdev_plmreq_start_cmd_fixed_param);
  4667. WMI_LOGD("vdev : %d measu token : %d", cmd->vdev_id, cmd->meas_token);
  4668. WMI_LOGD("dialog_token: %d", cmd->dialog_token);
  4669. WMI_LOGD("number_bursts: %d", cmd->number_bursts);
  4670. WMI_LOGD("burst_interval: %d", cmd->burst_interval);
  4671. WMI_LOGD("off_duration: %d", cmd->off_duration);
  4672. WMI_LOGD("burst_cycle: %d", cmd->burst_cycle);
  4673. WMI_LOGD("tx_power: %d", cmd->tx_power);
  4674. WMI_LOGD("Number of channels : %d", cmd->num_chans);
  4675. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  4676. (cmd->num_chans * sizeof(uint32_t)));
  4677. buf_ptr += WMI_TLV_HDR_SIZE;
  4678. if (cmd->num_chans) {
  4679. channel_list = (uint32_t *) buf_ptr;
  4680. for (count = 0; count < cmd->num_chans; count++) {
  4681. channel_list[count] = plm->plm_ch_list[count];
  4682. if (channel_list[count] < WMI_NLO_FREQ_THRESH)
  4683. channel_list[count] =
  4684. gchannel_list[count];
  4685. WMI_LOGD("Ch[%d]: %d MHz", count, channel_list[count]);
  4686. }
  4687. buf_ptr += cmd->num_chans * sizeof(uint32_t);
  4688. }
  4689. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4690. WMI_VDEV_PLMREQ_START_CMDID);
  4691. if (ret) {
  4692. WMI_LOGE("%s: Failed to send plm start wmi cmd", __func__);
  4693. wmi_buf_free(buf);
  4694. return QDF_STATUS_E_FAILURE;
  4695. }
  4696. return QDF_STATUS_SUCCESS;
  4697. }
  4698. /**
  4699. * send_pno_stop_cmd_tlv() - PNO stop request
  4700. * @wmi_handle: wmi handle
  4701. * @vdev_id: vdev id
  4702. *
  4703. * This function request FW to stop ongoing PNO operation.
  4704. *
  4705. * Return: CDF status
  4706. */
  4707. QDF_STATUS send_pno_stop_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id)
  4708. {
  4709. wmi_nlo_config_cmd_fixed_param *cmd;
  4710. int32_t len = sizeof(*cmd);
  4711. wmi_buf_t buf;
  4712. uint8_t *buf_ptr;
  4713. int ret;
  4714. /*
  4715. * TLV place holder for array of structures nlo_configured_parameters
  4716. * TLV place holder for array of uint32_t channel_list
  4717. * TLV place holder for chnl prediction cfg
  4718. */
  4719. len += WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE;
  4720. buf = wmi_buf_alloc(wmi_handle, len);
  4721. if (!buf) {
  4722. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  4723. return QDF_STATUS_E_NOMEM;
  4724. }
  4725. cmd = (wmi_nlo_config_cmd_fixed_param *) wmi_buf_data(buf);
  4726. buf_ptr = (uint8_t *) cmd;
  4727. WMITLV_SET_HDR(&cmd->tlv_header,
  4728. WMITLV_TAG_STRUC_wmi_nlo_config_cmd_fixed_param,
  4729. WMITLV_GET_STRUCT_TLVLEN
  4730. (wmi_nlo_config_cmd_fixed_param));
  4731. cmd->vdev_id = vdev_id;
  4732. cmd->flags = WMI_NLO_CONFIG_STOP;
  4733. buf_ptr += sizeof(*cmd);
  4734. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  4735. buf_ptr += WMI_TLV_HDR_SIZE;
  4736. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
  4737. buf_ptr += WMI_TLV_HDR_SIZE;
  4738. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  4739. buf_ptr += WMI_TLV_HDR_SIZE;
  4740. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4741. WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
  4742. if (ret) {
  4743. WMI_LOGE("%s: Failed to send nlo wmi cmd", __func__);
  4744. wmi_buf_free(buf);
  4745. return QDF_STATUS_E_FAILURE;
  4746. }
  4747. return QDF_STATUS_SUCCESS;
  4748. }
  4749. /**
  4750. * send_pno_start_cmd_tlv() - PNO start request
  4751. * @wmi_handle: wmi handle
  4752. * @pno: PNO request
  4753. *
  4754. * This function request FW to start PNO request.
  4755. * Request: CDF status
  4756. */
  4757. QDF_STATUS send_pno_start_cmd_tlv(wmi_unified_t wmi_handle,
  4758. struct pno_scan_req_params *pno,
  4759. uint32_t *gchannel_freq_list)
  4760. {
  4761. wmi_nlo_config_cmd_fixed_param *cmd;
  4762. nlo_configured_parameters *nlo_list;
  4763. uint32_t *channel_list;
  4764. int32_t len;
  4765. wmi_buf_t buf;
  4766. uint8_t *buf_ptr;
  4767. uint8_t i;
  4768. int ret;
  4769. /*
  4770. * TLV place holder for array nlo_configured_parameters(nlo_list)
  4771. * TLV place holder for array of uint32_t channel_list
  4772. * TLV place holder for chnnl prediction cfg
  4773. */
  4774. len = sizeof(*cmd) +
  4775. WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE + WMI_TLV_HDR_SIZE;
  4776. len += sizeof(uint32_t) * QDF_MIN(pno->aNetworks[0].ucChannelCount,
  4777. WMI_NLO_MAX_CHAN);
  4778. len += sizeof(nlo_configured_parameters) *
  4779. QDF_MIN(pno->ucNetworksCount, WMI_NLO_MAX_SSIDS);
  4780. len += sizeof(nlo_channel_prediction_cfg);
  4781. buf = wmi_buf_alloc(wmi_handle, len);
  4782. if (!buf) {
  4783. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  4784. return QDF_STATUS_E_NOMEM;
  4785. }
  4786. cmd = (wmi_nlo_config_cmd_fixed_param *) wmi_buf_data(buf);
  4787. buf_ptr = (uint8_t *) cmd;
  4788. WMITLV_SET_HDR(&cmd->tlv_header,
  4789. WMITLV_TAG_STRUC_wmi_nlo_config_cmd_fixed_param,
  4790. WMITLV_GET_STRUCT_TLVLEN
  4791. (wmi_nlo_config_cmd_fixed_param));
  4792. cmd->vdev_id = pno->sessionId;
  4793. cmd->flags = WMI_NLO_CONFIG_START | WMI_NLO_CONFIG_SSID_HIDE_EN;
  4794. /* Current FW does not support min-max range for dwell time */
  4795. cmd->active_dwell_time = pno->active_max_time;
  4796. cmd->passive_dwell_time = pno->passive_max_time;
  4797. /* Copy scan interval */
  4798. cmd->fast_scan_period = pno->fast_scan_period;
  4799. cmd->slow_scan_period = pno->slow_scan_period;
  4800. cmd->fast_scan_max_cycles = pno->fast_scan_max_cycles;
  4801. WMI_LOGD("fast_scan_period: %d msec slow_scan_period: %d msec",
  4802. cmd->fast_scan_period, cmd->slow_scan_period);
  4803. WMI_LOGD("fast_scan_max_cycles: %d", cmd->fast_scan_max_cycles);
  4804. buf_ptr += sizeof(wmi_nlo_config_cmd_fixed_param);
  4805. cmd->no_of_ssids = QDF_MIN(pno->ucNetworksCount, WMI_NLO_MAX_SSIDS);
  4806. WMI_LOGD("SSID count : %d", cmd->no_of_ssids);
  4807. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  4808. cmd->no_of_ssids * sizeof(nlo_configured_parameters));
  4809. buf_ptr += WMI_TLV_HDR_SIZE;
  4810. nlo_list = (nlo_configured_parameters *) buf_ptr;
  4811. for (i = 0; i < cmd->no_of_ssids; i++) {
  4812. WMITLV_SET_HDR(&nlo_list[i].tlv_header,
  4813. WMITLV_TAG_ARRAY_BYTE,
  4814. WMITLV_GET_STRUCT_TLVLEN
  4815. (nlo_configured_parameters));
  4816. /* Copy ssid and it's length */
  4817. nlo_list[i].ssid.valid = true;
  4818. nlo_list[i].ssid.ssid.ssid_len = pno->aNetworks[i].ssid.length;
  4819. qdf_mem_copy(nlo_list[i].ssid.ssid.ssid,
  4820. pno->aNetworks[i].ssid.mac_ssid,
  4821. nlo_list[i].ssid.ssid.ssid_len);
  4822. WMI_LOGD("index: %d ssid: %.*s len: %d", i,
  4823. nlo_list[i].ssid.ssid.ssid_len,
  4824. (char *)nlo_list[i].ssid.ssid.ssid,
  4825. nlo_list[i].ssid.ssid.ssid_len);
  4826. /* Copy rssi threshold */
  4827. if (pno->aNetworks[i].rssiThreshold &&
  4828. pno->aNetworks[i].rssiThreshold > WMI_RSSI_THOLD_DEFAULT) {
  4829. nlo_list[i].rssi_cond.valid = true;
  4830. nlo_list[i].rssi_cond.rssi =
  4831. pno->aNetworks[i].rssiThreshold;
  4832. WMI_LOGD("RSSI threshold : %d dBm",
  4833. nlo_list[i].rssi_cond.rssi);
  4834. }
  4835. nlo_list[i].bcast_nw_type.valid = true;
  4836. nlo_list[i].bcast_nw_type.bcast_nw_type =
  4837. pno->aNetworks[i].bcastNetwType;
  4838. WMI_LOGI("Broadcast NW type (%u)",
  4839. nlo_list[i].bcast_nw_type.bcast_nw_type);
  4840. }
  4841. buf_ptr += cmd->no_of_ssids * sizeof(nlo_configured_parameters);
  4842. /* Copy channel info */
  4843. cmd->num_of_channels = QDF_MIN(pno->aNetworks[0].ucChannelCount,
  4844. WMI_NLO_MAX_CHAN);
  4845. WMI_LOGD("Channel count: %d", cmd->num_of_channels);
  4846. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  4847. (cmd->num_of_channels * sizeof(uint32_t)));
  4848. buf_ptr += WMI_TLV_HDR_SIZE;
  4849. channel_list = (uint32_t *) buf_ptr;
  4850. for (i = 0; i < cmd->num_of_channels; i++) {
  4851. channel_list[i] = pno->aNetworks[0].aChannels[i];
  4852. if (channel_list[i] < WMI_NLO_FREQ_THRESH)
  4853. channel_list[i] = gchannel_freq_list[i];
  4854. WMI_LOGD("Ch[%d]: %d MHz", i, channel_list[i]);
  4855. }
  4856. buf_ptr += cmd->num_of_channels * sizeof(uint32_t);
  4857. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  4858. sizeof(nlo_channel_prediction_cfg));
  4859. buf_ptr += WMI_TLV_HDR_SIZE;
  4860. buf_ptr += WMI_TLV_HDR_SIZE;
  4861. /** TODO: Discrete firmware doesn't have command/option to configure
  4862. * App IE which comes from wpa_supplicant as of part PNO start request.
  4863. */
  4864. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4865. WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
  4866. if (ret) {
  4867. WMI_LOGE("%s: Failed to send nlo wmi cmd", __func__);
  4868. wmi_buf_free(buf);
  4869. return QDF_STATUS_E_FAILURE;
  4870. }
  4871. return QDF_STATUS_SUCCESS;
  4872. }
  4873. /* send_set_ric_req_cmd_tlv() - set ric request element
  4874. * @wmi_handle: wmi handle
  4875. * @msg: message
  4876. * @is_add_ts: is addts required
  4877. *
  4878. * This function sets ric request element for 11r roaming.
  4879. *
  4880. * Return: CDF status
  4881. */
  4882. QDF_STATUS send_set_ric_req_cmd_tlv(wmi_unified_t wmi_handle,
  4883. void *msg, uint8_t is_add_ts)
  4884. {
  4885. wmi_ric_request_fixed_param *cmd;
  4886. wmi_ric_tspec *tspec_param;
  4887. wmi_buf_t buf;
  4888. uint8_t *buf_ptr;
  4889. struct mac_tspec_ie *ptspecIE;
  4890. int32_t len = sizeof(wmi_ric_request_fixed_param) +
  4891. WMI_TLV_HDR_SIZE + sizeof(wmi_ric_tspec);
  4892. buf = wmi_buf_alloc(wmi_handle, len);
  4893. if (!buf) {
  4894. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  4895. return QDF_STATUS_E_NOMEM;
  4896. }
  4897. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4898. cmd = (wmi_ric_request_fixed_param *) buf_ptr;
  4899. WMITLV_SET_HDR(&cmd->tlv_header,
  4900. WMITLV_TAG_STRUC_wmi_ric_request_fixed_param,
  4901. WMITLV_GET_STRUCT_TLVLEN(wmi_ric_request_fixed_param));
  4902. if (is_add_ts)
  4903. cmd->vdev_id = ((struct add_ts_param *) msg)->sessionId;
  4904. else
  4905. cmd->vdev_id = ((struct del_ts_params *) msg)->sessionId;
  4906. cmd->num_ric_request = 1;
  4907. cmd->is_add_ric = is_add_ts;
  4908. buf_ptr += sizeof(wmi_ric_request_fixed_param);
  4909. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, sizeof(wmi_ric_tspec));
  4910. buf_ptr += WMI_TLV_HDR_SIZE;
  4911. tspec_param = (wmi_ric_tspec *) buf_ptr;
  4912. WMITLV_SET_HDR(&tspec_param->tlv_header,
  4913. WMITLV_TAG_STRUC_wmi_ric_tspec,
  4914. WMITLV_GET_STRUCT_TLVLEN(wmi_ric_tspec));
  4915. if (is_add_ts)
  4916. ptspecIE = &(((struct add_ts_param *) msg)->tspec);
  4917. else
  4918. ptspecIE = &(((struct del_ts_params *) msg)->delTsInfo.tspec);
  4919. /* Fill the tsinfo in the format expected by firmware */
  4920. #ifndef ANI_LITTLE_BIT_ENDIAN
  4921. qdf_mem_copy(((uint8_t *) &tspec_param->ts_info) + 1,
  4922. ((uint8_t *) &ptspecIE->tsinfo) + 1, 2);
  4923. #else
  4924. qdf_mem_copy(((uint8_t *) &tspec_param->ts_info),
  4925. ((uint8_t *) &ptspecIE->tsinfo) + 1, 2);
  4926. #endif /* ANI_LITTLE_BIT_ENDIAN */
  4927. tspec_param->nominal_msdu_size = ptspecIE->nomMsduSz;
  4928. tspec_param->maximum_msdu_size = ptspecIE->maxMsduSz;
  4929. tspec_param->min_service_interval = ptspecIE->minSvcInterval;
  4930. tspec_param->max_service_interval = ptspecIE->maxSvcInterval;
  4931. tspec_param->inactivity_interval = ptspecIE->inactInterval;
  4932. tspec_param->suspension_interval = ptspecIE->suspendInterval;
  4933. tspec_param->svc_start_time = ptspecIE->svcStartTime;
  4934. tspec_param->min_data_rate = ptspecIE->minDataRate;
  4935. tspec_param->mean_data_rate = ptspecIE->meanDataRate;
  4936. tspec_param->peak_data_rate = ptspecIE->peakDataRate;
  4937. tspec_param->max_burst_size = ptspecIE->maxBurstSz;
  4938. tspec_param->delay_bound = ptspecIE->delayBound;
  4939. tspec_param->min_phy_rate = ptspecIE->minPhyRate;
  4940. tspec_param->surplus_bw_allowance = ptspecIE->surplusBw;
  4941. tspec_param->medium_time = 0;
  4942. WMI_LOGI("%s: Set RIC Req is_add_ts:%d", __func__, is_add_ts);
  4943. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  4944. WMI_ROAM_SET_RIC_REQUEST_CMDID)) {
  4945. WMI_LOGP("%s: Failed to send vdev Set RIC Req command",
  4946. __func__);
  4947. if (is_add_ts)
  4948. ((struct add_ts_param *) msg)->status =
  4949. QDF_STATUS_E_FAILURE;
  4950. qdf_nbuf_free(buf);
  4951. return QDF_STATUS_E_FAILURE;
  4952. }
  4953. return QDF_STATUS_SUCCESS;
  4954. }
  4955. /**
  4956. * send_process_ll_stats_clear_cmd_tlv() - clear link layer stats
  4957. * @wmi_handle: wmi handle
  4958. * @clear_req: ll stats clear request command params
  4959. *
  4960. * Return: QDF_STATUS_SUCCESS for success or error code
  4961. */
  4962. QDF_STATUS send_process_ll_stats_clear_cmd_tlv(wmi_unified_t wmi_handle,
  4963. const struct ll_stats_clear_params *clear_req,
  4964. uint8_t addr[IEEE80211_ADDR_LEN])
  4965. {
  4966. wmi_clear_link_stats_cmd_fixed_param *cmd;
  4967. int32_t len;
  4968. wmi_buf_t buf;
  4969. uint8_t *buf_ptr;
  4970. int ret;
  4971. len = sizeof(*cmd);
  4972. buf = wmi_buf_alloc(wmi_handle, len);
  4973. if (!buf) {
  4974. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  4975. return QDF_STATUS_E_NOMEM;
  4976. }
  4977. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  4978. qdf_mem_zero(buf_ptr, len);
  4979. cmd = (wmi_clear_link_stats_cmd_fixed_param *) buf_ptr;
  4980. WMITLV_SET_HDR(&cmd->tlv_header,
  4981. WMITLV_TAG_STRUC_wmi_clear_link_stats_cmd_fixed_param,
  4982. WMITLV_GET_STRUCT_TLVLEN
  4983. (wmi_clear_link_stats_cmd_fixed_param));
  4984. cmd->stop_stats_collection_req = clear_req->stop_req;
  4985. cmd->vdev_id = clear_req->sta_id;
  4986. cmd->stats_clear_req_mask = clear_req->stats_clear_mask;
  4987. WMI_CHAR_ARRAY_TO_MAC_ADDR(addr,
  4988. &cmd->peer_macaddr);
  4989. WMI_LOGD("LINK_LAYER_STATS - Clear Request Params");
  4990. WMI_LOGD("StopReq : %d", cmd->stop_stats_collection_req);
  4991. WMI_LOGD("Vdev Id : %d", cmd->vdev_id);
  4992. WMI_LOGD("Clear Stat Mask : %d", cmd->stats_clear_req_mask);
  4993. /* WMI_LOGD("Peer MAC Addr : %pM",
  4994. cmd->peer_macaddr); */
  4995. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  4996. WMI_CLEAR_LINK_STATS_CMDID);
  4997. if (ret) {
  4998. WMI_LOGE("%s: Failed to send clear link stats req", __func__);
  4999. wmi_buf_free(buf);
  5000. return QDF_STATUS_E_FAILURE;
  5001. }
  5002. WMI_LOGD("Clear Link Layer Stats request sent successfully");
  5003. return QDF_STATUS_SUCCESS;
  5004. }
  5005. /**
  5006. * send_process_ll_stats_set_cmd_tlv() - link layer stats set request
  5007. * @wmi_handle: wmi handle
  5008. * @setReq: ll stats set request command params
  5009. *
  5010. * Return: QDF_STATUS_SUCCESS for success or error code
  5011. */
  5012. QDF_STATUS send_process_ll_stats_set_cmd_tlv(wmi_unified_t wmi_handle,
  5013. const struct ll_stats_set_params *set_req)
  5014. {
  5015. wmi_start_link_stats_cmd_fixed_param *cmd;
  5016. int32_t len;
  5017. wmi_buf_t buf;
  5018. uint8_t *buf_ptr;
  5019. int ret;
  5020. len = sizeof(*cmd);
  5021. buf = wmi_buf_alloc(wmi_handle, len);
  5022. if (!buf) {
  5023. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  5024. return QDF_STATUS_E_NOMEM;
  5025. }
  5026. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  5027. qdf_mem_zero(buf_ptr, len);
  5028. cmd = (wmi_start_link_stats_cmd_fixed_param *) buf_ptr;
  5029. WMITLV_SET_HDR(&cmd->tlv_header,
  5030. WMITLV_TAG_STRUC_wmi_start_link_stats_cmd_fixed_param,
  5031. WMITLV_GET_STRUCT_TLVLEN
  5032. (wmi_start_link_stats_cmd_fixed_param));
  5033. cmd->mpdu_size_threshold = set_req->mpdu_size_threshold;
  5034. cmd->aggressive_statistics_gathering =
  5035. set_req->aggressive_statistics_gathering;
  5036. WMI_LOGD("LINK_LAYER_STATS - Start/Set Request Params");
  5037. WMI_LOGD("MPDU Size Thresh : %d", cmd->mpdu_size_threshold);
  5038. WMI_LOGD("Aggressive Gather: %d", cmd->aggressive_statistics_gathering);
  5039. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5040. WMI_START_LINK_STATS_CMDID);
  5041. if (ret) {
  5042. WMI_LOGE("%s: Failed to send set link stats request", __func__);
  5043. wmi_buf_free(buf);
  5044. return QDF_STATUS_E_FAILURE;
  5045. }
  5046. return QDF_STATUS_SUCCESS;
  5047. }
  5048. /**
  5049. * send_process_ll_stats_get_cmd_tlv() - link layer stats get request
  5050. * @wmi_handle:wmi handle
  5051. * @get_req:ll stats get request command params
  5052. * @addr: mac address
  5053. *
  5054. * Return: QDF_STATUS_SUCCESS for success or error code
  5055. */
  5056. QDF_STATUS send_process_ll_stats_get_cmd_tlv(wmi_unified_t wmi_handle,
  5057. const struct ll_stats_get_params *get_req,
  5058. uint8_t addr[IEEE80211_ADDR_LEN])
  5059. {
  5060. wmi_request_link_stats_cmd_fixed_param *cmd;
  5061. int32_t len;
  5062. wmi_buf_t buf;
  5063. uint8_t *buf_ptr;
  5064. int ret;
  5065. len = sizeof(*cmd);
  5066. buf = wmi_buf_alloc(wmi_handle, len);
  5067. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  5068. qdf_mem_zero(buf_ptr, len);
  5069. cmd = (wmi_request_link_stats_cmd_fixed_param *) buf_ptr;
  5070. WMITLV_SET_HDR(&cmd->tlv_header,
  5071. WMITLV_TAG_STRUC_wmi_request_link_stats_cmd_fixed_param,
  5072. WMITLV_GET_STRUCT_TLVLEN
  5073. (wmi_request_link_stats_cmd_fixed_param));
  5074. cmd->request_id = get_req->req_id;
  5075. cmd->stats_type = get_req->param_id_mask;
  5076. cmd->vdev_id = get_req->sta_id;
  5077. WMI_CHAR_ARRAY_TO_MAC_ADDR(addr,
  5078. &cmd->peer_macaddr);
  5079. WMI_LOGD("LINK_LAYER_STATS - Get Request Params");
  5080. WMI_LOGD("Request ID : %d", cmd->request_id);
  5081. WMI_LOGD("Stats Type : %d", cmd->stats_type);
  5082. WMI_LOGD("Vdev ID : %d", cmd->vdev_id);
  5083. WMI_LOGD("Peer MAC Addr : %pM", addr);
  5084. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5085. WMI_REQUEST_LINK_STATS_CMDID);
  5086. if (ret) {
  5087. WMI_LOGE("%s: Failed to send get link stats request", __func__);
  5088. wmi_buf_free(buf);
  5089. return QDF_STATUS_E_FAILURE;
  5090. }
  5091. return QDF_STATUS_SUCCESS;
  5092. }
  5093. /**
  5094. * send_get_stats_cmd_tlv() - get stats request
  5095. * @wmi_handle: wmi handle
  5096. * @get_stats_param: stats params
  5097. * @addr: mac address
  5098. *
  5099. * Return: CDF status
  5100. */
  5101. QDF_STATUS send_get_stats_cmd_tlv(wmi_unified_t wmi_handle,
  5102. struct pe_stats_req *get_stats_param,
  5103. uint8_t addr[IEEE80211_ADDR_LEN])
  5104. {
  5105. wmi_buf_t buf;
  5106. wmi_request_stats_cmd_fixed_param *cmd;
  5107. uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
  5108. buf = wmi_buf_alloc(wmi_handle, len);
  5109. if (!buf) {
  5110. WMI_LOGE("%s: Failed to allocate wmi buffer", __func__);
  5111. return QDF_STATUS_E_FAILURE;
  5112. }
  5113. cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
  5114. WMITLV_SET_HDR(&cmd->tlv_header,
  5115. WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
  5116. WMITLV_GET_STRUCT_TLVLEN
  5117. (wmi_request_stats_cmd_fixed_param));
  5118. cmd->stats_id =
  5119. WMI_REQUEST_PEER_STAT | WMI_REQUEST_PDEV_STAT |
  5120. WMI_REQUEST_VDEV_STAT;
  5121. cmd->vdev_id = get_stats_param->session_id;
  5122. WMI_CHAR_ARRAY_TO_MAC_ADDR(addr, &cmd->peer_macaddr);
  5123. WMI_LOGD("STATS REQ VDEV_ID:%d-->", cmd->vdev_id);
  5124. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5125. WMI_REQUEST_STATS_CMDID)) {
  5126. WMI_LOGE("%s: Failed to send WMI_REQUEST_STATS_CMDID",
  5127. __func__);
  5128. wmi_buf_free(buf);
  5129. return QDF_STATUS_E_FAILURE;
  5130. }
  5131. return QDF_STATUS_SUCCESS;
  5132. }
  5133. /**
  5134. * send_snr_request_cmd_tlv() - send request to fw to get RSSI stats
  5135. * @wmi_handle: wmi handle
  5136. * @rssi_req: get RSSI request
  5137. *
  5138. * Return: CDF status
  5139. */
  5140. QDF_STATUS send_snr_request_cmd_tlv(wmi_unified_t wmi_handle)
  5141. {
  5142. wmi_buf_t buf;
  5143. wmi_request_stats_cmd_fixed_param *cmd;
  5144. uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
  5145. buf = wmi_buf_alloc(wmi_handle, len);
  5146. if (!buf) {
  5147. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  5148. return QDF_STATUS_E_FAILURE;
  5149. }
  5150. cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
  5151. WMITLV_SET_HDR(&cmd->tlv_header,
  5152. WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
  5153. WMITLV_GET_STRUCT_TLVLEN
  5154. (wmi_request_stats_cmd_fixed_param));
  5155. cmd->stats_id = WMI_REQUEST_VDEV_STAT;
  5156. if (wmi_unified_cmd_send
  5157. (wmi_handle, buf, len, WMI_REQUEST_STATS_CMDID)) {
  5158. WMI_LOGE("Failed to send host stats request to fw");
  5159. wmi_buf_free(buf);
  5160. return QDF_STATUS_E_FAILURE;
  5161. }
  5162. return QDF_STATUS_SUCCESS;
  5163. }
  5164. /**
  5165. * send_snr_cmd_tlv() - get RSSI from fw
  5166. * @wmi_handle: wmi handle
  5167. * @vdev_id: vdev id
  5168. *
  5169. * Return: CDF status
  5170. */
  5171. QDF_STATUS send_snr_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id)
  5172. {
  5173. wmi_buf_t buf;
  5174. wmi_request_stats_cmd_fixed_param *cmd;
  5175. uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
  5176. buf = wmi_buf_alloc(wmi_handle, len);
  5177. if (!buf) {
  5178. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  5179. return QDF_STATUS_E_FAILURE;
  5180. }
  5181. cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
  5182. cmd->vdev_id = vdev_id;
  5183. WMITLV_SET_HDR(&cmd->tlv_header,
  5184. WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
  5185. WMITLV_GET_STRUCT_TLVLEN
  5186. (wmi_request_stats_cmd_fixed_param));
  5187. cmd->stats_id = WMI_REQUEST_VDEV_STAT;
  5188. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5189. WMI_REQUEST_STATS_CMDID)) {
  5190. WMI_LOGE("Failed to send host stats request to fw");
  5191. wmi_buf_free(buf);
  5192. return QDF_STATUS_E_FAILURE;
  5193. }
  5194. return QDF_STATUS_SUCCESS;
  5195. }
  5196. /**
  5197. * send_link_status_req_cmd_tlv() - process link status request from UMAC
  5198. * @wmi_handle: wmi handle
  5199. * @link_status: get link params
  5200. *
  5201. * Return: CDF status
  5202. */
  5203. QDF_STATUS send_link_status_req_cmd_tlv(wmi_unified_t wmi_handle,
  5204. struct link_status_params *link_status)
  5205. {
  5206. wmi_buf_t buf;
  5207. wmi_request_stats_cmd_fixed_param *cmd;
  5208. uint8_t len = sizeof(wmi_request_stats_cmd_fixed_param);
  5209. buf = wmi_buf_alloc(wmi_handle, len);
  5210. if (!buf) {
  5211. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  5212. return QDF_STATUS_E_FAILURE;
  5213. }
  5214. cmd = (wmi_request_stats_cmd_fixed_param *) wmi_buf_data(buf);
  5215. WMITLV_SET_HDR(&cmd->tlv_header,
  5216. WMITLV_TAG_STRUC_wmi_request_stats_cmd_fixed_param,
  5217. WMITLV_GET_STRUCT_TLVLEN
  5218. (wmi_request_stats_cmd_fixed_param));
  5219. cmd->stats_id = WMI_REQUEST_VDEV_RATE_STAT;
  5220. cmd->vdev_id = link_status->session_id;
  5221. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5222. WMI_REQUEST_STATS_CMDID)) {
  5223. WMI_LOGE("Failed to send WMI link status request to fw");
  5224. wmi_buf_free(buf);
  5225. return QDF_STATUS_E_FAILURE;
  5226. }
  5227. return QDF_STATUS_SUCCESS;
  5228. }
  5229. #ifdef FEATURE_WLAN_LPHB
  5230. /**
  5231. * send_lphb_config_hbenable_cmd_tlv() - enable command of LPHB configuration
  5232. * @wmi_handle: wmi handle
  5233. * @lphb_conf_req: configuration info
  5234. *
  5235. * Return: CDF status
  5236. */
  5237. QDF_STATUS send_lphb_config_hbenable_cmd_tlv(wmi_unified_t wmi_handle,
  5238. wmi_hb_set_enable_cmd_fixed_param *params)
  5239. {
  5240. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  5241. int status = 0;
  5242. wmi_buf_t buf = NULL;
  5243. uint8_t *buf_ptr;
  5244. wmi_hb_set_enable_cmd_fixed_param *hb_enable_fp;
  5245. int len = sizeof(wmi_hb_set_enable_cmd_fixed_param);
  5246. buf = wmi_buf_alloc(wmi_handle, len);
  5247. if (!buf) {
  5248. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  5249. return QDF_STATUS_E_NOMEM;
  5250. }
  5251. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  5252. hb_enable_fp = (wmi_hb_set_enable_cmd_fixed_param *) buf_ptr;
  5253. WMITLV_SET_HDR(&hb_enable_fp->tlv_header,
  5254. WMITLV_TAG_STRUC_wmi_hb_set_enable_cmd_fixed_param,
  5255. WMITLV_GET_STRUCT_TLVLEN
  5256. (wmi_hb_set_enable_cmd_fixed_param));
  5257. /* fill in values */
  5258. hb_enable_fp->vdev_id = params->session;
  5259. hb_enable_fp->enable = params->enable;
  5260. hb_enable_fp->item = params->item;
  5261. hb_enable_fp->session = params->session;
  5262. status = wmi_unified_cmd_send(wmi_handle, buf,
  5263. len, WMI_HB_SET_ENABLE_CMDID);
  5264. if (status != EOK) {
  5265. WMI_LOGE("wmi_unified_cmd_send WMI_HB_SET_ENABLE returned Error %d",
  5266. status);
  5267. qdf_status = QDF_STATUS_E_FAILURE;
  5268. goto error;
  5269. }
  5270. return QDF_STATUS_SUCCESS;
  5271. error:
  5272. return qdf_status;
  5273. }
  5274. /**
  5275. * send_lphb_config_tcp_params_cmd_tlv() - set tcp params of LPHB configuration
  5276. * @wmi_handle: wmi handle
  5277. * @lphb_conf_req: lphb config request
  5278. *
  5279. * Return: CDF status
  5280. */
  5281. QDF_STATUS send_lphb_config_tcp_params_cmd_tlv(wmi_unified_t wmi_handle,
  5282. wmi_hb_set_tcp_params_cmd_fixed_param *lphb_conf_req)
  5283. {
  5284. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  5285. int status = 0;
  5286. wmi_buf_t buf = NULL;
  5287. uint8_t *buf_ptr;
  5288. wmi_hb_set_tcp_params_cmd_fixed_param *hb_tcp_params_fp;
  5289. int len = sizeof(wmi_hb_set_tcp_params_cmd_fixed_param);
  5290. buf = wmi_buf_alloc(wmi_handle, len);
  5291. if (!buf) {
  5292. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  5293. return QDF_STATUS_E_NOMEM;
  5294. }
  5295. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  5296. hb_tcp_params_fp = (wmi_hb_set_tcp_params_cmd_fixed_param *) buf_ptr;
  5297. WMITLV_SET_HDR(&hb_tcp_params_fp->tlv_header,
  5298. WMITLV_TAG_STRUC_wmi_hb_set_tcp_params_cmd_fixed_param,
  5299. WMITLV_GET_STRUCT_TLVLEN
  5300. (wmi_hb_set_tcp_params_cmd_fixed_param));
  5301. /* fill in values */
  5302. hb_tcp_params_fp->vdev_id = lphb_conf_req->vdev_id;
  5303. hb_tcp_params_fp->srv_ip = lphb_conf_req->srv_ip;
  5304. hb_tcp_params_fp->dev_ip = lphb_conf_req->dev_ip;
  5305. hb_tcp_params_fp->seq = lphb_conf_req->seq;
  5306. hb_tcp_params_fp->src_port = lphb_conf_req->src_port;
  5307. hb_tcp_params_fp->dst_port = lphb_conf_req->dst_port;
  5308. hb_tcp_params_fp->interval = lphb_conf_req->interval;
  5309. hb_tcp_params_fp->timeout = lphb_conf_req->timeout;
  5310. hb_tcp_params_fp->session = lphb_conf_req->session;
  5311. qdf_mem_copy(&hb_tcp_params_fp->gateway_mac,
  5312. &lphb_conf_req->gateway_mac,
  5313. sizeof(hb_tcp_params_fp->gateway_mac));
  5314. status = wmi_unified_cmd_send(wmi_handle, buf,
  5315. len, WMI_HB_SET_TCP_PARAMS_CMDID);
  5316. if (status != EOK) {
  5317. WMI_LOGE("wmi_unified_cmd_send WMI_HB_SET_TCP_PARAMS returned Error %d",
  5318. status);
  5319. qdf_status = QDF_STATUS_E_FAILURE;
  5320. goto error;
  5321. }
  5322. return QDF_STATUS_SUCCESS;
  5323. error:
  5324. return qdf_status;
  5325. }
  5326. /**
  5327. * send_lphb_config_tcp_pkt_filter_cmd_tlv() - configure tcp packet filter cmd
  5328. * @wmi_handle: wmi handle
  5329. * @lphb_conf_req: lphb config request
  5330. *
  5331. * Return: CDF status
  5332. */
  5333. QDF_STATUS send_lphb_config_tcp_pkt_filter_cmd_tlv(wmi_unified_t wmi_handle,
  5334. wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *g_hb_tcp_filter_fp)
  5335. {
  5336. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  5337. int status = 0;
  5338. wmi_buf_t buf = NULL;
  5339. uint8_t *buf_ptr;
  5340. wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *hb_tcp_filter_fp;
  5341. int len = sizeof(wmi_hb_set_tcp_pkt_filter_cmd_fixed_param);
  5342. buf = wmi_buf_alloc(wmi_handle, len);
  5343. if (!buf) {
  5344. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  5345. return QDF_STATUS_E_NOMEM;
  5346. }
  5347. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  5348. hb_tcp_filter_fp =
  5349. (wmi_hb_set_tcp_pkt_filter_cmd_fixed_param *) buf_ptr;
  5350. WMITLV_SET_HDR(&hb_tcp_filter_fp->tlv_header,
  5351. WMITLV_TAG_STRUC_wmi_hb_set_tcp_pkt_filter_cmd_fixed_param,
  5352. WMITLV_GET_STRUCT_TLVLEN
  5353. (wmi_hb_set_tcp_pkt_filter_cmd_fixed_param));
  5354. /* fill in values */
  5355. hb_tcp_filter_fp->vdev_id = g_hb_tcp_filter_fp->vdev_id;
  5356. hb_tcp_filter_fp->length = g_hb_tcp_filter_fp->length;
  5357. hb_tcp_filter_fp->offset = g_hb_tcp_filter_fp->offset;
  5358. hb_tcp_filter_fp->session = g_hb_tcp_filter_fp->session;
  5359. memcpy((void *)&hb_tcp_filter_fp->filter,
  5360. (void *)&g_hb_tcp_filter_fp->filter,
  5361. WMI_WLAN_HB_MAX_FILTER_SIZE);
  5362. status = wmi_unified_cmd_send(wmi_handle, buf,
  5363. len, WMI_HB_SET_TCP_PKT_FILTER_CMDID);
  5364. if (status != EOK) {
  5365. WMI_LOGE("wmi_unified_cmd_send WMI_HB_SET_TCP_PKT_FILTER returned Error %d",
  5366. status);
  5367. qdf_status = QDF_STATUS_E_FAILURE;
  5368. goto error;
  5369. }
  5370. return QDF_STATUS_SUCCESS;
  5371. error:
  5372. return qdf_status;
  5373. }
  5374. /**
  5375. * send_lphb_config_udp_params_cmd_tlv() - configure udp param command of LPHB
  5376. * @wmi_handle: wmi handle
  5377. * @lphb_conf_req: lphb config request
  5378. *
  5379. * Return: CDF status
  5380. */
  5381. QDF_STATUS send_lphb_config_udp_params_cmd_tlv(wmi_unified_t wmi_handle,
  5382. wmi_hb_set_udp_params_cmd_fixed_param *lphb_conf_req)
  5383. {
  5384. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  5385. int status = 0;
  5386. wmi_buf_t buf = NULL;
  5387. uint8_t *buf_ptr;
  5388. wmi_hb_set_udp_params_cmd_fixed_param *hb_udp_params_fp;
  5389. int len = sizeof(wmi_hb_set_udp_params_cmd_fixed_param);
  5390. buf = wmi_buf_alloc(wmi_handle, len);
  5391. if (!buf) {
  5392. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  5393. return QDF_STATUS_E_NOMEM;
  5394. }
  5395. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  5396. hb_udp_params_fp = (wmi_hb_set_udp_params_cmd_fixed_param *) buf_ptr;
  5397. WMITLV_SET_HDR(&hb_udp_params_fp->tlv_header,
  5398. WMITLV_TAG_STRUC_wmi_hb_set_udp_params_cmd_fixed_param,
  5399. WMITLV_GET_STRUCT_TLVLEN
  5400. (wmi_hb_set_udp_params_cmd_fixed_param));
  5401. /* fill in values */
  5402. hb_udp_params_fp->vdev_id = lphb_conf_req->vdev_id;
  5403. hb_udp_params_fp->srv_ip = lphb_conf_req->srv_ip;
  5404. hb_udp_params_fp->dev_ip = lphb_conf_req->dev_ip;
  5405. hb_udp_params_fp->src_port = lphb_conf_req->src_port;
  5406. hb_udp_params_fp->dst_port = lphb_conf_req->dst_port;
  5407. hb_udp_params_fp->interval = lphb_conf_req->interval;
  5408. hb_udp_params_fp->timeout = lphb_conf_req->timeout;
  5409. hb_udp_params_fp->session = lphb_conf_req->session;
  5410. qdf_mem_copy(&hb_udp_params_fp->gateway_mac,
  5411. &lphb_conf_req->gateway_mac,
  5412. sizeof(lphb_conf_req->gateway_mac));
  5413. status = wmi_unified_cmd_send(wmi_handle, buf,
  5414. len, WMI_HB_SET_UDP_PARAMS_CMDID);
  5415. if (status != EOK) {
  5416. WMI_LOGE("wmi_unified_cmd_send WMI_HB_SET_UDP_PARAMS returned Error %d",
  5417. status);
  5418. qdf_status = QDF_STATUS_E_FAILURE;
  5419. goto error;
  5420. }
  5421. return QDF_STATUS_SUCCESS;
  5422. error:
  5423. return qdf_status;
  5424. }
  5425. /**
  5426. * send_lphb_config_udp_pkt_filter_cmd_tlv() - configure udp pkt filter command
  5427. * @wmi_handle: wmi handle
  5428. * @lphb_conf_req: lphb config request
  5429. *
  5430. * Return: CDF status
  5431. */
  5432. QDF_STATUS send_lphb_config_udp_pkt_filter_cmd_tlv(wmi_unified_t wmi_handle,
  5433. wmi_hb_set_udp_pkt_filter_cmd_fixed_param *lphb_conf_req)
  5434. {
  5435. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  5436. int status = 0;
  5437. wmi_buf_t buf = NULL;
  5438. uint8_t *buf_ptr;
  5439. wmi_hb_set_udp_pkt_filter_cmd_fixed_param *hb_udp_filter_fp;
  5440. int len = sizeof(wmi_hb_set_udp_pkt_filter_cmd_fixed_param);
  5441. buf = wmi_buf_alloc(wmi_handle, len);
  5442. if (!buf) {
  5443. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  5444. return QDF_STATUS_E_NOMEM;
  5445. }
  5446. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  5447. hb_udp_filter_fp =
  5448. (wmi_hb_set_udp_pkt_filter_cmd_fixed_param *) buf_ptr;
  5449. WMITLV_SET_HDR(&hb_udp_filter_fp->tlv_header,
  5450. WMITLV_TAG_STRUC_wmi_hb_set_udp_pkt_filter_cmd_fixed_param,
  5451. WMITLV_GET_STRUCT_TLVLEN
  5452. (wmi_hb_set_udp_pkt_filter_cmd_fixed_param));
  5453. /* fill in values */
  5454. hb_udp_filter_fp->vdev_id = lphb_conf_req->vdev_id;
  5455. hb_udp_filter_fp->length = lphb_conf_req->length;
  5456. hb_udp_filter_fp->offset = lphb_conf_req->offset;
  5457. hb_udp_filter_fp->session = lphb_conf_req->session;
  5458. memcpy((void *)&hb_udp_filter_fp->filter,
  5459. (void *)&lphb_conf_req->filter,
  5460. WMI_WLAN_HB_MAX_FILTER_SIZE);
  5461. status = wmi_unified_cmd_send(wmi_handle, buf,
  5462. len, WMI_HB_SET_UDP_PKT_FILTER_CMDID);
  5463. if (status != EOK) {
  5464. WMI_LOGE("wmi_unified_cmd_send WMI_HB_SET_UDP_PKT_FILTER returned Error %d",
  5465. status);
  5466. qdf_status = QDF_STATUS_E_FAILURE;
  5467. goto error;
  5468. }
  5469. return QDF_STATUS_SUCCESS;
  5470. error:
  5471. return qdf_status;
  5472. }
  5473. #endif /* FEATURE_WLAN_LPHB */
  5474. /**
  5475. * send_process_dhcp_ind_cmd_tlv() - process dhcp indication from SME
  5476. * @wmi_handle: wmi handle
  5477. * @ta_dhcp_ind: DHCP indication parameter
  5478. *
  5479. * Return: CDF Status
  5480. */
  5481. QDF_STATUS send_process_dhcp_ind_cmd_tlv(wmi_unified_t wmi_handle,
  5482. wmi_peer_set_param_cmd_fixed_param *ta_dhcp_ind)
  5483. {
  5484. int status = 0;
  5485. wmi_buf_t buf = NULL;
  5486. uint8_t *buf_ptr;
  5487. wmi_peer_set_param_cmd_fixed_param *peer_set_param_fp;
  5488. int len = sizeof(wmi_peer_set_param_cmd_fixed_param);
  5489. buf = wmi_buf_alloc(wmi_handle, len);
  5490. if (!buf) {
  5491. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  5492. return QDF_STATUS_E_NOMEM;
  5493. }
  5494. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  5495. peer_set_param_fp = (wmi_peer_set_param_cmd_fixed_param *) buf_ptr;
  5496. WMITLV_SET_HDR(&peer_set_param_fp->tlv_header,
  5497. WMITLV_TAG_STRUC_wmi_peer_set_param_cmd_fixed_param,
  5498. WMITLV_GET_STRUCT_TLVLEN
  5499. (wmi_peer_set_param_cmd_fixed_param));
  5500. /* fill in values */
  5501. peer_set_param_fp->vdev_id = ta_dhcp_ind->vdev_id;
  5502. peer_set_param_fp->param_id = ta_dhcp_ind->param_id;
  5503. peer_set_param_fp->param_value = ta_dhcp_ind->param_value;
  5504. qdf_mem_copy(&peer_set_param_fp->peer_macaddr,
  5505. &ta_dhcp_ind->peer_macaddr,
  5506. sizeof(ta_dhcp_ind->peer_macaddr));
  5507. status = wmi_unified_cmd_send(wmi_handle, buf,
  5508. len, WMI_PEER_SET_PARAM_CMDID);
  5509. if (status != EOK) {
  5510. WMI_LOGE("%s: wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
  5511. " returned Error %d", __func__, status);
  5512. return QDF_STATUS_E_FAILURE;
  5513. }
  5514. return QDF_STATUS_SUCCESS;
  5515. }
  5516. /**
  5517. * send_get_link_speed_cmd_tlv() -send command to get linkspeed
  5518. * @wmi_handle: wmi handle
  5519. * @pLinkSpeed: link speed info
  5520. *
  5521. * Return: CDF status
  5522. */
  5523. QDF_STATUS send_get_link_speed_cmd_tlv(wmi_unified_t wmi_handle,
  5524. wmi_mac_addr peer_macaddr)
  5525. {
  5526. wmi_peer_get_estimated_linkspeed_cmd_fixed_param *cmd;
  5527. wmi_buf_t wmi_buf;
  5528. uint32_t len;
  5529. uint8_t *buf_ptr;
  5530. len = sizeof(wmi_peer_get_estimated_linkspeed_cmd_fixed_param);
  5531. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  5532. if (!wmi_buf) {
  5533. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  5534. return QDF_STATUS_E_NOMEM;
  5535. }
  5536. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  5537. cmd = (wmi_peer_get_estimated_linkspeed_cmd_fixed_param *) buf_ptr;
  5538. WMITLV_SET_HDR(&cmd->tlv_header,
  5539. WMITLV_TAG_STRUC_wmi_peer_get_estimated_linkspeed_cmd_fixed_param,
  5540. WMITLV_GET_STRUCT_TLVLEN
  5541. (wmi_peer_get_estimated_linkspeed_cmd_fixed_param));
  5542. /* Copy the peer macaddress to the wma buffer */
  5543. qdf_mem_copy(&cmd->peer_macaddr,
  5544. &peer_macaddr,
  5545. sizeof(peer_macaddr));
  5546. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  5547. WMI_PEER_GET_ESTIMATED_LINKSPEED_CMDID)) {
  5548. WMI_LOGE("%s: failed to send link speed command", __func__);
  5549. qdf_nbuf_free(wmi_buf);
  5550. return QDF_STATUS_E_FAILURE;
  5551. }
  5552. return QDF_STATUS_SUCCESS;
  5553. }
  5554. /**
  5555. * send_egap_conf_params_cmd_tlv() - send wmi cmd of egap configuration params
  5556. * @wmi_handle: wmi handler
  5557. * @egap_params: pointer to egap_params
  5558. *
  5559. * Return: 0 for success, otherwise appropriate error code
  5560. */
  5561. QDF_STATUS send_egap_conf_params_cmd_tlv(wmi_unified_t wmi_handle,
  5562. wmi_ap_ps_egap_param_cmd_fixed_param *egap_params)
  5563. {
  5564. wmi_ap_ps_egap_param_cmd_fixed_param *cmd;
  5565. wmi_buf_t buf;
  5566. int32_t err;
  5567. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  5568. if (!buf) {
  5569. WMI_LOGE("Failed to allocate buffer to send ap_ps_egap cmd");
  5570. return QDF_STATUS_E_NOMEM;
  5571. }
  5572. cmd = (wmi_ap_ps_egap_param_cmd_fixed_param *) wmi_buf_data(buf);
  5573. WMITLV_SET_HDR(&cmd->tlv_header,
  5574. WMITLV_TAG_STRUC_wmi_ap_ps_egap_param_cmd_fixed_param,
  5575. WMITLV_GET_STRUCT_TLVLEN(
  5576. wmi_ap_ps_egap_param_cmd_fixed_param));
  5577. cmd->enable = egap_params->enable;
  5578. cmd->inactivity_time = egap_params->inactivity_time;
  5579. cmd->wait_time = egap_params->wait_time;
  5580. cmd->flags = egap_params->flags;
  5581. err = wmi_unified_cmd_send(wmi_handle, buf,
  5582. sizeof(*cmd), WMI_AP_PS_EGAP_PARAM_CMDID);
  5583. if (err) {
  5584. WMI_LOGE("Failed to send ap_ps_egap cmd");
  5585. wmi_buf_free(buf);
  5586. return QDF_STATUS_E_FAILURE;
  5587. }
  5588. return QDF_STATUS_SUCCESS;
  5589. }
  5590. /**
  5591. * send_fw_profiling_cmd_tlv() - send FW profiling cmd to WLAN FW
  5592. * @wmi_handl: wmi handle
  5593. * @cmd: Profiling command index
  5594. * @value1: parameter1 value
  5595. * @value2: parameter2 value
  5596. *
  5597. * Return: 0 for success else error code
  5598. */
  5599. QDF_STATUS send_fw_profiling_cmd_tlv(wmi_unified_t wmi_handle,
  5600. uint32_t cmd, uint32_t value1, uint32_t value2)
  5601. {
  5602. wmi_buf_t buf;
  5603. int32_t len = 0;
  5604. int ret;
  5605. wmi_wlan_profile_trigger_cmd_fixed_param *prof_trig_cmd;
  5606. wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *hist_intvl_cmd;
  5607. wmi_wlan_profile_enable_profile_id_cmd_fixed_param *profile_enable_cmd;
  5608. wmi_wlan_profile_get_prof_data_cmd_fixed_param *profile_getdata_cmd;
  5609. switch (cmd) {
  5610. case WMI_WLAN_PROFILE_TRIGGER_CMDID:
  5611. len = sizeof(wmi_wlan_profile_trigger_cmd_fixed_param);
  5612. buf = wmi_buf_alloc(wmi_handle, len);
  5613. if (!buf) {
  5614. WMI_LOGP("%s: wmi_buf_alloc Failed", __func__);
  5615. return -ENOMEM;
  5616. }
  5617. prof_trig_cmd =
  5618. (wmi_wlan_profile_trigger_cmd_fixed_param *)
  5619. wmi_buf_data(buf);
  5620. WMITLV_SET_HDR(&prof_trig_cmd->tlv_header,
  5621. WMITLV_TAG_STRUC_wmi_wlan_profile_trigger_cmd_fixed_param,
  5622. WMITLV_GET_STRUCT_TLVLEN
  5623. (wmi_wlan_profile_trigger_cmd_fixed_param));
  5624. prof_trig_cmd->enable = value1;
  5625. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5626. WMI_WLAN_PROFILE_TRIGGER_CMDID);
  5627. if (ret) {
  5628. WMI_LOGE("PROFILE_TRIGGER cmd Failed with value %d",
  5629. value1);
  5630. qdf_nbuf_free(buf);
  5631. return ret;
  5632. }
  5633. break;
  5634. case WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID:
  5635. len = sizeof(wmi_wlan_profile_get_prof_data_cmd_fixed_param);
  5636. buf = wmi_buf_alloc(wmi_handle, len);
  5637. if (!buf) {
  5638. WMI_LOGP("%s: wmi_buf_alloc Failed", __func__);
  5639. return -ENOMEM;
  5640. }
  5641. profile_getdata_cmd =
  5642. (wmi_wlan_profile_get_prof_data_cmd_fixed_param *)
  5643. wmi_buf_data(buf);
  5644. WMITLV_SET_HDR(&profile_getdata_cmd->tlv_header,
  5645. WMITLV_TAG_STRUC_wmi_wlan_profile_get_prof_data_cmd_fixed_param,
  5646. WMITLV_GET_STRUCT_TLVLEN
  5647. (wmi_wlan_profile_get_prof_data_cmd_fixed_param));
  5648. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5649. WMI_WLAN_PROFILE_GET_PROFILE_DATA_CMDID);
  5650. if (ret) {
  5651. WMI_LOGE("PROFILE_DATA cmd Failed for id %d value %d",
  5652. value1, value2);
  5653. qdf_nbuf_free(buf);
  5654. return ret;
  5655. }
  5656. break;
  5657. case WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID:
  5658. len = sizeof(wmi_wlan_profile_set_hist_intvl_cmd_fixed_param);
  5659. buf = wmi_buf_alloc(wmi_handle, len);
  5660. if (!buf) {
  5661. WMI_LOGP("%s: wmi_buf_alloc Failed", __func__);
  5662. return -ENOMEM;
  5663. }
  5664. hist_intvl_cmd =
  5665. (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param *)
  5666. wmi_buf_data(buf);
  5667. WMITLV_SET_HDR(&hist_intvl_cmd->tlv_header,
  5668. WMITLV_TAG_STRUC_wmi_wlan_profile_set_hist_intvl_cmd_fixed_param,
  5669. WMITLV_GET_STRUCT_TLVLEN
  5670. (wmi_wlan_profile_set_hist_intvl_cmd_fixed_param));
  5671. hist_intvl_cmd->profile_id = value1;
  5672. hist_intvl_cmd->value = value2;
  5673. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5674. WMI_WLAN_PROFILE_SET_HIST_INTVL_CMDID);
  5675. if (ret) {
  5676. WMI_LOGE("HIST_INTVL cmd Failed for id %d value %d",
  5677. value1, value2);
  5678. qdf_nbuf_free(buf);
  5679. return ret;
  5680. }
  5681. break;
  5682. case WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID:
  5683. len =
  5684. sizeof(wmi_wlan_profile_enable_profile_id_cmd_fixed_param);
  5685. buf = wmi_buf_alloc(wmi_handle, len);
  5686. if (!buf) {
  5687. WMI_LOGP("%s: wmi_buf_alloc Failed", __func__);
  5688. return -ENOMEM;
  5689. }
  5690. profile_enable_cmd =
  5691. (wmi_wlan_profile_enable_profile_id_cmd_fixed_param *)
  5692. wmi_buf_data(buf);
  5693. WMITLV_SET_HDR(&profile_enable_cmd->tlv_header,
  5694. WMITLV_TAG_STRUC_wmi_wlan_profile_enable_profile_id_cmd_fixed_param,
  5695. WMITLV_GET_STRUCT_TLVLEN
  5696. (wmi_wlan_profile_enable_profile_id_cmd_fixed_param));
  5697. profile_enable_cmd->profile_id = value1;
  5698. profile_enable_cmd->enable = value2;
  5699. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5700. WMI_WLAN_PROFILE_ENABLE_PROFILE_ID_CMDID);
  5701. if (ret) {
  5702. WMI_LOGE("enable cmd Failed for id %d value %d",
  5703. value1, value2);
  5704. qdf_nbuf_free(buf);
  5705. return ret;
  5706. }
  5707. break;
  5708. default:
  5709. WMI_LOGD("%s: invalid profiling command", __func__);
  5710. break;
  5711. }
  5712. return 0;
  5713. }
  5714. #ifdef FEATURE_WLAN_RA_FILTERING
  5715. /**
  5716. * send_wow_sta_ra_filter_cmd_tlv() - set RA filter pattern in fw
  5717. * @wmi_handle: wmi handle
  5718. * @vdev_id: vdev id
  5719. *
  5720. * Return: CDF status
  5721. */
  5722. QDF_STATUS send_wow_sta_ra_filter_cmd_tlv(wmi_unified_t wmi_handle,
  5723. uint8_t vdev_id, uint8_t default_pattern,
  5724. uint16_t rate_limit_interval)
  5725. {
  5726. WMI_WOW_ADD_PATTERN_CMD_fixed_param *cmd;
  5727. wmi_buf_t buf;
  5728. uint8_t *buf_ptr;
  5729. int32_t len;
  5730. int ret;
  5731. len = sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param) +
  5732. WMI_TLV_HDR_SIZE +
  5733. 0 * sizeof(WOW_BITMAP_PATTERN_T) +
  5734. WMI_TLV_HDR_SIZE +
  5735. 0 * sizeof(WOW_IPV4_SYNC_PATTERN_T) +
  5736. WMI_TLV_HDR_SIZE +
  5737. 0 * sizeof(WOW_IPV6_SYNC_PATTERN_T) +
  5738. WMI_TLV_HDR_SIZE +
  5739. 0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
  5740. WMI_TLV_HDR_SIZE +
  5741. 0 * sizeof(A_UINT32) + WMI_TLV_HDR_SIZE + 1 * sizeof(A_UINT32);
  5742. buf = wmi_buf_alloc(wmi_handle, len);
  5743. if (!buf) {
  5744. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  5745. return QDF_STATUS_E_NOMEM;
  5746. }
  5747. cmd = (WMI_WOW_ADD_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
  5748. buf_ptr = (uint8_t *) cmd;
  5749. WMITLV_SET_HDR(&cmd->tlv_header,
  5750. WMITLV_TAG_STRUC_WMI_WOW_ADD_PATTERN_CMD_fixed_param,
  5751. WMITLV_GET_STRUCT_TLVLEN
  5752. (WMI_WOW_ADD_PATTERN_CMD_fixed_param));
  5753. cmd->vdev_id = vdev_id;
  5754. cmd->pattern_id = default_pattern,
  5755. cmd->pattern_type = WOW_IPV6_RA_PATTERN;
  5756. buf_ptr += sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param);
  5757. /* Fill TLV for WMITLV_TAG_STRUC_WOW_BITMAP_PATTERN_T but no data. */
  5758. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5759. buf_ptr += WMI_TLV_HDR_SIZE;
  5760. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV4_SYNC_PATTERN_T but no data. */
  5761. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5762. buf_ptr += WMI_TLV_HDR_SIZE;
  5763. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV6_SYNC_PATTERN_T but no data. */
  5764. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5765. buf_ptr += WMI_TLV_HDR_SIZE;
  5766. /* Fill TLV for WMITLV_TAG_STRUC_WOW_MAGIC_PATTERN_CMD but no data. */
  5767. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  5768. buf_ptr += WMI_TLV_HDR_SIZE;
  5769. /* Fill TLV for pattern_info_timeout but no data. */
  5770. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
  5771. buf_ptr += WMI_TLV_HDR_SIZE;
  5772. /* Fill TLV for ra_ratelimit_interval. */
  5773. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, sizeof(A_UINT32));
  5774. buf_ptr += WMI_TLV_HDR_SIZE;
  5775. *((A_UINT32 *) buf_ptr) = rate_limit_interval;
  5776. WMI_LOGD("%s: send RA rate limit [%d] to fw vdev = %d", __func__,
  5777. rate_limit_interval, vdev_id);
  5778. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5779. WMI_WOW_ADD_WAKE_PATTERN_CMDID);
  5780. if (ret) {
  5781. WMI_LOGE("%s: Failed to send RA rate limit to fw", __func__);
  5782. wmi_buf_free(buf);
  5783. return QDF_STATUS_E_FAILURE;
  5784. }
  5785. return QDF_STATUS_SUCCESS;
  5786. }
  5787. #endif /* FEATURE_WLAN_RA_FILTERING */
  5788. /**
  5789. * send_nat_keepalive_en_cmd_tlv() - enable NAT keepalive filter
  5790. * @wmi_handle: wmi handle
  5791. * @vdev_id: vdev id
  5792. *
  5793. * Return: 0 for success or error code
  5794. */
  5795. QDF_STATUS send_nat_keepalive_en_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id)
  5796. {
  5797. WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param *cmd;
  5798. wmi_buf_t buf;
  5799. int32_t len = sizeof(*cmd);
  5800. WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
  5801. buf = wmi_buf_alloc(wmi_handle, len);
  5802. if (!buf) {
  5803. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  5804. return -ENOMEM;
  5805. }
  5806. cmd = (WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param *)
  5807. wmi_buf_data(buf);
  5808. WMITLV_SET_HDR(&cmd->tlv_header,
  5809. WMITLV_TAG_STRUC_WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param,
  5810. WMITLV_GET_STRUCT_TLVLEN
  5811. (WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMD_fixed_param));
  5812. cmd->vdev_id = vdev_id;
  5813. cmd->action = IPSEC_NATKEEPALIVE_FILTER_ENABLE;
  5814. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5815. WMI_VDEV_IPSEC_NATKEEPALIVE_FILTER_CMDID)) {
  5816. WMI_LOGP("%s: Failed to send NAT keepalive enable command",
  5817. __func__);
  5818. wmi_buf_free(buf);
  5819. return -EIO;
  5820. }
  5821. return 0;
  5822. }
  5823. /**
  5824. * wmi_unified_csa_offload_enable() - sen CSA offload enable command
  5825. * @wmi_handle: wmi handle
  5826. * @vdev_id: vdev id
  5827. *
  5828. * Return: 0 for success or error code
  5829. */
  5830. QDF_STATUS send_csa_offload_enable_cmd_tlv(wmi_unified_t wmi_handle,
  5831. uint8_t vdev_id)
  5832. {
  5833. wmi_csa_offload_enable_cmd_fixed_param *cmd;
  5834. wmi_buf_t buf;
  5835. int32_t len = sizeof(*cmd);
  5836. WMI_LOGD("%s: vdev_id %d", __func__, vdev_id);
  5837. buf = wmi_buf_alloc(wmi_handle, len);
  5838. if (!buf) {
  5839. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  5840. return -ENOMEM;
  5841. }
  5842. cmd = (wmi_csa_offload_enable_cmd_fixed_param *) wmi_buf_data(buf);
  5843. WMITLV_SET_HDR(&cmd->tlv_header,
  5844. WMITLV_TAG_STRUC_wmi_csa_offload_enable_cmd_fixed_param,
  5845. WMITLV_GET_STRUCT_TLVLEN
  5846. (wmi_csa_offload_enable_cmd_fixed_param));
  5847. cmd->vdev_id = vdev_id;
  5848. cmd->csa_offload_enable = WMI_CSA_OFFLOAD_ENABLE;
  5849. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  5850. WMI_CSA_OFFLOAD_ENABLE_CMDID)) {
  5851. WMI_LOGP("%s: Failed to send CSA offload enable command",
  5852. __func__);
  5853. wmi_buf_free(buf);
  5854. return -EIO;
  5855. }
  5856. return 0;
  5857. }
  5858. /**
  5859. * send_start_oem_data_cmd_tlv() - start OEM data request to target
  5860. * @wmi_handle: wmi handle
  5861. * @startOemDataReq: start request params
  5862. *
  5863. * Return: CDF status
  5864. */
  5865. QDF_STATUS send_start_oem_data_cmd_tlv(wmi_unified_t wmi_handle,
  5866. uint8_t data_len,
  5867. uint8_t *data)
  5868. {
  5869. wmi_buf_t buf;
  5870. uint8_t *cmd;
  5871. int ret = 0;
  5872. buf = wmi_buf_alloc(wmi_handle,
  5873. (data_len + WMI_TLV_HDR_SIZE));
  5874. if (!buf) {
  5875. WMI_LOGE(FL("wmi_buf_alloc failed"));
  5876. return QDF_STATUS_E_FAILURE;
  5877. }
  5878. cmd = (uint8_t *) wmi_buf_data(buf);
  5879. WMITLV_SET_HDR(cmd, WMITLV_TAG_ARRAY_BYTE, data_len);
  5880. cmd += WMI_TLV_HDR_SIZE;
  5881. qdf_mem_copy(cmd, data,
  5882. data_len);
  5883. WMI_LOGI(FL("Sending OEM Data Request to target, data len %d"),
  5884. data_len);
  5885. ret = wmi_unified_cmd_send(wmi_handle, buf,
  5886. (data_len +
  5887. WMI_TLV_HDR_SIZE), WMI_OEM_REQ_CMDID);
  5888. if (ret != EOK) {
  5889. WMI_LOGE(FL(":wmi cmd send failed"));
  5890. qdf_nbuf_free(buf);
  5891. return QDF_STATUS_E_FAILURE;
  5892. }
  5893. return QDF_STATUS_SUCCESS;
  5894. }
  5895. /**
  5896. * send_dfs_phyerr_filter_offload_en_cmd_tlv() - enable dfs phyerr filter
  5897. * @wmi_handle: wmi handle
  5898. * @dfs_phyerr_filter_offload: is dfs phyerr filter offload
  5899. *
  5900. * Send WMI_DFS_PHYERR_FILTER_ENA_CMDID or
  5901. * WMI_DFS_PHYERR_FILTER_DIS_CMDID command
  5902. * to firmware based on phyerr filtering
  5903. * offload status.
  5904. *
  5905. * Return: 1 success, 0 failure
  5906. */
  5907. QDF_STATUS
  5908. send_dfs_phyerr_filter_offload_en_cmd_tlv(wmi_unified_t wmi_handle,
  5909. bool dfs_phyerr_filter_offload)
  5910. {
  5911. wmi_dfs_phyerr_filter_ena_cmd_fixed_param *enable_phyerr_offload_cmd;
  5912. wmi_dfs_phyerr_filter_dis_cmd_fixed_param *disable_phyerr_offload_cmd;
  5913. wmi_buf_t buf;
  5914. uint16_t len;
  5915. int ret;
  5916. if (dfs_phyerr_filter_offload) {
  5917. WMI_LOGD("%s:Phyerror Filtering offload is Disabled in ini",
  5918. __func__);
  5919. len = sizeof(*disable_phyerr_offload_cmd);
  5920. buf = wmi_buf_alloc(wmi_handle, len);
  5921. if (!buf) {
  5922. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  5923. return 0;
  5924. }
  5925. disable_phyerr_offload_cmd =
  5926. (wmi_dfs_phyerr_filter_dis_cmd_fixed_param *)
  5927. wmi_buf_data(buf);
  5928. WMITLV_SET_HDR(&disable_phyerr_offload_cmd->tlv_header,
  5929. WMITLV_TAG_STRUC_wmi_dfs_phyerr_filter_dis_cmd_fixed_param,
  5930. WMITLV_GET_STRUCT_TLVLEN
  5931. (wmi_dfs_phyerr_filter_dis_cmd_fixed_param));
  5932. /*
  5933. * Send WMI_DFS_PHYERR_FILTER_DIS_CMDID
  5934. * to the firmware to disable the phyerror
  5935. * filtering offload.
  5936. */
  5937. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5938. WMI_DFS_PHYERR_FILTER_DIS_CMDID);
  5939. if (ret < 0) {
  5940. WMI_LOGE("%s: Failed to send WMI_DFS_PHYERR_FILTER_DIS_CMDID ret=%d",
  5941. __func__, ret);
  5942. wmi_buf_free(buf);
  5943. return QDF_STATUS_E_FAILURE;
  5944. }
  5945. WMI_LOGD("%s: WMI_DFS_PHYERR_FILTER_DIS_CMDID Send Success",
  5946. __func__);
  5947. } else {
  5948. WMI_LOGD("%s:Phyerror Filtering offload is Enabled in ini",
  5949. __func__);
  5950. len = sizeof(*enable_phyerr_offload_cmd);
  5951. buf = wmi_buf_alloc(wmi_handle, len);
  5952. if (!buf) {
  5953. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  5954. return QDF_STATUS_E_FAILURE;
  5955. }
  5956. enable_phyerr_offload_cmd =
  5957. (wmi_dfs_phyerr_filter_ena_cmd_fixed_param *)
  5958. wmi_buf_data(buf);
  5959. WMITLV_SET_HDR(&enable_phyerr_offload_cmd->tlv_header,
  5960. WMITLV_TAG_STRUC_wmi_dfs_phyerr_filter_ena_cmd_fixed_param,
  5961. WMITLV_GET_STRUCT_TLVLEN
  5962. (wmi_dfs_phyerr_filter_ena_cmd_fixed_param));
  5963. /*
  5964. * Send a WMI_DFS_PHYERR_FILTER_ENA_CMDID
  5965. * to the firmware to enable the phyerror
  5966. * filtering offload.
  5967. */
  5968. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  5969. WMI_DFS_PHYERR_FILTER_ENA_CMDID);
  5970. if (ret < 0) {
  5971. WMI_LOGE("%s: Failed to send DFS PHYERR CMD ret=%d",
  5972. __func__, ret);
  5973. wmi_buf_free(buf);
  5974. return QDF_STATUS_E_FAILURE;
  5975. }
  5976. WMI_LOGD("%s: WMI_DFS_PHYERR_FILTER_ENA_CMDID Send Success",
  5977. __func__);
  5978. }
  5979. return QDF_STATUS_SUCCESS;
  5980. }
  5981. #if !defined(REMOVE_PKT_LOG)
  5982. /**
  5983. * send_pktlog_wmi_send_cmd_tlv() - send pktlog enable/disable command to target
  5984. * @wmi_handle: wmi handle
  5985. * @pktlog_event: pktlog event
  5986. * @cmd_id: pktlog cmd id
  5987. *
  5988. * Return: CDF status
  5989. */
  5990. QDF_STATUS send_pktlog_wmi_send_cmd_tlv(wmi_unified_t wmi_handle,
  5991. WMI_PKTLOG_EVENT pktlog_event,
  5992. WMI_CMD_ID cmd_id)
  5993. {
  5994. WMI_PKTLOG_EVENT PKTLOG_EVENT;
  5995. WMI_CMD_ID CMD_ID;
  5996. wmi_pdev_pktlog_enable_cmd_fixed_param *cmd;
  5997. wmi_pdev_pktlog_disable_cmd_fixed_param *disable_cmd;
  5998. int len = 0;
  5999. wmi_buf_t buf;
  6000. PKTLOG_EVENT = pktlog_event;
  6001. CMD_ID = cmd_id;
  6002. switch (CMD_ID) {
  6003. case WMI_PDEV_PKTLOG_ENABLE_CMDID:
  6004. len = sizeof(*cmd);
  6005. buf = wmi_buf_alloc(wmi_handle, len);
  6006. if (!buf) {
  6007. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  6008. return QDF_STATUS_E_NOMEM;
  6009. }
  6010. cmd = (wmi_pdev_pktlog_enable_cmd_fixed_param *)
  6011. wmi_buf_data(buf);
  6012. WMITLV_SET_HDR(&cmd->tlv_header,
  6013. WMITLV_TAG_STRUC_wmi_pdev_pktlog_enable_cmd_fixed_param,
  6014. WMITLV_GET_STRUCT_TLVLEN
  6015. (wmi_pdev_pktlog_enable_cmd_fixed_param));
  6016. cmd->evlist = PKTLOG_EVENT;
  6017. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  6018. WMI_PDEV_PKTLOG_ENABLE_CMDID)) {
  6019. WMI_LOGE("failed to send pktlog enable cmdid");
  6020. goto wmi_send_failed;
  6021. }
  6022. break;
  6023. case WMI_PDEV_PKTLOG_DISABLE_CMDID:
  6024. len = sizeof(*disable_cmd);
  6025. buf = wmi_buf_alloc(wmi_handle, len);
  6026. if (!buf) {
  6027. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  6028. return QDF_STATUS_E_NOMEM;
  6029. }
  6030. disable_cmd = (wmi_pdev_pktlog_disable_cmd_fixed_param *)
  6031. wmi_buf_data(buf);
  6032. WMITLV_SET_HDR(&disable_cmd->tlv_header,
  6033. WMITLV_TAG_STRUC_wmi_pdev_pktlog_disable_cmd_fixed_param,
  6034. WMITLV_GET_STRUCT_TLVLEN
  6035. (wmi_pdev_pktlog_disable_cmd_fixed_param));
  6036. disable_cmd->pdev_id = 0;
  6037. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  6038. WMI_PDEV_PKTLOG_DISABLE_CMDID)) {
  6039. WMI_LOGE("failed to send pktlog disable cmdid");
  6040. goto wmi_send_failed;
  6041. }
  6042. break;
  6043. default:
  6044. WMI_LOGD("%s: invalid PKTLOG command", __func__);
  6045. break;
  6046. }
  6047. return QDF_STATUS_SUCCESS;
  6048. wmi_send_failed:
  6049. wmi_buf_free(buf);
  6050. return QDF_STATUS_E_FAILURE;
  6051. }
  6052. #endif /* REMOVE_PKT_LOG */
  6053. /**
  6054. * send_add_wow_wakeup_event_cmd_tlv() - Configures wow wakeup events.
  6055. * @wmi_handle: wmi handle
  6056. * @vdev_id: vdev id
  6057. * @bitmap: Event bitmap
  6058. * @enable: enable/disable
  6059. *
  6060. * Return: CDF status
  6061. */
  6062. QDF_STATUS send_add_wow_wakeup_event_cmd_tlv(wmi_unified_t wmi_handle,
  6063. uint32_t vdev_id,
  6064. uint32_t bitmap,
  6065. bool enable)
  6066. {
  6067. WMI_WOW_ADD_DEL_EVT_CMD_fixed_param *cmd;
  6068. uint16_t len;
  6069. wmi_buf_t buf;
  6070. int ret;
  6071. len = sizeof(WMI_WOW_ADD_DEL_EVT_CMD_fixed_param);
  6072. buf = wmi_buf_alloc(wmi_handle, len);
  6073. if (!buf) {
  6074. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  6075. return QDF_STATUS_E_NOMEM;
  6076. }
  6077. cmd = (WMI_WOW_ADD_DEL_EVT_CMD_fixed_param *) wmi_buf_data(buf);
  6078. WMITLV_SET_HDR(&cmd->tlv_header,
  6079. WMITLV_TAG_STRUC_WMI_WOW_ADD_DEL_EVT_CMD_fixed_param,
  6080. WMITLV_GET_STRUCT_TLVLEN
  6081. (WMI_WOW_ADD_DEL_EVT_CMD_fixed_param));
  6082. cmd->vdev_id = vdev_id;
  6083. cmd->is_add = enable;
  6084. cmd->event_bitmap = bitmap;
  6085. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6086. WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID);
  6087. if (ret) {
  6088. WMI_LOGE("Failed to config wow wakeup event");
  6089. wmi_buf_free(buf);
  6090. return QDF_STATUS_E_FAILURE;
  6091. }
  6092. WMI_LOGD("Wakeup pattern 0x%x %s in fw", bitmap,
  6093. enable ? "enabled" : "disabled");
  6094. return QDF_STATUS_SUCCESS;
  6095. }
  6096. /**
  6097. * send_wow_patterns_to_fw_cmd_tlv() - Sends WOW patterns to FW.
  6098. * @wmi_handle: wmi handle
  6099. * @vdev_id: vdev id
  6100. * @ptrn_id: pattern id
  6101. * @ptrn: pattern
  6102. * @ptrn_len: pattern length
  6103. * @ptrn_offset: pattern offset
  6104. * @mask: mask
  6105. * @mask_len: mask length
  6106. * @user: true for user configured pattern and false for default pattern
  6107. * @default_patterns: default patterns
  6108. *
  6109. * Return: CDF status
  6110. */
  6111. QDF_STATUS send_wow_patterns_to_fw_cmd_tlv(wmi_unified_t wmi_handle,
  6112. uint8_t vdev_id, uint8_t ptrn_id,
  6113. const uint8_t *ptrn, uint8_t ptrn_len,
  6114. uint8_t ptrn_offset, const uint8_t *mask,
  6115. uint8_t mask_len, bool user,
  6116. uint8_t default_patterns)
  6117. {
  6118. WMI_WOW_ADD_PATTERN_CMD_fixed_param *cmd;
  6119. WOW_BITMAP_PATTERN_T *bitmap_pattern;
  6120. wmi_buf_t buf;
  6121. uint8_t *buf_ptr;
  6122. int32_t len;
  6123. int ret;
  6124. len = sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param) +
  6125. WMI_TLV_HDR_SIZE +
  6126. 1 * sizeof(WOW_BITMAP_PATTERN_T) +
  6127. WMI_TLV_HDR_SIZE +
  6128. 0 * sizeof(WOW_IPV4_SYNC_PATTERN_T) +
  6129. WMI_TLV_HDR_SIZE +
  6130. 0 * sizeof(WOW_IPV6_SYNC_PATTERN_T) +
  6131. WMI_TLV_HDR_SIZE +
  6132. 0 * sizeof(WOW_MAGIC_PATTERN_CMD) +
  6133. WMI_TLV_HDR_SIZE +
  6134. 0 * sizeof(A_UINT32) + WMI_TLV_HDR_SIZE + 1 * sizeof(A_UINT32);
  6135. buf = wmi_buf_alloc(wmi_handle, len);
  6136. if (!buf) {
  6137. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  6138. return QDF_STATUS_E_NOMEM;
  6139. }
  6140. cmd = (WMI_WOW_ADD_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
  6141. buf_ptr = (uint8_t *) cmd;
  6142. WMITLV_SET_HDR(&cmd->tlv_header,
  6143. WMITLV_TAG_STRUC_WMI_WOW_ADD_PATTERN_CMD_fixed_param,
  6144. WMITLV_GET_STRUCT_TLVLEN
  6145. (WMI_WOW_ADD_PATTERN_CMD_fixed_param));
  6146. cmd->vdev_id = vdev_id;
  6147. cmd->pattern_id = ptrn_id;
  6148. cmd->pattern_type = WOW_BITMAP_PATTERN;
  6149. buf_ptr += sizeof(WMI_WOW_ADD_PATTERN_CMD_fixed_param);
  6150. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  6151. sizeof(WOW_BITMAP_PATTERN_T));
  6152. buf_ptr += WMI_TLV_HDR_SIZE;
  6153. bitmap_pattern = (WOW_BITMAP_PATTERN_T *) buf_ptr;
  6154. WMITLV_SET_HDR(&bitmap_pattern->tlv_header,
  6155. WMITLV_TAG_STRUC_WOW_BITMAP_PATTERN_T,
  6156. WMITLV_GET_STRUCT_TLVLEN(WOW_BITMAP_PATTERN_T));
  6157. qdf_mem_copy(&bitmap_pattern->patternbuf[0], ptrn, ptrn_len);
  6158. qdf_mem_copy(&bitmap_pattern->bitmaskbuf[0], mask, mask_len);
  6159. bitmap_pattern->pattern_offset = ptrn_offset;
  6160. bitmap_pattern->pattern_len = ptrn_len;
  6161. if (bitmap_pattern->pattern_len > WOW_DEFAULT_BITMAP_PATTERN_SIZE)
  6162. bitmap_pattern->pattern_len = WOW_DEFAULT_BITMAP_PATTERN_SIZE;
  6163. if (bitmap_pattern->pattern_len > WOW_DEFAULT_BITMASK_SIZE)
  6164. bitmap_pattern->pattern_len = WOW_DEFAULT_BITMASK_SIZE;
  6165. bitmap_pattern->bitmask_len = bitmap_pattern->pattern_len;
  6166. bitmap_pattern->pattern_id = ptrn_id;
  6167. WMI_LOGI("vdev id : %d, ptrn id: %d, ptrn len: %d, ptrn offset: %d user %d",
  6168. cmd->vdev_id, cmd->pattern_id, bitmap_pattern->pattern_len,
  6169. bitmap_pattern->pattern_offset, user);
  6170. WMI_LOGI("Pattern : ");
  6171. QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_INFO,
  6172. &bitmap_pattern->patternbuf[0], bitmap_pattern->pattern_len);
  6173. WMI_LOGI("Mask : ");
  6174. QDF_TRACE_HEX_DUMP(QDF_MODULE_ID_WMI, QDF_TRACE_LEVEL_INFO,
  6175. &bitmap_pattern->bitmaskbuf[0], bitmap_pattern->pattern_len);
  6176. buf_ptr += sizeof(WOW_BITMAP_PATTERN_T);
  6177. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV4_SYNC_PATTERN_T but no data. */
  6178. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  6179. buf_ptr += WMI_TLV_HDR_SIZE;
  6180. /* Fill TLV for WMITLV_TAG_STRUC_WOW_IPV6_SYNC_PATTERN_T but no data. */
  6181. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  6182. buf_ptr += WMI_TLV_HDR_SIZE;
  6183. /* Fill TLV for WMITLV_TAG_STRUC_WOW_MAGIC_PATTERN_CMD but no data. */
  6184. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, 0);
  6185. buf_ptr += WMI_TLV_HDR_SIZE;
  6186. /* Fill TLV for pattern_info_timeout but no data. */
  6187. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 0);
  6188. buf_ptr += WMI_TLV_HDR_SIZE;
  6189. /* Fill TLV for ratelimit_interval with dummy data as this fix elem */
  6190. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32, 1 * sizeof(A_UINT32));
  6191. buf_ptr += WMI_TLV_HDR_SIZE;
  6192. *(A_UINT32 *) buf_ptr = 0;
  6193. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6194. WMI_WOW_ADD_WAKE_PATTERN_CMDID);
  6195. if (ret) {
  6196. WMI_LOGE("%s: Failed to send wow ptrn to fw", __func__);
  6197. wmi_buf_free(buf);
  6198. return QDF_STATUS_E_FAILURE;
  6199. }
  6200. return QDF_STATUS_SUCCESS;
  6201. }
  6202. /**
  6203. * send_wow_delete_pattern_cmd_tlv() - delete wow pattern in target
  6204. * @wmi_handle: wmi handle
  6205. * @ptrn_id: pattern id
  6206. * @vdev_id: vdev id
  6207. *
  6208. * Return: CDF status
  6209. */
  6210. QDF_STATUS send_wow_delete_pattern_cmd_tlv(wmi_unified_t wmi_handle, uint8_t ptrn_id,
  6211. uint8_t vdev_id)
  6212. {
  6213. WMI_WOW_DEL_PATTERN_CMD_fixed_param *cmd;
  6214. wmi_buf_t buf;
  6215. int32_t len;
  6216. int ret;
  6217. len = sizeof(WMI_WOW_DEL_PATTERN_CMD_fixed_param);
  6218. buf = wmi_buf_alloc(wmi_handle, len);
  6219. if (!buf) {
  6220. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  6221. return QDF_STATUS_E_NOMEM;
  6222. }
  6223. cmd = (WMI_WOW_DEL_PATTERN_CMD_fixed_param *) wmi_buf_data(buf);
  6224. WMITLV_SET_HDR(&cmd->tlv_header,
  6225. WMITLV_TAG_STRUC_WMI_WOW_DEL_PATTERN_CMD_fixed_param,
  6226. WMITLV_GET_STRUCT_TLVLEN(
  6227. WMI_WOW_DEL_PATTERN_CMD_fixed_param));
  6228. cmd->vdev_id = vdev_id;
  6229. cmd->pattern_id = ptrn_id;
  6230. cmd->pattern_type = WOW_BITMAP_PATTERN;
  6231. WMI_LOGI("Deleting pattern id: %d vdev id %d in fw",
  6232. cmd->pattern_id, vdev_id);
  6233. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6234. WMI_WOW_DEL_WAKE_PATTERN_CMDID);
  6235. if (ret) {
  6236. WMI_LOGE("%s: Failed to delete wow ptrn from fw", __func__);
  6237. wmi_buf_free(buf);
  6238. return QDF_STATUS_E_FAILURE;
  6239. }
  6240. return QDF_STATUS_SUCCESS;
  6241. }
  6242. /**
  6243. * send_host_wakeup_ind_to_fw_cmd_tlv() - send wakeup ind to fw
  6244. * @wmi_handle: wmi handle
  6245. *
  6246. * Sends host wakeup indication to FW. On receiving this indication,
  6247. * FW will come out of WOW.
  6248. *
  6249. * Return: CDF status
  6250. */
  6251. QDF_STATUS send_host_wakeup_ind_to_fw_cmd_tlv(wmi_unified_t wmi_handle)
  6252. {
  6253. wmi_wow_hostwakeup_from_sleep_cmd_fixed_param *cmd;
  6254. wmi_buf_t buf;
  6255. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  6256. int32_t len;
  6257. int ret;
  6258. len = sizeof(wmi_wow_hostwakeup_from_sleep_cmd_fixed_param);
  6259. buf = wmi_buf_alloc(wmi_handle, len);
  6260. if (!buf) {
  6261. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  6262. return QDF_STATUS_E_NOMEM;
  6263. }
  6264. cmd = (wmi_wow_hostwakeup_from_sleep_cmd_fixed_param *)
  6265. wmi_buf_data(buf);
  6266. WMITLV_SET_HDR(&cmd->tlv_header,
  6267. WMITLV_TAG_STRUC_wmi_wow_hostwakeup_from_sleep_cmd_fixed_param,
  6268. WMITLV_GET_STRUCT_TLVLEN
  6269. (wmi_wow_hostwakeup_from_sleep_cmd_fixed_param));
  6270. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6271. WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID);
  6272. if (ret) {
  6273. WMI_LOGE("Failed to send host wakeup indication to fw");
  6274. wmi_buf_free(buf);
  6275. return QDF_STATUS_E_FAILURE;
  6276. }
  6277. return qdf_status;
  6278. }
  6279. /**
  6280. * send_del_ts_cmd_tlv() - send DELTS request to fw
  6281. * @wmi_handle: wmi handle
  6282. * @msg: delts params
  6283. *
  6284. * Return: CDF status
  6285. */
  6286. QDF_STATUS send_del_ts_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
  6287. uint8_t ac)
  6288. {
  6289. wmi_vdev_wmm_delts_cmd_fixed_param *cmd;
  6290. wmi_buf_t buf;
  6291. int32_t len = sizeof(*cmd);
  6292. buf = wmi_buf_alloc(wmi_handle, len);
  6293. if (!buf) {
  6294. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  6295. return QDF_STATUS_E_NOMEM;
  6296. }
  6297. cmd = (wmi_vdev_wmm_delts_cmd_fixed_param *) wmi_buf_data(buf);
  6298. WMITLV_SET_HDR(&cmd->tlv_header,
  6299. WMITLV_TAG_STRUC_wmi_vdev_wmm_delts_cmd_fixed_param,
  6300. WMITLV_GET_STRUCT_TLVLEN
  6301. (wmi_vdev_wmm_delts_cmd_fixed_param));
  6302. cmd->vdev_id = vdev_id;
  6303. cmd->ac = ac;
  6304. WMI_LOGD("Delts vdev:%d, ac:%d, %s:%d",
  6305. cmd->vdev_id, cmd->ac, __func__, __LINE__);
  6306. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  6307. WMI_VDEV_WMM_DELTS_CMDID)) {
  6308. WMI_LOGP("%s: Failed to send vdev DELTS command", __func__);
  6309. qdf_nbuf_free(buf);
  6310. return QDF_STATUS_E_FAILURE;
  6311. }
  6312. return QDF_STATUS_SUCCESS;
  6313. }
  6314. /**
  6315. * send_aggr_qos_cmd_tlv() - send aggr qos request to fw
  6316. * @wmi_handle: handle to wmi
  6317. * @aggr_qos_rsp_msg - combined struct for all ADD_TS requests.
  6318. *
  6319. * A function to handle WMI_AGGR_QOS_REQ. This will send out
  6320. * ADD_TS requestes to firmware in loop for all the ACs with
  6321. * active flow.
  6322. *
  6323. * Return: CDF status
  6324. */
  6325. QDF_STATUS send_aggr_qos_cmd_tlv(wmi_unified_t wmi_handle,
  6326. struct aggr_add_ts_param *aggr_qos_rsp_msg)
  6327. {
  6328. int i = 0;
  6329. wmi_vdev_wmm_addts_cmd_fixed_param *cmd;
  6330. wmi_buf_t buf;
  6331. int32_t len = sizeof(*cmd);
  6332. for (i = 0; i < WMI_QOS_NUM_AC_MAX; i++) {
  6333. /* if flow in this AC is active */
  6334. if (((1 << i) & aggr_qos_rsp_msg->tspecIdx)) {
  6335. /*
  6336. * as per implementation of wma_add_ts_req() we
  6337. * are not waiting any response from firmware so
  6338. * apart from sending ADDTS to firmware just send
  6339. * success to upper layers
  6340. */
  6341. aggr_qos_rsp_msg->status[i] = QDF_STATUS_SUCCESS;
  6342. buf = wmi_buf_alloc(wmi_handle, len);
  6343. if (!buf) {
  6344. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  6345. return QDF_STATUS_E_NOMEM;
  6346. }
  6347. cmd = (wmi_vdev_wmm_addts_cmd_fixed_param *)
  6348. wmi_buf_data(buf);
  6349. WMITLV_SET_HDR(&cmd->tlv_header,
  6350. WMITLV_TAG_STRUC_wmi_vdev_wmm_addts_cmd_fixed_param,
  6351. WMITLV_GET_STRUCT_TLVLEN
  6352. (wmi_vdev_wmm_addts_cmd_fixed_param));
  6353. cmd->vdev_id = aggr_qos_rsp_msg->sessionId;
  6354. cmd->ac =
  6355. TID_TO_WME_AC(aggr_qos_rsp_msg->tspec[i].tsinfo.
  6356. traffic.userPrio);
  6357. cmd->medium_time_us =
  6358. aggr_qos_rsp_msg->tspec[i].mediumTime * 32;
  6359. cmd->downgrade_type = WMM_AC_DOWNGRADE_DEPRIO;
  6360. WMI_LOGD("%s:%d: Addts vdev:%d, ac:%d, mediumTime:%d downgrade_type:%d",
  6361. __func__, __LINE__, cmd->vdev_id, cmd->ac,
  6362. cmd->medium_time_us, cmd->downgrade_type);
  6363. if (wmi_unified_cmd_send
  6364. (wmi_handle, buf, len,
  6365. WMI_VDEV_WMM_ADDTS_CMDID)) {
  6366. WMI_LOGP("%s: Failed to send vdev ADDTS command",
  6367. __func__);
  6368. aggr_qos_rsp_msg->status[i] =
  6369. QDF_STATUS_E_FAILURE;
  6370. qdf_nbuf_free(buf);
  6371. return QDF_STATUS_E_FAILURE;
  6372. }
  6373. }
  6374. }
  6375. return QDF_STATUS_SUCCESS;
  6376. }
  6377. /**
  6378. * send_add_ts_cmd_tlv() - send ADDTS request to fw
  6379. * @wmi_handle: wmi handle
  6380. * @msg: ADDTS params
  6381. *
  6382. * Return: CDF status
  6383. */
  6384. QDF_STATUS send_add_ts_cmd_tlv(wmi_unified_t wmi_handle,
  6385. struct add_ts_param *msg)
  6386. {
  6387. wmi_vdev_wmm_addts_cmd_fixed_param *cmd;
  6388. wmi_buf_t buf;
  6389. int32_t len = sizeof(*cmd);
  6390. msg->status = QDF_STATUS_SUCCESS;
  6391. buf = wmi_buf_alloc(wmi_handle, len);
  6392. if (!buf) {
  6393. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  6394. return QDF_STATUS_E_NOMEM;
  6395. }
  6396. cmd = (wmi_vdev_wmm_addts_cmd_fixed_param *) wmi_buf_data(buf);
  6397. WMITLV_SET_HDR(&cmd->tlv_header,
  6398. WMITLV_TAG_STRUC_wmi_vdev_wmm_addts_cmd_fixed_param,
  6399. WMITLV_GET_STRUCT_TLVLEN
  6400. (wmi_vdev_wmm_addts_cmd_fixed_param));
  6401. cmd->vdev_id = msg->sme_session_id;
  6402. cmd->ac = msg->tspec.tsinfo.traffic.userPrio;
  6403. cmd->medium_time_us = msg->tspec.mediumTime * 32;
  6404. cmd->downgrade_type = WMM_AC_DOWNGRADE_DROP;
  6405. WMI_LOGD("Addts vdev:%d, ac:%d, mediumTime:%d, downgrade_type:%d %s:%d",
  6406. cmd->vdev_id, cmd->ac, cmd->medium_time_us,
  6407. cmd->downgrade_type, __func__, __LINE__);
  6408. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  6409. WMI_VDEV_WMM_ADDTS_CMDID)) {
  6410. WMI_LOGP("%s: Failed to send vdev ADDTS command", __func__);
  6411. msg->status = QDF_STATUS_E_FAILURE;
  6412. qdf_nbuf_free(buf);
  6413. return QDF_STATUS_E_FAILURE;
  6414. }
  6415. return QDF_STATUS_SUCCESS;
  6416. }
  6417. /**
  6418. * send_enable_disable_packet_filter_cmd_tlv() - enable/disable packet filter in target
  6419. * @wmi_handle: wmi handle
  6420. * @vdev_id: vdev id
  6421. * @enable: Flag to enable/disable packet filter
  6422. *
  6423. * Return: 0 for success or error code
  6424. */
  6425. QDF_STATUS send_enable_disable_packet_filter_cmd_tlv(wmi_unified_t wmi_handle,
  6426. uint8_t vdev_id, bool enable)
  6427. {
  6428. int32_t len;
  6429. int ret = 0;
  6430. wmi_buf_t buf;
  6431. WMI_PACKET_FILTER_ENABLE_CMD_fixed_param *cmd;
  6432. len = sizeof(WMI_PACKET_FILTER_ENABLE_CMD_fixed_param);
  6433. buf = wmi_buf_alloc(wmi_handle, len);
  6434. if (!buf) {
  6435. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  6436. return -ENOMEM;
  6437. }
  6438. cmd = (WMI_PACKET_FILTER_ENABLE_CMD_fixed_param *) wmi_buf_data(buf);
  6439. WMITLV_SET_HDR(&cmd->tlv_header,
  6440. WMITLV_TAG_STRUC_wmi_packet_filter_enable_fixed_param,
  6441. WMITLV_GET_STRUCT_TLVLEN(
  6442. WMI_PACKET_FILTER_ENABLE_CMD_fixed_param));
  6443. cmd->vdev_id = vdev_id;
  6444. if (enable)
  6445. cmd->enable = PACKET_FILTER_SET_ENABLE;
  6446. else
  6447. cmd->enable = PACKET_FILTER_SET_DISABLE;
  6448. WMI_LOGE("%s: Packet filter enable %d for vdev_id %d",
  6449. __func__, cmd->enable, vdev_id);
  6450. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6451. WMI_PACKET_FILTER_ENABLE_CMDID);
  6452. if (ret)
  6453. WMI_LOGE("Failed to send packet filter wmi cmd to fw");
  6454. return ret;
  6455. }
  6456. /**
  6457. * send_config_packet_filter_cmd_tlv() - configure packet filter in target
  6458. * @wmi_handle: wmi handle
  6459. * @vdev_id: vdev id
  6460. * @rcv_filter_param: Packet filter parameters
  6461. * @filter_id: Filter id
  6462. * @enable: Flag to add/delete packet filter configuration
  6463. *
  6464. * Return: 0 for success or error code
  6465. */
  6466. QDF_STATUS send_config_packet_filter_cmd_tlv(wmi_unified_t wmi_handle,
  6467. uint8_t vdev_id, struct rcv_pkt_filter_config *rcv_filter_param,
  6468. uint8_t filter_id, bool enable)
  6469. {
  6470. int len, i;
  6471. int err = 0;
  6472. wmi_buf_t buf;
  6473. WMI_PACKET_FILTER_CONFIG_CMD_fixed_param *cmd;
  6474. /* allocate the memory */
  6475. len = sizeof(*cmd);
  6476. buf = wmi_buf_alloc(wmi_handle, len);
  6477. if (!buf) {
  6478. WMI_LOGE("Failed to allocate buffer to send set_param cmd");
  6479. return -ENOMEM;
  6480. }
  6481. cmd = (WMI_PACKET_FILTER_CONFIG_CMD_fixed_param *)wmi_buf_data(buf);
  6482. WMITLV_SET_HDR(&cmd->tlv_header,
  6483. WMITLV_TAG_STRUC_wmi_packet_filter_config_fixed_param,
  6484. WMITLV_GET_STRUCT_TLVLEN
  6485. (WMI_PACKET_FILTER_CONFIG_CMD_fixed_param));
  6486. cmd->vdev_id = vdev_id;
  6487. cmd->filter_id = filter_id;
  6488. if (enable)
  6489. cmd->filter_action = PACKET_FILTER_SET_ACTIVE;
  6490. else
  6491. cmd->filter_action = PACKET_FILTER_SET_INACTIVE;
  6492. if (enable) {
  6493. cmd->num_params = QDF_MIN(
  6494. WMI_PACKET_FILTER_MAX_CMP_PER_PACKET_FILTER,
  6495. rcv_filter_param->numFieldParams);
  6496. cmd->filter_type = rcv_filter_param->filterType;
  6497. cmd->coalesce_time = rcv_filter_param->coalesceTime;
  6498. for (i = 0; i < cmd->num_params; i++) {
  6499. cmd->paramsData[i].proto_type =
  6500. rcv_filter_param->paramsData[i].protocolLayer;
  6501. cmd->paramsData[i].cmp_type =
  6502. rcv_filter_param->paramsData[i].cmpFlag;
  6503. cmd->paramsData[i].data_length =
  6504. rcv_filter_param->paramsData[i].dataLength;
  6505. cmd->paramsData[i].data_offset =
  6506. rcv_filter_param->paramsData[i].dataOffset;
  6507. memcpy(&cmd->paramsData[i].compareData,
  6508. rcv_filter_param->paramsData[i].compareData,
  6509. sizeof(cmd->paramsData[i].compareData));
  6510. memcpy(&cmd->paramsData[i].dataMask,
  6511. rcv_filter_param->paramsData[i].dataMask,
  6512. sizeof(cmd->paramsData[i].dataMask));
  6513. }
  6514. }
  6515. WMI_LOGE("Packet filter action %d filter with id: %d, num_params=%d",
  6516. cmd->filter_action, cmd->filter_id, cmd->num_params);
  6517. /* send the command along with data */
  6518. err = wmi_unified_cmd_send(wmi_handle, buf, len,
  6519. WMI_PACKET_FILTER_CONFIG_CMDID);
  6520. if (err) {
  6521. WMI_LOGE("Failed to send pkt_filter cmd");
  6522. wmi_buf_free(buf);
  6523. return -EIO;
  6524. }
  6525. return 0;
  6526. }
  6527. /**
  6528. * send_add_clear_mcbc_filter_cmd_tlv() - set mcast filter command to fw
  6529. * @wmi_handle: wmi handle
  6530. * @vdev_id: vdev id
  6531. * @multicastAddr: mcast address
  6532. * @clearList: clear list flag
  6533. *
  6534. * Return: 0 for success or error code
  6535. */
  6536. QDF_STATUS send_add_clear_mcbc_filter_cmd_tlv(wmi_unified_t wmi_handle,
  6537. uint8_t vdev_id,
  6538. struct qdf_mac_addr multicast_addr,
  6539. bool clearList)
  6540. {
  6541. WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param *cmd;
  6542. wmi_buf_t buf;
  6543. int err;
  6544. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  6545. if (!buf) {
  6546. WMI_LOGE("Failed to allocate buffer to send set_param cmd");
  6547. return -ENOMEM;
  6548. }
  6549. cmd = (WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param *) wmi_buf_data(buf);
  6550. qdf_mem_zero(cmd, sizeof(*cmd));
  6551. WMITLV_SET_HDR(&cmd->tlv_header,
  6552. WMITLV_TAG_STRUC_WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param,
  6553. WMITLV_GET_STRUCT_TLVLEN
  6554. (WMI_SET_MCASTBCAST_FILTER_CMD_fixed_param));
  6555. cmd->action =
  6556. (clearList ? WMI_MCAST_FILTER_DELETE : WMI_MCAST_FILTER_SET);
  6557. cmd->vdev_id = vdev_id;
  6558. WMI_CHAR_ARRAY_TO_MAC_ADDR(multicast_addr.bytes, &cmd->mcastbdcastaddr);
  6559. err = wmi_unified_cmd_send(wmi_handle, buf,
  6560. sizeof(*cmd),
  6561. WMI_SET_MCASTBCAST_FILTER_CMDID);
  6562. if (err) {
  6563. WMI_LOGE("Failed to send set_param cmd");
  6564. qdf_mem_free(buf);
  6565. return -EIO;
  6566. }
  6567. WMI_LOGD("Action:%d; vdev_id:%d; clearList:%d",
  6568. cmd->action, vdev_id, clearList);
  6569. WMI_LOGD("MCBC MAC Addr: "MAC_ADDRESS_STR,
  6570. MAC_ADDR_ARRAY(multicast_addr.bytes));
  6571. return 0;
  6572. }
  6573. /**
  6574. * send_gtk_offload_cmd_tlv() - send GTK offload command to fw
  6575. * @wmi_handle: wmi handle
  6576. * @vdev_id: vdev id
  6577. * @params: GTK offload parameters
  6578. *
  6579. * Return: CDF status
  6580. */
  6581. QDF_STATUS send_gtk_offload_cmd_tlv(wmi_unified_t wmi_handle, uint8_t vdev_id,
  6582. struct gtk_offload_params *params,
  6583. bool enable_offload,
  6584. uint32_t gtk_offload_opcode)
  6585. {
  6586. int len;
  6587. wmi_buf_t buf;
  6588. WMI_GTK_OFFLOAD_CMD_fixed_param *cmd;
  6589. QDF_STATUS status = QDF_STATUS_SUCCESS;
  6590. WMI_LOGD("%s Enter", __func__);
  6591. len = sizeof(*cmd);
  6592. /* alloc wmi buffer */
  6593. buf = wmi_buf_alloc(wmi_handle, len);
  6594. if (!buf) {
  6595. WMI_LOGE("wmi_buf_alloc failed for WMI_GTK_OFFLOAD_CMD");
  6596. status = QDF_STATUS_E_NOMEM;
  6597. goto out;
  6598. }
  6599. cmd = (WMI_GTK_OFFLOAD_CMD_fixed_param *) wmi_buf_data(buf);
  6600. WMITLV_SET_HDR(&cmd->tlv_header,
  6601. WMITLV_TAG_STRUC_WMI_GTK_OFFLOAD_CMD_fixed_param,
  6602. WMITLV_GET_STRUCT_TLVLEN
  6603. (WMI_GTK_OFFLOAD_CMD_fixed_param));
  6604. cmd->vdev_id = vdev_id;
  6605. /* Request target to enable GTK offload */
  6606. if (enable_offload) {
  6607. cmd->flags = gtk_offload_opcode;
  6608. /* Copy the keys and replay counter */
  6609. qdf_mem_copy(cmd->KCK, params->aKCK, WMI_GTK_OFFLOAD_KCK_BYTES);
  6610. qdf_mem_copy(cmd->KEK, params->aKEK, WMI_GTK_OFFLOAD_KEK_BYTES);
  6611. qdf_mem_copy(cmd->replay_counter, &params->ullKeyReplayCounter,
  6612. GTK_REPLAY_COUNTER_BYTES);
  6613. } else {
  6614. cmd->flags = gtk_offload_opcode;
  6615. }
  6616. /* send the wmi command */
  6617. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  6618. WMI_GTK_OFFLOAD_CMDID)) {
  6619. WMI_LOGE("Failed to send WMI_GTK_OFFLOAD_CMDID");
  6620. wmi_buf_free(buf);
  6621. status = QDF_STATUS_E_FAILURE;
  6622. }
  6623. WMI_LOGD("VDEVID: %d, GTK_FLAGS: x%x", vdev_id, cmd->flags);
  6624. out:
  6625. WMI_LOGD("%s Exit", __func__);
  6626. return status;
  6627. }
  6628. /**
  6629. * send_process_gtk_offload_getinfo_cmd_tlv() - send GTK offload cmd to fw
  6630. * @wmi_handle: wmi handle
  6631. * @params: GTK offload params
  6632. *
  6633. * Return: CDF status
  6634. */
  6635. QDF_STATUS send_process_gtk_offload_getinfo_cmd_tlv(wmi_unified_t wmi_handle,
  6636. uint8_t vdev_id,
  6637. uint64_t offload_req_opcode)
  6638. {
  6639. int len;
  6640. wmi_buf_t buf;
  6641. WMI_GTK_OFFLOAD_CMD_fixed_param *cmd;
  6642. QDF_STATUS status = QDF_STATUS_SUCCESS;
  6643. len = sizeof(*cmd);
  6644. /* alloc wmi buffer */
  6645. buf = wmi_buf_alloc(wmi_handle, len);
  6646. if (!buf) {
  6647. WMI_LOGE("wmi_buf_alloc failed for WMI_GTK_OFFLOAD_CMD");
  6648. status = QDF_STATUS_E_NOMEM;
  6649. goto out;
  6650. }
  6651. cmd = (WMI_GTK_OFFLOAD_CMD_fixed_param *) wmi_buf_data(buf);
  6652. WMITLV_SET_HDR(&cmd->tlv_header,
  6653. WMITLV_TAG_STRUC_WMI_GTK_OFFLOAD_CMD_fixed_param,
  6654. WMITLV_GET_STRUCT_TLVLEN
  6655. (WMI_GTK_OFFLOAD_CMD_fixed_param));
  6656. /* Request for GTK offload status */
  6657. cmd->flags = offload_req_opcode;
  6658. cmd->vdev_id = vdev_id;
  6659. /* send the wmi command */
  6660. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  6661. WMI_GTK_OFFLOAD_CMDID)) {
  6662. WMI_LOGE("Failed to send WMI_GTK_OFFLOAD_CMDID for req info");
  6663. wmi_buf_free(buf);
  6664. status = QDF_STATUS_E_FAILURE;
  6665. }
  6666. out:
  6667. return status;
  6668. }
  6669. /**
  6670. * send_process_add_periodic_tx_ptrn_cmd_tlv - add periodic tx ptrn
  6671. * @wmi_handle: wmi handle
  6672. * @pAddPeriodicTxPtrnParams: tx ptrn params
  6673. *
  6674. * Retrun: CDF status
  6675. */
  6676. QDF_STATUS send_process_add_periodic_tx_ptrn_cmd_tlv(wmi_unified_t wmi_handle,
  6677. struct periodic_tx_pattern *
  6678. pAddPeriodicTxPtrnParams,
  6679. uint8_t vdev_id)
  6680. {
  6681. WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *cmd;
  6682. wmi_buf_t wmi_buf;
  6683. uint32_t len;
  6684. uint8_t *buf_ptr;
  6685. uint32_t ptrn_len, ptrn_len_aligned;
  6686. int j;
  6687. ptrn_len = pAddPeriodicTxPtrnParams->ucPtrnSize;
  6688. ptrn_len_aligned = roundup(ptrn_len, sizeof(uint32_t));
  6689. len = sizeof(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param) +
  6690. WMI_TLV_HDR_SIZE + ptrn_len_aligned;
  6691. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  6692. if (!wmi_buf) {
  6693. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  6694. return QDF_STATUS_E_NOMEM;
  6695. }
  6696. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  6697. cmd = (WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *) buf_ptr;
  6698. WMITLV_SET_HDR(&cmd->tlv_header,
  6699. WMITLV_TAG_STRUC_WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param,
  6700. WMITLV_GET_STRUCT_TLVLEN
  6701. (WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param));
  6702. /* Pass the pattern id to delete for the corresponding vdev id */
  6703. cmd->vdev_id = vdev_id;
  6704. cmd->pattern_id = pAddPeriodicTxPtrnParams->ucPtrnId;
  6705. cmd->timeout = pAddPeriodicTxPtrnParams->usPtrnIntervalMs;
  6706. cmd->length = pAddPeriodicTxPtrnParams->ucPtrnSize;
  6707. /* Pattern info */
  6708. buf_ptr += sizeof(WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param);
  6709. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ptrn_len_aligned);
  6710. buf_ptr += WMI_TLV_HDR_SIZE;
  6711. qdf_mem_copy(buf_ptr, pAddPeriodicTxPtrnParams->ucPattern, ptrn_len);
  6712. for (j = 0; j < pAddPeriodicTxPtrnParams->ucPtrnSize; j++)
  6713. WMI_LOGD("%s: Add Ptrn: %02x", __func__, buf_ptr[j] & 0xff);
  6714. WMI_LOGD("%s: Add ptrn id: %d vdev_id: %d",
  6715. __func__, cmd->pattern_id, cmd->vdev_id);
  6716. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  6717. WMI_ADD_PROACTIVE_ARP_RSP_PATTERN_CMDID)) {
  6718. WMI_LOGE("%s: failed to add pattern set state command",
  6719. __func__);
  6720. qdf_nbuf_free(wmi_buf);
  6721. return QDF_STATUS_E_FAILURE;
  6722. }
  6723. return QDF_STATUS_SUCCESS;
  6724. }
  6725. /**
  6726. * send_process_del_periodic_tx_ptrn_cmd_tlv - del periodic tx ptrn
  6727. * @wmi_handle: wmi handle
  6728. * @vdev_id: vdev id
  6729. * @pattern_id: pattern id
  6730. *
  6731. * Retrun: CDF status
  6732. */
  6733. QDF_STATUS send_process_del_periodic_tx_ptrn_cmd_tlv(wmi_unified_t wmi_handle,
  6734. uint8_t vdev_id,
  6735. uint8_t pattern_id)
  6736. {
  6737. WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *cmd;
  6738. wmi_buf_t wmi_buf;
  6739. uint32_t len =
  6740. sizeof(WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param);
  6741. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  6742. if (!wmi_buf) {
  6743. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  6744. return QDF_STATUS_E_NOMEM;
  6745. }
  6746. cmd = (WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param *)
  6747. wmi_buf_data(wmi_buf);
  6748. WMITLV_SET_HDR(&cmd->tlv_header,
  6749. WMITLV_TAG_STRUC_WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param,
  6750. WMITLV_GET_STRUCT_TLVLEN
  6751. (WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMD_fixed_param));
  6752. /* Pass the pattern id to delete for the corresponding vdev id */
  6753. cmd->vdev_id = vdev_id;
  6754. cmd->pattern_id = pattern_id;
  6755. WMI_LOGD("%s: Del ptrn id: %d vdev_id: %d",
  6756. __func__, cmd->pattern_id, cmd->vdev_id);
  6757. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  6758. WMI_DEL_PROACTIVE_ARP_RSP_PATTERN_CMDID)) {
  6759. WMI_LOGE("%s: failed to send del pattern command", __func__);
  6760. qdf_nbuf_free(wmi_buf);
  6761. return QDF_STATUS_E_FAILURE;
  6762. }
  6763. return QDF_STATUS_SUCCESS;
  6764. }
  6765. /**
  6766. * send_stats_ext_req_cmd_tlv() - request ext stats from fw
  6767. * @wmi_handle: wmi handle
  6768. * @preq: stats ext params
  6769. *
  6770. * Return: CDF status
  6771. */
  6772. QDF_STATUS send_stats_ext_req_cmd_tlv(wmi_unified_t wmi_handle,
  6773. struct stats_ext_params *preq)
  6774. {
  6775. int32_t ret;
  6776. wmi_req_stats_ext_cmd_fixed_param *cmd;
  6777. wmi_buf_t buf;
  6778. uint16_t len;
  6779. uint8_t *buf_ptr;
  6780. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + preq->request_data_len;
  6781. buf = wmi_buf_alloc(wmi_handle, len);
  6782. if (!buf) {
  6783. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  6784. return -ENOMEM;
  6785. }
  6786. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  6787. cmd = (wmi_req_stats_ext_cmd_fixed_param *) buf_ptr;
  6788. WMITLV_SET_HDR(&cmd->tlv_header,
  6789. WMITLV_TAG_STRUC_wmi_req_stats_ext_cmd_fixed_param,
  6790. WMITLV_GET_STRUCT_TLVLEN
  6791. (wmi_req_stats_ext_cmd_fixed_param));
  6792. cmd->vdev_id = preq->vdev_id;
  6793. cmd->data_len = preq->request_data_len;
  6794. WMI_LOGD("%s: The data len value is %u and vdev id set is %u ",
  6795. __func__, preq->request_data_len, preq->vdev_id);
  6796. buf_ptr += sizeof(wmi_req_stats_ext_cmd_fixed_param);
  6797. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, cmd->data_len);
  6798. buf_ptr += WMI_TLV_HDR_SIZE;
  6799. qdf_mem_copy(buf_ptr, preq->request_data, cmd->data_len);
  6800. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6801. WMI_REQUEST_STATS_EXT_CMDID);
  6802. if (ret != EOK) {
  6803. WMI_LOGE("%s: Failed to send notify cmd ret = %d", __func__,
  6804. ret);
  6805. wmi_buf_free(buf);
  6806. }
  6807. return ret;
  6808. }
  6809. /**
  6810. * send_enable_ext_wow_cmd_tlv() - enable ext wow in fw
  6811. * @wmi_handle: wmi handle
  6812. * @params: ext wow params
  6813. *
  6814. * Return:0 for success or error code
  6815. */
  6816. QDF_STATUS send_enable_ext_wow_cmd_tlv(wmi_unified_t wmi_handle,
  6817. struct ext_wow_params *params)
  6818. {
  6819. wmi_extwow_enable_cmd_fixed_param *cmd;
  6820. wmi_buf_t buf;
  6821. int32_t len;
  6822. int ret;
  6823. len = sizeof(wmi_extwow_enable_cmd_fixed_param);
  6824. buf = wmi_buf_alloc(wmi_handle, len);
  6825. if (!buf) {
  6826. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  6827. return QDF_STATUS_E_NOMEM;
  6828. }
  6829. cmd = (wmi_extwow_enable_cmd_fixed_param *) wmi_buf_data(buf);
  6830. WMITLV_SET_HDR(&cmd->tlv_header,
  6831. WMITLV_TAG_STRUC_wmi_extwow_enable_cmd_fixed_param,
  6832. WMITLV_GET_STRUCT_TLVLEN
  6833. (wmi_extwow_enable_cmd_fixed_param));
  6834. cmd->vdev_id = params->vdev_id;
  6835. cmd->type = params->type;
  6836. cmd->wakeup_pin_num = params->wakeup_pin_num;
  6837. WMI_LOGD("%s: vdev_id %d type %d Wakeup_pin_num %x",
  6838. __func__, cmd->vdev_id, cmd->type, cmd->wakeup_pin_num);
  6839. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6840. WMI_EXTWOW_ENABLE_CMDID);
  6841. if (ret) {
  6842. WMI_LOGE("%s: Failed to set EXTWOW Enable", __func__);
  6843. wmi_buf_free(buf);
  6844. return QDF_STATUS_E_FAILURE;
  6845. }
  6846. return QDF_STATUS_SUCCESS;
  6847. }
  6848. /**
  6849. * send_app_type1_params_in_fw_cmd_tlv() - set app type1 params in fw
  6850. * @wmi_handle: wmi handle
  6851. * @app_type1_params: app type1 params
  6852. *
  6853. * Return: CDF status
  6854. */
  6855. QDF_STATUS send_app_type1_params_in_fw_cmd_tlv(wmi_unified_t wmi_handle,
  6856. struct app_type1_params *app_type1_params)
  6857. {
  6858. wmi_extwow_set_app_type1_params_cmd_fixed_param *cmd;
  6859. wmi_buf_t buf;
  6860. int32_t len;
  6861. int ret;
  6862. len = sizeof(wmi_extwow_set_app_type1_params_cmd_fixed_param);
  6863. buf = wmi_buf_alloc(wmi_handle, len);
  6864. if (!buf) {
  6865. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  6866. return QDF_STATUS_E_NOMEM;
  6867. }
  6868. cmd = (wmi_extwow_set_app_type1_params_cmd_fixed_param *)
  6869. wmi_buf_data(buf);
  6870. WMITLV_SET_HDR(&cmd->tlv_header,
  6871. WMITLV_TAG_STRUC_wmi_extwow_set_app_type1_params_cmd_fixed_param,
  6872. WMITLV_GET_STRUCT_TLVLEN
  6873. (wmi_extwow_set_app_type1_params_cmd_fixed_param));
  6874. cmd->vdev_id = app_type1_params->vdev_id;
  6875. WMI_CHAR_ARRAY_TO_MAC_ADDR(app_type1_params->wakee_mac_addr.bytes,
  6876. &cmd->wakee_mac);
  6877. qdf_mem_copy(cmd->ident, app_type1_params->identification_id, 8);
  6878. cmd->ident_len = app_type1_params->id_length;
  6879. qdf_mem_copy(cmd->passwd, app_type1_params->password, 16);
  6880. cmd->passwd_len = app_type1_params->pass_length;
  6881. WMI_LOGD("%s: vdev_id %d wakee_mac_addr %pM "
  6882. "identification_id %.8s id_length %u "
  6883. "password %.16s pass_length %u",
  6884. __func__, cmd->vdev_id, app_type1_params->wakee_mac_addr.bytes,
  6885. cmd->ident, cmd->ident_len, cmd->passwd, cmd->passwd_len);
  6886. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6887. WMI_EXTWOW_SET_APP_TYPE1_PARAMS_CMDID);
  6888. if (ret) {
  6889. WMI_LOGE("%s: Failed to set APP TYPE1 PARAMS", __func__);
  6890. wmi_buf_free(buf);
  6891. return QDF_STATUS_E_FAILURE;
  6892. }
  6893. return QDF_STATUS_SUCCESS;
  6894. }
  6895. /**
  6896. * send_set_app_type2_params_in_fw_cmd_tlv() - set app type2 params in fw
  6897. * @wmi_handle: wmi handle
  6898. * @appType2Params: app type2 params
  6899. *
  6900. * Return: CDF status
  6901. */
  6902. QDF_STATUS send_set_app_type2_params_in_fw_cmd_tlv(wmi_unified_t wmi_handle,
  6903. struct app_type2_params *appType2Params)
  6904. {
  6905. wmi_extwow_set_app_type2_params_cmd_fixed_param *cmd;
  6906. wmi_buf_t buf;
  6907. int32_t len;
  6908. int ret;
  6909. len = sizeof(wmi_extwow_set_app_type2_params_cmd_fixed_param);
  6910. buf = wmi_buf_alloc(wmi_handle, len);
  6911. if (!buf) {
  6912. WMI_LOGE("%s: Failed allocate wmi buffer", __func__);
  6913. return QDF_STATUS_E_NOMEM;
  6914. }
  6915. cmd = (wmi_extwow_set_app_type2_params_cmd_fixed_param *)
  6916. wmi_buf_data(buf);
  6917. WMITLV_SET_HDR(&cmd->tlv_header,
  6918. WMITLV_TAG_STRUC_wmi_extwow_set_app_type2_params_cmd_fixed_param,
  6919. WMITLV_GET_STRUCT_TLVLEN
  6920. (wmi_extwow_set_app_type2_params_cmd_fixed_param));
  6921. cmd->vdev_id = appType2Params->vdev_id;
  6922. qdf_mem_copy(cmd->rc4_key, appType2Params->rc4_key, 16);
  6923. cmd->rc4_key_len = appType2Params->rc4_key_len;
  6924. cmd->ip_id = appType2Params->ip_id;
  6925. cmd->ip_device_ip = appType2Params->ip_device_ip;
  6926. cmd->ip_server_ip = appType2Params->ip_server_ip;
  6927. cmd->tcp_src_port = appType2Params->tcp_src_port;
  6928. cmd->tcp_dst_port = appType2Params->tcp_dst_port;
  6929. cmd->tcp_seq = appType2Params->tcp_seq;
  6930. cmd->tcp_ack_seq = appType2Params->tcp_ack_seq;
  6931. cmd->keepalive_init = appType2Params->keepalive_init;
  6932. cmd->keepalive_min = appType2Params->keepalive_min;
  6933. cmd->keepalive_max = appType2Params->keepalive_max;
  6934. cmd->keepalive_inc = appType2Params->keepalive_inc;
  6935. WMI_CHAR_ARRAY_TO_MAC_ADDR(appType2Params->gateway_mac.bytes,
  6936. &cmd->gateway_mac);
  6937. cmd->tcp_tx_timeout_val = appType2Params->tcp_tx_timeout_val;
  6938. cmd->tcp_rx_timeout_val = appType2Params->tcp_rx_timeout_val;
  6939. WMI_LOGD("%s: vdev_id %d gateway_mac %pM "
  6940. "rc4_key %.16s rc4_key_len %u "
  6941. "ip_id %x ip_device_ip %x ip_server_ip %x "
  6942. "tcp_src_port %u tcp_dst_port %u tcp_seq %u "
  6943. "tcp_ack_seq %u keepalive_init %u keepalive_min %u "
  6944. "keepalive_max %u keepalive_inc %u "
  6945. "tcp_tx_timeout_val %u tcp_rx_timeout_val %u",
  6946. __func__, cmd->vdev_id, appType2Params->gateway_mac.bytes,
  6947. cmd->rc4_key, cmd->rc4_key_len,
  6948. cmd->ip_id, cmd->ip_device_ip, cmd->ip_server_ip,
  6949. cmd->tcp_src_port, cmd->tcp_dst_port, cmd->tcp_seq,
  6950. cmd->tcp_ack_seq, cmd->keepalive_init, cmd->keepalive_min,
  6951. cmd->keepalive_max, cmd->keepalive_inc,
  6952. cmd->tcp_tx_timeout_val, cmd->tcp_rx_timeout_val);
  6953. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  6954. WMI_EXTWOW_SET_APP_TYPE2_PARAMS_CMDID);
  6955. if (ret) {
  6956. WMI_LOGE("%s: Failed to set APP TYPE2 PARAMS", __func__);
  6957. wmi_buf_free(buf);
  6958. return QDF_STATUS_E_FAILURE;
  6959. }
  6960. return QDF_STATUS_SUCCESS;
  6961. }
  6962. /**
  6963. * send_set_auto_shutdown_timer_cmd_tlv() - sets auto shutdown timer in firmware
  6964. * @wmi_handle: wmi handle
  6965. * @timer_val: auto shutdown timer value
  6966. *
  6967. * Return: CDF status
  6968. */
  6969. QDF_STATUS send_set_auto_shutdown_timer_cmd_tlv(wmi_unified_t wmi_handle,
  6970. uint32_t timer_val)
  6971. {
  6972. int status = 0;
  6973. wmi_buf_t buf = NULL;
  6974. uint8_t *buf_ptr;
  6975. wmi_host_auto_shutdown_cfg_cmd_fixed_param *wmi_auto_sh_cmd;
  6976. int len = sizeof(wmi_host_auto_shutdown_cfg_cmd_fixed_param);
  6977. WMI_LOGD("%s: Set WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID:TIMER_VAL=%d",
  6978. __func__, timer_val);
  6979. buf = wmi_buf_alloc(wmi_handle, len);
  6980. if (!buf) {
  6981. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  6982. return QDF_STATUS_E_NOMEM;
  6983. }
  6984. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  6985. wmi_auto_sh_cmd =
  6986. (wmi_host_auto_shutdown_cfg_cmd_fixed_param *) buf_ptr;
  6987. wmi_auto_sh_cmd->timer_value = timer_val;
  6988. WMITLV_SET_HDR(&wmi_auto_sh_cmd->tlv_header,
  6989. WMITLV_TAG_STRUC_wmi_host_auto_shutdown_cfg_cmd_fixed_param,
  6990. WMITLV_GET_STRUCT_TLVLEN
  6991. (wmi_host_auto_shutdown_cfg_cmd_fixed_param));
  6992. status = wmi_unified_cmd_send(wmi_handle, buf,
  6993. len, WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID);
  6994. if (status != EOK) {
  6995. WMI_LOGE("%s: WMI_HOST_AUTO_SHUTDOWN_CFG_CMDID Err %d",
  6996. __func__, status);
  6997. wmi_buf_free(buf);
  6998. return QDF_STATUS_E_FAILURE;
  6999. }
  7000. return QDF_STATUS_SUCCESS;
  7001. }
  7002. /**
  7003. * send_nan_req_cmd_tlv() - to send nan request to target
  7004. * @wmi_handle: wmi handle
  7005. * @nan_req: request data which will be non-null
  7006. *
  7007. * Return: CDF status
  7008. */
  7009. QDF_STATUS send_nan_req_cmd_tlv(wmi_unified_t wmi_handle,
  7010. struct nan_req_params *nan_req)
  7011. {
  7012. int ret;
  7013. wmi_nan_cmd_param *cmd;
  7014. wmi_buf_t buf;
  7015. uint16_t len = sizeof(*cmd);
  7016. uint16_t nan_data_len, nan_data_len_aligned;
  7017. uint8_t *buf_ptr;
  7018. /*
  7019. * <----- cmd ------------><-- WMI_TLV_HDR_SIZE --><--- data ---->
  7020. * +------------+----------+-----------------------+--------------+
  7021. * | tlv_header | data_len | WMITLV_TAG_ARRAY_BYTE | nan_req_data |
  7022. * +------------+----------+-----------------------+--------------+
  7023. */
  7024. if (!nan_req) {
  7025. WMI_LOGE("%s:nan req is not valid", __func__);
  7026. return QDF_STATUS_E_FAILURE;
  7027. }
  7028. nan_data_len = nan_req->request_data_len;
  7029. nan_data_len_aligned = roundup(nan_req->request_data_len,
  7030. sizeof(uint32_t));
  7031. len += WMI_TLV_HDR_SIZE + nan_data_len_aligned;
  7032. buf = wmi_buf_alloc(wmi_handle, len);
  7033. if (!buf) {
  7034. WMI_LOGE("%s:wmi_buf_alloc failed", __func__);
  7035. return QDF_STATUS_E_NOMEM;
  7036. }
  7037. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  7038. cmd = (wmi_nan_cmd_param *) buf_ptr;
  7039. WMITLV_SET_HDR(&cmd->tlv_header,
  7040. WMITLV_TAG_STRUC_wmi_nan_cmd_param,
  7041. WMITLV_GET_STRUCT_TLVLEN(wmi_nan_cmd_param));
  7042. cmd->data_len = nan_req->request_data_len;
  7043. WMI_LOGD("%s: The data len value is %u",
  7044. __func__, nan_req->request_data_len);
  7045. buf_ptr += sizeof(wmi_nan_cmd_param);
  7046. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, nan_data_len_aligned);
  7047. buf_ptr += WMI_TLV_HDR_SIZE;
  7048. qdf_mem_copy(buf_ptr, nan_req->request_data, cmd->data_len);
  7049. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  7050. WMI_NAN_CMDID);
  7051. if (ret != EOK) {
  7052. WMI_LOGE("%s Failed to send set param command ret = %d",
  7053. __func__, ret);
  7054. wmi_buf_free(buf);
  7055. }
  7056. return ret;
  7057. }
  7058. /**
  7059. * send_process_dhcpserver_offload_cmd_tlv() - enable DHCP server offload
  7060. * @wmi_handle: wmi handle
  7061. * @pDhcpSrvOffloadInfo: DHCP server offload info
  7062. *
  7063. * Return: 0 for success or error code
  7064. */
  7065. QDF_STATUS send_process_dhcpserver_offload_cmd_tlv(wmi_unified_t wmi_handle,
  7066. struct dhcp_offload_info_params *pDhcpSrvOffloadInfo)
  7067. {
  7068. wmi_set_dhcp_server_offload_cmd_fixed_param *cmd;
  7069. wmi_buf_t buf;
  7070. int err;
  7071. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  7072. if (!buf) {
  7073. WMI_LOGE("Failed to allocate buffer to send "
  7074. "set_dhcp_server_offload cmd");
  7075. return -ENOMEM;
  7076. }
  7077. cmd = (wmi_set_dhcp_server_offload_cmd_fixed_param *) wmi_buf_data(buf);
  7078. qdf_mem_zero(cmd, sizeof(*cmd));
  7079. WMITLV_SET_HDR(&cmd->tlv_header,
  7080. WMITLV_TAG_STRUC_wmi_set_dhcp_server_offload_cmd_fixed_param,
  7081. WMITLV_GET_STRUCT_TLVLEN
  7082. (wmi_set_dhcp_server_offload_cmd_fixed_param));
  7083. cmd->vdev_id = pDhcpSrvOffloadInfo->vdev_id;
  7084. cmd->enable = pDhcpSrvOffloadInfo->dhcpSrvOffloadEnabled;
  7085. cmd->num_client = pDhcpSrvOffloadInfo->dhcpClientNum;
  7086. cmd->srv_ipv4 = pDhcpSrvOffloadInfo->dhcpSrvIP;
  7087. cmd->start_lsb = 0;
  7088. err = wmi_unified_cmd_send(wmi_handle, buf,
  7089. sizeof(*cmd),
  7090. WMI_SET_DHCP_SERVER_OFFLOAD_CMDID);
  7091. if (err) {
  7092. WMI_LOGE("Failed to send set_dhcp_server_offload cmd");
  7093. wmi_buf_free(buf);
  7094. return -EIO;
  7095. }
  7096. WMI_LOGD("Set dhcp server offload to vdevId %d",
  7097. pDhcpSrvOffloadInfo->vdev_id);
  7098. return 0;
  7099. }
  7100. /**
  7101. * send_set_led_flashing_cmd_tlv() - set led flashing in fw
  7102. * @wmi_handle: wmi handle
  7103. * @flashing: flashing request
  7104. *
  7105. * Return: CDF status
  7106. */
  7107. QDF_STATUS send_set_led_flashing_cmd_tlv(wmi_unified_t wmi_handle,
  7108. struct flashing_req_params *flashing)
  7109. {
  7110. wmi_set_led_flashing_cmd_fixed_param *cmd;
  7111. int status = 0;
  7112. wmi_buf_t buf;
  7113. uint8_t *buf_ptr;
  7114. int32_t len = sizeof(wmi_set_led_flashing_cmd_fixed_param);
  7115. buf = wmi_buf_alloc(wmi_handle, len);
  7116. if (!buf) {
  7117. WMI_LOGP(FL("wmi_buf_alloc failed"));
  7118. return -ENOMEM;
  7119. }
  7120. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  7121. cmd = (wmi_set_led_flashing_cmd_fixed_param *) buf_ptr;
  7122. WMITLV_SET_HDR(&cmd->tlv_header,
  7123. WMITLV_TAG_STRUC_wmi_set_led_flashing_cmd_fixed_param,
  7124. WMITLV_GET_STRUCT_TLVLEN
  7125. (wmi_set_led_flashing_cmd_fixed_param));
  7126. cmd->pattern_id = flashing->pattern_id;
  7127. cmd->led_x0 = flashing->led_x0;
  7128. cmd->led_x1 = flashing->led_x1;
  7129. status = wmi_unified_cmd_send(wmi_handle, buf, len,
  7130. WMI_PDEV_SET_LED_FLASHING_CMDID);
  7131. if (status != EOK) {
  7132. WMI_LOGE("%s: wmi_unified_cmd_send WMI_PEER_SET_PARAM_CMD"
  7133. " returned Error %d", __func__, status);
  7134. return QDF_STATUS_E_FAILURE;
  7135. }
  7136. return QDF_STATUS_SUCCESS;
  7137. }
  7138. /**
  7139. * send_process_ch_avoid_update_cmd_tlv() - handles channel avoid update request
  7140. * @wmi_handle: wmi handle
  7141. * @ch_avoid_update_req: channel avoid update params
  7142. *
  7143. * Return: CDF status
  7144. */
  7145. QDF_STATUS send_process_ch_avoid_update_cmd_tlv(wmi_unified_t wmi_handle)
  7146. {
  7147. int status = 0;
  7148. wmi_buf_t buf = NULL;
  7149. uint8_t *buf_ptr;
  7150. wmi_chan_avoid_update_cmd_param *ch_avoid_update_fp;
  7151. int len = sizeof(wmi_chan_avoid_update_cmd_param);
  7152. buf = wmi_buf_alloc(wmi_handle, len);
  7153. if (!buf) {
  7154. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  7155. return QDF_STATUS_E_NOMEM;
  7156. }
  7157. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  7158. ch_avoid_update_fp = (wmi_chan_avoid_update_cmd_param *) buf_ptr;
  7159. WMITLV_SET_HDR(&ch_avoid_update_fp->tlv_header,
  7160. WMITLV_TAG_STRUC_wmi_chan_avoid_update_cmd_param,
  7161. WMITLV_GET_STRUCT_TLVLEN
  7162. (wmi_chan_avoid_update_cmd_param));
  7163. status = wmi_unified_cmd_send(wmi_handle, buf,
  7164. len, WMI_CHAN_AVOID_UPDATE_CMDID);
  7165. if (status != EOK) {
  7166. WMI_LOGE("wmi_unified_cmd_send"
  7167. " WMITLV_TABLE_WMI_CHAN_AVOID_UPDATE"
  7168. " returned Error %d", status);
  7169. wmi_buf_free(buf);
  7170. return QDF_STATUS_E_FAILURE;
  7171. }
  7172. return QDF_STATUS_SUCCESS;
  7173. }
  7174. /**
  7175. * send_regdomain_info_to_fw_cmd_tlv() - send regdomain info to fw
  7176. * @wmi_handle: wmi handle
  7177. * @reg_dmn: reg domain
  7178. * @regdmn2G: 2G reg domain
  7179. * @regdmn5G: 5G reg domain
  7180. * @ctl2G: 2G test limit
  7181. * @ctl5G: 5G test limit
  7182. *
  7183. * Return: none
  7184. */
  7185. QDF_STATUS send_regdomain_info_to_fw_cmd_tlv(wmi_unified_t wmi_handle,
  7186. uint32_t reg_dmn, uint16_t regdmn2G,
  7187. uint16_t regdmn5G, int8_t ctl2G,
  7188. int8_t ctl5G)
  7189. {
  7190. wmi_buf_t buf;
  7191. wmi_pdev_set_regdomain_cmd_fixed_param *cmd;
  7192. int32_t len = sizeof(*cmd);
  7193. buf = wmi_buf_alloc(wmi_handle, len);
  7194. if (!buf) {
  7195. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  7196. return QDF_STATUS_E_NOMEM;
  7197. }
  7198. cmd = (wmi_pdev_set_regdomain_cmd_fixed_param *) wmi_buf_data(buf);
  7199. WMITLV_SET_HDR(&cmd->tlv_header,
  7200. WMITLV_TAG_STRUC_wmi_pdev_set_regdomain_cmd_fixed_param,
  7201. WMITLV_GET_STRUCT_TLVLEN
  7202. (wmi_pdev_set_regdomain_cmd_fixed_param));
  7203. cmd->reg_domain = reg_dmn;
  7204. cmd->reg_domain_2G = regdmn2G;
  7205. cmd->reg_domain_5G = regdmn5G;
  7206. cmd->conformance_test_limit_2G = ctl2G;
  7207. cmd->conformance_test_limit_5G = ctl5G;
  7208. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  7209. WMI_PDEV_SET_REGDOMAIN_CMDID)) {
  7210. WMI_LOGP("%s: Failed to send pdev set regdomain command",
  7211. __func__);
  7212. qdf_nbuf_free(buf);
  7213. return QDF_STATUS_E_FAILURE;
  7214. }
  7215. return QDF_STATUS_SUCCESS;
  7216. }
  7217. /**
  7218. * send_set_tdls_offchan_mode_cmd_tlv() - set tdls off channel mode
  7219. * @wmi_handle: wmi handle
  7220. * @chan_switch_params: Pointer to tdls channel switch parameter structure
  7221. *
  7222. * This function sets tdls off channel mode
  7223. *
  7224. * Return: 0 on success; Negative errno otherwise
  7225. */
  7226. QDF_STATUS send_set_tdls_offchan_mode_cmd_tlv(wmi_unified_t wmi_handle,
  7227. struct tdls_channel_switch_params *chan_switch_params)
  7228. {
  7229. wmi_tdls_set_offchan_mode_cmd_fixed_param *cmd;
  7230. wmi_buf_t wmi_buf;
  7231. u_int16_t len = sizeof(wmi_tdls_set_offchan_mode_cmd_fixed_param);
  7232. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  7233. if (!wmi_buf) {
  7234. WMI_LOGE(FL("wmi_buf_alloc failed"));
  7235. return QDF_STATUS_E_FAILURE;
  7236. }
  7237. cmd = (wmi_tdls_set_offchan_mode_cmd_fixed_param *)
  7238. wmi_buf_data(wmi_buf);
  7239. WMITLV_SET_HDR(&cmd->tlv_header,
  7240. WMITLV_TAG_STRUC_wmi_tdls_set_offchan_mode_cmd_fixed_param,
  7241. WMITLV_GET_STRUCT_TLVLEN(
  7242. wmi_tdls_set_offchan_mode_cmd_fixed_param));
  7243. WMI_CHAR_ARRAY_TO_MAC_ADDR(chan_switch_params->peer_mac_addr,
  7244. &cmd->peer_macaddr);
  7245. cmd->vdev_id = chan_switch_params->vdev_id;
  7246. cmd->offchan_mode = chan_switch_params->tdls_sw_mode;
  7247. cmd->is_peer_responder = chan_switch_params->is_responder;
  7248. cmd->offchan_num = chan_switch_params->tdls_off_ch;
  7249. cmd->offchan_bw_bitmap = chan_switch_params->tdls_off_ch_bw_offset;
  7250. cmd->offchan_oper_class = chan_switch_params->oper_class;
  7251. WMI_LOGD(FL("Peer MAC Addr mac_addr31to0: 0x%x, mac_addr47to32: 0x%x"),
  7252. cmd->peer_macaddr.mac_addr31to0,
  7253. cmd->peer_macaddr.mac_addr47to32);
  7254. WMI_LOGD(FL(
  7255. "vdev_id: %d, off channel mode: %d, off channel Num: %d, "
  7256. "off channel offset: 0x%x, is_peer_responder: %d, operating class: %d"
  7257. ),
  7258. cmd->vdev_id,
  7259. cmd->offchan_mode,
  7260. cmd->offchan_num,
  7261. cmd->offchan_bw_bitmap,
  7262. cmd->is_peer_responder,
  7263. cmd->offchan_oper_class);
  7264. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  7265. WMI_TDLS_SET_OFFCHAN_MODE_CMDID)) {
  7266. WMI_LOGP(FL("failed to send tdls off chan command"));
  7267. qdf_nbuf_free(wmi_buf);
  7268. return QDF_STATUS_E_FAILURE;
  7269. }
  7270. return QDF_STATUS_SUCCESS;
  7271. }
  7272. /**
  7273. * send_update_fw_tdls_state_cmd_tlv() - send enable/disable tdls for a vdev
  7274. * @wmi_handle: wmi handle
  7275. * @pwmaTdlsparams: TDLS params
  7276. *
  7277. * Return: 0 for sucess or error code
  7278. */
  7279. QDF_STATUS send_update_fw_tdls_state_cmd_tlv(wmi_unified_t wmi_handle,
  7280. void *tdls_param, uint8_t tdls_state)
  7281. {
  7282. wmi_tdls_set_state_cmd_fixed_param *cmd;
  7283. wmi_buf_t wmi_buf;
  7284. struct wmi_tdls_params *wmi_tdls = (struct wmi_tdls_params *) tdls_param;
  7285. uint16_t len = sizeof(wmi_tdls_set_state_cmd_fixed_param);
  7286. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  7287. if (!wmi_buf) {
  7288. WMI_LOGE("%s: wmai_buf_alloc failed", __func__);
  7289. return QDF_STATUS_E_FAILURE;
  7290. }
  7291. cmd = (wmi_tdls_set_state_cmd_fixed_param *) wmi_buf_data(wmi_buf);
  7292. WMITLV_SET_HDR(&cmd->tlv_header,
  7293. WMITLV_TAG_STRUC_wmi_tdls_set_state_cmd_fixed_param,
  7294. WMITLV_GET_STRUCT_TLVLEN
  7295. (wmi_tdls_set_state_cmd_fixed_param));
  7296. cmd->vdev_id = wmi_tdls->vdev_id;
  7297. cmd->state = tdls_state;
  7298. cmd->notification_interval_ms = wmi_tdls->notification_interval_ms;
  7299. cmd->tx_discovery_threshold = wmi_tdls->tx_discovery_threshold;
  7300. cmd->tx_teardown_threshold = wmi_tdls->tx_teardown_threshold;
  7301. cmd->rssi_teardown_threshold = wmi_tdls->rssi_teardown_threshold;
  7302. cmd->rssi_delta = wmi_tdls->rssi_delta;
  7303. cmd->tdls_options = wmi_tdls->tdls_options;
  7304. cmd->tdls_peer_traffic_ind_window = wmi_tdls->peer_traffic_ind_window;
  7305. cmd->tdls_peer_traffic_response_timeout_ms =
  7306. wmi_tdls->peer_traffic_response_timeout;
  7307. cmd->tdls_puapsd_mask = wmi_tdls->puapsd_mask;
  7308. cmd->tdls_puapsd_inactivity_time_ms = wmi_tdls->puapsd_inactivity_time;
  7309. cmd->tdls_puapsd_rx_frame_threshold =
  7310. wmi_tdls->puapsd_rx_frame_threshold;
  7311. cmd->teardown_notification_ms =
  7312. wmi_tdls->teardown_notification_ms;
  7313. cmd->tdls_peer_kickout_threshold =
  7314. wmi_tdls->tdls_peer_kickout_threshold;
  7315. WMI_LOGD("%s: tdls_state: %d, state: %d, "
  7316. "notification_interval_ms: %d, "
  7317. "tx_discovery_threshold: %d, "
  7318. "tx_teardown_threshold: %d, "
  7319. "rssi_teardown_threshold: %d, "
  7320. "rssi_delta: %d, "
  7321. "tdls_options: 0x%x, "
  7322. "tdls_peer_traffic_ind_window: %d, "
  7323. "tdls_peer_traffic_response_timeout: %d, "
  7324. "tdls_puapsd_mask: 0x%x, "
  7325. "tdls_puapsd_inactivity_time: %d, "
  7326. "tdls_puapsd_rx_frame_threshold: %d, "
  7327. "teardown_notification_ms: %d, "
  7328. "tdls_peer_kickout_threshold: %d",
  7329. __func__, tdls_state, cmd->state,
  7330. cmd->notification_interval_ms,
  7331. cmd->tx_discovery_threshold,
  7332. cmd->tx_teardown_threshold,
  7333. cmd->rssi_teardown_threshold,
  7334. cmd->rssi_delta,
  7335. cmd->tdls_options,
  7336. cmd->tdls_peer_traffic_ind_window,
  7337. cmd->tdls_peer_traffic_response_timeout_ms,
  7338. cmd->tdls_puapsd_mask,
  7339. cmd->tdls_puapsd_inactivity_time_ms,
  7340. cmd->tdls_puapsd_rx_frame_threshold,
  7341. cmd->teardown_notification_ms,
  7342. cmd->tdls_peer_kickout_threshold);
  7343. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  7344. WMI_TDLS_SET_STATE_CMDID)) {
  7345. WMI_LOGP("%s: failed to send tdls set state command", __func__);
  7346. qdf_nbuf_free(wmi_buf);
  7347. return QDF_STATUS_E_FAILURE;
  7348. }
  7349. WMI_LOGD("%s: vdev_id %d", __func__, wmi_tdls->vdev_id);
  7350. return QDF_STATUS_SUCCESS;
  7351. }
  7352. /**
  7353. * send_update_tdls_peer_state_cmd_tlv() - update TDLS peer state
  7354. * @wmi_handle: wmi handle
  7355. * @peerStateParams: TDLS peer state params
  7356. *
  7357. * Return: 0 for success or error code
  7358. */
  7359. QDF_STATUS send_update_tdls_peer_state_cmd_tlv(wmi_unified_t wmi_handle,
  7360. struct tdls_peer_state_params *peerStateParams,
  7361. uint32_t *ch_mhz)
  7362. {
  7363. wmi_tdls_peer_update_cmd_fixed_param *cmd;
  7364. wmi_tdls_peer_capabilities *peer_cap;
  7365. wmi_channel *chan_info;
  7366. wmi_buf_t wmi_buf;
  7367. uint8_t *buf_ptr;
  7368. uint32_t i;
  7369. int32_t len = sizeof(wmi_tdls_peer_update_cmd_fixed_param) +
  7370. sizeof(wmi_tdls_peer_capabilities);
  7371. len += WMI_TLV_HDR_SIZE +
  7372. sizeof(wmi_channel) * peerStateParams->peerCap.peerChanLen;
  7373. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  7374. if (!wmi_buf) {
  7375. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  7376. return QDF_STATUS_E_FAILURE;
  7377. }
  7378. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  7379. cmd = (wmi_tdls_peer_update_cmd_fixed_param *) buf_ptr;
  7380. WMITLV_SET_HDR(&cmd->tlv_header,
  7381. WMITLV_TAG_STRUC_wmi_tdls_peer_update_cmd_fixed_param,
  7382. WMITLV_GET_STRUCT_TLVLEN
  7383. (wmi_tdls_peer_update_cmd_fixed_param));
  7384. cmd->vdev_id = peerStateParams->vdevId;
  7385. WMI_CHAR_ARRAY_TO_MAC_ADDR(peerStateParams->peerMacAddr,
  7386. &cmd->peer_macaddr);
  7387. cmd->peer_state = peerStateParams->peerState;
  7388. WMI_LOGD("%s: vdev_id: %d, peerStateParams->peerMacAddr: %pM, "
  7389. "peer_macaddr.mac_addr31to0: 0x%x, "
  7390. "peer_macaddr.mac_addr47to32: 0x%x, peer_state: %d",
  7391. __func__, cmd->vdev_id, peerStateParams->peerMacAddr,
  7392. cmd->peer_macaddr.mac_addr31to0,
  7393. cmd->peer_macaddr.mac_addr47to32, cmd->peer_state);
  7394. buf_ptr += sizeof(wmi_tdls_peer_update_cmd_fixed_param);
  7395. peer_cap = (wmi_tdls_peer_capabilities *) buf_ptr;
  7396. WMITLV_SET_HDR(&peer_cap->tlv_header,
  7397. WMITLV_TAG_STRUC_wmi_tdls_peer_capabilities,
  7398. WMITLV_GET_STRUCT_TLVLEN(wmi_tdls_peer_capabilities));
  7399. if ((peerStateParams->peerCap.peerUapsdQueue & 0x08) >> 3)
  7400. WMI_SET_TDLS_PEER_VO_UAPSD(peer_cap);
  7401. if ((peerStateParams->peerCap.peerUapsdQueue & 0x04) >> 2)
  7402. WMI_SET_TDLS_PEER_VI_UAPSD(peer_cap);
  7403. if ((peerStateParams->peerCap.peerUapsdQueue & 0x02) >> 1)
  7404. WMI_SET_TDLS_PEER_BK_UAPSD(peer_cap);
  7405. if (peerStateParams->peerCap.peerUapsdQueue & 0x01)
  7406. WMI_SET_TDLS_PEER_BE_UAPSD(peer_cap);
  7407. /* Ack and More Data Ack are sent as 0, so no need to set
  7408. * but fill SP
  7409. */
  7410. WMI_SET_TDLS_PEER_SP_UAPSD(peer_cap,
  7411. peerStateParams->peerCap.peerMaxSp);
  7412. peer_cap->buff_sta_support =
  7413. peerStateParams->peerCap.peerBuffStaSupport;
  7414. peer_cap->off_chan_support =
  7415. peerStateParams->peerCap.peerOffChanSupport;
  7416. peer_cap->peer_curr_operclass =
  7417. peerStateParams->peerCap.peerCurrOperClass;
  7418. /* self curr operclass is not being used and so pass op class for
  7419. * preferred off chan in it.
  7420. */
  7421. peer_cap->self_curr_operclass =
  7422. peerStateParams->peerCap.opClassForPrefOffChan;
  7423. peer_cap->peer_chan_len = peerStateParams->peerCap.peerChanLen;
  7424. peer_cap->peer_operclass_len =
  7425. peerStateParams->peerCap.peerOperClassLen;
  7426. WMI_LOGD("%s: peer_operclass_len: %d",
  7427. __func__, peer_cap->peer_operclass_len);
  7428. for (i = 0; i < WMI_TDLS_MAX_SUPP_OPER_CLASSES; i++) {
  7429. peer_cap->peer_operclass[i] =
  7430. peerStateParams->peerCap.peerOperClass[i];
  7431. WMI_LOGD("%s: peer_operclass[%d]: %d",
  7432. __func__, i, peer_cap->peer_operclass[i]);
  7433. }
  7434. peer_cap->is_peer_responder = peerStateParams->peerCap.isPeerResponder;
  7435. peer_cap->pref_offchan_num = peerStateParams->peerCap.prefOffChanNum;
  7436. peer_cap->pref_offchan_bw =
  7437. peerStateParams->peerCap.prefOffChanBandwidth;
  7438. WMI_LOGD
  7439. ("%s: peer_qos: 0x%x, buff_sta_support: %d, off_chan_support: %d, "
  7440. "peer_curr_operclass: %d, self_curr_operclass: %d, peer_chan_len: "
  7441. "%d, peer_operclass_len: %d, is_peer_responder: %d, pref_offchan_num:"
  7442. " %d, pref_offchan_bw: %d",
  7443. __func__, peer_cap->peer_qos, peer_cap->buff_sta_support,
  7444. peer_cap->off_chan_support, peer_cap->peer_curr_operclass,
  7445. peer_cap->self_curr_operclass, peer_cap->peer_chan_len,
  7446. peer_cap->peer_operclass_len, peer_cap->is_peer_responder,
  7447. peer_cap->pref_offchan_num, peer_cap->pref_offchan_bw);
  7448. /* next fill variable size array of peer chan info */
  7449. buf_ptr += sizeof(wmi_tdls_peer_capabilities);
  7450. WMITLV_SET_HDR(buf_ptr,
  7451. WMITLV_TAG_ARRAY_STRUC,
  7452. sizeof(wmi_channel) *
  7453. peerStateParams->peerCap.peerChanLen);
  7454. chan_info = (wmi_channel *) (buf_ptr + WMI_TLV_HDR_SIZE);
  7455. for (i = 0; i < peerStateParams->peerCap.peerChanLen; ++i) {
  7456. WMITLV_SET_HDR(&chan_info->tlv_header,
  7457. WMITLV_TAG_STRUC_wmi_channel,
  7458. WMITLV_GET_STRUCT_TLVLEN(wmi_channel));
  7459. chan_info->mhz = ch_mhz[i];
  7460. chan_info->band_center_freq1 = chan_info->mhz;
  7461. chan_info->band_center_freq2 = 0;
  7462. WMI_LOGD("%s: chan[%d] = %u", __func__, i, chan_info->mhz);
  7463. if (peerStateParams->peerCap.peerChan[i].dfsSet) {
  7464. WMI_SET_CHANNEL_FLAG(chan_info, WMI_CHAN_FLAG_PASSIVE);
  7465. WMI_LOGI("chan[%d] DFS[%d]\n",
  7466. peerStateParams->peerCap.peerChan[i].chanId,
  7467. peerStateParams->peerCap.peerChan[i].dfsSet);
  7468. }
  7469. if (chan_info->mhz < WMI_2_4_GHZ_MAX_FREQ)
  7470. WMI_SET_CHANNEL_MODE(chan_info, MODE_11G);
  7471. else
  7472. WMI_SET_CHANNEL_MODE(chan_info, MODE_11A);
  7473. WMI_SET_CHANNEL_MAX_TX_POWER(chan_info,
  7474. peerStateParams->peerCap.
  7475. peerChan[i].pwr);
  7476. WMI_SET_CHANNEL_REG_POWER(chan_info,
  7477. peerStateParams->peerCap.peerChan[i].
  7478. pwr);
  7479. WMI_LOGD("Channel TX power[%d] = %u: %d", i, chan_info->mhz,
  7480. peerStateParams->peerCap.peerChan[i].pwr);
  7481. chan_info++;
  7482. }
  7483. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  7484. WMI_TDLS_PEER_UPDATE_CMDID)) {
  7485. WMI_LOGE("%s: failed to send tdls peer update state command",
  7486. __func__);
  7487. qdf_nbuf_free(wmi_buf);
  7488. return QDF_STATUS_E_FAILURE;
  7489. }
  7490. return QDF_STATUS_SUCCESS;
  7491. }
  7492. /*
  7493. * send_process_fw_mem_dump_cmd_tlv() - Function to request fw memory dump from
  7494. * firmware
  7495. * @wmi_handle: Pointer to wmi handle
  7496. * @mem_dump_req: Pointer for mem_dump_req
  7497. *
  7498. * This function sends memory dump request to firmware
  7499. *
  7500. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  7501. *
  7502. */
  7503. QDF_STATUS send_process_fw_mem_dump_cmd_tlv(wmi_unified_t wmi_handle,
  7504. struct fw_dump_req_param *mem_dump_req)
  7505. {
  7506. wmi_get_fw_mem_dump_fixed_param *cmd;
  7507. wmi_fw_mem_dump *dump_params;
  7508. struct fw_dump_seg_req *seg_req;
  7509. int32_t len;
  7510. wmi_buf_t buf;
  7511. u_int8_t *buf_ptr;
  7512. int ret, loop;
  7513. /*
  7514. * len = sizeof(fixed param) that includes tlv header +
  7515. * tlv header for array of struc +
  7516. * sizeof (each struct)
  7517. */
  7518. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE;
  7519. len += mem_dump_req->num_seg * sizeof(wmi_fw_mem_dump);
  7520. buf = wmi_buf_alloc(wmi_handle, len);
  7521. if (!buf) {
  7522. WMI_LOGE(FL("Failed allocate wmi buffer"));
  7523. return QDF_STATUS_E_NOMEM;
  7524. }
  7525. buf_ptr = (u_int8_t *) wmi_buf_data(buf);
  7526. qdf_mem_zero(buf_ptr, len);
  7527. cmd = (wmi_get_fw_mem_dump_fixed_param *) buf_ptr;
  7528. WMITLV_SET_HDR(&cmd->tlv_header,
  7529. WMITLV_TAG_STRUC_wmi_get_fw_mem_dump_fixed_param,
  7530. WMITLV_GET_STRUCT_TLVLEN(wmi_get_fw_mem_dump_fixed_param));
  7531. cmd->request_id = mem_dump_req->request_id;
  7532. cmd->num_fw_mem_dump_segs = mem_dump_req->num_seg;
  7533. /* TLV indicating array of structures to follow */
  7534. buf_ptr += sizeof(wmi_get_fw_mem_dump_fixed_param);
  7535. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  7536. sizeof(wmi_fw_mem_dump) *
  7537. cmd->num_fw_mem_dump_segs);
  7538. buf_ptr += WMI_TLV_HDR_SIZE;
  7539. dump_params = (wmi_fw_mem_dump *) buf_ptr;
  7540. WMI_LOGI(FL("request_id:%d num_seg:%d"),
  7541. mem_dump_req->request_id, mem_dump_req->num_seg);
  7542. for (loop = 0; loop < cmd->num_fw_mem_dump_segs; loop++) {
  7543. seg_req = (struct fw_dump_seg_req *)
  7544. ((uint8_t *)(mem_dump_req->segment) +
  7545. loop * sizeof(*seg_req));
  7546. WMITLV_SET_HDR(&dump_params->tlv_header,
  7547. WMITLV_TAG_STRUC_wmi_fw_mem_dump_params,
  7548. WMITLV_GET_STRUCT_TLVLEN(wmi_fw_mem_dump));
  7549. dump_params->seg_id = seg_req->seg_id;
  7550. dump_params->seg_start_addr_lo = seg_req->seg_start_addr_lo;
  7551. dump_params->seg_start_addr_hi = seg_req->seg_start_addr_hi;
  7552. dump_params->seg_length = seg_req->seg_length;
  7553. dump_params->dest_addr_lo = seg_req->dst_addr_lo;
  7554. dump_params->dest_addr_hi = seg_req->dst_addr_hi;
  7555. WMI_LOGI(FL("seg_number:%d"), loop);
  7556. WMI_LOGI(FL("seg_id:%d start_addr_lo:0x%x start_addr_hi:0x%x"),
  7557. dump_params->seg_id, dump_params->seg_start_addr_lo,
  7558. dump_params->seg_start_addr_hi);
  7559. WMI_LOGI(FL("seg_length:%d dst_addr_lo:0x%x dst_addr_hi:0x%x"),
  7560. dump_params->seg_length, dump_params->dest_addr_lo,
  7561. dump_params->dest_addr_hi);
  7562. dump_params++;
  7563. }
  7564. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  7565. WMI_GET_FW_MEM_DUMP_CMDID);
  7566. if (ret) {
  7567. WMI_LOGE(FL("Failed to send get firmware mem dump request"));
  7568. wmi_buf_free(buf);
  7569. return QDF_STATUS_E_FAILURE;
  7570. }
  7571. WMI_LOGI(FL("Get firmware mem dump request sent successfully"));
  7572. return QDF_STATUS_SUCCESS;
  7573. }
  7574. /*
  7575. * send_process_set_ie_info_cmd_tlv() - Function to send IE info to firmware
  7576. * @wmi_handle: Pointer to WMi handle
  7577. * @ie_data: Pointer for ie data
  7578. *
  7579. * This function sends IE information to firmware
  7580. *
  7581. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  7582. *
  7583. */
  7584. QDF_STATUS send_process_set_ie_info_cmd_tlv(wmi_unified_t wmi_handle,
  7585. struct vdev_ie_info_param *ie_info)
  7586. {
  7587. wmi_vdev_set_ie_cmd_fixed_param *cmd;
  7588. wmi_buf_t buf;
  7589. uint8_t *buf_ptr;
  7590. uint32_t len, ie_len_aligned;
  7591. int ret;
  7592. ie_len_aligned = roundup(ie_info->length, sizeof(uint32_t));
  7593. /* Allocate memory for the WMI command */
  7594. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE + ie_len_aligned;
  7595. buf = wmi_buf_alloc(wmi_handle, len);
  7596. if (!buf) {
  7597. WMI_LOGE(FL("wmi_buf_alloc failed"));
  7598. return QDF_STATUS_E_NOMEM;
  7599. }
  7600. buf_ptr = wmi_buf_data(buf);
  7601. qdf_mem_zero(buf_ptr, len);
  7602. /* Populate the WMI command */
  7603. cmd = (wmi_vdev_set_ie_cmd_fixed_param *)buf_ptr;
  7604. WMITLV_SET_HDR(&cmd->tlv_header,
  7605. WMITLV_TAG_STRUC_wmi_vdev_set_ie_cmd_fixed_param,
  7606. WMITLV_GET_STRUCT_TLVLEN(
  7607. wmi_vdev_set_ie_cmd_fixed_param));
  7608. cmd->vdev_id = ie_info->vdev_id;
  7609. cmd->ie_id = ie_info->ie_id;
  7610. cmd->ie_len = ie_info->length;
  7611. WMI_LOGD(FL("IE:%d of size:%d sent for vdev:%d"), ie_info->ie_id,
  7612. ie_info->length, ie_info->vdev_id);
  7613. buf_ptr += sizeof(*cmd);
  7614. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_BYTE, ie_len_aligned);
  7615. buf_ptr += WMI_TLV_HDR_SIZE;
  7616. qdf_mem_copy(buf_ptr, ie_info->data, cmd->ie_len);
  7617. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  7618. WMI_VDEV_SET_IE_CMDID);
  7619. if (ret != EOK) {
  7620. WMI_LOGE(FL("Failed to send set IE command ret = %d"), ret);
  7621. wmi_buf_free(buf);
  7622. }
  7623. return ret;
  7624. }
  7625. void wmi_copy_resource_config(wmi_resource_config *resource_cfg,
  7626. wmi_resource_config *tgt_res_cfg)
  7627. {
  7628. resource_cfg->num_peers = tgt_res_cfg->num_peers;
  7629. resource_cfg->num_offload_peers = tgt_res_cfg->num_offload_peers;
  7630. resource_cfg->num_offload_reorder_buffs =
  7631. tgt_res_cfg->num_offload_reorder_buffs;
  7632. resource_cfg->num_peer_keys = tgt_res_cfg->num_peer_keys;
  7633. resource_cfg->num_tids = tgt_res_cfg->num_tids;
  7634. resource_cfg->ast_skid_limit = tgt_res_cfg->ast_skid_limit;
  7635. resource_cfg->tx_chain_mask = tgt_res_cfg->tx_chain_mask;
  7636. resource_cfg->rx_chain_mask = tgt_res_cfg->rx_chain_mask;
  7637. resource_cfg->rx_timeout_pri[0] = tgt_res_cfg->rx_timeout_pri[0];
  7638. resource_cfg->rx_timeout_pri[1] = tgt_res_cfg->rx_timeout_pri[1];
  7639. resource_cfg->rx_timeout_pri[2] = tgt_res_cfg->rx_timeout_pri[2];
  7640. resource_cfg->rx_timeout_pri[3] = tgt_res_cfg->rx_timeout_pri[3];
  7641. resource_cfg->rx_decap_mode = tgt_res_cfg->rx_decap_mode;
  7642. resource_cfg->scan_max_pending_req =
  7643. tgt_res_cfg->scan_max_pending_req;
  7644. resource_cfg->bmiss_offload_max_vdev =
  7645. tgt_res_cfg->bmiss_offload_max_vdev;
  7646. resource_cfg->roam_offload_max_vdev =
  7647. tgt_res_cfg->roam_offload_max_vdev;
  7648. resource_cfg->roam_offload_max_ap_profiles =
  7649. tgt_res_cfg->roam_offload_max_ap_profiles;
  7650. resource_cfg->num_mcast_groups = tgt_res_cfg->num_mcast_groups;
  7651. resource_cfg->num_mcast_table_elems =
  7652. tgt_res_cfg->num_mcast_table_elems;
  7653. resource_cfg->mcast2ucast_mode = tgt_res_cfg->mcast2ucast_mode;
  7654. resource_cfg->tx_dbg_log_size = tgt_res_cfg->tx_dbg_log_size;
  7655. resource_cfg->num_wds_entries = tgt_res_cfg->num_wds_entries;
  7656. resource_cfg->dma_burst_size = tgt_res_cfg->dma_burst_size;
  7657. resource_cfg->mac_aggr_delim = tgt_res_cfg->mac_aggr_delim;
  7658. resource_cfg->rx_skip_defrag_timeout_dup_detection_check =
  7659. tgt_res_cfg->rx_skip_defrag_timeout_dup_detection_check;
  7660. resource_cfg->vow_config = tgt_res_cfg->vow_config;
  7661. resource_cfg->gtk_offload_max_vdev = tgt_res_cfg->gtk_offload_max_vdev;
  7662. resource_cfg->num_msdu_desc = tgt_res_cfg->num_msdu_desc;
  7663. resource_cfg->max_frag_entries = tgt_res_cfg->max_frag_entries;
  7664. resource_cfg->num_tdls_vdevs = tgt_res_cfg->num_tdls_vdevs;
  7665. resource_cfg->num_tdls_conn_table_entries =
  7666. tgt_res_cfg->num_tdls_conn_table_entries;
  7667. resource_cfg->beacon_tx_offload_max_vdev =
  7668. tgt_res_cfg->beacon_tx_offload_max_vdev;
  7669. resource_cfg->num_multicast_filter_entries =
  7670. tgt_res_cfg->num_multicast_filter_entries;
  7671. resource_cfg->num_wow_filters =
  7672. tgt_res_cfg->num_wow_filters;
  7673. resource_cfg->num_keep_alive_pattern =
  7674. tgt_res_cfg->num_keep_alive_pattern;
  7675. resource_cfg->keep_alive_pattern_size =
  7676. tgt_res_cfg->keep_alive_pattern_size;
  7677. resource_cfg->max_tdls_concurrent_sleep_sta =
  7678. tgt_res_cfg->max_tdls_concurrent_sleep_sta;
  7679. resource_cfg->max_tdls_concurrent_buffer_sta =
  7680. tgt_res_cfg->max_tdls_concurrent_buffer_sta;
  7681. resource_cfg->wmi_send_separate =
  7682. tgt_res_cfg->wmi_send_separate;
  7683. resource_cfg->num_ocb_vdevs =
  7684. tgt_res_cfg->num_ocb_vdevs;
  7685. resource_cfg->num_ocb_channels =
  7686. tgt_res_cfg->num_ocb_channels;
  7687. resource_cfg->num_ocb_schedules =
  7688. tgt_res_cfg->num_ocb_schedules;
  7689. }
  7690. /**
  7691. * send_init_cmd_tlv() - wmi init command
  7692. * @wmi_handle: pointer to wmi handle
  7693. * @res_cfg: resource config
  7694. * @num_mem_chunks: no of mem chunck
  7695. * @mem_chunk: pointer to mem chunck structure
  7696. *
  7697. * This function sends IE information to firmware
  7698. *
  7699. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  7700. *
  7701. */
  7702. QDF_STATUS send_init_cmd_tlv(wmi_unified_t wmi_handle,
  7703. wmi_resource_config *tgt_res_cfg,
  7704. uint8_t num_mem_chunks, struct wmi_host_mem_chunk *mem_chunks,
  7705. bool action)
  7706. {
  7707. wmi_buf_t buf;
  7708. wmi_init_cmd_fixed_param *cmd;
  7709. wmi_abi_version my_vers;
  7710. int num_whitelist;
  7711. uint8_t *buf_ptr;
  7712. wmi_resource_config *resource_cfg;
  7713. wlan_host_memory_chunk *host_mem_chunks;
  7714. uint32_t mem_chunk_len = 0;
  7715. uint16_t idx;
  7716. int len;
  7717. int ret;
  7718. len = sizeof(*cmd) + sizeof(wmi_resource_config) + WMI_TLV_HDR_SIZE;
  7719. mem_chunk_len = (sizeof(wlan_host_memory_chunk) * MAX_MEM_CHUNKS);
  7720. buf = wmi_buf_alloc(wmi_handle, len + mem_chunk_len);
  7721. if (!buf) {
  7722. WMI_LOGD("%s: wmi_buf_alloc failed\n", __func__);
  7723. return QDF_STATUS_E_FAILURE;
  7724. }
  7725. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  7726. cmd = (wmi_init_cmd_fixed_param *) buf_ptr;
  7727. resource_cfg = (wmi_resource_config *) (buf_ptr + sizeof(*cmd));
  7728. host_mem_chunks = (wlan_host_memory_chunk *)
  7729. (buf_ptr + sizeof(*cmd) + sizeof(wmi_resource_config)
  7730. + WMI_TLV_HDR_SIZE);
  7731. WMITLV_SET_HDR(&cmd->tlv_header,
  7732. WMITLV_TAG_STRUC_wmi_init_cmd_fixed_param,
  7733. WMITLV_GET_STRUCT_TLVLEN(wmi_init_cmd_fixed_param));
  7734. qdf_mem_copy(resource_cfg, tgt_res_cfg, sizeof(wmi_resource_config));
  7735. WMITLV_SET_HDR(&resource_cfg->tlv_header,
  7736. WMITLV_TAG_STRUC_wmi_resource_config,
  7737. WMITLV_GET_STRUCT_TLVLEN(wmi_resource_config));
  7738. for (idx = 0; idx < num_mem_chunks; ++idx) {
  7739. WMITLV_SET_HDR(&(host_mem_chunks[idx].tlv_header),
  7740. WMITLV_TAG_STRUC_wlan_host_memory_chunk,
  7741. WMITLV_GET_STRUCT_TLVLEN
  7742. (wlan_host_memory_chunk));
  7743. host_mem_chunks[idx].ptr = mem_chunks[idx].paddr;
  7744. host_mem_chunks[idx].size = mem_chunks[idx].len;
  7745. host_mem_chunks[idx].req_id = mem_chunks[idx].req_id;
  7746. WMI_LOGD("chunk %d len %d requested ,ptr 0x%x ",
  7747. idx, host_mem_chunks[idx].size,
  7748. host_mem_chunks[idx].ptr);
  7749. }
  7750. cmd->num_host_mem_chunks = num_mem_chunks;
  7751. len += (num_mem_chunks * sizeof(wlan_host_memory_chunk));
  7752. WMITLV_SET_HDR((buf_ptr + sizeof(*cmd) + sizeof(wmi_resource_config)),
  7753. WMITLV_TAG_ARRAY_STRUC,
  7754. (sizeof(wlan_host_memory_chunk) *
  7755. num_mem_chunks));
  7756. num_whitelist = sizeof(version_whitelist) /
  7757. sizeof(wmi_whitelist_version_info);
  7758. my_vers.abi_version_0 = WMI_ABI_VERSION_0;
  7759. my_vers.abi_version_1 = WMI_ABI_VERSION_1;
  7760. my_vers.abi_version_ns_0 = WMI_ABI_VERSION_NS_0;
  7761. my_vers.abi_version_ns_1 = WMI_ABI_VERSION_NS_1;
  7762. my_vers.abi_version_ns_2 = WMI_ABI_VERSION_NS_2;
  7763. my_vers.abi_version_ns_3 = WMI_ABI_VERSION_NS_3;
  7764. wmi_cmp_and_set_abi_version(num_whitelist, version_whitelist,
  7765. &my_vers,
  7766. &wmi_handle->fw_abi_version,
  7767. &cmd->host_abi_vers);
  7768. WMI_LOGD("%s: INIT_CMD version: %d, %d, 0x%x, 0x%x, 0x%x, 0x%x",
  7769. __func__, WMI_VER_GET_MAJOR(cmd->host_abi_vers.abi_version_0),
  7770. WMI_VER_GET_MINOR(cmd->host_abi_vers.abi_version_0),
  7771. cmd->host_abi_vers.abi_version_ns_0,
  7772. cmd->host_abi_vers.abi_version_ns_1,
  7773. cmd->host_abi_vers.abi_version_ns_2,
  7774. cmd->host_abi_vers.abi_version_ns_3);
  7775. /* Save version sent from host -
  7776. * Will be used to check ready event
  7777. */
  7778. qdf_mem_copy(&wmi_handle->final_abi_vers, &cmd->host_abi_vers,
  7779. sizeof(wmi_abi_version));
  7780. if (action) {
  7781. ret = wmi_unified_cmd_send(wmi_handle, buf, len,
  7782. WMI_INIT_CMDID);
  7783. if (ret) {
  7784. WMI_LOGE(FL("Failed to send set WMI INIT command ret = %d"), ret);
  7785. wmi_buf_free(buf);
  7786. return QDF_STATUS_E_FAILURE;
  7787. }
  7788. } else {
  7789. wmi_handle->saved_wmi_init_cmd.buf = buf;
  7790. wmi_handle->saved_wmi_init_cmd.buf_len = len;
  7791. }
  7792. return QDF_STATUS_SUCCESS;
  7793. }
  7794. /**
  7795. * send_saved_init_cmd_tlv() - wmi init command
  7796. * @wmi_handle: pointer to wmi handle
  7797. *
  7798. * This function sends IE information to firmware
  7799. *
  7800. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  7801. *
  7802. */
  7803. QDF_STATUS send_saved_init_cmd_tlv(wmi_unified_t wmi_handle)
  7804. {
  7805. int status;
  7806. if (!wmi_handle->saved_wmi_init_cmd.buf ||
  7807. !wmi_handle->saved_wmi_init_cmd.buf_len) {
  7808. WMI_LOGP("Service ready ext event w/o WMI_SERVICE_EXT_MSG!");
  7809. return QDF_STATUS_E_FAILURE;
  7810. }
  7811. status = wmi_unified_cmd_send(wmi_handle,
  7812. wmi_handle->saved_wmi_init_cmd.buf,
  7813. wmi_handle->saved_wmi_init_cmd.buf_len,
  7814. WMI_INIT_CMDID);
  7815. if (status) {
  7816. WMI_LOGE(FL("Failed to send set WMI INIT command ret = %d"), status);
  7817. wmi_buf_free(wmi_handle->saved_wmi_init_cmd.buf);
  7818. return QDF_STATUS_E_FAILURE;
  7819. }
  7820. wmi_handle->saved_wmi_init_cmd.buf = NULL;
  7821. wmi_handle->saved_wmi_init_cmd.buf_len = 0;
  7822. return QDF_STATUS_SUCCESS;
  7823. }
  7824. QDF_STATUS save_fw_version_cmd_tlv(wmi_unified_t wmi_handle, void *evt_buf)
  7825. {
  7826. WMI_SERVICE_READY_EVENTID_param_tlvs *param_buf;
  7827. wmi_service_ready_event_fixed_param *ev;
  7828. param_buf = (WMI_SERVICE_READY_EVENTID_param_tlvs *) evt_buf;
  7829. ev = (wmi_service_ready_event_fixed_param *) param_buf->fixed_param;
  7830. if (!ev)
  7831. qdf_assert(0);
  7832. /*Save fw version from service ready message */
  7833. /*This will be used while sending INIT message */
  7834. qdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers,
  7835. sizeof(wmi_handle->fw_abi_version));
  7836. return QDF_STATUS_SUCCESS;
  7837. }
  7838. /**
  7839. * wmi_unified_save_fw_version_cmd() - save fw version
  7840. * @wmi_handle: pointer to wmi handle
  7841. * @res_cfg: resource config
  7842. * @num_mem_chunks: no of mem chunck
  7843. * @mem_chunk: pointer to mem chunck structure
  7844. *
  7845. * This function sends IE information to firmware
  7846. *
  7847. * Return: QDF_STATUS_SUCCESS for success otherwise failure
  7848. *
  7849. */
  7850. QDF_STATUS check_and_update_fw_version_cmd_tlv(wmi_unified_t wmi_handle,
  7851. void *evt_buf)
  7852. {
  7853. WMI_READY_EVENTID_param_tlvs *param_buf = NULL;
  7854. wmi_ready_event_fixed_param *ev = NULL;
  7855. param_buf = (WMI_READY_EVENTID_param_tlvs *) evt_buf;
  7856. ev = param_buf->fixed_param;
  7857. if (!wmi_versions_are_compatible(&wmi_handle->final_abi_vers,
  7858. &ev->fw_abi_vers)) {
  7859. /*
  7860. * Error: Our host version and the given firmware version
  7861. * are incompatible.
  7862. **/
  7863. WMI_LOGD("%s: Error: Incompatible WMI version."
  7864. "Host: %d,%d,0x%x 0x%x 0x%x 0x%x, FW: %d,%d,0x%x 0x%x 0x%x 0x%x\n",
  7865. __func__,
  7866. WMI_VER_GET_MAJOR(wmi_handle->final_abi_vers.
  7867. abi_version_0),
  7868. WMI_VER_GET_MINOR(wmi_handle->final_abi_vers.
  7869. abi_version_0),
  7870. wmi_handle->final_abi_vers.abi_version_ns_0,
  7871. wmi_handle->final_abi_vers.abi_version_ns_1,
  7872. wmi_handle->final_abi_vers.abi_version_ns_2,
  7873. wmi_handle->final_abi_vers.abi_version_ns_3,
  7874. WMI_VER_GET_MAJOR(ev->fw_abi_vers.abi_version_0),
  7875. WMI_VER_GET_MINOR(ev->fw_abi_vers.abi_version_0),
  7876. ev->fw_abi_vers.abi_version_ns_0,
  7877. ev->fw_abi_vers.abi_version_ns_1,
  7878. ev->fw_abi_vers.abi_version_ns_2,
  7879. ev->fw_abi_vers.abi_version_ns_3);
  7880. return QDF_STATUS_E_FAILURE;
  7881. }
  7882. qdf_mem_copy(&wmi_handle->final_abi_vers, &ev->fw_abi_vers,
  7883. sizeof(wmi_abi_version));
  7884. qdf_mem_copy(&wmi_handle->fw_abi_version, &ev->fw_abi_vers,
  7885. sizeof(wmi_abi_version));
  7886. return QDF_STATUS_SUCCESS;
  7887. }
  7888. /**
  7889. * send_set_base_macaddr_indicate_cmd_tlv() - set base mac address in fw
  7890. * @wmi_handle: wmi handle
  7891. * @custom_addr: base mac address
  7892. *
  7893. * Return: 0 for success or error code
  7894. */
  7895. QDF_STATUS send_set_base_macaddr_indicate_cmd_tlv(wmi_unified_t wmi_handle,
  7896. uint8_t *custom_addr)
  7897. {
  7898. wmi_pdev_set_base_macaddr_cmd_fixed_param *cmd;
  7899. wmi_buf_t buf;
  7900. int err;
  7901. buf = wmi_buf_alloc(wmi_handle, sizeof(*cmd));
  7902. if (!buf) {
  7903. WMI_LOGE("Failed to allocate buffer to send base macaddr cmd");
  7904. return -ENOMEM;
  7905. }
  7906. cmd = (wmi_pdev_set_base_macaddr_cmd_fixed_param *) wmi_buf_data(buf);
  7907. qdf_mem_zero(cmd, sizeof(*cmd));
  7908. WMITLV_SET_HDR(&cmd->tlv_header,
  7909. WMITLV_TAG_STRUC_wmi_pdev_set_base_macaddr_cmd_fixed_param,
  7910. WMITLV_GET_STRUCT_TLVLEN
  7911. (wmi_pdev_set_base_macaddr_cmd_fixed_param));
  7912. WMI_CHAR_ARRAY_TO_MAC_ADDR(custom_addr, &cmd->base_macaddr);
  7913. err = wmi_unified_cmd_send(wmi_handle, buf,
  7914. sizeof(*cmd),
  7915. WMI_PDEV_SET_BASE_MACADDR_CMDID);
  7916. if (err) {
  7917. WMI_LOGE("Failed to send set_base_macaddr cmd");
  7918. qdf_mem_free(buf);
  7919. return -EIO;
  7920. }
  7921. return 0;
  7922. }
  7923. /**
  7924. * send_log_supported_evt_cmd_tlv() - Enable/Disable FW diag/log events
  7925. * @handle: wmi handle
  7926. * @event: Event received from FW
  7927. * @len: Length of the event
  7928. *
  7929. * Enables the low frequency events and disables the high frequency
  7930. * events. Bit 17 indicates if the event if low/high frequency.
  7931. * 1 - high frequency, 0 - low frequency
  7932. *
  7933. * Return: 0 on successfully enabling/disabling the events
  7934. */
  7935. QDF_STATUS send_log_supported_evt_cmd_tlv(wmi_unified_t wmi_handle,
  7936. uint8_t *event,
  7937. uint32_t len)
  7938. {
  7939. uint32_t num_of_diag_events_logs;
  7940. wmi_diag_event_log_config_fixed_param *cmd;
  7941. wmi_buf_t buf;
  7942. uint8_t *buf_ptr;
  7943. uint32_t *cmd_args, *evt_args;
  7944. uint32_t buf_len, i;
  7945. WMI_DIAG_EVENT_LOG_SUPPORTED_EVENTID_param_tlvs *param_buf;
  7946. wmi_diag_event_log_supported_event_fixed_params *wmi_event;
  7947. WMI_LOGI("Received WMI_DIAG_EVENT_LOG_SUPPORTED_EVENTID");
  7948. param_buf = (WMI_DIAG_EVENT_LOG_SUPPORTED_EVENTID_param_tlvs *) event;
  7949. if (!param_buf) {
  7950. WMI_LOGE("Invalid log supported event buffer");
  7951. return -EINVAL;
  7952. }
  7953. wmi_event = param_buf->fixed_param;
  7954. num_of_diag_events_logs = wmi_event->num_of_diag_events_logs;
  7955. evt_args = param_buf->diag_events_logs_list;
  7956. if (!evt_args) {
  7957. WMI_LOGE("%s: Event list is empty, num_of_diag_events_logs=%d",
  7958. __func__, num_of_diag_events_logs);
  7959. return -EINVAL;
  7960. }
  7961. WMI_LOGD("%s: num_of_diag_events_logs=%d",
  7962. __func__, num_of_diag_events_logs);
  7963. /* Free any previous allocation */
  7964. if (wmi_handle->events_logs_list)
  7965. qdf_mem_free(wmi_handle->events_logs_list);
  7966. /* Store the event list for run time enable/disable */
  7967. wmi_handle->events_logs_list = qdf_mem_malloc(num_of_diag_events_logs *
  7968. sizeof(uint32_t));
  7969. if (!wmi_handle->events_logs_list) {
  7970. WMI_LOGE("%s: event log list memory allocation failed",
  7971. __func__);
  7972. return -ENOMEM;
  7973. }
  7974. wmi_handle->num_of_diag_events_logs = num_of_diag_events_logs;
  7975. /* Prepare the send buffer */
  7976. buf_len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
  7977. (num_of_diag_events_logs * sizeof(uint32_t));
  7978. buf = wmi_buf_alloc(wmi_handle, buf_len);
  7979. if (!buf) {
  7980. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  7981. qdf_mem_free(wmi_handle->events_logs_list);
  7982. wmi_handle->events_logs_list = NULL;
  7983. return -ENOMEM;
  7984. }
  7985. cmd = (wmi_diag_event_log_config_fixed_param *) wmi_buf_data(buf);
  7986. buf_ptr = (uint8_t *) cmd;
  7987. WMITLV_SET_HDR(&cmd->tlv_header,
  7988. WMITLV_TAG_STRUC_wmi_diag_event_log_config_fixed_param,
  7989. WMITLV_GET_STRUCT_TLVLEN(
  7990. wmi_diag_event_log_config_fixed_param));
  7991. cmd->num_of_diag_events_logs = num_of_diag_events_logs;
  7992. buf_ptr += sizeof(wmi_diag_event_log_config_fixed_param);
  7993. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  7994. (num_of_diag_events_logs * sizeof(uint32_t)));
  7995. cmd_args = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE);
  7996. /* Populate the events */
  7997. for (i = 0; i < num_of_diag_events_logs; i++) {
  7998. /* Low freq (0) - Enable (1) the event
  7999. * High freq (1) - Disable (0) the event
  8000. */
  8001. WMI_DIAG_ID_ENABLED_DISABLED_SET(cmd_args[i],
  8002. !(WMI_DIAG_FREQUENCY_GET(evt_args[i])));
  8003. /* Set the event ID */
  8004. WMI_DIAG_ID_SET(cmd_args[i],
  8005. WMI_DIAG_ID_GET(evt_args[i]));
  8006. /* Set the type */
  8007. WMI_DIAG_TYPE_SET(cmd_args[i],
  8008. WMI_DIAG_TYPE_GET(evt_args[i]));
  8009. /* Storing the event/log list in WMI */
  8010. wmi_handle->events_logs_list[i] = evt_args[i];
  8011. }
  8012. if (wmi_unified_cmd_send(wmi_handle, buf, buf_len,
  8013. WMI_DIAG_EVENT_LOG_CONFIG_CMDID)) {
  8014. WMI_LOGE("%s: WMI_DIAG_EVENT_LOG_CONFIG_CMDID failed",
  8015. __func__);
  8016. wmi_buf_free(buf);
  8017. /* Not clearing events_logs_list, though wmi cmd failed.
  8018. * Host can still have this list
  8019. */
  8020. return -EINVAL;
  8021. }
  8022. return 0;
  8023. }
  8024. /**
  8025. * send_enable_specific_fw_logs_cmd_tlv() - Start/Stop logging of diag log id
  8026. * @wmi_handle: wmi handle
  8027. * @start_log: Start logging related parameters
  8028. *
  8029. * Send the command to the FW based on which specific logging of diag
  8030. * event/log id can be started/stopped
  8031. *
  8032. * Return: None
  8033. */
  8034. QDF_STATUS send_enable_specific_fw_logs_cmd_tlv(wmi_unified_t wmi_handle,
  8035. struct wmi_wifi_start_log *start_log)
  8036. {
  8037. wmi_diag_event_log_config_fixed_param *cmd;
  8038. wmi_buf_t buf;
  8039. uint8_t *buf_ptr;
  8040. uint32_t len, count, log_level, i;
  8041. uint32_t *cmd_args;
  8042. uint32_t total_len;
  8043. count = 0;
  8044. if (!wmi_handle->events_logs_list) {
  8045. WMI_LOGE("%s: Not received event/log list from FW, yet",
  8046. __func__);
  8047. return -ENOMEM;
  8048. }
  8049. /* total_len stores the number of events where BITS 17 and 18 are set.
  8050. * i.e., events of high frequency (17) and for extended debugging (18)
  8051. */
  8052. total_len = 0;
  8053. for (i = 0; i < wmi_handle->num_of_diag_events_logs; i++) {
  8054. if ((WMI_DIAG_FREQUENCY_GET(wmi_handle->events_logs_list[i])) &&
  8055. (WMI_DIAG_EXT_FEATURE_GET(wmi_handle->events_logs_list[i])))
  8056. total_len++;
  8057. }
  8058. len = sizeof(*cmd) + WMI_TLV_HDR_SIZE +
  8059. (total_len * sizeof(uint32_t));
  8060. buf = wmi_buf_alloc(wmi_handle, len);
  8061. if (!buf) {
  8062. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  8063. return -ENOMEM;
  8064. }
  8065. cmd = (wmi_diag_event_log_config_fixed_param *) wmi_buf_data(buf);
  8066. buf_ptr = (uint8_t *) cmd;
  8067. WMITLV_SET_HDR(&cmd->tlv_header,
  8068. WMITLV_TAG_STRUC_wmi_diag_event_log_config_fixed_param,
  8069. WMITLV_GET_STRUCT_TLVLEN(
  8070. wmi_diag_event_log_config_fixed_param));
  8071. cmd->num_of_diag_events_logs = total_len;
  8072. buf_ptr += sizeof(wmi_diag_event_log_config_fixed_param);
  8073. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  8074. (total_len * sizeof(uint32_t)));
  8075. cmd_args = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE);
  8076. if (start_log->verbose_level >= LOG_LEVEL_ACTIVE)
  8077. log_level = 1;
  8078. else
  8079. log_level = 0;
  8080. WMI_LOGD("%s: Length:%d, Log_level:%d", __func__, total_len, log_level);
  8081. for (i = 0; i < wmi_handle->num_of_diag_events_logs; i++) {
  8082. uint32_t val = wmi_handle->events_logs_list[i];
  8083. if ((WMI_DIAG_FREQUENCY_GET(val)) &&
  8084. (WMI_DIAG_EXT_FEATURE_GET(val))) {
  8085. WMI_DIAG_ID_SET(cmd_args[count],
  8086. WMI_DIAG_ID_GET(val));
  8087. WMI_DIAG_TYPE_SET(cmd_args[count],
  8088. WMI_DIAG_TYPE_GET(val));
  8089. WMI_DIAG_ID_ENABLED_DISABLED_SET(cmd_args[count],
  8090. log_level);
  8091. WMI_LOGD("%s: Idx:%d, val:%x", __func__, i, val);
  8092. count++;
  8093. }
  8094. }
  8095. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  8096. WMI_DIAG_EVENT_LOG_CONFIG_CMDID)) {
  8097. WMI_LOGE("%s: WMI_DIAG_EVENT_LOG_CONFIG_CMDID failed",
  8098. __func__);
  8099. wmi_buf_free(buf);
  8100. return -EINVAL;
  8101. }
  8102. return QDF_STATUS_SUCCESS;
  8103. }
  8104. /**
  8105. * send_flush_logs_to_fw_cmd_tlv() - Send log flush command to FW
  8106. * @wmi_handle: WMI handle
  8107. *
  8108. * This function is used to send the flush command to the FW,
  8109. * that will flush the fw logs that are residue in the FW
  8110. *
  8111. * Return: None
  8112. */
  8113. QDF_STATUS send_flush_logs_to_fw_cmd_tlv(wmi_unified_t wmi_handle)
  8114. {
  8115. wmi_debug_mesg_flush_fixed_param *cmd;
  8116. wmi_buf_t buf;
  8117. int len = sizeof(*cmd);
  8118. int ret;
  8119. buf = wmi_buf_alloc(wmi_handle, len);
  8120. if (!buf) {
  8121. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  8122. return -ENOMEM;
  8123. }
  8124. cmd = (wmi_debug_mesg_flush_fixed_param *) wmi_buf_data(buf);
  8125. WMITLV_SET_HDR(&cmd->tlv_header,
  8126. WMITLV_TAG_STRUC_wmi_debug_mesg_flush_fixed_param,
  8127. WMITLV_GET_STRUCT_TLVLEN(
  8128. wmi_debug_mesg_flush_fixed_param));
  8129. cmd->reserved0 = 0;
  8130. ret = wmi_unified_cmd_send(wmi_handle,
  8131. buf,
  8132. len,
  8133. WMI_DEBUG_MESG_FLUSH_CMDID);
  8134. if (ret != EOK) {
  8135. WMI_LOGE("Failed to send WMI_DEBUG_MESG_FLUSH_CMDID");
  8136. wmi_buf_free(buf);
  8137. return -EINVAL;
  8138. }
  8139. WMI_LOGI("Sent WMI_DEBUG_MESG_FLUSH_CMDID to FW");
  8140. return QDF_STATUS_SUCCESS;
  8141. }
  8142. /**
  8143. * send_soc_set_pcl_cmd_tlv() - Send WMI_SOC_SET_PCL_CMDID to FW
  8144. * @wmi_handle: wmi handle
  8145. * @msg: PCL structure containing the PCL and the number of channels
  8146. *
  8147. * WMI_SOC_SET_PCL_CMDID provides a Preferred Channel List (PCL) to the WLAN
  8148. * firmware. The DBS Manager is the consumer of this information in the WLAN
  8149. * firmware. The channel list will be used when a Virtual DEVice (VDEV) needs
  8150. * to migrate to a new channel without host driver involvement. An example of
  8151. * this behavior is Legacy Fast Roaming (LFR 3.0). Generally, the host will
  8152. * manage the channel selection without firmware involvement.
  8153. *
  8154. * Return: Success if the cmd is sent successfully to the firmware
  8155. */
  8156. QDF_STATUS send_soc_set_pcl_cmd_tlv(wmi_unified_t wmi_handle,
  8157. struct wmi_pcl_list *msg)
  8158. {
  8159. wmi_soc_set_pcl_cmd_fixed_param *cmd;
  8160. wmi_buf_t buf;
  8161. uint8_t *buf_ptr;
  8162. uint32_t *cmd_args, i, len;
  8163. len = sizeof(*cmd) +
  8164. WMI_TLV_HDR_SIZE + (msg->pcl_len * sizeof(uint32_t));
  8165. buf = wmi_buf_alloc(wmi_handle, len);
  8166. if (!buf) {
  8167. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  8168. return QDF_STATUS_E_NOMEM;
  8169. }
  8170. cmd = (wmi_soc_set_pcl_cmd_fixed_param *) wmi_buf_data(buf);
  8171. buf_ptr = (uint8_t *) cmd;
  8172. WMITLV_SET_HDR(&cmd->tlv_header,
  8173. WMITLV_TAG_STRUC_wmi_soc_set_pcl_cmd_fixed_param,
  8174. WMITLV_GET_STRUCT_TLVLEN(wmi_soc_set_pcl_cmd_fixed_param));
  8175. cmd->num_chan = msg->pcl_len;
  8176. WMI_LOGI("%s: PCL len:%d", __func__, cmd->num_chan);
  8177. buf_ptr += sizeof(wmi_soc_set_pcl_cmd_fixed_param);
  8178. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  8179. (msg->pcl_len * sizeof(uint32_t)));
  8180. cmd_args = (uint32_t *) (buf_ptr + WMI_TLV_HDR_SIZE);
  8181. for (i = 0; i < msg->pcl_len ; i++) {
  8182. cmd_args[i] = msg->pcl_list[i];
  8183. WMI_LOGI("%s: PCL chan:%d", __func__, cmd_args[i]);
  8184. }
  8185. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  8186. WMI_SOC_SET_PCL_CMDID)) {
  8187. WMI_LOGE("%s: Failed to send WMI_SOC_SET_PCL_CMDID", __func__);
  8188. qdf_nbuf_free(buf);
  8189. return QDF_STATUS_E_FAILURE;
  8190. }
  8191. return QDF_STATUS_SUCCESS;
  8192. }
  8193. /**
  8194. * send_soc_set_hw_mode_cmd_tlv() - Send WMI_SOC_SET_HW_MODE_CMDID to FW
  8195. * @wmi_handle: wmi handle
  8196. * @msg: Structure containing the following parameters
  8197. *
  8198. * - hw_mode_index: The HW_Mode field is a enumerated type that is selected
  8199. * from the HW_Mode table, which is returned in the WMI_SERVICE_READY_EVENTID.
  8200. *
  8201. * Provides notification to the WLAN firmware that host driver is requesting a
  8202. * HardWare (HW) Mode change. This command is needed to support iHelium in the
  8203. * configurations that include the Dual Band Simultaneous (DBS) feature.
  8204. *
  8205. * Return: Success if the cmd is sent successfully to the firmware
  8206. */
  8207. QDF_STATUS send_soc_set_hw_mode_cmd_tlv(wmi_unified_t wmi_handle,
  8208. uint32_t hw_mode_index)
  8209. {
  8210. wmi_soc_set_hw_mode_cmd_fixed_param *cmd;
  8211. wmi_buf_t buf;
  8212. uint32_t len;
  8213. len = sizeof(*cmd);
  8214. buf = wmi_buf_alloc(wmi_handle, len);
  8215. if (!buf) {
  8216. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  8217. return QDF_STATUS_E_NOMEM;
  8218. }
  8219. cmd = (wmi_soc_set_hw_mode_cmd_fixed_param *) wmi_buf_data(buf);
  8220. WMITLV_SET_HDR(&cmd->tlv_header,
  8221. WMITLV_TAG_STRUC_wmi_soc_set_hw_mode_cmd_fixed_param,
  8222. WMITLV_GET_STRUCT_TLVLEN(wmi_soc_set_hw_mode_cmd_fixed_param));
  8223. cmd->hw_mode_index = hw_mode_index;
  8224. WMI_LOGI("%s: HW mode index:%d", __func__, cmd->hw_mode_index);
  8225. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  8226. WMI_SOC_SET_HW_MODE_CMDID)) {
  8227. WMI_LOGE("%s: Failed to send WMI_SOC_SET_HW_MODE_CMDID",
  8228. __func__);
  8229. qdf_nbuf_free(buf);
  8230. return QDF_STATUS_E_FAILURE;
  8231. }
  8232. return QDF_STATUS_SUCCESS;
  8233. }
  8234. /**
  8235. * send_soc_set_dual_mac_config_cmd_tlv() - Set dual mac config to FW
  8236. * @wmi_handle: wmi handle
  8237. * @msg: Dual MAC config parameters
  8238. *
  8239. * Configures WLAN firmware with the dual MAC features
  8240. *
  8241. * Return: QDF_STATUS. 0 on success.
  8242. */
  8243. QDF_STATUS send_soc_set_dual_mac_config_cmd_tlv(wmi_unified_t wmi_handle,
  8244. struct wmi_dual_mac_config *msg)
  8245. {
  8246. wmi_soc_set_dual_mac_config_cmd_fixed_param *cmd;
  8247. wmi_buf_t buf;
  8248. uint32_t len;
  8249. len = sizeof(*cmd);
  8250. buf = wmi_buf_alloc(wmi_handle, len);
  8251. if (!buf) {
  8252. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  8253. return QDF_STATUS_E_FAILURE;
  8254. }
  8255. cmd = (wmi_soc_set_dual_mac_config_cmd_fixed_param *) wmi_buf_data(buf);
  8256. WMITLV_SET_HDR(&cmd->tlv_header,
  8257. WMITLV_TAG_STRUC_wmi_soc_set_dual_mac_config_cmd_fixed_param,
  8258. WMITLV_GET_STRUCT_TLVLEN(
  8259. wmi_soc_set_dual_mac_config_cmd_fixed_param));
  8260. cmd->concurrent_scan_config_bits = msg->scan_config;
  8261. cmd->fw_mode_config_bits = msg->fw_mode_config;
  8262. WMI_LOGI("%s: scan_config:%x fw_mode_config:%x",
  8263. __func__, msg->scan_config, msg->fw_mode_config);
  8264. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  8265. WMI_SOC_SET_DUAL_MAC_CONFIG_CMDID)) {
  8266. WMI_LOGE("%s: Failed to send WMI_SOC_SET_DUAL_MAC_CONFIG_CMDID",
  8267. __func__);
  8268. qdf_nbuf_free(buf);
  8269. }
  8270. return QDF_STATUS_SUCCESS;
  8271. }
  8272. /**
  8273. * send_enable_arp_ns_offload_cmd_tlv() - enable ARP NS offload
  8274. * @wma: wmi handle
  8275. * @tpSirHostOffloadReq: offload request
  8276. * @arp_only: flag
  8277. *
  8278. * To configure ARP NS off load data to firmware
  8279. * when target goes to wow mode.
  8280. *
  8281. * Return: CDF Status
  8282. */
  8283. QDF_STATUS send_enable_arp_ns_offload_cmd_tlv(wmi_unified_t wmi_handle,
  8284. struct host_offload_req_param *param, bool arp_only,
  8285. uint8_t vdev_id)
  8286. {
  8287. int32_t i;
  8288. int32_t res;
  8289. WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param *cmd;
  8290. WMI_NS_OFFLOAD_TUPLE *ns_tuple;
  8291. WMI_ARP_OFFLOAD_TUPLE *arp_tuple;
  8292. A_UINT8 *buf_ptr;
  8293. wmi_buf_t buf;
  8294. int32_t len;
  8295. uint32_t count = 0, num_ns_ext_tuples = 0;
  8296. if (!arp_only)
  8297. count = param->num_ns_offload_count;
  8298. /*
  8299. * TLV place holder size for array of NS tuples
  8300. * TLV place holder size for array of ARP tuples
  8301. */
  8302. len = sizeof(WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param) + WMI_TLV_HDR_SIZE +
  8303. WMI_MAX_NS_OFFLOADS * sizeof(WMI_NS_OFFLOAD_TUPLE) + WMI_TLV_HDR_SIZE +
  8304. WMI_MAX_ARP_OFFLOADS * sizeof(WMI_ARP_OFFLOAD_TUPLE);
  8305. /*
  8306. * If there are more than WMI_MAX_NS_OFFLOADS addresses then allocate
  8307. * extra length for extended NS offload tuples which follows ARP offload
  8308. * tuples. Host needs to fill this structure in following format:
  8309. * 2 NS ofload tuples
  8310. * 2 ARP offload tuples
  8311. * N numbers of extended NS offload tuples if HDD has given more than
  8312. * 2 NS offload addresses
  8313. */
  8314. if (!arp_only && count > WMI_MAX_NS_OFFLOADS) {
  8315. num_ns_ext_tuples = count - WMI_MAX_NS_OFFLOADS;
  8316. len += WMI_TLV_HDR_SIZE + num_ns_ext_tuples *
  8317. sizeof(WMI_NS_OFFLOAD_TUPLE);
  8318. }
  8319. buf = wmi_buf_alloc(wmi_handle, len);
  8320. if (!buf) {
  8321. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  8322. return QDF_STATUS_E_NOMEM;
  8323. }
  8324. buf_ptr = (A_UINT8 *) wmi_buf_data(buf);
  8325. cmd = (WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param *) buf_ptr;
  8326. WMITLV_SET_HDR(&cmd->tlv_header,
  8327. WMITLV_TAG_STRUC_WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param,
  8328. WMITLV_GET_STRUCT_TLVLEN
  8329. (WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param));
  8330. cmd->flags = 0;
  8331. cmd->vdev_id = vdev_id;
  8332. if (!arp_only)
  8333. cmd->num_ns_ext_tuples = num_ns_ext_tuples;
  8334. WMI_LOGD("ARP NS Offload vdev_id: %d", cmd->vdev_id);
  8335. /* Have copy of arp info to send along with NS, Since FW expects
  8336. * both ARP and NS info in single cmd */
  8337. if (arp_only)
  8338. qdf_mem_copy(&wmi_handle->arp_info, param,
  8339. sizeof(struct host_offload_req_param));
  8340. buf_ptr += sizeof(WMI_SET_ARP_NS_OFFLOAD_CMD_fixed_param);
  8341. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  8342. (WMI_MAX_NS_OFFLOADS * sizeof(WMI_NS_OFFLOAD_TUPLE)));
  8343. buf_ptr += WMI_TLV_HDR_SIZE;
  8344. for (i = 0; i < WMI_MAX_NS_OFFLOADS; i++) {
  8345. ns_tuple = (WMI_NS_OFFLOAD_TUPLE *) buf_ptr;
  8346. WMITLV_SET_HDR(&ns_tuple->tlv_header,
  8347. WMITLV_TAG_STRUC_WMI_NS_OFFLOAD_TUPLE,
  8348. (sizeof(WMI_NS_OFFLOAD_TUPLE) -
  8349. WMI_TLV_HDR_SIZE));
  8350. /* Fill data only for NS offload in the first ARP tuple for LA */
  8351. if (!arp_only &&
  8352. ((param->enableOrDisable & SIR_OFFLOAD_ENABLE))) {
  8353. ns_tuple->flags |= WMI_NSOFF_FLAGS_VALID;
  8354. #ifdef WLAN_NS_OFFLOAD
  8355. /*Copy the target/solicitation/remote ip addr */
  8356. if (param->nsOffloadInfo.
  8357. targetIPv6AddrValid[i])
  8358. A_MEMCPY(&ns_tuple->target_ipaddr[0],
  8359. &param->nsOffloadInfo.
  8360. targetIPv6Addr[i],
  8361. sizeof(WMI_IPV6_ADDR));
  8362. A_MEMCPY(&ns_tuple->solicitation_ipaddr,
  8363. &param->nsOffloadInfo.
  8364. selfIPv6Addr[i], sizeof(WMI_IPV6_ADDR));
  8365. WMI_LOGD("NS solicitedIp: %pI6, targetIp: %pI6",
  8366. &param->nsOffloadInfo.selfIPv6Addr[i],
  8367. &param->nsOffloadInfo.
  8368. targetIPv6Addr[i]);
  8369. /* target MAC is optional, check if it is valid,
  8370. * if this is not valid, the target will use the known
  8371. * local MAC address rather than the tuple
  8372. */
  8373. WMI_CHAR_ARRAY_TO_MAC_ADDR(param->
  8374. nsOffloadInfo.self_macaddr.bytes,
  8375. &ns_tuple->target_mac);
  8376. #endif /* WLAN_NS_OFFLOAD */
  8377. if ((ns_tuple->target_mac.mac_addr31to0 != 0) ||
  8378. (ns_tuple->target_mac.mac_addr47to32 != 0)) {
  8379. ns_tuple->flags |= WMI_NSOFF_FLAGS_MAC_VALID;
  8380. }
  8381. }
  8382. buf_ptr += sizeof(WMI_NS_OFFLOAD_TUPLE);
  8383. }
  8384. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  8385. (WMI_MAX_ARP_OFFLOADS * sizeof(WMI_ARP_OFFLOAD_TUPLE)));
  8386. buf_ptr += WMI_TLV_HDR_SIZE;
  8387. for (i = 0; i < WMI_MAX_ARP_OFFLOADS; i++) {
  8388. arp_tuple = (WMI_ARP_OFFLOAD_TUPLE *) buf_ptr;
  8389. WMITLV_SET_HDR(&arp_tuple->tlv_header,
  8390. WMITLV_TAG_STRUC_WMI_ARP_OFFLOAD_TUPLE,
  8391. WMITLV_GET_STRUCT_TLVLEN(WMI_ARP_OFFLOAD_TUPLE));
  8392. /* Fill data for ARP and NS in the first tupple for LA */
  8393. if ((wmi_handle->arp_info.enableOrDisable & SIR_OFFLOAD_ENABLE)
  8394. && (i == 0)) {
  8395. /*Copy the target ip addr and flags */
  8396. arp_tuple->flags = WMI_ARPOFF_FLAGS_VALID;
  8397. A_MEMCPY(&arp_tuple->target_ipaddr,
  8398. wmi_handle->arp_info.params.hostIpv4Addr,
  8399. SIR_IPV4_ADDR_LEN);
  8400. WMI_LOGD("ARPOffload IP4 address: %pI4",
  8401. wmi_handle->arp_info.params.hostIpv4Addr);
  8402. }
  8403. buf_ptr += sizeof(WMI_ARP_OFFLOAD_TUPLE);
  8404. }
  8405. /* Populate extended NS offload tuples */
  8406. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC,
  8407. (num_ns_ext_tuples*sizeof(WMI_NS_OFFLOAD_TUPLE)));
  8408. buf_ptr += WMI_TLV_HDR_SIZE;
  8409. if (num_ns_ext_tuples) {
  8410. for (i = WMI_MAX_NS_OFFLOADS; i < count; i++) {
  8411. ns_tuple = (WMI_NS_OFFLOAD_TUPLE *)buf_ptr;
  8412. WMITLV_SET_HDR(&ns_tuple->tlv_header,
  8413. WMITLV_TAG_STRUC_WMI_NS_OFFLOAD_TUPLE,
  8414. (sizeof(WMI_NS_OFFLOAD_TUPLE)-WMI_TLV_HDR_SIZE));
  8415. /* Fill data only for NS offload in the first ARP tuple for LA */
  8416. if (!arp_only &&
  8417. ((param->enableOrDisable & SIR_OFFLOAD_ENABLE))) {
  8418. ns_tuple->flags |= WMI_NSOFF_FLAGS_VALID;
  8419. #ifdef WLAN_NS_OFFLOAD
  8420. /*Copy the target/solicitation/remote ip addr */
  8421. if (param->nsOffloadInfo.targetIPv6AddrValid[i])
  8422. A_MEMCPY(&ns_tuple->target_ipaddr[0],
  8423. &param->nsOffloadInfo.targetIPv6Addr[i],
  8424. sizeof(WMI_IPV6_ADDR));
  8425. A_MEMCPY(&ns_tuple->solicitation_ipaddr,
  8426. &param->nsOffloadInfo.selfIPv6Addr[i],
  8427. sizeof(WMI_IPV6_ADDR));
  8428. WMI_LOGD("Index %d NS solicitedIp: %pI6, targetIp: %pI6", i,
  8429. &param->nsOffloadInfo.selfIPv6Addr[i],
  8430. &param->nsOffloadInfo.targetIPv6Addr[i]);
  8431. /* target MAC is optional, check if it is valid, if this is not valid,
  8432. * the target will use the known local MAC address rather than the tuple */
  8433. WMI_CHAR_ARRAY_TO_MAC_ADDR(
  8434. param->nsOffloadInfo.self_macaddr.bytes,
  8435. &ns_tuple->target_mac);
  8436. #endif
  8437. if ((ns_tuple->target_mac.mac_addr31to0 != 0) ||
  8438. (ns_tuple->target_mac.mac_addr47to32 != 0)) {
  8439. ns_tuple->flags |= WMI_NSOFF_FLAGS_MAC_VALID;
  8440. }
  8441. }
  8442. buf_ptr += sizeof(WMI_NS_OFFLOAD_TUPLE);
  8443. }
  8444. }
  8445. res = wmi_unified_cmd_send(wmi_handle, buf, len,
  8446. WMI_SET_ARP_NS_OFFLOAD_CMDID);
  8447. if (res) {
  8448. WMI_LOGE("Failed to enable ARP NDP/NSffload");
  8449. wmi_buf_free(buf);
  8450. return QDF_STATUS_E_FAILURE;
  8451. }
  8452. return QDF_STATUS_SUCCESS;
  8453. }
  8454. /**
  8455. * send_set_ssid_hotlist_cmd_tlv() - Handle an SSID hotlist set request
  8456. * @wmi_handle: wmi handle
  8457. * @request: SSID hotlist set request
  8458. *
  8459. * Return: QDF_STATUS enumeration
  8460. */
  8461. QDF_STATUS
  8462. send_set_ssid_hotlist_cmd_tlv(wmi_unified_t wmi_handle,
  8463. struct ssid_hotlist_request_params *request)
  8464. {
  8465. wmi_extscan_configure_hotlist_ssid_monitor_cmd_fixed_param *cmd;
  8466. wmi_buf_t wmi_buf;
  8467. uint32_t len;
  8468. uint32_t array_size;
  8469. uint8_t *buf_ptr;
  8470. /* length of fixed portion */
  8471. len = sizeof(*cmd);
  8472. /* length of variable portion */
  8473. array_size =
  8474. request->ssid_count * sizeof(wmi_extscan_hotlist_ssid_entry);
  8475. len += WMI_TLV_HDR_SIZE + array_size;
  8476. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  8477. if (!wmi_buf) {
  8478. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  8479. return QDF_STATUS_E_NOMEM;
  8480. }
  8481. buf_ptr = (uint8_t *) wmi_buf_data(wmi_buf);
  8482. cmd = (wmi_extscan_configure_hotlist_ssid_monitor_cmd_fixed_param *)
  8483. buf_ptr;
  8484. WMITLV_SET_HDR
  8485. (&cmd->tlv_header,
  8486. WMITLV_TAG_STRUC_wmi_extscan_configure_hotlist_ssid_monitor_cmd_fixed_param,
  8487. WMITLV_GET_STRUCT_TLVLEN
  8488. (wmi_extscan_configure_hotlist_ssid_monitor_cmd_fixed_param));
  8489. cmd->request_id = request->request_id;
  8490. cmd->requestor_id = 0;
  8491. cmd->vdev_id = request->session_id;
  8492. cmd->table_id = 0;
  8493. cmd->lost_ap_scan_count = request->lost_ssid_sample_size;
  8494. cmd->total_entries = request->ssid_count;
  8495. cmd->num_entries_in_page = request->ssid_count;
  8496. cmd->first_entry_index = 0;
  8497. buf_ptr += sizeof(*cmd);
  8498. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_STRUC, array_size);
  8499. if (request->ssid_count) {
  8500. wmi_extscan_hotlist_ssid_entry *entry;
  8501. int i;
  8502. buf_ptr += WMI_TLV_HDR_SIZE;
  8503. entry = (wmi_extscan_hotlist_ssid_entry *)buf_ptr;
  8504. for (i = 0; i < request->ssid_count; i++) {
  8505. WMITLV_SET_HDR
  8506. (entry,
  8507. WMITLV_TAG_ARRAY_STRUC,
  8508. WMITLV_GET_STRUCT_TLVLEN
  8509. (wmi_extscan_hotlist_ssid_entry));
  8510. entry->ssid.ssid_len = request->ssids[i].ssid.length;
  8511. qdf_mem_copy(entry->ssid.ssid,
  8512. request->ssids[i].ssid.mac_ssid,
  8513. request->ssids[i].ssid.length);
  8514. entry->band = request->ssids[i].band;
  8515. entry->min_rssi = request->ssids[i].rssi_low;
  8516. entry->max_rssi = request->ssids[i].rssi_high;
  8517. entry++;
  8518. }
  8519. cmd->mode = WMI_EXTSCAN_MODE_START;
  8520. } else {
  8521. cmd->mode = WMI_EXTSCAN_MODE_STOP;
  8522. }
  8523. if (wmi_unified_cmd_send
  8524. (wmi_handle, wmi_buf, len,
  8525. WMI_EXTSCAN_CONFIGURE_HOTLIST_SSID_MONITOR_CMDID)) {
  8526. WMI_LOGE("%s: failed to send command", __func__);
  8527. wmi_buf_free(wmi_buf);
  8528. return QDF_STATUS_E_FAILURE;
  8529. }
  8530. return QDF_STATUS_SUCCESS;
  8531. }
  8532. /**
  8533. * send_process_roam_synch_complete_cmd_tlv() - roam synch complete command to fw.
  8534. * @wmi_handle: wmi handle
  8535. * @vdev_id: vdev id
  8536. *
  8537. * This function sends roam synch complete event to fw.
  8538. *
  8539. * Return: CDF STATUS
  8540. */
  8541. QDF_STATUS send_process_roam_synch_complete_cmd_tlv(wmi_unified_t wmi_handle,
  8542. uint8_t vdev_id)
  8543. {
  8544. wmi_roam_synch_complete_fixed_param *cmd;
  8545. wmi_buf_t wmi_buf;
  8546. uint8_t *buf_ptr;
  8547. uint16_t len;
  8548. len = sizeof(wmi_roam_synch_complete_fixed_param);
  8549. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  8550. if (!wmi_buf) {
  8551. WMI_LOGE("%s: wmi_buf_alloc failed", __func__);
  8552. return QDF_STATUS_E_NOMEM;
  8553. }
  8554. cmd = (wmi_roam_synch_complete_fixed_param *) wmi_buf_data(wmi_buf);
  8555. buf_ptr = (uint8_t *) cmd;
  8556. WMITLV_SET_HDR(&cmd->tlv_header,
  8557. WMITLV_TAG_STRUC_wmi_roam_synch_complete_fixed_param,
  8558. WMITLV_GET_STRUCT_TLVLEN
  8559. (wmi_roam_synch_complete_fixed_param));
  8560. cmd->vdev_id = vdev_id;
  8561. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  8562. WMI_ROAM_SYNCH_COMPLETE)) {
  8563. WMI_LOGP("%s: failed to send roam synch confirmation",
  8564. __func__);
  8565. qdf_nbuf_free(wmi_buf);
  8566. return QDF_STATUS_E_FAILURE;
  8567. }
  8568. return QDF_STATUS_SUCCESS;
  8569. }
  8570. /**
  8571. * send_unit_test_cmd_tlv() - send unit test command to fw.
  8572. * @wmi_handle: wmi handle
  8573. * @wmi_utest: unit test command
  8574. *
  8575. * This function send unit test command to fw.
  8576. *
  8577. * Return: CDF STATUS
  8578. */
  8579. QDF_STATUS send_unit_test_cmd_tlv(wmi_unified_t wmi_handle,
  8580. struct wmi_unit_test_cmd *wmi_utest)
  8581. {
  8582. wmi_unit_test_cmd_fixed_param *cmd;
  8583. wmi_buf_t wmi_buf;
  8584. uint8_t *buf_ptr;
  8585. int i;
  8586. uint16_t len, args_tlv_len;
  8587. A_UINT32 *unit_test_cmd_args;
  8588. args_tlv_len =
  8589. WMI_TLV_HDR_SIZE + wmi_utest->num_args * sizeof(A_UINT32);
  8590. len = sizeof(wmi_unit_test_cmd_fixed_param) + args_tlv_len;
  8591. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  8592. if (!wmi_buf) {
  8593. WMI_LOGE("%s: wmai_buf_alloc failed", __func__);
  8594. return QDF_STATUS_E_NOMEM;
  8595. }
  8596. cmd = (wmi_unit_test_cmd_fixed_param *) wmi_buf_data(wmi_buf);
  8597. buf_ptr = (uint8_t *) cmd;
  8598. WMITLV_SET_HDR(&cmd->tlv_header,
  8599. WMITLV_TAG_STRUC_wmi_unit_test_cmd_fixed_param,
  8600. WMITLV_GET_STRUCT_TLVLEN(wmi_unit_test_cmd_fixed_param));
  8601. cmd->vdev_id = wmi_utest->vdev_id;
  8602. cmd->module_id = wmi_utest->module_id;
  8603. cmd->num_args = wmi_utest->num_args;
  8604. buf_ptr += sizeof(wmi_unit_test_cmd_fixed_param);
  8605. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  8606. (wmi_utest->num_args * sizeof(uint32_t)));
  8607. unit_test_cmd_args = (A_UINT32 *) (buf_ptr + WMI_TLV_HDR_SIZE);
  8608. WMI_LOGI("%s: %d num of args = ", __func__, wmi_utest->num_args);
  8609. for (i = 0; (i < wmi_utest->num_args && i < WMI_MAX_NUM_ARGS); i++) {
  8610. unit_test_cmd_args[i] = wmi_utest->args[i];
  8611. WMI_LOGI("%d,", wmi_utest->args[i]);
  8612. }
  8613. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  8614. WMI_UNIT_TEST_CMDID)) {
  8615. WMI_LOGP("%s: failed to send unit test command", __func__);
  8616. qdf_nbuf_free(wmi_buf);
  8617. return QDF_STATUS_E_FAILURE;
  8618. }
  8619. return QDF_STATUS_SUCCESS;
  8620. }
  8621. /**
  8622. * send_roam_invoke_cmd_tlv() - send roam invoke command to fw.
  8623. * @wmi_handle: wma handle
  8624. * @roaminvoke: roam invoke command
  8625. *
  8626. * Send roam invoke command to fw for fastreassoc.
  8627. *
  8628. * Return: CDF STATUS
  8629. */
  8630. QDF_STATUS send_roam_invoke_cmd_tlv(wmi_unified_t wmi_handle,
  8631. struct wmi_roam_invoke_cmd *roaminvoke,
  8632. uint32_t ch_hz)
  8633. {
  8634. wmi_roam_invoke_cmd_fixed_param *cmd;
  8635. wmi_buf_t wmi_buf;
  8636. u_int8_t *buf_ptr;
  8637. u_int16_t len, args_tlv_len;
  8638. A_UINT32 *channel_list;
  8639. wmi_mac_addr *bssid_list;
  8640. /* Host sends only one channel and one bssid */
  8641. args_tlv_len = 2 * WMI_TLV_HDR_SIZE + sizeof(A_UINT32) +
  8642. sizeof(wmi_mac_addr);
  8643. len = sizeof(wmi_roam_invoke_cmd_fixed_param) + args_tlv_len;
  8644. wmi_buf = wmi_buf_alloc(wmi_handle, len);
  8645. if (!wmi_buf) {
  8646. WMI_LOGE("%s: wmai_buf_alloc failed", __func__);
  8647. return QDF_STATUS_E_NOMEM;
  8648. }
  8649. cmd = (wmi_roam_invoke_cmd_fixed_param *)wmi_buf_data(wmi_buf);
  8650. buf_ptr = (u_int8_t *) cmd;
  8651. WMITLV_SET_HDR(&cmd->tlv_header,
  8652. WMITLV_TAG_STRUC_wmi_roam_invoke_cmd_fixed_param,
  8653. WMITLV_GET_STRUCT_TLVLEN(wmi_roam_invoke_cmd_fixed_param));
  8654. cmd->vdev_id = roaminvoke->vdev_id;
  8655. cmd->flags = 0;
  8656. cmd->roam_scan_mode = 0;
  8657. cmd->roam_ap_sel_mode = 0;
  8658. cmd->roam_delay = 0;
  8659. cmd->num_chan = 1;
  8660. cmd->num_bssid = 1;
  8661. buf_ptr += sizeof(wmi_roam_invoke_cmd_fixed_param);
  8662. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  8663. (sizeof(u_int32_t)));
  8664. channel_list = (A_UINT32 *)(buf_ptr + WMI_TLV_HDR_SIZE);
  8665. *channel_list = ch_hz;
  8666. buf_ptr += sizeof(A_UINT32) + WMI_TLV_HDR_SIZE;
  8667. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_FIXED_STRUC,
  8668. (sizeof(wmi_mac_addr)));
  8669. bssid_list = (wmi_mac_addr *)(buf_ptr + WMI_TLV_HDR_SIZE);
  8670. WMI_CHAR_ARRAY_TO_MAC_ADDR(roaminvoke->bssid, bssid_list);
  8671. if (wmi_unified_cmd_send(wmi_handle, wmi_buf, len,
  8672. WMI_ROAM_INVOKE_CMDID)) {
  8673. WMI_LOGP("%s: failed to send roam invoke command", __func__);
  8674. wmi_buf_free(wmi_buf);
  8675. return QDF_STATUS_E_FAILURE;
  8676. }
  8677. return QDF_STATUS_SUCCESS;
  8678. }
  8679. /**
  8680. * send_roam_scan_offload_cmd_tlv() - set roam offload command
  8681. * @wmi_handle: wmi handle
  8682. * @command: command
  8683. * @vdev_id: vdev id
  8684. *
  8685. * This function set roam offload command to fw.
  8686. *
  8687. * Return: CDF status
  8688. */
  8689. QDF_STATUS send_roam_scan_offload_cmd_tlv(wmi_unified_t wmi_handle,
  8690. uint32_t command, uint32_t vdev_id)
  8691. {
  8692. QDF_STATUS qdf_status;
  8693. wmi_roam_scan_cmd_fixed_param *cmd_fp;
  8694. wmi_buf_t buf = NULL;
  8695. int status = 0;
  8696. int len;
  8697. uint8_t *buf_ptr;
  8698. len = sizeof(wmi_roam_scan_cmd_fixed_param);
  8699. buf = wmi_buf_alloc(wmi_handle, len);
  8700. if (!buf) {
  8701. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  8702. return QDF_STATUS_E_NOMEM;
  8703. }
  8704. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  8705. cmd_fp = (wmi_roam_scan_cmd_fixed_param *) buf_ptr;
  8706. WMITLV_SET_HDR(&cmd_fp->tlv_header,
  8707. WMITLV_TAG_STRUC_wmi_roam_scan_cmd_fixed_param,
  8708. WMITLV_GET_STRUCT_TLVLEN(wmi_roam_scan_cmd_fixed_param));
  8709. cmd_fp->vdev_id = vdev_id;
  8710. cmd_fp->command_arg = command;
  8711. status = wmi_unified_cmd_send(wmi_handle, buf,
  8712. len, WMI_ROAM_SCAN_CMD);
  8713. if (status != EOK) {
  8714. WMI_LOGE("wmi_unified_cmd_send WMI_ROAM_SCAN_CMD returned Error %d",
  8715. status);
  8716. qdf_status = QDF_STATUS_E_FAILURE;
  8717. goto error;
  8718. }
  8719. WMI_LOGI("%s: WMI --> WMI_ROAM_SCAN_CMD", __func__);
  8720. return QDF_STATUS_SUCCESS;
  8721. error:
  8722. wmi_buf_free(buf);
  8723. return qdf_status;
  8724. }
  8725. /**
  8726. * send_roam_scan_offload_ap_profile_cmd_tlv() - set roam ap profile in fw
  8727. * @wmi_handle: wmi handle
  8728. * @ap_profile_p: ap profile
  8729. * @vdev_id: vdev id
  8730. *
  8731. * Send WMI_ROAM_AP_PROFILE to firmware
  8732. *
  8733. * Return: CDF status
  8734. */
  8735. QDF_STATUS send_roam_scan_offload_ap_profile_cmd_tlv(wmi_unified_t wmi_handle,
  8736. wmi_ap_profile *ap_profile_p,
  8737. uint32_t vdev_id)
  8738. {
  8739. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  8740. wmi_buf_t buf = NULL;
  8741. int status = 0;
  8742. int len;
  8743. uint8_t *buf_ptr;
  8744. wmi_roam_ap_profile_fixed_param *roam_ap_profile_fp;
  8745. len = sizeof(wmi_roam_ap_profile_fixed_param) + sizeof(wmi_ap_profile);
  8746. buf = wmi_buf_alloc(wmi_handle, len);
  8747. if (!buf) {
  8748. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  8749. return QDF_STATUS_E_NOMEM;
  8750. }
  8751. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  8752. roam_ap_profile_fp = (wmi_roam_ap_profile_fixed_param *) buf_ptr;
  8753. WMITLV_SET_HDR(&roam_ap_profile_fp->tlv_header,
  8754. WMITLV_TAG_STRUC_wmi_roam_ap_profile_fixed_param,
  8755. WMITLV_GET_STRUCT_TLVLEN
  8756. (wmi_roam_ap_profile_fixed_param));
  8757. /* fill in threshold values */
  8758. roam_ap_profile_fp->vdev_id = vdev_id;
  8759. roam_ap_profile_fp->id = 0;
  8760. buf_ptr += sizeof(wmi_roam_ap_profile_fixed_param);
  8761. qdf_mem_copy(buf_ptr, ap_profile_p, sizeof(wmi_ap_profile));
  8762. WMITLV_SET_HDR(buf_ptr,
  8763. WMITLV_TAG_STRUC_wmi_ap_profile,
  8764. WMITLV_GET_STRUCT_TLVLEN(wmi_ap_profile));
  8765. status = wmi_unified_cmd_send(wmi_handle, buf,
  8766. len, WMI_ROAM_AP_PROFILE);
  8767. if (status != EOK) {
  8768. WMI_LOGE("wmi_unified_cmd_send WMI_ROAM_AP_PROFILE returned Error %d",
  8769. status);
  8770. qdf_status = QDF_STATUS_E_FAILURE;
  8771. goto error;
  8772. }
  8773. WMI_LOGI("WMI --> WMI_ROAM_AP_PROFILE and other parameters");
  8774. return QDF_STATUS_SUCCESS;
  8775. error:
  8776. wmi_buf_free(buf);
  8777. return qdf_status;
  8778. }
  8779. /**
  8780. * send_roam_scan_offload_scan_period_cmd_tlv() - set roam offload scan period
  8781. * @wmi_handle: wmi handle
  8782. * @scan_period: scan period
  8783. * @scan_age: scan age
  8784. * @vdev_id: vdev id
  8785. *
  8786. * Send WMI_ROAM_SCAN_PERIOD parameters to fw.
  8787. *
  8788. * Return: CDF status
  8789. */
  8790. QDF_STATUS send_roam_scan_offload_scan_period_cmd_tlv(wmi_unified_t wmi_handle,
  8791. uint32_t scan_period,
  8792. uint32_t scan_age,
  8793. uint32_t vdev_id)
  8794. {
  8795. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  8796. wmi_buf_t buf = NULL;
  8797. int status = 0;
  8798. int len;
  8799. uint8_t *buf_ptr;
  8800. wmi_roam_scan_period_fixed_param *scan_period_fp;
  8801. /* Send scan period values */
  8802. len = sizeof(wmi_roam_scan_period_fixed_param);
  8803. buf = wmi_buf_alloc(wmi_handle, len);
  8804. if (!buf) {
  8805. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  8806. return QDF_STATUS_E_NOMEM;
  8807. }
  8808. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  8809. scan_period_fp = (wmi_roam_scan_period_fixed_param *) buf_ptr;
  8810. WMITLV_SET_HDR(&scan_period_fp->tlv_header,
  8811. WMITLV_TAG_STRUC_wmi_roam_scan_period_fixed_param,
  8812. WMITLV_GET_STRUCT_TLVLEN
  8813. (wmi_roam_scan_period_fixed_param));
  8814. /* fill in scan period values */
  8815. scan_period_fp->vdev_id = vdev_id;
  8816. scan_period_fp->roam_scan_period = scan_period; /* 20 seconds */
  8817. scan_period_fp->roam_scan_age = scan_age;
  8818. status = wmi_unified_cmd_send(wmi_handle, buf,
  8819. len, WMI_ROAM_SCAN_PERIOD);
  8820. if (status != EOK) {
  8821. WMI_LOGE("wmi_unified_cmd_send WMI_ROAM_SCAN_PERIOD returned Error %d",
  8822. status);
  8823. qdf_status = QDF_STATUS_E_FAILURE;
  8824. goto error;
  8825. }
  8826. WMI_LOGI("%s: WMI --> WMI_ROAM_SCAN_PERIOD roam_scan_period=%d, roam_scan_age=%d",
  8827. __func__, scan_period, scan_age);
  8828. return QDF_STATUS_SUCCESS;
  8829. error:
  8830. wmi_buf_free(buf);
  8831. return qdf_status;
  8832. }
  8833. /**
  8834. * send_roam_scan_offload_chan_list_cmd_tlv() - set roam offload channel list
  8835. * @wmi_handle: wmi handle
  8836. * @chan_count: channel count
  8837. * @chan_list: channel list
  8838. * @list_type: list type
  8839. * @vdev_id: vdev id
  8840. *
  8841. * Set roam offload channel list.
  8842. *
  8843. * Return: CDF status
  8844. */
  8845. QDF_STATUS send_roam_scan_offload_chan_list_cmd_tlv(wmi_unified_t wmi_handle,
  8846. uint8_t chan_count,
  8847. uint8_t *chan_list,
  8848. uint8_t list_type, uint32_t vdev_id)
  8849. {
  8850. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  8851. wmi_buf_t buf = NULL;
  8852. int status = 0;
  8853. int len, list_tlv_len;
  8854. int i;
  8855. uint8_t *buf_ptr;
  8856. wmi_roam_chan_list_fixed_param *chan_list_fp;
  8857. A_UINT32 *roam_chan_list_array;
  8858. if (chan_count == 0) {
  8859. WMI_LOGD("%s : invalid number of channels %d", __func__,
  8860. chan_count);
  8861. return QDF_STATUS_E_EMPTY;
  8862. }
  8863. /* Channel list is a table of 2 TLV's */
  8864. list_tlv_len = WMI_TLV_HDR_SIZE + chan_count * sizeof(A_UINT32);
  8865. len = sizeof(wmi_roam_chan_list_fixed_param) + list_tlv_len;
  8866. buf = wmi_buf_alloc(wmi_handle, len);
  8867. if (!buf) {
  8868. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  8869. return QDF_STATUS_E_NOMEM;
  8870. }
  8871. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  8872. chan_list_fp = (wmi_roam_chan_list_fixed_param *) buf_ptr;
  8873. WMITLV_SET_HDR(&chan_list_fp->tlv_header,
  8874. WMITLV_TAG_STRUC_wmi_roam_chan_list_fixed_param,
  8875. WMITLV_GET_STRUCT_TLVLEN
  8876. (wmi_roam_chan_list_fixed_param));
  8877. chan_list_fp->vdev_id = vdev_id;
  8878. chan_list_fp->num_chan = chan_count;
  8879. if (chan_count > 0 && list_type == CHANNEL_LIST_STATIC) {
  8880. /* external app is controlling channel list */
  8881. chan_list_fp->chan_list_type =
  8882. WMI_ROAM_SCAN_CHAN_LIST_TYPE_STATIC;
  8883. } else {
  8884. /* umac supplied occupied channel list in LFR */
  8885. chan_list_fp->chan_list_type =
  8886. WMI_ROAM_SCAN_CHAN_LIST_TYPE_DYNAMIC;
  8887. }
  8888. buf_ptr += sizeof(wmi_roam_chan_list_fixed_param);
  8889. WMITLV_SET_HDR(buf_ptr, WMITLV_TAG_ARRAY_UINT32,
  8890. (chan_list_fp->num_chan * sizeof(uint32_t)));
  8891. roam_chan_list_array = (A_UINT32 *) (buf_ptr + WMI_TLV_HDR_SIZE);
  8892. WMI_LOGI("%s: %d channels = ", __func__, chan_list_fp->num_chan);
  8893. for (i = 0; ((i < chan_list_fp->num_chan) &&
  8894. (i < WMI_ROAM_MAX_CHANNELS)); i++) {
  8895. roam_chan_list_array[i] = chan_list[i];
  8896. WMI_LOGI("%d,", roam_chan_list_array[i]);
  8897. }
  8898. status = wmi_unified_cmd_send(wmi_handle, buf,
  8899. len, WMI_ROAM_CHAN_LIST);
  8900. if (status != EOK) {
  8901. WMI_LOGE("wmi_unified_cmd_send WMI_ROAM_CHAN_LIST returned Error %d",
  8902. status);
  8903. qdf_status = QDF_STATUS_E_FAILURE;
  8904. goto error;
  8905. }
  8906. WMI_LOGI("%s: WMI --> WMI_ROAM_SCAN_CHAN_LIST", __func__);
  8907. return QDF_STATUS_SUCCESS;
  8908. error:
  8909. wmi_buf_free(buf);
  8910. return qdf_status;
  8911. }
  8912. /**
  8913. * send_roam_scan_offload_rssi_change_cmd_tlv() - set roam offload RSSI th
  8914. * @wmi_handle: wmi handle
  8915. * @rssi_change_thresh: RSSI Change threshold
  8916. * @bcn_rssi_weight: beacon RSSI weight
  8917. * @vdev_id: vdev id
  8918. *
  8919. * Send WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD parameters to fw.
  8920. *
  8921. * Return: CDF status
  8922. */
  8923. QDF_STATUS send_roam_scan_offload_rssi_change_cmd_tlv(wmi_unified_t wmi_handle,
  8924. uint32_t vdev_id,
  8925. int32_t rssi_change_thresh,
  8926. uint32_t bcn_rssi_weight,
  8927. uint32_t hirssi_delay_btw_scans)
  8928. {
  8929. QDF_STATUS qdf_status = QDF_STATUS_SUCCESS;
  8930. wmi_buf_t buf = NULL;
  8931. int status = 0;
  8932. int len;
  8933. uint8_t *buf_ptr;
  8934. wmi_roam_scan_rssi_change_threshold_fixed_param *rssi_change_fp;
  8935. /* Send rssi change parameters */
  8936. len = sizeof(wmi_roam_scan_rssi_change_threshold_fixed_param);
  8937. buf = wmi_buf_alloc(wmi_handle, len);
  8938. if (!buf) {
  8939. WMI_LOGE("%s : wmi_buf_alloc failed", __func__);
  8940. return QDF_STATUS_E_NOMEM;
  8941. }
  8942. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  8943. rssi_change_fp =
  8944. (wmi_roam_scan_rssi_change_threshold_fixed_param *) buf_ptr;
  8945. WMITLV_SET_HDR(&rssi_change_fp->tlv_header,
  8946. WMITLV_TAG_STRUC_wmi_roam_scan_rssi_change_threshold_fixed_param,
  8947. WMITLV_GET_STRUCT_TLVLEN
  8948. (wmi_roam_scan_rssi_change_threshold_fixed_param));
  8949. /* fill in rssi change threshold (hysteresis) values */
  8950. rssi_change_fp->vdev_id = vdev_id;
  8951. rssi_change_fp->roam_scan_rssi_change_thresh = rssi_change_thresh;
  8952. rssi_change_fp->bcn_rssi_weight = bcn_rssi_weight;
  8953. rssi_change_fp->hirssi_delay_btw_scans = hirssi_delay_btw_scans;
  8954. status = wmi_unified_cmd_send(wmi_handle, buf,
  8955. len, WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD);
  8956. if (status != EOK) {
  8957. WMI_LOGE("wmi_unified_cmd_send WMI_ROAM_SCAN_RSSI_CHANGE_THRESHOLD returned Error %d",
  8958. status);
  8959. qdf_status = QDF_STATUS_E_FAILURE;
  8960. goto error;
  8961. }
  8962. WMI_LOGI(FL("roam_scan_rssi_change_thresh=%d, bcn_rssi_weight=%d"),
  8963. rssi_change_thresh, bcn_rssi_weight);
  8964. WMI_LOGI(FL("hirssi_delay_btw_scans=%d"), hirssi_delay_btw_scans);
  8965. return QDF_STATUS_SUCCESS;
  8966. error:
  8967. wmi_buf_free(buf);
  8968. return qdf_status;
  8969. }
  8970. /** wmi_get_hotlist_entries_per_page() - hotlist entries per page
  8971. * @wmi_handle: wmi handle.
  8972. * @cmd: size of command structure.
  8973. * @per_entry_size: per entry size.
  8974. *
  8975. * This utility function calculates how many hotlist entries can
  8976. * fit in one page.
  8977. *
  8978. * Return: number of entries
  8979. */
  8980. static inline int wmi_get_hotlist_entries_per_page(wmi_unified_t wmi_handle,
  8981. size_t cmd_size,
  8982. size_t per_entry_size)
  8983. {
  8984. uint32_t avail_space = 0;
  8985. int num_entries = 0;
  8986. uint16_t max_msg_len = wmi_get_max_msg_len(wmi_handle);
  8987. /* Calculate number of hotlist entries that can
  8988. * be passed in wma message request.
  8989. */
  8990. avail_space = max_msg_len - cmd_size;
  8991. num_entries = avail_space / per_entry_size;
  8992. return num_entries;
  8993. }
  8994. /**
  8995. * send_get_buf_extscan_hotlist_cmd_tlv() - prepare hotlist command
  8996. * @wmi_handle: wmi handle
  8997. * @photlist: hotlist command params
  8998. * @buf_len: buffer length
  8999. *
  9000. * This function fills individual elements for hotlist request and
  9001. * TLV for bssid entries
  9002. *
  9003. * Return: CDF Status.
  9004. */
  9005. QDF_STATUS send_get_buf_extscan_hotlist_cmd_tlv(wmi_unified_t wmi_handle,
  9006. struct ext_scan_setbssi_hotlist_params *
  9007. photlist, int *buf_len)
  9008. {
  9009. wmi_extscan_configure_hotlist_monitor_cmd_fixed_param *cmd = NULL;
  9010. wmi_extscan_hotlist_entry *dest_hotlist;
  9011. struct ap_threshold_params *src_ap = photlist->ap;
  9012. wmi_buf_t buf;
  9013. uint8_t *buf_ptr;
  9014. int j, index = 0;
  9015. int cmd_len = 0;
  9016. int num_entries;
  9017. int min_entries = 0;
  9018. int numap = photlist->numAp;
  9019. int len = sizeof(*cmd);
  9020. len += WMI_TLV_HDR_SIZE;
  9021. cmd_len = len;
  9022. num_entries = wmi_get_hotlist_entries_per_page(wmi_handle,
  9023. cmd_len,
  9024. sizeof(*dest_hotlist));
  9025. /* setbssid hotlist expects the bssid list
  9026. * to be non zero value
  9027. */
  9028. if (!numap) {
  9029. WMI_LOGE("%s: Invalid number of bssid's", __func__);
  9030. return QDF_STATUS_E_INVAL;
  9031. }
  9032. /* Split the hot list entry pages and send multiple command
  9033. * requests if the buffer reaches the maximum request size
  9034. */
  9035. while (index < numap) {
  9036. min_entries = QDF_MIN(num_entries, numap);
  9037. len += min_entries * sizeof(wmi_extscan_hotlist_entry);
  9038. buf = wmi_buf_alloc(wmi_handle, len);
  9039. if (!buf) {
  9040. WMI_LOGP("%s: wmi_buf_alloc failed", __func__);
  9041. return QDF_STATUS_E_FAILURE;
  9042. }
  9043. buf_ptr = (uint8_t *) wmi_buf_data(buf);
  9044. cmd = (wmi_extscan_configure_hotlist_monitor_cmd_fixed_param *)
  9045. buf_ptr;
  9046. WMITLV_SET_HDR(&cmd->tlv_header,
  9047. WMITLV_TAG_STRUC_wmi_extscan_configure_hotlist_monitor_cmd_fixed_param,
  9048. WMITLV_GET_STRUCT_TLVLEN
  9049. (wmi_extscan_configure_hotlist_monitor_cmd_fixed_param));
  9050. /* Multiple requests are sent until the num_entries_in_page
  9051. * matches the total_entries
  9052. */
  9053. cmd->request_id = photlist->requestId;
  9054. cmd->vdev_id = photlist->sessionId;
  9055. cmd->total_entries = numap;
  9056. cmd->mode = 1;
  9057. cmd->num_entries_in_page = min_entries;
  9058. cmd->lost_ap_scan_count = photlist->lost_ap_sample_size;
  9059. cmd->first_entry_index = index;
  9060. WMI_LOGD("%s: vdev id:%d total_entries: %d num_entries: %d lost_ap_sample_size: %d",
  9061. __func__, cmd->vdev_id, cmd->total_entries,
  9062. cmd->num_entries_in_page,
  9063. cmd->lost_ap_scan_count);
  9064. buf_ptr += sizeof(*cmd);
  9065. WMITLV_SET_HDR(buf_ptr,
  9066. WMITLV_TAG_ARRAY_STRUC,
  9067. min_entries * sizeof(wmi_extscan_hotlist_entry));
  9068. dest_hotlist = (wmi_extscan_hotlist_entry *)
  9069. (buf_ptr + WMI_TLV_HDR_SIZE);
  9070. /* Populate bssid, channel info and rssi
  9071. * for the bssid's that are sent as hotlists.
  9072. */
  9073. for (j = 0; j < min_entries; j++) {
  9074. WMITLV_SET_HDR(dest_hotlist,
  9075. WMITLV_TAG_STRUC_wmi_extscan_bucket_cmd_fixed_param,
  9076. WMITLV_GET_STRUCT_TLVLEN
  9077. (wmi_extscan_hotlist_entry));
  9078. dest_hotlist->min_rssi = src_ap->low;
  9079. WMI_CHAR_ARRAY_TO_MAC_ADDR(src_ap->bssid.bytes,
  9080. &dest_hotlist->bssid);
  9081. WMI_LOGD("%s:channel:%d min_rssi %d",
  9082. __func__, dest_hotlist->channel,
  9083. dest_hotlist->min_rssi);
  9084. WMI_LOGD
  9085. ("%s: bssid mac_addr31to0: 0x%x, mac_addr47to32: 0x%x",
  9086. __func__, dest_hotlist->bssid.mac_addr31to0,
  9087. dest_hotlist->bssid.mac_addr47to32);
  9088. dest_hotlist++;
  9089. src_ap++;
  9090. }
  9091. buf_ptr += WMI_TLV_HDR_SIZE +
  9092. (min_entries * sizeof(wmi_extscan_hotlist_entry));
  9093. if (wmi_unified_cmd_send(wmi_handle, buf, len,
  9094. WMI_EXTSCAN_CONFIGURE_HOTLIST_MONITOR_CMDID)) {
  9095. WMI_LOGE("%s: failed to send command", __func__);
  9096. qdf_nbuf_free(buf);
  9097. return QDF_STATUS_E_FAILURE;
  9098. }
  9099. index = index + min_entries;
  9100. num_entries = numap - min_entries;
  9101. len = cmd_len;
  9102. }
  9103. return QDF_STATUS_SUCCESS;
  9104. }
  9105. struct wmi_ops tlv_ops = {
  9106. .send_vdev_create_cmd = send_vdev_create_cmd_tlv,
  9107. .send_vdev_delete_cmd = send_vdev_delete_cmd_tlv,
  9108. .send_vdev_down_cmd = send_vdev_down_cmd_tlv,
  9109. .send_vdev_start_cmd = send_vdev_start_cmd_tlv,
  9110. .send_hidden_ssid_vdev_restart_cmd =
  9111. send_hidden_ssid_vdev_restart_cmd_tlv,
  9112. .send_peer_flush_tids_cmd = send_peer_flush_tids_cmd_tlv,
  9113. .send_peer_param_cmd = send_peer_param_cmd_tlv,
  9114. .send_vdev_up_cmd = send_vdev_up_cmd_tlv,
  9115. .send_vdev_stop_cmd = send_vdev_stop_cmd_tlv,
  9116. .send_peer_create_cmd = send_peer_create_cmd_tlv,
  9117. .send_peer_delete_cmd = send_peer_delete_cmd_tlv,
  9118. .send_green_ap_ps_cmd = send_green_ap_ps_cmd_tlv,
  9119. .send_pdev_utf_cmd = send_pdev_utf_cmd_tlv,
  9120. .send_pdev_param_cmd = send_pdev_param_cmd_tlv,
  9121. .send_suspend_cmd = send_suspend_cmd_tlv,
  9122. .send_resume_cmd = send_resume_cmd_tlv,
  9123. .send_wow_enable_cmd = send_wow_enable_cmd_tlv,
  9124. .send_set_ap_ps_param_cmd = send_set_ap_ps_param_cmd_tlv,
  9125. .send_set_sta_ps_param_cmd = send_set_sta_ps_param_cmd_tlv,
  9126. .send_crash_inject_cmd = send_crash_inject_cmd_tlv,
  9127. .send_dbglog_cmd = send_dbglog_cmd_tlv,
  9128. .send_vdev_set_param_cmd = send_vdev_set_param_cmd_tlv,
  9129. .send_stats_request_cmd = send_stats_request_cmd_tlv,
  9130. .send_packet_log_enable_cmd = send_packet_log_enable_cmd_tlv,
  9131. .send_beacon_send_cmd = send_beacon_send_cmd_tlv,
  9132. .send_peer_assoc_cmd = send_peer_assoc_cmd_tlv,
  9133. .send_scan_start_cmd = send_scan_start_cmd_tlv,
  9134. .send_scan_stop_cmd = send_scan_stop_cmd_tlv,
  9135. .send_scan_chan_list_cmd = send_scan_chan_list_cmd_tlv,
  9136. .send_mgmt_cmd = send_mgmt_cmd_tlv,
  9137. .send_modem_power_state_cmd = send_modem_power_state_cmd_tlv,
  9138. .send_set_sta_ps_mode_cmd = send_set_sta_ps_mode_cmd_tlv,
  9139. .send_set_sta_uapsd_auto_trig_cmd =
  9140. send_set_sta_uapsd_auto_trig_cmd_tlv,
  9141. .send_get_temperature_cmd = send_get_temperature_cmd_tlv,
  9142. .send_set_p2pgo_oppps_req_cmd = send_set_p2pgo_oppps_req_cmd_tlv,
  9143. .send_set_p2pgo_noa_req_cmd = send_set_p2pgo_noa_req_cmd_tlv,
  9144. .send_set_smps_params_cmd = send_set_smps_params_cmd_tlv,
  9145. .send_set_mimops_cmd = send_set_mimops_cmd_tlv,
  9146. .send_ocb_set_utc_time_cmd = send_ocb_set_utc_time_cmd_tlv,
  9147. .send_ocb_get_tsf_timer_cmd = send_ocb_get_tsf_timer_cmd_tlv,
  9148. .send_dcc_clear_stats_cmd = send_dcc_clear_stats_cmd_tlv,
  9149. .send_dcc_get_stats_cmd = send_dcc_get_stats_cmd_tlv,
  9150. .send_dcc_update_ndl_cmd = send_dcc_update_ndl_cmd_tlv,
  9151. .send_ocb_set_config_cmd = send_ocb_set_config_cmd_tlv,
  9152. .send_ocb_stop_timing_advert_cmd = send_ocb_stop_timing_advert_cmd_tlv,
  9153. .send_ocb_start_timing_advert_cmd =
  9154. send_ocb_start_timing_advert_cmd_tlv,
  9155. .send_set_enable_disable_mcc_adaptive_scheduler_cmd =
  9156. send_set_enable_disable_mcc_adaptive_scheduler_cmd_tlv,
  9157. .send_set_mcc_channel_time_latency_cmd =
  9158. send_set_mcc_channel_time_latency_cmd_tlv,
  9159. .send_set_mcc_channel_time_quota_cmd =
  9160. send_set_mcc_channel_time_quota_cmd_tlv,
  9161. .send_set_thermal_mgmt_cmd = send_set_thermal_mgmt_cmd_tlv,
  9162. .send_lro_config_cmd = send_lro_config_cmd_tlv,
  9163. .send_bcn_buf_ll_cmd = send_bcn_buf_ll_cmd_tlv,
  9164. .send_set_sta_sa_query_param_cmd = send_set_sta_sa_query_param_cmd_tlv,
  9165. .send_set_sta_keep_alive_cmd = send_set_sta_keep_alive_cmd_tlv,
  9166. .send_vdev_set_gtx_cfg_cmd = send_vdev_set_gtx_cfg_cmd_tlv,
  9167. .send_process_update_edca_param_cmd =
  9168. send_process_update_edca_param_cmd_tlv,
  9169. .send_probe_rsp_tmpl_send_cmd =
  9170. send_probe_rsp_tmpl_send_cmd_tlv,
  9171. .send_p2p_go_set_beacon_ie_cmd =
  9172. send_p2p_go_set_beacon_ie_cmd_tlv,
  9173. .send_setup_install_key_cmd =
  9174. send_setup_install_key_cmd_tlv,
  9175. .send_set_gateway_params_cmd =
  9176. send_set_gateway_params_cmd_tlv,
  9177. .send_set_rssi_monitoring_cmd =
  9178. send_set_rssi_monitoring_cmd_tlv,
  9179. .send_scan_probe_setoui_cmd =
  9180. send_scan_probe_setoui_cmd_tlv,
  9181. .send_reset_passpoint_network_list_cmd =
  9182. send_reset_passpoint_network_list_cmd_tlv,
  9183. .send_set_passpoint_network_list_cmd =
  9184. send_set_passpoint_network_list_cmd_tlv,
  9185. .send_roam_scan_offload_mode_cmd =
  9186. send_roam_scan_offload_mode_cmd_tlv,
  9187. .send_roam_scan_offload_rssi_thresh_cmd =
  9188. send_roam_scan_offload_rssi_thresh_cmd_tlv,
  9189. .send_roam_scan_filter_cmd =
  9190. send_roam_scan_filter_cmd_tlv,
  9191. .send_set_epno_network_list_cmd =
  9192. send_set_epno_network_list_cmd_tlv,
  9193. .send_ipa_offload_control_cmd =
  9194. send_ipa_offload_control_cmd_tlv,
  9195. .send_extscan_get_capabilities_cmd =
  9196. send_extscan_get_capabilities_cmd_tlv,
  9197. .send_extscan_get_cached_results_cmd =
  9198. send_extscan_get_cached_results_cmd_tlv,
  9199. .send_extscan_stop_change_monitor_cmd =
  9200. send_extscan_stop_change_monitor_cmd_tlv,
  9201. .send_extscan_start_change_monitor_cmd =
  9202. send_extscan_start_change_monitor_cmd_tlv,
  9203. .send_extscan_stop_hotlist_monitor_cmd =
  9204. send_extscan_stop_hotlist_monitor_cmd_tlv,
  9205. .send_stop_extscan_cmd = send_stop_extscan_cmd_tlv,
  9206. .send_start_extscan_cmd = send_start_extscan_cmd_tlv,
  9207. .send_plm_stop_cmd = send_plm_stop_cmd_tlv,
  9208. .send_plm_start_cmd = send_plm_start_cmd_tlv,
  9209. .send_pno_stop_cmd = send_pno_stop_cmd_tlv,
  9210. .send_pno_start_cmd = send_pno_start_cmd_tlv,
  9211. .send_set_ric_req_cmd = send_set_ric_req_cmd_tlv,
  9212. .send_process_ll_stats_clear_cmd = send_process_ll_stats_clear_cmd_tlv,
  9213. .send_process_ll_stats_set_cmd = send_process_ll_stats_set_cmd_tlv,
  9214. .send_process_ll_stats_get_cmd = send_process_ll_stats_get_cmd_tlv,
  9215. .send_get_stats_cmd = send_get_stats_cmd_tlv,
  9216. .send_snr_request_cmd = send_snr_request_cmd_tlv,
  9217. .send_snr_cmd = send_snr_cmd_tlv,
  9218. .send_link_status_req_cmd = send_link_status_req_cmd_tlv,
  9219. .send_lphb_config_hbenable_cmd = send_lphb_config_hbenable_cmd_tlv,
  9220. .send_lphb_config_tcp_params_cmd = send_lphb_config_tcp_params_cmd_tlv,
  9221. .send_lphb_config_udp_params_cmd = send_lphb_config_udp_params_cmd_tlv,
  9222. .send_lphb_config_udp_pkt_filter_cmd =
  9223. send_lphb_config_udp_pkt_filter_cmd_tlv,
  9224. .send_process_dhcp_ind_cmd = send_process_dhcp_ind_cmd_tlv,
  9225. .send_get_link_speed_cmd = send_get_link_speed_cmd_tlv,
  9226. .send_egap_conf_params_cmd = send_egap_conf_params_cmd_tlv,
  9227. .send_fw_profiling_cmd = send_fw_profiling_cmd_tlv,
  9228. .send_csa_offload_enable_cmd = send_csa_offload_enable_cmd_tlv,
  9229. .send_wow_sta_ra_filter_cmd = send_wow_sta_ra_filter_cmd_tlv,
  9230. .send_nat_keepalive_en_cmd = send_nat_keepalive_en_cmd_tlv,
  9231. .send_start_oem_data_cmd = send_start_oem_data_cmd_tlv,
  9232. .send_dfs_phyerr_filter_offload_en_cmd =
  9233. send_dfs_phyerr_filter_offload_en_cmd_tlv,
  9234. .send_pktlog_wmi_send_cmd = send_pktlog_wmi_send_cmd_tlv,
  9235. .send_add_wow_wakeup_event_cmd = send_add_wow_wakeup_event_cmd_tlv,
  9236. .send_wow_patterns_to_fw_cmd = send_wow_patterns_to_fw_cmd_tlv,
  9237. .send_wow_delete_pattern_cmd = send_wow_delete_pattern_cmd_tlv,
  9238. .send_host_wakeup_ind_to_fw_cmd = send_host_wakeup_ind_to_fw_cmd_tlv,
  9239. .send_del_ts_cmd = send_del_ts_cmd_tlv,
  9240. .send_aggr_qos_cmd = send_aggr_qos_cmd_tlv,
  9241. .send_add_ts_cmd = send_add_ts_cmd_tlv,
  9242. .send_enable_disable_packet_filter_cmd =
  9243. send_enable_disable_packet_filter_cmd_tlv,
  9244. .send_config_packet_filter_cmd = send_config_packet_filter_cmd_tlv,
  9245. .send_add_clear_mcbc_filter_cmd = send_add_clear_mcbc_filter_cmd_tlv,
  9246. .send_gtk_offload_cmd = send_gtk_offload_cmd_tlv,
  9247. .send_process_gtk_offload_getinfo_cmd =
  9248. send_process_gtk_offload_getinfo_cmd_tlv,
  9249. .send_process_add_periodic_tx_ptrn_cmd =
  9250. send_process_add_periodic_tx_ptrn_cmd_tlv,
  9251. .send_process_del_periodic_tx_ptrn_cmd =
  9252. send_process_del_periodic_tx_ptrn_cmd_tlv,
  9253. .send_stats_ext_req_cmd = send_stats_ext_req_cmd_tlv,
  9254. .send_enable_ext_wow_cmd = send_enable_ext_wow_cmd_tlv,
  9255. .send_set_app_type2_params_in_fw_cmd =
  9256. send_set_app_type2_params_in_fw_cmd_tlv,
  9257. .send_set_auto_shutdown_timer_cmd =
  9258. send_set_auto_shutdown_timer_cmd_tlv,
  9259. .send_nan_req_cmd = send_nan_req_cmd_tlv,
  9260. .send_process_dhcpserver_offload_cmd =
  9261. send_process_dhcpserver_offload_cmd_tlv,
  9262. .send_set_led_flashing_cmd = send_set_led_flashing_cmd_tlv,
  9263. .send_process_ch_avoid_update_cmd =
  9264. send_process_ch_avoid_update_cmd_tlv,
  9265. .send_regdomain_info_to_fw_cmd = send_regdomain_info_to_fw_cmd_tlv,
  9266. .send_set_tdls_offchan_mode_cmd = send_set_tdls_offchan_mode_cmd_tlv,
  9267. .send_update_fw_tdls_state_cmd = send_update_fw_tdls_state_cmd_tlv,
  9268. .send_update_tdls_peer_state_cmd = send_update_tdls_peer_state_cmd_tlv,
  9269. .send_process_fw_mem_dump_cmd = send_process_fw_mem_dump_cmd_tlv,
  9270. .send_process_set_ie_info_cmd = send_process_set_ie_info_cmd_tlv,
  9271. .send_init_cmd = send_init_cmd_tlv,
  9272. .save_fw_version_cmd = save_fw_version_cmd_tlv,
  9273. .check_and_update_fw_version_cmd =
  9274. check_and_update_fw_version_cmd_tlv,
  9275. .send_saved_init_cmd = send_saved_init_cmd_tlv,
  9276. .send_set_base_macaddr_indicate_cmd =
  9277. send_set_base_macaddr_indicate_cmd_tlv,
  9278. .send_log_supported_evt_cmd = send_log_supported_evt_cmd_tlv,
  9279. .send_enable_specific_fw_logs_cmd =
  9280. send_enable_specific_fw_logs_cmd_tlv,
  9281. .send_flush_logs_to_fw_cmd = send_flush_logs_to_fw_cmd_tlv,
  9282. .send_soc_set_pcl_cmd = send_soc_set_pcl_cmd_tlv,
  9283. .send_soc_set_hw_mode_cmd = send_soc_set_hw_mode_cmd_tlv,
  9284. .send_soc_set_dual_mac_config_cmd =
  9285. send_soc_set_dual_mac_config_cmd_tlv,
  9286. .send_enable_arp_ns_offload_cmd =
  9287. send_enable_arp_ns_offload_cmd_tlv,
  9288. .send_app_type1_params_in_fw_cmd =
  9289. send_app_type1_params_in_fw_cmd_tlv,
  9290. .send_set_ssid_hotlist_cmd = send_set_ssid_hotlist_cmd_tlv,
  9291. .send_process_roam_synch_complete_cmd =
  9292. send_process_roam_synch_complete_cmd_tlv,
  9293. .send_unit_test_cmd = send_unit_test_cmd_tlv,
  9294. .send_roam_invoke_cmd = send_roam_invoke_cmd_tlv,
  9295. .send_roam_scan_offload_cmd = send_roam_scan_offload_cmd_tlv,
  9296. .send_roam_scan_offload_ap_profile_cmd =
  9297. send_roam_scan_offload_ap_profile_cmd_tlv,
  9298. .send_roam_scan_offload_scan_period_cmd =
  9299. send_roam_scan_offload_scan_period_cmd_tlv,
  9300. .send_roam_scan_offload_chan_list_cmd =
  9301. send_roam_scan_offload_chan_list_cmd_tlv,
  9302. .send_roam_scan_offload_rssi_change_cmd =
  9303. send_roam_scan_offload_rssi_change_cmd_tlv,
  9304. .send_get_buf_extscan_hotlist_cmd =
  9305. send_get_buf_extscan_hotlist_cmd_tlv,
  9306. /* TODO - Add other tlv apis here */
  9307. };
  9308. /**
  9309. * wmi_get_tlv_ops() - gives pointer to wmi tlv ops
  9310. *
  9311. * Return: pointer to wmi tlv ops
  9312. */
  9313. struct wmi_ops *wmi_get_tlv_ops(void)
  9314. {
  9315. return &tlv_ops;
  9316. }