dp_peer.c 128 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179418041814182418341844185418641874188418941904191419241934194419541964197419841994200420142024203420442054206420742084209421042114212421342144215421642174218421942204221422242234224422542264227422842294230423142324233423442354236423742384239424042414242424342444245424642474248424942504251425242534254425542564257425842594260426142624263426442654266426742684269427042714272427342744275427642774278427942804281428242834284428542864287428842894290429142924293429442954296429742984299430043014302430343044305430643074308430943104311431243134314431543164317431843194320432143224323432443254326432743284329433043314332433343344335433643374338433943404341434243434344434543464347434843494350435143524353435443554356435743584359436043614362436343644365436643674368436943704371437243734374437543764377437843794380438143824383438443854386438743884389439043914392439343944395439643974398439944004401440244034404440544064407440844094410441144124413441444154416441744184419442044214422442344244425442644274428442944304431443244334434443544364437443844394440444144424443444444454446444744484449445044514452445344544455445644574458445944604461446244634464446544664467446844694470447144724473447444754476447744784479448044814482448344844485448644874488448944904491449244934494449544964497449844994500450145024503450445054506450745084509451045114512451345144515451645174518451945204521452245234524452545264527452845294530453145324533453445354536453745384539454045414542454345444545454645474548454945504551455245534554455545564557455845594560456145624563456445654566456745684569457045714572457345744575457645774578457945804581458245834584458545864587458845894590459145924593459445954596459745984599460046014602460346044605460646074608460946104611461246134614461546164617461846194620462146224623462446254626462746284629463046314632463346344635463646374638463946404641464246434644464546464647464846494650465146524653465446554656465746584659466046614662466346644665466646674668466946704671467246734674467546764677467846794680468146824683468446854686468746884689469046914692469346944695469646974698469947004701470247034704470547064707470847094710471147124713471447154716471747184719472047214722472347244725472647274728472947304731473247334734473547364737473847394740474147424743474447454746474747484749475047514752475347544755475647574758475947604761476247634764476547664767476847694770477147724773477447754776477747784779478047814782478347844785478647874788478947904791479247934794479547964797479847994800480148024803480448054806480748084809481048114812481348144815481648174818481948204821482248234824482548264827482848294830483148324833483448354836483748384839
  1. /*
  2. * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
  3. *
  4. * Permission to use, copy, modify, and/or distribute this software for
  5. * any purpose with or without fee is hereby granted, provided that the
  6. * above copyright notice and this permission notice appear in all
  7. * copies.
  8. *
  9. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  10. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  11. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  12. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  13. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  14. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  15. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  16. * PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #include <qdf_types.h>
  19. #include <qdf_lock.h>
  20. #include <hal_hw_headers.h>
  21. #include "dp_htt.h"
  22. #include "dp_types.h"
  23. #include "dp_internal.h"
  24. #include "dp_peer.h"
  25. #include "dp_rx_defrag.h"
  26. #include "dp_rx.h"
  27. #include <hal_api.h>
  28. #include <hal_reo.h>
  29. #include <cdp_txrx_handle.h>
  30. #include <wlan_cfg.h>
  31. #ifdef WIFI_MONITOR_SUPPORT
  32. #include <dp_mon.h>
  33. #endif
  34. #ifdef FEATURE_WDS
  35. #include "dp_txrx_wds.h"
  36. #endif
  37. #include <qdf_module.h>
  38. #ifdef QCA_PEER_EXT_STATS
  39. #include "dp_hist.h"
  40. #endif
  41. #ifdef REO_QDESC_HISTORY
  42. #define REO_QDESC_HISTORY_SIZE 512
  43. uint64_t reo_qdesc_history_idx;
  44. struct reo_qdesc_event reo_qdesc_history[REO_QDESC_HISTORY_SIZE];
  45. #endif
  46. #ifdef FEATURE_WDS
  47. static inline bool
  48. dp_peer_ast_free_in_unmap_supported(struct dp_soc *soc,
  49. struct dp_ast_entry *ast_entry)
  50. {
  51. /* if peer map v2 is enabled we are not freeing ast entry
  52. * here and it is supposed to be freed in unmap event (after
  53. * we receive delete confirmation from target)
  54. *
  55. * if peer_id is invalid we did not get the peer map event
  56. * for the peer free ast entry from here only in this case
  57. */
  58. if ((ast_entry->type != CDP_TXRX_AST_TYPE_WDS_HM_SEC) &&
  59. (ast_entry->type != CDP_TXRX_AST_TYPE_SELF))
  60. return true;
  61. return false;
  62. }
  63. #else
  64. static inline bool
  65. dp_peer_ast_free_in_unmap_supported(struct dp_soc *soc,
  66. struct dp_ast_entry *ast_entry)
  67. {
  68. return false;
  69. }
  70. void dp_soc_wds_attach(struct dp_soc *soc)
  71. {
  72. }
  73. void dp_soc_wds_detach(struct dp_soc *soc)
  74. {
  75. }
  76. #endif
  77. #ifdef REO_QDESC_HISTORY
  78. static inline void
  79. dp_rx_reo_qdesc_history_add(struct reo_desc_list_node *free_desc,
  80. enum reo_qdesc_event_type type)
  81. {
  82. struct reo_qdesc_event *evt;
  83. struct dp_rx_tid *rx_tid = &free_desc->rx_tid;
  84. uint32_t idx;
  85. reo_qdesc_history_idx++;
  86. idx = (reo_qdesc_history_idx & (REO_QDESC_HISTORY_SIZE - 1));
  87. evt = &reo_qdesc_history[idx];
  88. qdf_mem_copy(evt->peer_mac, free_desc->peer_mac, QDF_MAC_ADDR_SIZE);
  89. evt->qdesc_addr = rx_tid->hw_qdesc_paddr;
  90. evt->ts = qdf_get_log_timestamp();
  91. evt->type = type;
  92. }
  93. #ifdef WLAN_DP_FEATURE_DEFERRED_REO_QDESC_DESTROY
  94. static inline void
  95. dp_rx_reo_qdesc_deferred_evt_add(struct reo_desc_deferred_freelist_node *desc,
  96. enum reo_qdesc_event_type type)
  97. {
  98. struct reo_qdesc_event *evt;
  99. uint32_t idx;
  100. reo_qdesc_history_idx++;
  101. idx = (reo_qdesc_history_idx & (REO_QDESC_HISTORY_SIZE - 1));
  102. evt = &reo_qdesc_history[idx];
  103. qdf_mem_copy(evt->peer_mac, desc->peer_mac, QDF_MAC_ADDR_SIZE);
  104. evt->qdesc_addr = desc->hw_qdesc_paddr;
  105. evt->ts = qdf_get_log_timestamp();
  106. evt->type = type;
  107. }
  108. #define DP_RX_REO_QDESC_DEFERRED_FREE_EVT(desc) \
  109. dp_rx_reo_qdesc_deferred_evt_add((desc), REO_QDESC_FREE)
  110. #define DP_RX_REO_QDESC_DEFERRED_GET_MAC(desc, freedesc) \
  111. qdf_mem_copy(desc->peer_mac, freedesc->peer_mac, QDF_MAC_ADDR_SIZE)
  112. #endif /* WLAN_DP_FEATURE_DEFERRED_REO_QDESC_DESTROY */
  113. #define DP_RX_REO_QDESC_GET_MAC(freedesc, peer) \
  114. qdf_mem_copy(freedesc->peer_mac, peer->mac_addr.raw, QDF_MAC_ADDR_SIZE)
  115. #define DP_RX_REO_QDESC_UPDATE_EVT(free_desc) \
  116. dp_rx_reo_qdesc_history_add((free_desc), REO_QDESC_UPDATE_CB)
  117. #define DP_RX_REO_QDESC_FREE_EVT(free_desc) \
  118. dp_rx_reo_qdesc_history_add((free_desc), REO_QDESC_FREE)
  119. #else
  120. #define DP_RX_REO_QDESC_GET_MAC(freedesc, peer)
  121. #define DP_RX_REO_QDESC_UPDATE_EVT(free_desc)
  122. #define DP_RX_REO_QDESC_FREE_EVT(free_desc)
  123. #define DP_RX_REO_QDESC_DEFERRED_FREE_EVT(desc)
  124. #define DP_RX_REO_QDESC_DEFERRED_GET_MAC(desc, freedesc)
  125. #endif
  126. static inline void
  127. dp_set_ssn_valid_flag(struct hal_reo_cmd_params *params,
  128. uint8_t valid)
  129. {
  130. params->u.upd_queue_params.update_svld = 1;
  131. params->u.upd_queue_params.svld = valid;
  132. dp_peer_debug("Setting SSN valid bit to %d",
  133. valid);
  134. }
  135. static inline int dp_peer_find_mac_addr_cmp(
  136. union dp_align_mac_addr *mac_addr1,
  137. union dp_align_mac_addr *mac_addr2)
  138. {
  139. /*
  140. * Intentionally use & rather than &&.
  141. * because the operands are binary rather than generic boolean,
  142. * the functionality is equivalent.
  143. * Using && has the advantage of short-circuited evaluation,
  144. * but using & has the advantage of no conditional branching,
  145. * which is a more significant benefit.
  146. */
  147. return !((mac_addr1->align4.bytes_abcd == mac_addr2->align4.bytes_abcd)
  148. & (mac_addr1->align4.bytes_ef == mac_addr2->align4.bytes_ef));
  149. }
  150. QDF_STATUS dp_peer_ast_table_attach(struct dp_soc *soc)
  151. {
  152. uint32_t max_ast_index;
  153. max_ast_index = wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx);
  154. /* allocate ast_table for ast entry to ast_index map */
  155. dp_peer_info("\n%pK:<=== cfg max ast idx %d ====>", soc, max_ast_index);
  156. soc->ast_table = qdf_mem_malloc(max_ast_index *
  157. sizeof(struct dp_ast_entry *));
  158. if (!soc->ast_table) {
  159. dp_peer_err("%pK: ast_table memory allocation failed", soc);
  160. return QDF_STATUS_E_NOMEM;
  161. }
  162. return QDF_STATUS_SUCCESS; /* success */
  163. }
  164. /*
  165. * dp_peer_find_map_attach() - allocate memory for peer_id_to_obj_map
  166. * @soc: soc handle
  167. *
  168. * return: QDF_STATUS
  169. */
  170. static QDF_STATUS dp_peer_find_map_attach(struct dp_soc *soc)
  171. {
  172. uint32_t max_peers, peer_map_size;
  173. max_peers = soc->max_peers;
  174. /* allocate the peer ID -> peer object map */
  175. dp_peer_info("\n%pK:<=== cfg max peer id %d ====>", soc, max_peers);
  176. peer_map_size = max_peers * sizeof(soc->peer_id_to_obj_map[0]);
  177. soc->peer_id_to_obj_map = qdf_mem_malloc(peer_map_size);
  178. if (!soc->peer_id_to_obj_map) {
  179. dp_peer_err("%pK: peer map memory allocation failed", soc);
  180. return QDF_STATUS_E_NOMEM;
  181. }
  182. /*
  183. * The peer_id_to_obj_map doesn't really need to be initialized,
  184. * since elements are only used after they have been individually
  185. * initialized.
  186. * However, it is convenient for debugging to have all elements
  187. * that are not in use set to 0.
  188. */
  189. qdf_mem_zero(soc->peer_id_to_obj_map, peer_map_size);
  190. qdf_spinlock_create(&soc->peer_map_lock);
  191. return QDF_STATUS_SUCCESS; /* success */
  192. }
  193. static int dp_log2_ceil(unsigned int value)
  194. {
  195. unsigned int tmp = value;
  196. int log2 = -1;
  197. while (tmp) {
  198. log2++;
  199. tmp >>= 1;
  200. }
  201. if (1 << log2 != value)
  202. log2++;
  203. return log2;
  204. }
  205. #define DP_PEER_HASH_LOAD_MULT 2
  206. #define DP_PEER_HASH_LOAD_SHIFT 0
  207. #define DP_AST_HASH_LOAD_MULT 2
  208. #define DP_AST_HASH_LOAD_SHIFT 0
  209. /*
  210. * dp_peer_find_hash_attach() - allocate memory for peer_hash table
  211. * @soc: soc handle
  212. *
  213. * return: QDF_STATUS
  214. */
  215. static QDF_STATUS dp_peer_find_hash_attach(struct dp_soc *soc)
  216. {
  217. int i, hash_elems, log2;
  218. /* allocate the peer MAC address -> peer object hash table */
  219. hash_elems = soc->max_peers;
  220. hash_elems *= DP_PEER_HASH_LOAD_MULT;
  221. hash_elems >>= DP_PEER_HASH_LOAD_SHIFT;
  222. log2 = dp_log2_ceil(hash_elems);
  223. hash_elems = 1 << log2;
  224. soc->peer_hash.mask = hash_elems - 1;
  225. soc->peer_hash.idx_bits = log2;
  226. /* allocate an array of TAILQ peer object lists */
  227. soc->peer_hash.bins = qdf_mem_malloc(
  228. hash_elems * sizeof(TAILQ_HEAD(anonymous_tail_q, dp_peer)));
  229. if (!soc->peer_hash.bins)
  230. return QDF_STATUS_E_NOMEM;
  231. for (i = 0; i < hash_elems; i++)
  232. TAILQ_INIT(&soc->peer_hash.bins[i]);
  233. qdf_spinlock_create(&soc->peer_hash_lock);
  234. return QDF_STATUS_SUCCESS;
  235. }
  236. /*
  237. * dp_peer_find_hash_detach() - cleanup memory for peer_hash table
  238. * @soc: soc handle
  239. *
  240. * return: none
  241. */
  242. static void dp_peer_find_hash_detach(struct dp_soc *soc)
  243. {
  244. if (soc->peer_hash.bins) {
  245. qdf_mem_free(soc->peer_hash.bins);
  246. soc->peer_hash.bins = NULL;
  247. qdf_spinlock_destroy(&soc->peer_hash_lock);
  248. }
  249. }
  250. static inline unsigned dp_peer_find_hash_index(struct dp_soc *soc,
  251. union dp_align_mac_addr *mac_addr)
  252. {
  253. unsigned index;
  254. index =
  255. mac_addr->align2.bytes_ab ^
  256. mac_addr->align2.bytes_cd ^
  257. mac_addr->align2.bytes_ef;
  258. index ^= index >> soc->peer_hash.idx_bits;
  259. index &= soc->peer_hash.mask;
  260. return index;
  261. }
  262. /*
  263. * dp_peer_find_hash_add() - add peer to peer_hash_table
  264. * @soc: soc handle
  265. * @peer: peer handle
  266. *
  267. * return: none
  268. */
  269. void dp_peer_find_hash_add(struct dp_soc *soc, struct dp_peer *peer)
  270. {
  271. unsigned index;
  272. index = dp_peer_find_hash_index(soc, &peer->mac_addr);
  273. qdf_spin_lock_bh(&soc->peer_hash_lock);
  274. if (QDF_IS_STATUS_ERROR(dp_peer_get_ref(soc, peer, DP_MOD_ID_CONFIG))) {
  275. dp_err("unable to get peer ref at MAP mac: "QDF_MAC_ADDR_FMT,
  276. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  277. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  278. return;
  279. }
  280. /*
  281. * It is important to add the new peer at the tail of the peer list
  282. * with the bin index. Together with having the hash_find function
  283. * search from head to tail, this ensures that if two entries with
  284. * the same MAC address are stored, the one added first will be
  285. * found first.
  286. */
  287. TAILQ_INSERT_TAIL(&soc->peer_hash.bins[index], peer, hash_list_elem);
  288. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  289. }
  290. /*
  291. * dp_peer_vdev_list_add() - add peer into vdev's peer list
  292. * @soc: soc handle
  293. * @vdev: vdev handle
  294. * @peer: peer handle
  295. *
  296. * return: none
  297. */
  298. void dp_peer_vdev_list_add(struct dp_soc *soc, struct dp_vdev *vdev,
  299. struct dp_peer *peer)
  300. {
  301. qdf_spin_lock_bh(&vdev->peer_list_lock);
  302. if (QDF_IS_STATUS_ERROR(dp_peer_get_ref(soc, peer, DP_MOD_ID_CONFIG))) {
  303. dp_err("unable to get peer ref at MAP mac: "QDF_MAC_ADDR_FMT,
  304. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  305. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  306. return;
  307. }
  308. /* add this peer into the vdev's list */
  309. if (wlan_op_mode_sta == vdev->opmode)
  310. TAILQ_INSERT_HEAD(&vdev->peer_list, peer, peer_list_elem);
  311. else
  312. TAILQ_INSERT_TAIL(&vdev->peer_list, peer, peer_list_elem);
  313. vdev->num_peers++;
  314. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  315. }
  316. /*
  317. * dp_peer_vdev_list_remove() - remove peer from vdev's peer list
  318. * @soc: SoC handle
  319. * @vdev: VDEV handle
  320. * @peer: peer handle
  321. *
  322. * Return: none
  323. */
  324. void dp_peer_vdev_list_remove(struct dp_soc *soc, struct dp_vdev *vdev,
  325. struct dp_peer *peer)
  326. {
  327. uint8_t found = 0;
  328. struct dp_peer *tmppeer = NULL;
  329. qdf_spin_lock_bh(&vdev->peer_list_lock);
  330. TAILQ_FOREACH(tmppeer, &peer->vdev->peer_list, peer_list_elem) {
  331. if (tmppeer == peer) {
  332. found = 1;
  333. break;
  334. }
  335. }
  336. if (found) {
  337. TAILQ_REMOVE(&peer->vdev->peer_list, peer,
  338. peer_list_elem);
  339. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  340. vdev->num_peers--;
  341. } else {
  342. /*Ignoring the remove operation as peer not found*/
  343. dp_peer_debug("%pK: peer:%pK not found in vdev:%pK peerlist:%pK"
  344. , soc, peer, vdev, &peer->vdev->peer_list);
  345. }
  346. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  347. }
  348. /*
  349. * dp_peer_find_id_to_obj_add() - Add peer into peer_id table
  350. * @soc: SoC handle
  351. * @peer: peer handle
  352. * @peer_id: peer_id
  353. *
  354. * Return: None
  355. */
  356. void dp_peer_find_id_to_obj_add(struct dp_soc *soc,
  357. struct dp_peer *peer,
  358. uint16_t peer_id)
  359. {
  360. QDF_ASSERT(peer_id <= soc->max_peers);
  361. qdf_spin_lock_bh(&soc->peer_map_lock);
  362. if (QDF_IS_STATUS_ERROR(dp_peer_get_ref(soc, peer, DP_MOD_ID_CONFIG))) {
  363. dp_err("unable to get peer ref at MAP mac: "QDF_MAC_ADDR_FMT" peer_id %u",
  364. QDF_MAC_ADDR_REF(peer->mac_addr.raw), peer_id);
  365. qdf_spin_unlock_bh(&soc->peer_map_lock);
  366. return;
  367. }
  368. if (!soc->peer_id_to_obj_map[peer_id]) {
  369. soc->peer_id_to_obj_map[peer_id] = peer;
  370. } else {
  371. /* Peer map event came for peer_id which
  372. * is already mapped, this is not expected
  373. */
  374. QDF_ASSERT(0);
  375. }
  376. qdf_spin_unlock_bh(&soc->peer_map_lock);
  377. }
  378. /*
  379. * dp_peer_find_id_to_obj_remove() - remove peer from peer_id table
  380. * @soc: SoC handle
  381. * @peer_id: peer_id
  382. *
  383. * Return: None
  384. */
  385. void dp_peer_find_id_to_obj_remove(struct dp_soc *soc,
  386. uint16_t peer_id)
  387. {
  388. struct dp_peer *peer = NULL;
  389. QDF_ASSERT(peer_id <= soc->max_peers);
  390. qdf_spin_lock_bh(&soc->peer_map_lock);
  391. peer = soc->peer_id_to_obj_map[peer_id];
  392. soc->peer_id_to_obj_map[peer_id] = NULL;
  393. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  394. qdf_spin_unlock_bh(&soc->peer_map_lock);
  395. }
  396. /*
  397. * dp_peer_exist_on_pdev - check if peer with mac address exist on pdev
  398. *
  399. * @soc: Datapath SOC handle
  400. * @peer_mac_addr: peer mac address
  401. * @mac_addr_is_aligned: is mac address aligned
  402. * @pdev: Datapath PDEV handle
  403. *
  404. * Return: true if peer found else return false
  405. */
  406. static bool dp_peer_exist_on_pdev(struct dp_soc *soc,
  407. uint8_t *peer_mac_addr,
  408. int mac_addr_is_aligned,
  409. struct dp_pdev *pdev)
  410. {
  411. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  412. unsigned int index;
  413. struct dp_peer *peer;
  414. bool found = false;
  415. if (mac_addr_is_aligned) {
  416. mac_addr = (union dp_align_mac_addr *)peer_mac_addr;
  417. } else {
  418. qdf_mem_copy(
  419. &local_mac_addr_aligned.raw[0],
  420. peer_mac_addr, QDF_MAC_ADDR_SIZE);
  421. mac_addr = &local_mac_addr_aligned;
  422. }
  423. index = dp_peer_find_hash_index(soc, mac_addr);
  424. qdf_spin_lock_bh(&soc->peer_hash_lock);
  425. TAILQ_FOREACH(peer, &soc->peer_hash.bins[index], hash_list_elem) {
  426. if (dp_peer_find_mac_addr_cmp(mac_addr, &peer->mac_addr) == 0 &&
  427. (peer->vdev->pdev == pdev)) {
  428. found = true;
  429. break;
  430. }
  431. }
  432. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  433. return found;
  434. }
  435. #ifdef FEATURE_MEC
  436. /**
  437. * dp_peer_mec_hash_attach() - Allocate and initialize MEC Hash Table
  438. * @soc: SoC handle
  439. *
  440. * Return: QDF_STATUS
  441. */
  442. QDF_STATUS dp_peer_mec_hash_attach(struct dp_soc *soc)
  443. {
  444. int log2, hash_elems, i;
  445. log2 = dp_log2_ceil(DP_PEER_MAX_MEC_IDX);
  446. hash_elems = 1 << log2;
  447. soc->mec_hash.mask = hash_elems - 1;
  448. soc->mec_hash.idx_bits = log2;
  449. dp_peer_info("%pK: max mec index: %d",
  450. soc, DP_PEER_MAX_MEC_IDX);
  451. /* allocate an array of TAILQ mec object lists */
  452. soc->mec_hash.bins = qdf_mem_malloc(hash_elems *
  453. sizeof(TAILQ_HEAD(anonymous_tail_q,
  454. dp_mec_entry)));
  455. if (!soc->mec_hash.bins)
  456. return QDF_STATUS_E_NOMEM;
  457. for (i = 0; i < hash_elems; i++)
  458. TAILQ_INIT(&soc->mec_hash.bins[i]);
  459. return QDF_STATUS_SUCCESS;
  460. }
  461. /**
  462. * dp_peer_mec_hash_index() - Compute the MEC hash from MAC address
  463. * @soc: SoC handle
  464. *
  465. * Return: MEC hash
  466. */
  467. static inline uint32_t dp_peer_mec_hash_index(struct dp_soc *soc,
  468. union dp_align_mac_addr *mac_addr)
  469. {
  470. uint32_t index;
  471. index =
  472. mac_addr->align2.bytes_ab ^
  473. mac_addr->align2.bytes_cd ^
  474. mac_addr->align2.bytes_ef;
  475. index ^= index >> soc->mec_hash.idx_bits;
  476. index &= soc->mec_hash.mask;
  477. return index;
  478. }
  479. struct dp_mec_entry *dp_peer_mec_hash_find_by_pdevid(struct dp_soc *soc,
  480. uint8_t pdev_id,
  481. uint8_t *mec_mac_addr)
  482. {
  483. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  484. uint32_t index;
  485. struct dp_mec_entry *mecentry;
  486. qdf_mem_copy(&local_mac_addr_aligned.raw[0],
  487. mec_mac_addr, QDF_MAC_ADDR_SIZE);
  488. mac_addr = &local_mac_addr_aligned;
  489. index = dp_peer_mec_hash_index(soc, mac_addr);
  490. TAILQ_FOREACH(mecentry, &soc->mec_hash.bins[index], hash_list_elem) {
  491. if ((pdev_id == mecentry->pdev_id) &&
  492. !dp_peer_find_mac_addr_cmp(mac_addr, &mecentry->mac_addr))
  493. return mecentry;
  494. }
  495. return NULL;
  496. }
  497. /**
  498. * dp_peer_mec_hash_add() - Add MEC entry into hash table
  499. * @soc: SoC handle
  500. *
  501. * This function adds the MEC entry into SoC MEC hash table
  502. *
  503. * Return: None
  504. */
  505. static inline void dp_peer_mec_hash_add(struct dp_soc *soc,
  506. struct dp_mec_entry *mecentry)
  507. {
  508. uint32_t index;
  509. index = dp_peer_mec_hash_index(soc, &mecentry->mac_addr);
  510. qdf_spin_lock_bh(&soc->mec_lock);
  511. TAILQ_INSERT_TAIL(&soc->mec_hash.bins[index], mecentry, hash_list_elem);
  512. qdf_spin_unlock_bh(&soc->mec_lock);
  513. }
  514. QDF_STATUS dp_peer_mec_add_entry(struct dp_soc *soc,
  515. struct dp_vdev *vdev,
  516. uint8_t *mac_addr)
  517. {
  518. struct dp_mec_entry *mecentry = NULL;
  519. struct dp_pdev *pdev = NULL;
  520. if (!vdev) {
  521. dp_peer_err("%pK: Peers vdev is NULL", soc);
  522. return QDF_STATUS_E_INVAL;
  523. }
  524. pdev = vdev->pdev;
  525. if (qdf_unlikely(qdf_atomic_read(&soc->mec_cnt) >=
  526. DP_PEER_MAX_MEC_ENTRY)) {
  527. dp_peer_warn("%pK: max MEC entry limit reached mac_addr: "
  528. QDF_MAC_ADDR_FMT, soc, QDF_MAC_ADDR_REF(mac_addr));
  529. return QDF_STATUS_E_NOMEM;
  530. }
  531. qdf_spin_lock_bh(&soc->mec_lock);
  532. mecentry = dp_peer_mec_hash_find_by_pdevid(soc, pdev->pdev_id,
  533. mac_addr);
  534. if (qdf_likely(mecentry)) {
  535. mecentry->is_active = TRUE;
  536. qdf_spin_unlock_bh(&soc->mec_lock);
  537. return QDF_STATUS_E_ALREADY;
  538. }
  539. qdf_spin_unlock_bh(&soc->mec_lock);
  540. dp_peer_debug("%pK: pdevid: %u vdev: %u type: MEC mac_addr: "
  541. QDF_MAC_ADDR_FMT,
  542. soc, pdev->pdev_id, vdev->vdev_id,
  543. QDF_MAC_ADDR_REF(mac_addr));
  544. mecentry = (struct dp_mec_entry *)
  545. qdf_mem_malloc(sizeof(struct dp_mec_entry));
  546. if (qdf_unlikely(!mecentry)) {
  547. dp_peer_err("%pK: fail to allocate mecentry", soc);
  548. return QDF_STATUS_E_NOMEM;
  549. }
  550. qdf_copy_macaddr((struct qdf_mac_addr *)&mecentry->mac_addr.raw[0],
  551. (struct qdf_mac_addr *)mac_addr);
  552. mecentry->pdev_id = pdev->pdev_id;
  553. mecentry->vdev_id = vdev->vdev_id;
  554. mecentry->is_active = TRUE;
  555. dp_peer_mec_hash_add(soc, mecentry);
  556. qdf_atomic_inc(&soc->mec_cnt);
  557. DP_STATS_INC(soc, mec.added, 1);
  558. return QDF_STATUS_SUCCESS;
  559. }
  560. void dp_peer_mec_detach_entry(struct dp_soc *soc, struct dp_mec_entry *mecentry,
  561. void *ptr)
  562. {
  563. uint32_t index = dp_peer_mec_hash_index(soc, &mecentry->mac_addr);
  564. TAILQ_HEAD(, dp_mec_entry) * free_list = ptr;
  565. TAILQ_REMOVE(&soc->mec_hash.bins[index], mecentry,
  566. hash_list_elem);
  567. TAILQ_INSERT_TAIL(free_list, mecentry, hash_list_elem);
  568. }
  569. void dp_peer_mec_free_list(struct dp_soc *soc, void *ptr)
  570. {
  571. struct dp_mec_entry *mecentry, *mecentry_next;
  572. TAILQ_HEAD(, dp_mec_entry) * free_list = ptr;
  573. TAILQ_FOREACH_SAFE(mecentry, free_list, hash_list_elem,
  574. mecentry_next) {
  575. dp_peer_debug("%pK: MEC delete for mac_addr " QDF_MAC_ADDR_FMT,
  576. soc, QDF_MAC_ADDR_REF(&mecentry->mac_addr));
  577. qdf_mem_free(mecentry);
  578. qdf_atomic_dec(&soc->mec_cnt);
  579. DP_STATS_INC(soc, mec.deleted, 1);
  580. }
  581. }
  582. /**
  583. * dp_peer_mec_hash_detach() - Free MEC Hash table
  584. * @soc: SoC handle
  585. *
  586. * Return: None
  587. */
  588. void dp_peer_mec_hash_detach(struct dp_soc *soc)
  589. {
  590. dp_peer_mec_flush_entries(soc);
  591. qdf_mem_free(soc->mec_hash.bins);
  592. soc->mec_hash.bins = NULL;
  593. }
  594. void dp_peer_mec_spinlock_destroy(struct dp_soc *soc)
  595. {
  596. qdf_spinlock_destroy(&soc->mec_lock);
  597. }
  598. void dp_peer_mec_spinlock_create(struct dp_soc *soc)
  599. {
  600. qdf_spinlock_create(&soc->mec_lock);
  601. }
  602. #else
  603. QDF_STATUS dp_peer_mec_hash_attach(struct dp_soc *soc)
  604. {
  605. return QDF_STATUS_SUCCESS;
  606. }
  607. void dp_peer_mec_hash_detach(struct dp_soc *soc)
  608. {
  609. }
  610. #endif
  611. #ifdef FEATURE_AST
  612. /*
  613. * dp_peer_ast_hash_attach() - Allocate and initialize AST Hash Table
  614. * @soc: SoC handle
  615. *
  616. * Return: QDF_STATUS
  617. */
  618. QDF_STATUS dp_peer_ast_hash_attach(struct dp_soc *soc)
  619. {
  620. int i, hash_elems, log2;
  621. unsigned int max_ast_idx = wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx);
  622. hash_elems = ((max_ast_idx * DP_AST_HASH_LOAD_MULT) >>
  623. DP_AST_HASH_LOAD_SHIFT);
  624. log2 = dp_log2_ceil(hash_elems);
  625. hash_elems = 1 << log2;
  626. soc->ast_hash.mask = hash_elems - 1;
  627. soc->ast_hash.idx_bits = log2;
  628. dp_peer_info("%pK: ast hash_elems: %d, max_ast_idx: %d",
  629. soc, hash_elems, max_ast_idx);
  630. /* allocate an array of TAILQ peer object lists */
  631. soc->ast_hash.bins = qdf_mem_malloc(
  632. hash_elems * sizeof(TAILQ_HEAD(anonymous_tail_q,
  633. dp_ast_entry)));
  634. if (!soc->ast_hash.bins)
  635. return QDF_STATUS_E_NOMEM;
  636. for (i = 0; i < hash_elems; i++)
  637. TAILQ_INIT(&soc->ast_hash.bins[i]);
  638. return QDF_STATUS_SUCCESS;
  639. }
  640. /*
  641. * dp_peer_ast_cleanup() - cleanup the references
  642. * @soc: SoC handle
  643. * @ast: ast entry
  644. *
  645. * Return: None
  646. */
  647. static inline void dp_peer_ast_cleanup(struct dp_soc *soc,
  648. struct dp_ast_entry *ast)
  649. {
  650. txrx_ast_free_cb cb = ast->callback;
  651. void *cookie = ast->cookie;
  652. dp_peer_debug("mac_addr: " QDF_MAC_ADDR_FMT ", cb: %pK, cookie: %pK",
  653. QDF_MAC_ADDR_REF(ast->mac_addr.raw), cb, cookie);
  654. /* Call the callbacks to free up the cookie */
  655. if (cb) {
  656. ast->callback = NULL;
  657. ast->cookie = NULL;
  658. cb(soc->ctrl_psoc,
  659. dp_soc_to_cdp_soc(soc),
  660. cookie,
  661. CDP_TXRX_AST_DELETE_IN_PROGRESS);
  662. }
  663. }
  664. /*
  665. * dp_peer_ast_hash_detach() - Free AST Hash table
  666. * @soc: SoC handle
  667. *
  668. * Return: None
  669. */
  670. void dp_peer_ast_hash_detach(struct dp_soc *soc)
  671. {
  672. unsigned int index;
  673. struct dp_ast_entry *ast, *ast_next;
  674. if (!soc->ast_hash.mask)
  675. return;
  676. if (!soc->ast_hash.bins)
  677. return;
  678. dp_peer_debug("%pK: num_ast_entries: %u", soc, soc->num_ast_entries);
  679. qdf_spin_lock_bh(&soc->ast_lock);
  680. for (index = 0; index <= soc->ast_hash.mask; index++) {
  681. if (!TAILQ_EMPTY(&soc->ast_hash.bins[index])) {
  682. TAILQ_FOREACH_SAFE(ast, &soc->ast_hash.bins[index],
  683. hash_list_elem, ast_next) {
  684. TAILQ_REMOVE(&soc->ast_hash.bins[index], ast,
  685. hash_list_elem);
  686. dp_peer_ast_cleanup(soc, ast);
  687. soc->num_ast_entries--;
  688. qdf_mem_free(ast);
  689. }
  690. }
  691. }
  692. qdf_spin_unlock_bh(&soc->ast_lock);
  693. qdf_mem_free(soc->ast_hash.bins);
  694. soc->ast_hash.bins = NULL;
  695. }
  696. /*
  697. * dp_peer_ast_hash_index() - Compute the AST hash from MAC address
  698. * @soc: SoC handle
  699. *
  700. * Return: AST hash
  701. */
  702. static inline uint32_t dp_peer_ast_hash_index(struct dp_soc *soc,
  703. union dp_align_mac_addr *mac_addr)
  704. {
  705. uint32_t index;
  706. index =
  707. mac_addr->align2.bytes_ab ^
  708. mac_addr->align2.bytes_cd ^
  709. mac_addr->align2.bytes_ef;
  710. index ^= index >> soc->ast_hash.idx_bits;
  711. index &= soc->ast_hash.mask;
  712. return index;
  713. }
  714. /*
  715. * dp_peer_ast_hash_add() - Add AST entry into hash table
  716. * @soc: SoC handle
  717. *
  718. * This function adds the AST entry into SoC AST hash table
  719. * It assumes caller has taken the ast lock to protect the access to this table
  720. *
  721. * Return: None
  722. */
  723. static inline void dp_peer_ast_hash_add(struct dp_soc *soc,
  724. struct dp_ast_entry *ase)
  725. {
  726. uint32_t index;
  727. index = dp_peer_ast_hash_index(soc, &ase->mac_addr);
  728. TAILQ_INSERT_TAIL(&soc->ast_hash.bins[index], ase, hash_list_elem);
  729. }
  730. /*
  731. * dp_peer_ast_hash_remove() - Look up and remove AST entry from hash table
  732. * @soc: SoC handle
  733. *
  734. * This function removes the AST entry from soc AST hash table
  735. * It assumes caller has taken the ast lock to protect the access to this table
  736. *
  737. * Return: None
  738. */
  739. void dp_peer_ast_hash_remove(struct dp_soc *soc,
  740. struct dp_ast_entry *ase)
  741. {
  742. unsigned index;
  743. struct dp_ast_entry *tmpase;
  744. int found = 0;
  745. if (soc->ast_offload_support)
  746. return;
  747. index = dp_peer_ast_hash_index(soc, &ase->mac_addr);
  748. /* Check if tail is not empty before delete*/
  749. QDF_ASSERT(!TAILQ_EMPTY(&soc->ast_hash.bins[index]));
  750. dp_peer_debug("ID: %u idx: %u mac_addr: " QDF_MAC_ADDR_FMT,
  751. ase->peer_id, index, QDF_MAC_ADDR_REF(ase->mac_addr.raw));
  752. TAILQ_FOREACH(tmpase, &soc->ast_hash.bins[index], hash_list_elem) {
  753. if (tmpase == ase) {
  754. found = 1;
  755. break;
  756. }
  757. }
  758. QDF_ASSERT(found);
  759. if (found)
  760. TAILQ_REMOVE(&soc->ast_hash.bins[index], ase, hash_list_elem);
  761. }
  762. /*
  763. * dp_peer_ast_hash_find_by_vdevid() - Find AST entry by MAC address
  764. * @soc: SoC handle
  765. *
  766. * It assumes caller has taken the ast lock to protect the access to
  767. * AST hash table
  768. *
  769. * Return: AST entry
  770. */
  771. struct dp_ast_entry *dp_peer_ast_hash_find_by_vdevid(struct dp_soc *soc,
  772. uint8_t *ast_mac_addr,
  773. uint8_t vdev_id)
  774. {
  775. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  776. uint32_t index;
  777. struct dp_ast_entry *ase;
  778. qdf_mem_copy(&local_mac_addr_aligned.raw[0],
  779. ast_mac_addr, QDF_MAC_ADDR_SIZE);
  780. mac_addr = &local_mac_addr_aligned;
  781. index = dp_peer_ast_hash_index(soc, mac_addr);
  782. TAILQ_FOREACH(ase, &soc->ast_hash.bins[index], hash_list_elem) {
  783. if ((vdev_id == ase->vdev_id) &&
  784. !dp_peer_find_mac_addr_cmp(mac_addr, &ase->mac_addr)) {
  785. return ase;
  786. }
  787. }
  788. return NULL;
  789. }
  790. /*
  791. * dp_peer_ast_hash_find_by_pdevid() - Find AST entry by MAC address
  792. * @soc: SoC handle
  793. *
  794. * It assumes caller has taken the ast lock to protect the access to
  795. * AST hash table
  796. *
  797. * Return: AST entry
  798. */
  799. struct dp_ast_entry *dp_peer_ast_hash_find_by_pdevid(struct dp_soc *soc,
  800. uint8_t *ast_mac_addr,
  801. uint8_t pdev_id)
  802. {
  803. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  804. uint32_t index;
  805. struct dp_ast_entry *ase;
  806. qdf_mem_copy(&local_mac_addr_aligned.raw[0],
  807. ast_mac_addr, QDF_MAC_ADDR_SIZE);
  808. mac_addr = &local_mac_addr_aligned;
  809. index = dp_peer_ast_hash_index(soc, mac_addr);
  810. TAILQ_FOREACH(ase, &soc->ast_hash.bins[index], hash_list_elem) {
  811. if ((pdev_id == ase->pdev_id) &&
  812. !dp_peer_find_mac_addr_cmp(mac_addr, &ase->mac_addr)) {
  813. return ase;
  814. }
  815. }
  816. return NULL;
  817. }
  818. /*
  819. * dp_peer_ast_hash_find_soc() - Find AST entry by MAC address
  820. * @soc: SoC handle
  821. *
  822. * It assumes caller has taken the ast lock to protect the access to
  823. * AST hash table
  824. *
  825. * Return: AST entry
  826. */
  827. struct dp_ast_entry *dp_peer_ast_hash_find_soc(struct dp_soc *soc,
  828. uint8_t *ast_mac_addr)
  829. {
  830. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  831. unsigned index;
  832. struct dp_ast_entry *ase;
  833. qdf_mem_copy(&local_mac_addr_aligned.raw[0],
  834. ast_mac_addr, QDF_MAC_ADDR_SIZE);
  835. mac_addr = &local_mac_addr_aligned;
  836. index = dp_peer_ast_hash_index(soc, mac_addr);
  837. TAILQ_FOREACH(ase, &soc->ast_hash.bins[index], hash_list_elem) {
  838. if (dp_peer_find_mac_addr_cmp(mac_addr, &ase->mac_addr) == 0) {
  839. return ase;
  840. }
  841. }
  842. return NULL;
  843. }
  844. /*
  845. * dp_peer_map_ast() - Map the ast entry with HW AST Index
  846. * @soc: SoC handle
  847. * @peer: peer to which ast node belongs
  848. * @mac_addr: MAC address of ast node
  849. * @hw_peer_id: HW AST Index returned by target in peer map event
  850. * @vdev_id: vdev id for VAP to which the peer belongs to
  851. * @ast_hash: ast hash value in HW
  852. * @is_wds: flag to indicate peer map event for WDS ast entry
  853. *
  854. * Return: QDF_STATUS code
  855. */
  856. static inline QDF_STATUS dp_peer_map_ast(struct dp_soc *soc,
  857. struct dp_peer *peer,
  858. uint8_t *mac_addr,
  859. uint16_t hw_peer_id,
  860. uint8_t vdev_id,
  861. uint16_t ast_hash,
  862. uint8_t is_wds)
  863. {
  864. struct dp_ast_entry *ast_entry = NULL;
  865. enum cdp_txrx_ast_entry_type peer_type = CDP_TXRX_AST_TYPE_STATIC;
  866. void *cookie = NULL;
  867. txrx_ast_free_cb cb = NULL;
  868. QDF_STATUS err = QDF_STATUS_SUCCESS;
  869. if (soc->ast_offload_support)
  870. return QDF_STATUS_SUCCESS;
  871. if (!peer) {
  872. return QDF_STATUS_E_INVAL;
  873. }
  874. dp_peer_err("%pK: peer %pK ID %d vid %d mac " QDF_MAC_ADDR_FMT,
  875. soc, peer, hw_peer_id, vdev_id,
  876. QDF_MAC_ADDR_REF(mac_addr));
  877. qdf_spin_lock_bh(&soc->ast_lock);
  878. ast_entry = dp_peer_ast_hash_find_by_vdevid(soc, mac_addr, vdev_id);
  879. if (is_wds) {
  880. /*
  881. * In certain cases like Auth attack on a repeater
  882. * can result in the number of ast_entries falling
  883. * in the same hash bucket to exceed the max_skid
  884. * length supported by HW in root AP. In these cases
  885. * the FW will return the hw_peer_id (ast_index) as
  886. * 0xffff indicating HW could not add the entry in
  887. * its table. Host has to delete the entry from its
  888. * table in these cases.
  889. */
  890. if (hw_peer_id == HTT_INVALID_PEER) {
  891. DP_STATS_INC(soc, ast.map_err, 1);
  892. if (ast_entry) {
  893. if (ast_entry->is_mapped) {
  894. soc->ast_table[ast_entry->ast_idx] =
  895. NULL;
  896. }
  897. cb = ast_entry->callback;
  898. cookie = ast_entry->cookie;
  899. peer_type = ast_entry->type;
  900. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  901. dp_peer_free_ast_entry(soc, ast_entry);
  902. qdf_spin_unlock_bh(&soc->ast_lock);
  903. if (cb) {
  904. cb(soc->ctrl_psoc,
  905. dp_soc_to_cdp_soc(soc),
  906. cookie,
  907. CDP_TXRX_AST_DELETED);
  908. }
  909. } else {
  910. qdf_spin_unlock_bh(&soc->ast_lock);
  911. dp_peer_alert("AST entry not found with peer %pK peer_id %u peer_mac " QDF_MAC_ADDR_FMT " mac_addr " QDF_MAC_ADDR_FMT " vdev_id %u next_hop %u",
  912. peer, peer->peer_id,
  913. QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  914. QDF_MAC_ADDR_REF(mac_addr),
  915. vdev_id, is_wds);
  916. }
  917. err = QDF_STATUS_E_INVAL;
  918. dp_hmwds_ast_add_notify(peer, mac_addr,
  919. peer_type, err, true);
  920. return err;
  921. }
  922. }
  923. if (ast_entry) {
  924. ast_entry->ast_idx = hw_peer_id;
  925. soc->ast_table[hw_peer_id] = ast_entry;
  926. ast_entry->is_active = TRUE;
  927. peer_type = ast_entry->type;
  928. ast_entry->ast_hash_value = ast_hash;
  929. ast_entry->is_mapped = TRUE;
  930. qdf_assert_always(ast_entry->peer_id == HTT_INVALID_PEER);
  931. ast_entry->peer_id = peer->peer_id;
  932. TAILQ_INSERT_TAIL(&peer->ast_entry_list, ast_entry,
  933. ase_list_elem);
  934. }
  935. if (ast_entry || (peer->vdev && peer->vdev->proxysta_vdev)) {
  936. if (soc->cdp_soc.ol_ops->peer_map_event) {
  937. soc->cdp_soc.ol_ops->peer_map_event(
  938. soc->ctrl_psoc, peer->peer_id,
  939. hw_peer_id, vdev_id,
  940. mac_addr, peer_type, ast_hash);
  941. }
  942. } else {
  943. dp_peer_err("%pK: AST entry not found", soc);
  944. err = QDF_STATUS_E_NOENT;
  945. }
  946. qdf_spin_unlock_bh(&soc->ast_lock);
  947. dp_hmwds_ast_add_notify(peer, mac_addr,
  948. peer_type, err, true);
  949. return err;
  950. }
  951. void dp_peer_free_hmwds_cb(struct cdp_ctrl_objmgr_psoc *ctrl_psoc,
  952. struct cdp_soc *dp_soc,
  953. void *cookie,
  954. enum cdp_ast_free_status status)
  955. {
  956. struct dp_ast_free_cb_params *param =
  957. (struct dp_ast_free_cb_params *)cookie;
  958. struct dp_soc *soc = (struct dp_soc *)dp_soc;
  959. struct dp_peer *peer = NULL;
  960. QDF_STATUS err = QDF_STATUS_SUCCESS;
  961. if (status != CDP_TXRX_AST_DELETED) {
  962. qdf_mem_free(cookie);
  963. return;
  964. }
  965. peer = dp_peer_find_hash_find(soc, &param->peer_mac_addr.raw[0],
  966. 0, param->vdev_id, DP_MOD_ID_AST);
  967. if (peer) {
  968. err = dp_peer_add_ast(soc, peer,
  969. &param->mac_addr.raw[0],
  970. param->type,
  971. param->flags);
  972. dp_hmwds_ast_add_notify(peer, &param->mac_addr.raw[0],
  973. param->type, err, false);
  974. dp_peer_unref_delete(peer, DP_MOD_ID_AST);
  975. }
  976. qdf_mem_free(cookie);
  977. }
  978. /*
  979. * dp_peer_add_ast() - Allocate and add AST entry into peer list
  980. * @soc: SoC handle
  981. * @peer: peer to which ast node belongs
  982. * @mac_addr: MAC address of ast node
  983. * @is_self: Is this base AST entry with peer mac address
  984. *
  985. * This API is used by WDS source port learning function to
  986. * add a new AST entry into peer AST list
  987. *
  988. * Return: QDF_STATUS code
  989. */
  990. QDF_STATUS dp_peer_add_ast(struct dp_soc *soc,
  991. struct dp_peer *peer,
  992. uint8_t *mac_addr,
  993. enum cdp_txrx_ast_entry_type type,
  994. uint32_t flags)
  995. {
  996. struct dp_ast_entry *ast_entry = NULL;
  997. struct dp_vdev *vdev = NULL;
  998. struct dp_pdev *pdev = NULL;
  999. uint8_t next_node_mac[6];
  1000. txrx_ast_free_cb cb = NULL;
  1001. void *cookie = NULL;
  1002. struct dp_peer *vap_bss_peer = NULL;
  1003. bool is_peer_found = false;
  1004. if (soc->ast_offload_support)
  1005. return QDF_STATUS_E_INVAL;
  1006. vdev = peer->vdev;
  1007. if (!vdev) {
  1008. dp_peer_err("%pK: Peers vdev is NULL", soc);
  1009. QDF_ASSERT(0);
  1010. return QDF_STATUS_E_INVAL;
  1011. }
  1012. pdev = vdev->pdev;
  1013. is_peer_found = dp_peer_exist_on_pdev(soc, mac_addr, 0, pdev);
  1014. qdf_spin_lock_bh(&soc->ast_lock);
  1015. if (!dp_peer_state_cmp(peer, DP_PEER_STATE_ACTIVE)) {
  1016. if ((type != CDP_TXRX_AST_TYPE_STATIC) &&
  1017. (type != CDP_TXRX_AST_TYPE_SELF)) {
  1018. qdf_spin_unlock_bh(&soc->ast_lock);
  1019. return QDF_STATUS_E_BUSY;
  1020. }
  1021. }
  1022. dp_peer_debug("%pK: pdevid: %u vdev: %u ast_entry->type: %d flags: 0x%x peer_mac: " QDF_MAC_ADDR_FMT " peer: %pK mac " QDF_MAC_ADDR_FMT,
  1023. soc, pdev->pdev_id, vdev->vdev_id, type, flags,
  1024. QDF_MAC_ADDR_REF(peer->mac_addr.raw), peer,
  1025. QDF_MAC_ADDR_REF(mac_addr));
  1026. /* fw supports only 2 times the max_peers ast entries */
  1027. if (soc->num_ast_entries >=
  1028. wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
  1029. qdf_spin_unlock_bh(&soc->ast_lock);
  1030. dp_peer_err("%pK: Max ast entries reached", soc);
  1031. return QDF_STATUS_E_RESOURCES;
  1032. }
  1033. /* If AST entry already exists , just return from here
  1034. * ast entry with same mac address can exist on different radios
  1035. * if ast_override support is enabled use search by pdev in this
  1036. * case
  1037. */
  1038. if (soc->ast_override_support) {
  1039. ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, mac_addr,
  1040. pdev->pdev_id);
  1041. if (ast_entry) {
  1042. qdf_spin_unlock_bh(&soc->ast_lock);
  1043. return QDF_STATUS_E_ALREADY;
  1044. }
  1045. if (is_peer_found) {
  1046. /* During WDS to static roaming, peer is added
  1047. * to the list before static AST entry create.
  1048. * So, allow AST entry for STATIC type
  1049. * even if peer is present
  1050. */
  1051. if (type != CDP_TXRX_AST_TYPE_STATIC) {
  1052. qdf_spin_unlock_bh(&soc->ast_lock);
  1053. return QDF_STATUS_E_ALREADY;
  1054. }
  1055. }
  1056. } else {
  1057. /* For HWMWDS_SEC entries can be added for same mac address
  1058. * do not check for existing entry
  1059. */
  1060. if (type == CDP_TXRX_AST_TYPE_WDS_HM_SEC)
  1061. goto add_ast_entry;
  1062. ast_entry = dp_peer_ast_hash_find_soc(soc, mac_addr);
  1063. if (ast_entry) {
  1064. if ((ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM) &&
  1065. !ast_entry->delete_in_progress) {
  1066. qdf_spin_unlock_bh(&soc->ast_lock);
  1067. return QDF_STATUS_E_ALREADY;
  1068. }
  1069. /* Add for HMWDS entry we cannot be ignored if there
  1070. * is AST entry with same mac address
  1071. *
  1072. * if ast entry exists with the requested mac address
  1073. * send a delete command and register callback which
  1074. * can take care of adding HMWDS ast enty on delete
  1075. * confirmation from target
  1076. */
  1077. if (type == CDP_TXRX_AST_TYPE_WDS_HM) {
  1078. struct dp_ast_free_cb_params *param = NULL;
  1079. if (ast_entry->type ==
  1080. CDP_TXRX_AST_TYPE_WDS_HM_SEC)
  1081. goto add_ast_entry;
  1082. /* save existing callback */
  1083. if (ast_entry->callback) {
  1084. cb = ast_entry->callback;
  1085. cookie = ast_entry->cookie;
  1086. }
  1087. param = qdf_mem_malloc(sizeof(*param));
  1088. if (!param) {
  1089. QDF_TRACE(QDF_MODULE_ID_TXRX,
  1090. QDF_TRACE_LEVEL_ERROR,
  1091. "Allocation failed");
  1092. qdf_spin_unlock_bh(&soc->ast_lock);
  1093. return QDF_STATUS_E_NOMEM;
  1094. }
  1095. qdf_mem_copy(&param->mac_addr.raw[0], mac_addr,
  1096. QDF_MAC_ADDR_SIZE);
  1097. qdf_mem_copy(&param->peer_mac_addr.raw[0],
  1098. &peer->mac_addr.raw[0],
  1099. QDF_MAC_ADDR_SIZE);
  1100. param->type = type;
  1101. param->flags = flags;
  1102. param->vdev_id = vdev->vdev_id;
  1103. ast_entry->callback = dp_peer_free_hmwds_cb;
  1104. ast_entry->pdev_id = vdev->pdev->pdev_id;
  1105. ast_entry->type = type;
  1106. ast_entry->cookie = (void *)param;
  1107. if (!ast_entry->delete_in_progress)
  1108. dp_peer_del_ast(soc, ast_entry);
  1109. qdf_spin_unlock_bh(&soc->ast_lock);
  1110. /* Call the saved callback*/
  1111. if (cb) {
  1112. cb(soc->ctrl_psoc,
  1113. dp_soc_to_cdp_soc(soc),
  1114. cookie,
  1115. CDP_TXRX_AST_DELETE_IN_PROGRESS);
  1116. }
  1117. return QDF_STATUS_E_AGAIN;
  1118. }
  1119. qdf_spin_unlock_bh(&soc->ast_lock);
  1120. return QDF_STATUS_E_ALREADY;
  1121. }
  1122. }
  1123. add_ast_entry:
  1124. ast_entry = (struct dp_ast_entry *)
  1125. qdf_mem_malloc(sizeof(struct dp_ast_entry));
  1126. if (!ast_entry) {
  1127. qdf_spin_unlock_bh(&soc->ast_lock);
  1128. dp_peer_err("%pK: fail to allocate ast_entry", soc);
  1129. QDF_ASSERT(0);
  1130. return QDF_STATUS_E_NOMEM;
  1131. }
  1132. qdf_mem_copy(&ast_entry->mac_addr.raw[0], mac_addr, QDF_MAC_ADDR_SIZE);
  1133. ast_entry->pdev_id = vdev->pdev->pdev_id;
  1134. ast_entry->is_mapped = false;
  1135. ast_entry->delete_in_progress = false;
  1136. ast_entry->peer_id = HTT_INVALID_PEER;
  1137. ast_entry->next_hop = 0;
  1138. ast_entry->vdev_id = vdev->vdev_id;
  1139. switch (type) {
  1140. case CDP_TXRX_AST_TYPE_STATIC:
  1141. peer->self_ast_entry = ast_entry;
  1142. ast_entry->type = CDP_TXRX_AST_TYPE_STATIC;
  1143. if (peer->vdev->opmode == wlan_op_mode_sta)
  1144. ast_entry->type = CDP_TXRX_AST_TYPE_STA_BSS;
  1145. break;
  1146. case CDP_TXRX_AST_TYPE_SELF:
  1147. peer->self_ast_entry = ast_entry;
  1148. ast_entry->type = CDP_TXRX_AST_TYPE_SELF;
  1149. break;
  1150. case CDP_TXRX_AST_TYPE_WDS:
  1151. ast_entry->next_hop = 1;
  1152. ast_entry->type = CDP_TXRX_AST_TYPE_WDS;
  1153. break;
  1154. case CDP_TXRX_AST_TYPE_WDS_HM:
  1155. ast_entry->next_hop = 1;
  1156. ast_entry->type = CDP_TXRX_AST_TYPE_WDS_HM;
  1157. break;
  1158. case CDP_TXRX_AST_TYPE_WDS_HM_SEC:
  1159. ast_entry->next_hop = 1;
  1160. ast_entry->type = CDP_TXRX_AST_TYPE_WDS_HM_SEC;
  1161. ast_entry->peer_id = peer->peer_id;
  1162. TAILQ_INSERT_TAIL(&peer->ast_entry_list, ast_entry,
  1163. ase_list_elem);
  1164. break;
  1165. case CDP_TXRX_AST_TYPE_DA:
  1166. vap_bss_peer = dp_vdev_bss_peer_ref_n_get(soc, vdev,
  1167. DP_MOD_ID_AST);
  1168. if (!vap_bss_peer) {
  1169. qdf_spin_unlock_bh(&soc->ast_lock);
  1170. qdf_mem_free(ast_entry);
  1171. return QDF_STATUS_E_FAILURE;
  1172. }
  1173. peer = vap_bss_peer;
  1174. ast_entry->next_hop = 1;
  1175. ast_entry->type = CDP_TXRX_AST_TYPE_DA;
  1176. break;
  1177. default:
  1178. dp_peer_err("%pK: Incorrect AST entry type", soc);
  1179. }
  1180. ast_entry->is_active = TRUE;
  1181. DP_STATS_INC(soc, ast.added, 1);
  1182. soc->num_ast_entries++;
  1183. dp_peer_ast_hash_add(soc, ast_entry);
  1184. qdf_copy_macaddr((struct qdf_mac_addr *)next_node_mac,
  1185. (struct qdf_mac_addr *)peer->mac_addr.raw);
  1186. if ((ast_entry->type != CDP_TXRX_AST_TYPE_STATIC) &&
  1187. (ast_entry->type != CDP_TXRX_AST_TYPE_SELF) &&
  1188. (ast_entry->type != CDP_TXRX_AST_TYPE_STA_BSS) &&
  1189. (ast_entry->type != CDP_TXRX_AST_TYPE_WDS_HM_SEC)) {
  1190. if (QDF_STATUS_SUCCESS ==
  1191. soc->cdp_soc.ol_ops->peer_add_wds_entry(
  1192. soc->ctrl_psoc,
  1193. peer->vdev->vdev_id,
  1194. peer->mac_addr.raw,
  1195. peer->peer_id,
  1196. mac_addr,
  1197. next_node_mac,
  1198. flags,
  1199. ast_entry->type)) {
  1200. if (vap_bss_peer)
  1201. dp_peer_unref_delete(vap_bss_peer,
  1202. DP_MOD_ID_AST);
  1203. qdf_spin_unlock_bh(&soc->ast_lock);
  1204. return QDF_STATUS_SUCCESS;
  1205. }
  1206. }
  1207. if (vap_bss_peer)
  1208. dp_peer_unref_delete(vap_bss_peer, DP_MOD_ID_AST);
  1209. qdf_spin_unlock_bh(&soc->ast_lock);
  1210. return QDF_STATUS_E_FAILURE;
  1211. }
  1212. qdf_export_symbol(dp_peer_add_ast);
  1213. /*
  1214. * dp_peer_free_ast_entry() - Free up the ast entry memory
  1215. * @soc: SoC handle
  1216. * @ast_entry: Address search entry
  1217. *
  1218. * This API is used to free up the memory associated with
  1219. * AST entry.
  1220. *
  1221. * Return: None
  1222. */
  1223. void dp_peer_free_ast_entry(struct dp_soc *soc,
  1224. struct dp_ast_entry *ast_entry)
  1225. {
  1226. /*
  1227. * NOTE: Ensure that call to this API is done
  1228. * after soc->ast_lock is taken
  1229. */
  1230. dp_peer_debug("type: %d ID: %u vid: %u mac_addr: " QDF_MAC_ADDR_FMT,
  1231. ast_entry->type, ast_entry->peer_id, ast_entry->vdev_id,
  1232. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw));
  1233. ast_entry->callback = NULL;
  1234. ast_entry->cookie = NULL;
  1235. DP_STATS_INC(soc, ast.deleted, 1);
  1236. dp_peer_ast_hash_remove(soc, ast_entry);
  1237. dp_peer_ast_cleanup(soc, ast_entry);
  1238. qdf_mem_free(ast_entry);
  1239. soc->num_ast_entries--;
  1240. }
  1241. /*
  1242. * dp_peer_unlink_ast_entry() - Free up the ast entry memory
  1243. * @soc: SoC handle
  1244. * @ast_entry: Address search entry
  1245. * @peer: peer
  1246. *
  1247. * This API is used to remove/unlink AST entry from the peer list
  1248. * and hash list.
  1249. *
  1250. * Return: None
  1251. */
  1252. void dp_peer_unlink_ast_entry(struct dp_soc *soc,
  1253. struct dp_ast_entry *ast_entry,
  1254. struct dp_peer *peer)
  1255. {
  1256. if (!peer) {
  1257. dp_info_rl("NULL peer");
  1258. return;
  1259. }
  1260. if (ast_entry->peer_id == HTT_INVALID_PEER) {
  1261. dp_info_rl("Invalid peer id in AST entry mac addr:"QDF_MAC_ADDR_FMT" type:%d",
  1262. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw),
  1263. ast_entry->type);
  1264. return;
  1265. }
  1266. /*
  1267. * NOTE: Ensure that call to this API is done
  1268. * after soc->ast_lock is taken
  1269. */
  1270. qdf_assert_always(ast_entry->peer_id == peer->peer_id);
  1271. TAILQ_REMOVE(&peer->ast_entry_list, ast_entry, ase_list_elem);
  1272. if (ast_entry == peer->self_ast_entry)
  1273. peer->self_ast_entry = NULL;
  1274. /*
  1275. * release the reference only if it is mapped
  1276. * to ast_table
  1277. */
  1278. if (ast_entry->is_mapped)
  1279. soc->ast_table[ast_entry->ast_idx] = NULL;
  1280. ast_entry->peer_id = HTT_INVALID_PEER;
  1281. }
  1282. /*
  1283. * dp_peer_del_ast() - Delete and free AST entry
  1284. * @soc: SoC handle
  1285. * @ast_entry: AST entry of the node
  1286. *
  1287. * This function removes the AST entry from peer and soc tables
  1288. * It assumes caller has taken the ast lock to protect the access to these
  1289. * tables
  1290. *
  1291. * Return: None
  1292. */
  1293. void dp_peer_del_ast(struct dp_soc *soc, struct dp_ast_entry *ast_entry)
  1294. {
  1295. struct dp_peer *peer = NULL;
  1296. if (soc->ast_offload_support)
  1297. return;
  1298. if (!ast_entry) {
  1299. dp_info_rl("NULL AST entry");
  1300. return;
  1301. }
  1302. if (ast_entry->delete_in_progress) {
  1303. dp_info_rl("AST entry deletion in progress mac addr:"QDF_MAC_ADDR_FMT" type:%d",
  1304. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw),
  1305. ast_entry->type);
  1306. return;
  1307. }
  1308. dp_peer_debug("call by %ps: ID: %u vid: %u mac_addr: " QDF_MAC_ADDR_FMT,
  1309. (void *)_RET_IP_, ast_entry->peer_id, ast_entry->vdev_id,
  1310. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw));
  1311. ast_entry->delete_in_progress = true;
  1312. /* In teardown del ast is called after setting logical delete state
  1313. * use __dp_peer_get_ref_by_id to get the reference irrespective of
  1314. * state
  1315. */
  1316. peer = __dp_peer_get_ref_by_id(soc, ast_entry->peer_id,
  1317. DP_MOD_ID_AST);
  1318. dp_peer_ast_send_wds_del(soc, ast_entry, peer);
  1319. /* Remove SELF and STATIC entries in teardown itself */
  1320. if (!ast_entry->next_hop)
  1321. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  1322. if (ast_entry->is_mapped)
  1323. soc->ast_table[ast_entry->ast_idx] = NULL;
  1324. /* if peer map v2 is enabled we are not freeing ast entry
  1325. * here and it is supposed to be freed in unmap event (after
  1326. * we receive delete confirmation from target)
  1327. *
  1328. * if peer_id is invalid we did not get the peer map event
  1329. * for the peer free ast entry from here only in this case
  1330. */
  1331. if (dp_peer_ast_free_in_unmap_supported(soc, ast_entry))
  1332. goto end;
  1333. /* for WDS secondary entry ast_entry->next_hop would be set so
  1334. * unlinking has to be done explicitly here.
  1335. * As this entry is not a mapped entry unmap notification from
  1336. * FW wil not come. Hence unlinkling is done right here.
  1337. */
  1338. if (ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM_SEC)
  1339. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  1340. dp_peer_free_ast_entry(soc, ast_entry);
  1341. end:
  1342. if (peer)
  1343. dp_peer_unref_delete(peer, DP_MOD_ID_AST);
  1344. }
  1345. /*
  1346. * dp_peer_update_ast() - Delete and free AST entry
  1347. * @soc: SoC handle
  1348. * @peer: peer to which ast node belongs
  1349. * @ast_entry: AST entry of the node
  1350. * @flags: wds or hmwds
  1351. *
  1352. * This function update the AST entry to the roamed peer and soc tables
  1353. * It assumes caller has taken the ast lock to protect the access to these
  1354. * tables
  1355. *
  1356. * Return: 0 if ast entry is updated successfully
  1357. * -1 failure
  1358. */
  1359. int dp_peer_update_ast(struct dp_soc *soc, struct dp_peer *peer,
  1360. struct dp_ast_entry *ast_entry, uint32_t flags)
  1361. {
  1362. int ret = -1;
  1363. struct dp_peer *old_peer;
  1364. if (soc->ast_offload_support)
  1365. return QDF_STATUS_E_INVAL;
  1366. dp_peer_debug("%pK: ast_entry->type: %d pdevid: %u vdevid: %u flags: 0x%x mac_addr: " QDF_MAC_ADDR_FMT " peer_mac: " QDF_MAC_ADDR_FMT "\n",
  1367. soc, ast_entry->type, peer->vdev->pdev->pdev_id,
  1368. peer->vdev->vdev_id, flags,
  1369. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw),
  1370. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  1371. /* Do not send AST update in below cases
  1372. * 1) Ast entry delete has already triggered
  1373. * 2) Peer delete is already triggered
  1374. * 3) We did not get the HTT map for create event
  1375. */
  1376. if (ast_entry->delete_in_progress ||
  1377. !dp_peer_state_cmp(peer, DP_PEER_STATE_ACTIVE) ||
  1378. !ast_entry->is_mapped)
  1379. return ret;
  1380. if ((ast_entry->type == CDP_TXRX_AST_TYPE_STATIC) ||
  1381. (ast_entry->type == CDP_TXRX_AST_TYPE_SELF) ||
  1382. (ast_entry->type == CDP_TXRX_AST_TYPE_STA_BSS) ||
  1383. (ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM_SEC))
  1384. return 0;
  1385. /*
  1386. * Avoids flood of WMI update messages sent to FW for same peer.
  1387. */
  1388. if (qdf_unlikely(ast_entry->peer_id == peer->peer_id) &&
  1389. (ast_entry->type == CDP_TXRX_AST_TYPE_WDS) &&
  1390. (ast_entry->vdev_id == peer->vdev->vdev_id) &&
  1391. (ast_entry->is_active))
  1392. return 0;
  1393. old_peer = dp_peer_get_ref_by_id(soc, ast_entry->peer_id,
  1394. DP_MOD_ID_AST);
  1395. if (!old_peer)
  1396. return 0;
  1397. TAILQ_REMOVE(&old_peer->ast_entry_list, ast_entry, ase_list_elem);
  1398. dp_peer_unref_delete(old_peer, DP_MOD_ID_AST);
  1399. ast_entry->peer_id = peer->peer_id;
  1400. ast_entry->type = CDP_TXRX_AST_TYPE_WDS;
  1401. ast_entry->pdev_id = peer->vdev->pdev->pdev_id;
  1402. ast_entry->vdev_id = peer->vdev->vdev_id;
  1403. ast_entry->is_active = TRUE;
  1404. TAILQ_INSERT_TAIL(&peer->ast_entry_list, ast_entry, ase_list_elem);
  1405. ret = soc->cdp_soc.ol_ops->peer_update_wds_entry(
  1406. soc->ctrl_psoc,
  1407. peer->vdev->vdev_id,
  1408. ast_entry->mac_addr.raw,
  1409. peer->mac_addr.raw,
  1410. flags);
  1411. return ret;
  1412. }
  1413. /*
  1414. * dp_peer_ast_get_pdev_id() - get pdev_id from the ast entry
  1415. * @soc: SoC handle
  1416. * @ast_entry: AST entry of the node
  1417. *
  1418. * This function gets the pdev_id from the ast entry.
  1419. *
  1420. * Return: (uint8_t) pdev_id
  1421. */
  1422. uint8_t dp_peer_ast_get_pdev_id(struct dp_soc *soc,
  1423. struct dp_ast_entry *ast_entry)
  1424. {
  1425. return ast_entry->pdev_id;
  1426. }
  1427. /*
  1428. * dp_peer_ast_get_next_hop() - get next_hop from the ast entry
  1429. * @soc: SoC handle
  1430. * @ast_entry: AST entry of the node
  1431. *
  1432. * This function gets the next hop from the ast entry.
  1433. *
  1434. * Return: (uint8_t) next_hop
  1435. */
  1436. uint8_t dp_peer_ast_get_next_hop(struct dp_soc *soc,
  1437. struct dp_ast_entry *ast_entry)
  1438. {
  1439. return ast_entry->next_hop;
  1440. }
  1441. /*
  1442. * dp_peer_ast_set_type() - set type from the ast entry
  1443. * @soc: SoC handle
  1444. * @ast_entry: AST entry of the node
  1445. *
  1446. * This function sets the type in the ast entry.
  1447. *
  1448. * Return:
  1449. */
  1450. void dp_peer_ast_set_type(struct dp_soc *soc,
  1451. struct dp_ast_entry *ast_entry,
  1452. enum cdp_txrx_ast_entry_type type)
  1453. {
  1454. ast_entry->type = type;
  1455. }
  1456. #else
  1457. QDF_STATUS dp_peer_add_ast(struct dp_soc *soc,
  1458. struct dp_peer *peer,
  1459. uint8_t *mac_addr,
  1460. enum cdp_txrx_ast_entry_type type,
  1461. uint32_t flags)
  1462. {
  1463. return QDF_STATUS_E_FAILURE;
  1464. }
  1465. void dp_peer_del_ast(struct dp_soc *soc, struct dp_ast_entry *ast_entry)
  1466. {
  1467. }
  1468. int dp_peer_update_ast(struct dp_soc *soc, struct dp_peer *peer,
  1469. struct dp_ast_entry *ast_entry, uint32_t flags)
  1470. {
  1471. return 1;
  1472. }
  1473. struct dp_ast_entry *dp_peer_ast_hash_find_soc(struct dp_soc *soc,
  1474. uint8_t *ast_mac_addr)
  1475. {
  1476. return NULL;
  1477. }
  1478. struct dp_ast_entry *dp_peer_ast_hash_find_by_pdevid(struct dp_soc *soc,
  1479. uint8_t *ast_mac_addr,
  1480. uint8_t pdev_id)
  1481. {
  1482. return NULL;
  1483. }
  1484. QDF_STATUS dp_peer_ast_hash_attach(struct dp_soc *soc)
  1485. {
  1486. return QDF_STATUS_SUCCESS;
  1487. }
  1488. static inline QDF_STATUS dp_peer_map_ast(struct dp_soc *soc,
  1489. struct dp_peer *peer,
  1490. uint8_t *mac_addr,
  1491. uint16_t hw_peer_id,
  1492. uint8_t vdev_id,
  1493. uint16_t ast_hash,
  1494. uint8_t is_wds)
  1495. {
  1496. return QDF_STATUS_SUCCESS;
  1497. }
  1498. void dp_peer_ast_hash_detach(struct dp_soc *soc)
  1499. {
  1500. }
  1501. void dp_peer_ast_set_type(struct dp_soc *soc,
  1502. struct dp_ast_entry *ast_entry,
  1503. enum cdp_txrx_ast_entry_type type)
  1504. {
  1505. }
  1506. uint8_t dp_peer_ast_get_pdev_id(struct dp_soc *soc,
  1507. struct dp_ast_entry *ast_entry)
  1508. {
  1509. return 0xff;
  1510. }
  1511. uint8_t dp_peer_ast_get_next_hop(struct dp_soc *soc,
  1512. struct dp_ast_entry *ast_entry)
  1513. {
  1514. return 0xff;
  1515. }
  1516. int dp_peer_update_ast(struct dp_soc *soc, struct dp_peer *peer,
  1517. struct dp_ast_entry *ast_entry, uint32_t flags)
  1518. {
  1519. return 1;
  1520. }
  1521. #endif
  1522. void dp_peer_ast_send_wds_del(struct dp_soc *soc,
  1523. struct dp_ast_entry *ast_entry,
  1524. struct dp_peer *peer)
  1525. {
  1526. struct cdp_soc_t *cdp_soc = &soc->cdp_soc;
  1527. bool delete_in_fw = false;
  1528. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_TRACE,
  1529. "%s: ast_entry->type: %d pdevid: %u vdev: %u mac_addr: "QDF_MAC_ADDR_FMT" next_hop: %u peer_id: %uM\n",
  1530. __func__, ast_entry->type, ast_entry->pdev_id,
  1531. ast_entry->vdev_id,
  1532. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw),
  1533. ast_entry->next_hop, ast_entry->peer_id);
  1534. /*
  1535. * If peer state is logical delete, the peer is about to get
  1536. * teared down with a peer delete command to firmware,
  1537. * which will cleanup all the wds ast entries.
  1538. * So, no need to send explicit wds ast delete to firmware.
  1539. */
  1540. if (ast_entry->next_hop) {
  1541. if (peer && dp_peer_state_cmp(peer,
  1542. DP_PEER_STATE_LOGICAL_DELETE))
  1543. delete_in_fw = false;
  1544. else
  1545. delete_in_fw = true;
  1546. cdp_soc->ol_ops->peer_del_wds_entry(soc->ctrl_psoc,
  1547. ast_entry->vdev_id,
  1548. ast_entry->mac_addr.raw,
  1549. ast_entry->type,
  1550. delete_in_fw);
  1551. }
  1552. }
  1553. #ifdef FEATURE_WDS
  1554. /**
  1555. * dp_peer_ast_free_wds_entries() - Free wds ast entries associated with peer
  1556. * @soc: soc handle
  1557. * @peer: peer handle
  1558. *
  1559. * Free all the wds ast entries associated with peer
  1560. *
  1561. * Return: Number of wds ast entries freed
  1562. */
  1563. static uint32_t dp_peer_ast_free_wds_entries(struct dp_soc *soc,
  1564. struct dp_peer *peer)
  1565. {
  1566. TAILQ_HEAD(, dp_ast_entry) ast_local_list = {0};
  1567. struct dp_ast_entry *ast_entry, *temp_ast_entry;
  1568. uint32_t num_ast = 0;
  1569. TAILQ_INIT(&ast_local_list);
  1570. qdf_spin_lock_bh(&soc->ast_lock);
  1571. DP_PEER_ITERATE_ASE_LIST(peer, ast_entry, temp_ast_entry) {
  1572. if (ast_entry->next_hop)
  1573. num_ast++;
  1574. if (ast_entry->is_mapped)
  1575. soc->ast_table[ast_entry->ast_idx] = NULL;
  1576. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  1577. DP_STATS_INC(soc, ast.deleted, 1);
  1578. dp_peer_ast_hash_remove(soc, ast_entry);
  1579. TAILQ_INSERT_TAIL(&ast_local_list, ast_entry,
  1580. ase_list_elem);
  1581. soc->num_ast_entries--;
  1582. }
  1583. qdf_spin_unlock_bh(&soc->ast_lock);
  1584. TAILQ_FOREACH_SAFE(ast_entry, &ast_local_list, ase_list_elem,
  1585. temp_ast_entry) {
  1586. if (ast_entry->callback)
  1587. ast_entry->callback(soc->ctrl_psoc,
  1588. dp_soc_to_cdp_soc(soc),
  1589. ast_entry->cookie,
  1590. CDP_TXRX_AST_DELETED);
  1591. qdf_mem_free(ast_entry);
  1592. }
  1593. return num_ast;
  1594. }
  1595. /**
  1596. * dp_peer_clean_wds_entries() - Clean wds ast entries and compare
  1597. * @soc: soc handle
  1598. * @peer: peer handle
  1599. * @free_wds_count - number of wds entries freed by FW with peer delete
  1600. *
  1601. * Free all the wds ast entries associated with peer and compare with
  1602. * the value received from firmware
  1603. *
  1604. * Return: Number of wds ast entries freed
  1605. */
  1606. static void
  1607. dp_peer_clean_wds_entries(struct dp_soc *soc, struct dp_peer *peer,
  1608. uint32_t free_wds_count)
  1609. {
  1610. uint32_t wds_deleted = 0;
  1611. if (soc->ast_offload_support)
  1612. return;
  1613. wds_deleted = dp_peer_ast_free_wds_entries(soc, peer);
  1614. if ((DP_PEER_WDS_COUNT_INVALID != free_wds_count) &&
  1615. (free_wds_count != wds_deleted)) {
  1616. DP_STATS_INC(soc, ast.ast_mismatch, 1);
  1617. dp_alert("For peer %pK (mac: "QDF_MAC_ADDR_FMT")number of wds entries deleted by fw = %d during peer delete is not same as the numbers deleted by host = %d",
  1618. peer, peer->mac_addr.raw, free_wds_count,
  1619. wds_deleted);
  1620. }
  1621. }
  1622. #else
  1623. static void
  1624. dp_peer_clean_wds_entries(struct dp_soc *soc, struct dp_peer *peer,
  1625. uint32_t free_wds_count)
  1626. {
  1627. struct dp_ast_entry *ast_entry, *temp_ast_entry;
  1628. qdf_spin_lock_bh(&soc->ast_lock);
  1629. DP_PEER_ITERATE_ASE_LIST(peer, ast_entry, temp_ast_entry) {
  1630. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  1631. if (ast_entry->is_mapped)
  1632. soc->ast_table[ast_entry->ast_idx] = NULL;
  1633. dp_peer_free_ast_entry(soc, ast_entry);
  1634. }
  1635. peer->self_ast_entry = NULL;
  1636. qdf_spin_unlock_bh(&soc->ast_lock);
  1637. }
  1638. #endif
  1639. /**
  1640. * dp_peer_ast_free_entry_by_mac() - find ast entry by MAC address and delete
  1641. * @soc: soc handle
  1642. * @peer: peer handle
  1643. * @vdev_id: vdev_id
  1644. * @mac_addr: mac address of the AST entry to searc and delete
  1645. *
  1646. * find the ast entry from the peer list using the mac address and free
  1647. * the entry.
  1648. *
  1649. * Return: SUCCESS or NOENT
  1650. */
  1651. static int dp_peer_ast_free_entry_by_mac(struct dp_soc *soc,
  1652. struct dp_peer *peer,
  1653. uint8_t vdev_id,
  1654. uint8_t *mac_addr)
  1655. {
  1656. struct dp_ast_entry *ast_entry;
  1657. void *cookie = NULL;
  1658. txrx_ast_free_cb cb = NULL;
  1659. /*
  1660. * release the reference only if it is mapped
  1661. * to ast_table
  1662. */
  1663. qdf_spin_lock_bh(&soc->ast_lock);
  1664. ast_entry = dp_peer_ast_hash_find_by_vdevid(soc, mac_addr, vdev_id);
  1665. if (!ast_entry) {
  1666. qdf_spin_unlock_bh(&soc->ast_lock);
  1667. return QDF_STATUS_E_NOENT;
  1668. } else if (ast_entry->is_mapped) {
  1669. soc->ast_table[ast_entry->ast_idx] = NULL;
  1670. }
  1671. cb = ast_entry->callback;
  1672. cookie = ast_entry->cookie;
  1673. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  1674. dp_peer_free_ast_entry(soc, ast_entry);
  1675. qdf_spin_unlock_bh(&soc->ast_lock);
  1676. if (cb) {
  1677. cb(soc->ctrl_psoc,
  1678. dp_soc_to_cdp_soc(soc),
  1679. cookie,
  1680. CDP_TXRX_AST_DELETED);
  1681. }
  1682. return QDF_STATUS_SUCCESS;
  1683. }
  1684. /*
  1685. * dp_peer_find_hash_find() - returns peer from peer_hash_table matching
  1686. * vdev_id and mac_address
  1687. * @soc: soc handle
  1688. * @peer_mac_addr: peer mac address
  1689. * @mac_addr_is_aligned: is mac addr alligned
  1690. * @vdev_id: vdev_id
  1691. * @mod_id: id of module requesting reference
  1692. *
  1693. * return: peer in sucsess
  1694. * NULL in failure
  1695. */
  1696. struct dp_peer *dp_peer_find_hash_find(struct dp_soc *soc,
  1697. uint8_t *peer_mac_addr, int mac_addr_is_aligned, uint8_t vdev_id,
  1698. enum dp_mod_id mod_id)
  1699. {
  1700. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  1701. unsigned index;
  1702. struct dp_peer *peer;
  1703. if (!soc->peer_hash.bins)
  1704. return NULL;
  1705. if (mac_addr_is_aligned) {
  1706. mac_addr = (union dp_align_mac_addr *) peer_mac_addr;
  1707. } else {
  1708. qdf_mem_copy(
  1709. &local_mac_addr_aligned.raw[0],
  1710. peer_mac_addr, QDF_MAC_ADDR_SIZE);
  1711. mac_addr = &local_mac_addr_aligned;
  1712. }
  1713. index = dp_peer_find_hash_index(soc, mac_addr);
  1714. qdf_spin_lock_bh(&soc->peer_hash_lock);
  1715. TAILQ_FOREACH(peer, &soc->peer_hash.bins[index], hash_list_elem) {
  1716. if (dp_peer_find_mac_addr_cmp(mac_addr, &peer->mac_addr) == 0 &&
  1717. ((peer->vdev->vdev_id == vdev_id) ||
  1718. (vdev_id == DP_VDEV_ALL))) {
  1719. /* take peer reference before returning */
  1720. if (dp_peer_get_ref(soc, peer, mod_id) !=
  1721. QDF_STATUS_SUCCESS)
  1722. peer = NULL;
  1723. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  1724. return peer;
  1725. }
  1726. }
  1727. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  1728. return NULL; /* failure */
  1729. }
  1730. qdf_export_symbol(dp_peer_find_hash_find);
  1731. /*
  1732. * dp_peer_find_hash_remove() - remove peer from peer_hash_table
  1733. * @soc: soc handle
  1734. * @peer: peer handle
  1735. *
  1736. * return: none
  1737. */
  1738. void dp_peer_find_hash_remove(struct dp_soc *soc, struct dp_peer *peer)
  1739. {
  1740. unsigned index;
  1741. struct dp_peer *tmppeer = NULL;
  1742. int found = 0;
  1743. index = dp_peer_find_hash_index(soc, &peer->mac_addr);
  1744. /* Check if tail is not empty before delete*/
  1745. QDF_ASSERT(!TAILQ_EMPTY(&soc->peer_hash.bins[index]));
  1746. qdf_spin_lock_bh(&soc->peer_hash_lock);
  1747. TAILQ_FOREACH(tmppeer, &soc->peer_hash.bins[index], hash_list_elem) {
  1748. if (tmppeer == peer) {
  1749. found = 1;
  1750. break;
  1751. }
  1752. }
  1753. QDF_ASSERT(found);
  1754. TAILQ_REMOVE(&soc->peer_hash.bins[index], peer, hash_list_elem);
  1755. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  1756. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  1757. }
  1758. void dp_peer_find_hash_erase(struct dp_soc *soc)
  1759. {
  1760. int i;
  1761. /*
  1762. * Not really necessary to take peer_ref_mutex lock - by this point,
  1763. * it's known that the soc is no longer in use.
  1764. */
  1765. for (i = 0; i <= soc->peer_hash.mask; i++) {
  1766. if (!TAILQ_EMPTY(&soc->peer_hash.bins[i])) {
  1767. struct dp_peer *peer, *peer_next;
  1768. /*
  1769. * TAILQ_FOREACH_SAFE must be used here to avoid any
  1770. * memory access violation after peer is freed
  1771. */
  1772. TAILQ_FOREACH_SAFE(peer, &soc->peer_hash.bins[i],
  1773. hash_list_elem, peer_next) {
  1774. /*
  1775. * Don't remove the peer from the hash table -
  1776. * that would modify the list we are currently
  1777. * traversing, and it's not necessary anyway.
  1778. */
  1779. /*
  1780. * Artificially adjust the peer's ref count to
  1781. * 1, so it will get deleted by
  1782. * dp_peer_unref_delete.
  1783. */
  1784. /* set to zero */
  1785. qdf_atomic_init(&peer->ref_cnt);
  1786. for (i = 0; i < DP_MOD_ID_MAX; i++)
  1787. qdf_atomic_init(&peer->mod_refs[i]);
  1788. /* incr to one */
  1789. qdf_atomic_inc(&peer->ref_cnt);
  1790. qdf_atomic_inc(&peer->mod_refs
  1791. [DP_MOD_ID_CONFIG]);
  1792. dp_peer_unref_delete(peer,
  1793. DP_MOD_ID_CONFIG);
  1794. }
  1795. }
  1796. }
  1797. }
  1798. void dp_peer_ast_table_detach(struct dp_soc *soc)
  1799. {
  1800. if (soc->ast_table) {
  1801. qdf_mem_free(soc->ast_table);
  1802. soc->ast_table = NULL;
  1803. }
  1804. }
  1805. /*
  1806. * dp_peer_find_map_detach() - cleanup memory for peer_id_to_obj_map
  1807. * @soc: soc handle
  1808. *
  1809. * return: none
  1810. */
  1811. void dp_peer_find_map_detach(struct dp_soc *soc)
  1812. {
  1813. if (soc->peer_id_to_obj_map) {
  1814. qdf_mem_free(soc->peer_id_to_obj_map);
  1815. soc->peer_id_to_obj_map = NULL;
  1816. qdf_spinlock_destroy(&soc->peer_map_lock);
  1817. }
  1818. }
  1819. #ifndef AST_OFFLOAD_ENABLE
  1820. QDF_STATUS dp_peer_find_attach(struct dp_soc *soc)
  1821. {
  1822. QDF_STATUS status;
  1823. status = dp_peer_find_map_attach(soc);
  1824. if (!QDF_IS_STATUS_SUCCESS(status))
  1825. return status;
  1826. status = dp_peer_find_hash_attach(soc);
  1827. if (!QDF_IS_STATUS_SUCCESS(status))
  1828. goto map_detach;
  1829. status = dp_peer_ast_table_attach(soc);
  1830. if (!QDF_IS_STATUS_SUCCESS(status))
  1831. goto hash_detach;
  1832. status = dp_peer_ast_hash_attach(soc);
  1833. if (!QDF_IS_STATUS_SUCCESS(status))
  1834. goto ast_table_detach;
  1835. status = dp_peer_mec_hash_attach(soc);
  1836. if (QDF_IS_STATUS_SUCCESS(status)) {
  1837. dp_soc_wds_attach(soc);
  1838. return status;
  1839. }
  1840. dp_peer_ast_hash_detach(soc);
  1841. ast_table_detach:
  1842. dp_peer_ast_table_detach(soc);
  1843. hash_detach:
  1844. dp_peer_find_hash_detach(soc);
  1845. map_detach:
  1846. dp_peer_find_map_detach(soc);
  1847. return status;
  1848. }
  1849. #else
  1850. QDF_STATUS dp_peer_find_attach(struct dp_soc *soc)
  1851. {
  1852. QDF_STATUS status;
  1853. status = dp_peer_find_map_attach(soc);
  1854. if (!QDF_IS_STATUS_SUCCESS(status))
  1855. return status;
  1856. status = dp_peer_find_hash_attach(soc);
  1857. if (!QDF_IS_STATUS_SUCCESS(status))
  1858. goto map_detach;
  1859. return status;
  1860. map_detach:
  1861. dp_peer_find_map_detach(soc);
  1862. return status;
  1863. }
  1864. #endif
  1865. void dp_rx_tid_stats_cb(struct dp_soc *soc, void *cb_ctxt,
  1866. union hal_reo_status *reo_status)
  1867. {
  1868. struct dp_rx_tid *rx_tid = (struct dp_rx_tid *)cb_ctxt;
  1869. struct hal_reo_queue_status *queue_status = &(reo_status->queue_status);
  1870. if (queue_status->header.status == HAL_REO_CMD_DRAIN)
  1871. return;
  1872. if (queue_status->header.status != HAL_REO_CMD_SUCCESS) {
  1873. DP_PRINT_STATS("REO stats failure %d for TID %d\n",
  1874. queue_status->header.status, rx_tid->tid);
  1875. return;
  1876. }
  1877. DP_PRINT_STATS("REO queue stats (TID: %d):\n"
  1878. "ssn: %d\n"
  1879. "curr_idx : %d\n"
  1880. "pn_31_0 : %08x\n"
  1881. "pn_63_32 : %08x\n"
  1882. "pn_95_64 : %08x\n"
  1883. "pn_127_96 : %08x\n"
  1884. "last_rx_enq_tstamp : %08x\n"
  1885. "last_rx_deq_tstamp : %08x\n"
  1886. "rx_bitmap_31_0 : %08x\n"
  1887. "rx_bitmap_63_32 : %08x\n"
  1888. "rx_bitmap_95_64 : %08x\n"
  1889. "rx_bitmap_127_96 : %08x\n"
  1890. "rx_bitmap_159_128 : %08x\n"
  1891. "rx_bitmap_191_160 : %08x\n"
  1892. "rx_bitmap_223_192 : %08x\n"
  1893. "rx_bitmap_255_224 : %08x\n",
  1894. rx_tid->tid,
  1895. queue_status->ssn, queue_status->curr_idx,
  1896. queue_status->pn_31_0, queue_status->pn_63_32,
  1897. queue_status->pn_95_64, queue_status->pn_127_96,
  1898. queue_status->last_rx_enq_tstamp,
  1899. queue_status->last_rx_deq_tstamp,
  1900. queue_status->rx_bitmap_31_0,
  1901. queue_status->rx_bitmap_63_32,
  1902. queue_status->rx_bitmap_95_64,
  1903. queue_status->rx_bitmap_127_96,
  1904. queue_status->rx_bitmap_159_128,
  1905. queue_status->rx_bitmap_191_160,
  1906. queue_status->rx_bitmap_223_192,
  1907. queue_status->rx_bitmap_255_224);
  1908. DP_PRINT_STATS(
  1909. "curr_mpdu_cnt : %d\n"
  1910. "curr_msdu_cnt : %d\n"
  1911. "fwd_timeout_cnt : %d\n"
  1912. "fwd_bar_cnt : %d\n"
  1913. "dup_cnt : %d\n"
  1914. "frms_in_order_cnt : %d\n"
  1915. "bar_rcvd_cnt : %d\n"
  1916. "mpdu_frms_cnt : %d\n"
  1917. "msdu_frms_cnt : %d\n"
  1918. "total_byte_cnt : %d\n"
  1919. "late_recv_mpdu_cnt : %d\n"
  1920. "win_jump_2k : %d\n"
  1921. "hole_cnt : %d\n",
  1922. queue_status->curr_mpdu_cnt,
  1923. queue_status->curr_msdu_cnt,
  1924. queue_status->fwd_timeout_cnt,
  1925. queue_status->fwd_bar_cnt,
  1926. queue_status->dup_cnt,
  1927. queue_status->frms_in_order_cnt,
  1928. queue_status->bar_rcvd_cnt,
  1929. queue_status->mpdu_frms_cnt,
  1930. queue_status->msdu_frms_cnt,
  1931. queue_status->total_cnt,
  1932. queue_status->late_recv_mpdu_cnt,
  1933. queue_status->win_jump_2k,
  1934. queue_status->hole_cnt);
  1935. DP_PRINT_STATS("Addba Req : %d\n"
  1936. "Addba Resp : %d\n"
  1937. "Addba Resp success : %d\n"
  1938. "Addba Resp failed : %d\n"
  1939. "Delba Req received : %d\n"
  1940. "Delba Tx success : %d\n"
  1941. "Delba Tx Fail : %d\n"
  1942. "BA window size : %d\n"
  1943. "Pn size : %d\n",
  1944. rx_tid->num_of_addba_req,
  1945. rx_tid->num_of_addba_resp,
  1946. rx_tid->num_addba_rsp_success,
  1947. rx_tid->num_addba_rsp_failed,
  1948. rx_tid->num_of_delba_req,
  1949. rx_tid->delba_tx_success_cnt,
  1950. rx_tid->delba_tx_fail_cnt,
  1951. rx_tid->ba_win_size,
  1952. rx_tid->pn_size);
  1953. }
  1954. /*
  1955. * dp_peer_find_add_id() - map peer_id with peer
  1956. * @soc: soc handle
  1957. * @peer_mac_addr: peer mac address
  1958. * @peer_id: peer id to be mapped
  1959. * @hw_peer_id: HW ast index
  1960. * @vdev_id: vdev_id
  1961. *
  1962. * return: peer in success
  1963. * NULL in failure
  1964. */
  1965. static inline struct dp_peer *dp_peer_find_add_id(struct dp_soc *soc,
  1966. uint8_t *peer_mac_addr, uint16_t peer_id, uint16_t hw_peer_id,
  1967. uint8_t vdev_id)
  1968. {
  1969. struct dp_peer *peer;
  1970. QDF_ASSERT(peer_id <= soc->max_peers);
  1971. /* check if there's already a peer object with this MAC address */
  1972. peer = dp_peer_find_hash_find(soc, peer_mac_addr,
  1973. 0 /* is aligned */, vdev_id, DP_MOD_ID_CONFIG);
  1974. dp_peer_err("%pK: peer %pK ID %d vid %d mac " QDF_MAC_ADDR_FMT,
  1975. soc, peer, peer_id, vdev_id,
  1976. QDF_MAC_ADDR_REF(peer_mac_addr));
  1977. if (peer) {
  1978. /* peer's ref count was already incremented by
  1979. * peer_find_hash_find
  1980. */
  1981. dp_peer_info("%pK: ref_cnt: %d", soc,
  1982. qdf_atomic_read(&peer->ref_cnt));
  1983. /*
  1984. * if peer is in logical delete CP triggered delete before map
  1985. * is received ignore this event
  1986. */
  1987. if (dp_peer_state_cmp(peer, DP_PEER_STATE_LOGICAL_DELETE)) {
  1988. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  1989. dp_alert("Peer %pK["QDF_MAC_ADDR_FMT"] logical delete state vid %d",
  1990. peer, QDF_MAC_ADDR_REF(peer_mac_addr),
  1991. vdev_id);
  1992. return NULL;
  1993. }
  1994. dp_peer_find_id_to_obj_add(soc, peer, peer_id);
  1995. if (peer->peer_id == HTT_INVALID_PEER) {
  1996. peer->peer_id = peer_id;
  1997. dp_monitor_peer_tid_peer_id_update(soc, peer,
  1998. peer->peer_id);
  1999. } else {
  2000. QDF_ASSERT(0);
  2001. }
  2002. dp_peer_update_state(soc, peer, DP_PEER_STATE_ACTIVE);
  2003. return peer;
  2004. }
  2005. return NULL;
  2006. }
  2007. /**
  2008. * dp_rx_peer_map_handler() - handle peer map event from firmware
  2009. * @soc_handle - genereic soc handle
  2010. * @peeri_id - peer_id from firmware
  2011. * @hw_peer_id - ast index for this peer
  2012. * @vdev_id - vdev ID
  2013. * @peer_mac_addr - mac address of the peer
  2014. * @ast_hash - ast hash value
  2015. * @is_wds - flag to indicate peer map event for WDS ast entry
  2016. *
  2017. * associate the peer_id that firmware provided with peer entry
  2018. * and update the ast table in the host with the hw_peer_id.
  2019. *
  2020. * Return: QDF_STATUS code
  2021. */
  2022. QDF_STATUS
  2023. dp_rx_peer_map_handler(struct dp_soc *soc, uint16_t peer_id,
  2024. uint16_t hw_peer_id, uint8_t vdev_id,
  2025. uint8_t *peer_mac_addr, uint16_t ast_hash,
  2026. uint8_t is_wds)
  2027. {
  2028. struct dp_peer *peer = NULL;
  2029. enum cdp_txrx_ast_entry_type type = CDP_TXRX_AST_TYPE_STATIC;
  2030. QDF_STATUS err = QDF_STATUS_SUCCESS;
  2031. dp_info("peer_map_event (soc:%pK): peer_id %d, hw_peer_id %d, peer_mac "QDF_MAC_ADDR_FMT", vdev_id %d",
  2032. soc, peer_id, hw_peer_id,
  2033. QDF_MAC_ADDR_REF(peer_mac_addr), vdev_id);
  2034. /* Peer map event for WDS ast entry get the peer from
  2035. * obj map
  2036. */
  2037. if (is_wds) {
  2038. if (!soc->ast_offload_support) {
  2039. peer = dp_peer_get_ref_by_id(soc, peer_id,
  2040. DP_MOD_ID_HTT);
  2041. err = dp_peer_map_ast(soc, peer, peer_mac_addr,
  2042. hw_peer_id,
  2043. vdev_id, ast_hash, is_wds);
  2044. if (peer)
  2045. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  2046. }
  2047. } else {
  2048. /*
  2049. * It's the responsibility of the CP and FW to ensure
  2050. * that peer is created successfully. Ideally DP should
  2051. * not hit the below condition for directly assocaited
  2052. * peers.
  2053. */
  2054. if ((!soc->ast_offload_support) && ((hw_peer_id < 0) ||
  2055. (hw_peer_id >=
  2056. wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)))) {
  2057. dp_peer_err("%pK: invalid hw_peer_id: %d", soc, hw_peer_id);
  2058. qdf_assert_always(0);
  2059. }
  2060. peer = dp_peer_find_add_id(soc, peer_mac_addr, peer_id,
  2061. hw_peer_id, vdev_id);
  2062. if (peer) {
  2063. if (wlan_op_mode_sta == peer->vdev->opmode &&
  2064. qdf_mem_cmp(peer->mac_addr.raw,
  2065. peer->vdev->mac_addr.raw,
  2066. QDF_MAC_ADDR_SIZE) != 0) {
  2067. dp_peer_info("%pK: STA vdev bss_peer!!!!", soc);
  2068. peer->bss_peer = 1;
  2069. }
  2070. if (peer->vdev->opmode == wlan_op_mode_sta) {
  2071. peer->vdev->bss_ast_hash = ast_hash;
  2072. peer->vdev->bss_ast_idx = hw_peer_id;
  2073. }
  2074. /* Add ast entry incase self ast entry is
  2075. * deleted due to DP CP sync issue
  2076. *
  2077. * self_ast_entry is modified in peer create
  2078. * and peer unmap path which cannot run in
  2079. * parllel with peer map, no lock need before
  2080. * referring it
  2081. */
  2082. if (!soc->ast_offload_support &&
  2083. !peer->self_ast_entry) {
  2084. dp_info("Add self ast from map "QDF_MAC_ADDR_FMT,
  2085. QDF_MAC_ADDR_REF(peer_mac_addr));
  2086. dp_peer_add_ast(soc, peer,
  2087. peer_mac_addr,
  2088. type, 0);
  2089. }
  2090. }
  2091. err = dp_peer_map_ast(soc, peer, peer_mac_addr, hw_peer_id,
  2092. vdev_id, ast_hash, is_wds);
  2093. }
  2094. return err;
  2095. }
  2096. /**
  2097. * dp_rx_peer_unmap_handler() - handle peer unmap event from firmware
  2098. * @soc_handle - genereic soc handle
  2099. * @peeri_id - peer_id from firmware
  2100. * @vdev_id - vdev ID
  2101. * @mac_addr - mac address of the peer or wds entry
  2102. * @is_wds - flag to indicate peer map event for WDS ast entry
  2103. * @free_wds_count - number of wds entries freed by FW with peer delete
  2104. *
  2105. * Return: none
  2106. */
  2107. void
  2108. dp_rx_peer_unmap_handler(struct dp_soc *soc, uint16_t peer_id,
  2109. uint8_t vdev_id, uint8_t *mac_addr,
  2110. uint8_t is_wds, uint32_t free_wds_count)
  2111. {
  2112. struct dp_peer *peer;
  2113. struct dp_vdev *vdev = NULL;
  2114. if (soc->ast_offload_support && is_wds)
  2115. return;
  2116. peer = __dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_HTT);
  2117. /*
  2118. * Currently peer IDs are assigned for vdevs as well as peers.
  2119. * If the peer ID is for a vdev, then the peer pointer stored
  2120. * in peer_id_to_obj_map will be NULL.
  2121. */
  2122. if (!peer) {
  2123. dp_err("Received unmap event for invalid peer_id %u",
  2124. peer_id);
  2125. return;
  2126. }
  2127. /* If V2 Peer map messages are enabled AST entry has to be
  2128. * freed here
  2129. */
  2130. if (is_wds) {
  2131. if (!dp_peer_ast_free_entry_by_mac(soc, peer, vdev_id,
  2132. mac_addr)) {
  2133. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  2134. return;
  2135. }
  2136. dp_alert("AST entry not found with peer %pK peer_id %u peer_mac "QDF_MAC_ADDR_FMT" mac_addr "QDF_MAC_ADDR_FMT" vdev_id %u next_hop %u",
  2137. peer, peer->peer_id,
  2138. QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  2139. QDF_MAC_ADDR_REF(mac_addr), vdev_id,
  2140. is_wds);
  2141. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  2142. return;
  2143. }
  2144. dp_peer_clean_wds_entries(soc, peer, free_wds_count);
  2145. dp_info("peer_unmap_event (soc:%pK) peer_id %d peer %pK",
  2146. soc, peer_id, peer);
  2147. dp_peer_find_id_to_obj_remove(soc, peer_id);
  2148. peer->peer_id = HTT_INVALID_PEER;
  2149. /*
  2150. * Reset ast flow mapping table
  2151. */
  2152. if (!soc->ast_offload_support)
  2153. dp_peer_reset_flowq_map(peer);
  2154. if (soc->cdp_soc.ol_ops->peer_unmap_event) {
  2155. soc->cdp_soc.ol_ops->peer_unmap_event(soc->ctrl_psoc,
  2156. peer_id, vdev_id);
  2157. }
  2158. vdev = peer->vdev;
  2159. DP_UPDATE_STATS(vdev, peer);
  2160. dp_peer_update_state(soc, peer, DP_PEER_STATE_INACTIVE);
  2161. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  2162. /*
  2163. * Remove a reference to the peer.
  2164. * If there are no more references, delete the peer object.
  2165. */
  2166. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  2167. }
  2168. #ifndef AST_OFFLOAD_ENABLE
  2169. void
  2170. dp_peer_find_detach(struct dp_soc *soc)
  2171. {
  2172. dp_soc_wds_detach(soc);
  2173. dp_peer_find_map_detach(soc);
  2174. dp_peer_find_hash_detach(soc);
  2175. dp_peer_ast_hash_detach(soc);
  2176. dp_peer_ast_table_detach(soc);
  2177. dp_peer_mec_hash_detach(soc);
  2178. }
  2179. #else
  2180. void
  2181. dp_peer_find_detach(struct dp_soc *soc)
  2182. {
  2183. dp_peer_find_map_detach(soc);
  2184. dp_peer_find_hash_detach(soc);
  2185. }
  2186. #endif
  2187. static void dp_rx_tid_update_cb(struct dp_soc *soc, void *cb_ctxt,
  2188. union hal_reo_status *reo_status)
  2189. {
  2190. struct dp_rx_tid *rx_tid = (struct dp_rx_tid *)cb_ctxt;
  2191. if ((reo_status->rx_queue_status.header.status !=
  2192. HAL_REO_CMD_SUCCESS) &&
  2193. (reo_status->rx_queue_status.header.status !=
  2194. HAL_REO_CMD_DRAIN)) {
  2195. /* Should not happen normally. Just print error for now */
  2196. dp_peer_err("%pK: Rx tid HW desc update failed(%d): tid %d",
  2197. soc, reo_status->rx_queue_status.header.status,
  2198. rx_tid->tid);
  2199. }
  2200. }
  2201. static bool dp_get_peer_vdev_roaming_in_progress(struct dp_peer *peer)
  2202. {
  2203. struct ol_if_ops *ol_ops = NULL;
  2204. bool is_roaming = false;
  2205. uint8_t vdev_id = -1;
  2206. struct cdp_soc_t *soc;
  2207. if (!peer) {
  2208. dp_peer_info("Peer is NULL. No roaming possible");
  2209. return false;
  2210. }
  2211. soc = dp_soc_to_cdp_soc_t(peer->vdev->pdev->soc);
  2212. ol_ops = peer->vdev->pdev->soc->cdp_soc.ol_ops;
  2213. if (ol_ops && ol_ops->is_roam_inprogress) {
  2214. dp_get_vdevid(soc, peer->mac_addr.raw, &vdev_id);
  2215. is_roaming = ol_ops->is_roam_inprogress(vdev_id);
  2216. }
  2217. dp_peer_info("peer: " QDF_MAC_ADDR_FMT ", vdev_id: %d, is_roaming: %d",
  2218. QDF_MAC_ADDR_REF(peer->mac_addr.raw), vdev_id, is_roaming);
  2219. return is_roaming;
  2220. }
  2221. QDF_STATUS dp_rx_tid_update_wifi3(struct dp_peer *peer, int tid, uint32_t
  2222. ba_window_size, uint32_t start_seq,
  2223. bool bar_update)
  2224. {
  2225. struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
  2226. struct dp_soc *soc = peer->vdev->pdev->soc;
  2227. struct hal_reo_cmd_params params;
  2228. qdf_mem_zero(&params, sizeof(params));
  2229. params.std.need_status = 1;
  2230. params.std.addr_lo = rx_tid->hw_qdesc_paddr & 0xffffffff;
  2231. params.std.addr_hi = (uint64_t)(rx_tid->hw_qdesc_paddr) >> 32;
  2232. params.u.upd_queue_params.update_ba_window_size = 1;
  2233. params.u.upd_queue_params.ba_window_size = ba_window_size;
  2234. if (start_seq < IEEE80211_SEQ_MAX) {
  2235. params.u.upd_queue_params.update_ssn = 1;
  2236. params.u.upd_queue_params.ssn = start_seq;
  2237. } else {
  2238. dp_set_ssn_valid_flag(&params, 0);
  2239. }
  2240. if (dp_reo_send_cmd(soc, CMD_UPDATE_RX_REO_QUEUE, &params,
  2241. dp_rx_tid_update_cb, rx_tid)) {
  2242. dp_err_log("failed to send reo cmd CMD_UPDATE_RX_REO_QUEUE");
  2243. DP_STATS_INC(soc, rx.err.reo_cmd_send_fail, 1);
  2244. }
  2245. rx_tid->ba_win_size = ba_window_size;
  2246. if (dp_get_peer_vdev_roaming_in_progress(peer))
  2247. return QDF_STATUS_E_PERM;
  2248. if (soc->cdp_soc.ol_ops->peer_rx_reorder_queue_setup && !bar_update)
  2249. soc->cdp_soc.ol_ops->peer_rx_reorder_queue_setup(
  2250. soc->ctrl_psoc, peer->vdev->pdev->pdev_id,
  2251. peer->vdev->vdev_id, peer->mac_addr.raw,
  2252. rx_tid->hw_qdesc_paddr, tid, tid, 1, ba_window_size);
  2253. return QDF_STATUS_SUCCESS;
  2254. }
  2255. #ifdef WLAN_DP_FEATURE_DEFERRED_REO_QDESC_DESTROY
  2256. /*
  2257. * dp_reo_desc_defer_free_enqueue() - enqueue REO QDESC to be freed into
  2258. * the deferred list
  2259. * @soc: Datapath soc handle
  2260. * @free_desc: REO DESC reference that needs to be freed
  2261. *
  2262. * Return: true if enqueued, else false
  2263. */
  2264. static bool dp_reo_desc_defer_free_enqueue(struct dp_soc *soc,
  2265. struct reo_desc_list_node *freedesc)
  2266. {
  2267. struct reo_desc_deferred_freelist_node *desc;
  2268. if (!qdf_atomic_read(&soc->cmn_init_done))
  2269. return false;
  2270. desc = qdf_mem_malloc(sizeof(*desc));
  2271. if (!desc)
  2272. return false;
  2273. desc->hw_qdesc_paddr = freedesc->rx_tid.hw_qdesc_paddr;
  2274. desc->hw_qdesc_alloc_size = freedesc->rx_tid.hw_qdesc_alloc_size;
  2275. desc->hw_qdesc_vaddr_unaligned =
  2276. freedesc->rx_tid.hw_qdesc_vaddr_unaligned;
  2277. desc->free_ts = qdf_get_system_timestamp();
  2278. DP_RX_REO_QDESC_DEFERRED_GET_MAC(desc, freedesc);
  2279. qdf_spin_lock_bh(&soc->reo_desc_deferred_freelist_lock);
  2280. if (!soc->reo_desc_deferred_freelist_init) {
  2281. qdf_mem_free(desc);
  2282. qdf_spin_unlock_bh(&soc->reo_desc_deferred_freelist_lock);
  2283. return false;
  2284. }
  2285. qdf_list_insert_back(&soc->reo_desc_deferred_freelist,
  2286. (qdf_list_node_t *)desc);
  2287. qdf_spin_unlock_bh(&soc->reo_desc_deferred_freelist_lock);
  2288. return true;
  2289. }
  2290. /*
  2291. * dp_reo_desc_defer_free() - free the REO QDESC in the deferred list
  2292. * based on time threshold
  2293. * @soc: Datapath soc handle
  2294. * @free_desc: REO DESC reference that needs to be freed
  2295. *
  2296. * Return: true if enqueued, else false
  2297. */
  2298. static void dp_reo_desc_defer_free(struct dp_soc *soc)
  2299. {
  2300. struct reo_desc_deferred_freelist_node *desc;
  2301. unsigned long curr_ts = qdf_get_system_timestamp();
  2302. qdf_spin_lock_bh(&soc->reo_desc_deferred_freelist_lock);
  2303. while ((qdf_list_peek_front(&soc->reo_desc_deferred_freelist,
  2304. (qdf_list_node_t **)&desc) == QDF_STATUS_SUCCESS) &&
  2305. (curr_ts > (desc->free_ts + REO_DESC_DEFERRED_FREE_MS))) {
  2306. qdf_list_remove_front(&soc->reo_desc_deferred_freelist,
  2307. (qdf_list_node_t **)&desc);
  2308. DP_RX_REO_QDESC_DEFERRED_FREE_EVT(desc);
  2309. qdf_mem_unmap_nbytes_single(soc->osdev,
  2310. desc->hw_qdesc_paddr,
  2311. QDF_DMA_BIDIRECTIONAL,
  2312. desc->hw_qdesc_alloc_size);
  2313. qdf_mem_free(desc->hw_qdesc_vaddr_unaligned);
  2314. qdf_mem_free(desc);
  2315. curr_ts = qdf_get_system_timestamp();
  2316. }
  2317. qdf_spin_unlock_bh(&soc->reo_desc_deferred_freelist_lock);
  2318. }
  2319. #else
  2320. static inline bool
  2321. dp_reo_desc_defer_free_enqueue(struct dp_soc *soc,
  2322. struct reo_desc_list_node *freedesc)
  2323. {
  2324. return false;
  2325. }
  2326. static void dp_reo_desc_defer_free(struct dp_soc *soc)
  2327. {
  2328. }
  2329. #endif /* !WLAN_DP_FEATURE_DEFERRED_REO_QDESC_DESTROY */
  2330. /*
  2331. * dp_reo_desc_free() - Callback free reo descriptor memory after
  2332. * HW cache flush
  2333. *
  2334. * @soc: DP SOC handle
  2335. * @cb_ctxt: Callback context
  2336. * @reo_status: REO command status
  2337. */
  2338. static void dp_reo_desc_free(struct dp_soc *soc, void *cb_ctxt,
  2339. union hal_reo_status *reo_status)
  2340. {
  2341. struct reo_desc_list_node *freedesc =
  2342. (struct reo_desc_list_node *)cb_ctxt;
  2343. struct dp_rx_tid *rx_tid = &freedesc->rx_tid;
  2344. unsigned long curr_ts = qdf_get_system_timestamp();
  2345. if ((reo_status->fl_cache_status.header.status !=
  2346. HAL_REO_CMD_SUCCESS) &&
  2347. (reo_status->fl_cache_status.header.status !=
  2348. HAL_REO_CMD_DRAIN)) {
  2349. dp_peer_err("%pK: Rx tid HW desc flush failed(%d): tid %d",
  2350. soc, reo_status->rx_queue_status.header.status,
  2351. freedesc->rx_tid.tid);
  2352. }
  2353. dp_peer_info("%pK: %lu hw_qdesc_paddr: %pK, tid:%d", soc,
  2354. curr_ts, (void *)(rx_tid->hw_qdesc_paddr),
  2355. rx_tid->tid);
  2356. /* REO desc is enqueued to be freed at a later point
  2357. * in time, just free the freedesc alone and return
  2358. */
  2359. if (dp_reo_desc_defer_free_enqueue(soc, freedesc))
  2360. goto out;
  2361. DP_RX_REO_QDESC_FREE_EVT(freedesc);
  2362. qdf_mem_unmap_nbytes_single(soc->osdev,
  2363. rx_tid->hw_qdesc_paddr,
  2364. QDF_DMA_BIDIRECTIONAL,
  2365. rx_tid->hw_qdesc_alloc_size);
  2366. qdf_mem_free(rx_tid->hw_qdesc_vaddr_unaligned);
  2367. out:
  2368. qdf_mem_free(freedesc);
  2369. }
  2370. #if defined(CONFIG_WIFI_EMULATION_WIFI_3_0) && defined(BUILD_X86)
  2371. /* Hawkeye emulation requires bus address to be >= 0x50000000 */
  2372. static inline int dp_reo_desc_addr_chk(qdf_dma_addr_t dma_addr)
  2373. {
  2374. if (dma_addr < 0x50000000)
  2375. return QDF_STATUS_E_FAILURE;
  2376. else
  2377. return QDF_STATUS_SUCCESS;
  2378. }
  2379. #else
  2380. static inline int dp_reo_desc_addr_chk(qdf_dma_addr_t dma_addr)
  2381. {
  2382. return QDF_STATUS_SUCCESS;
  2383. }
  2384. #endif
  2385. /*
  2386. * dp_rx_tid_setup_wifi3() – Setup receive TID state
  2387. * @peer: Datapath peer handle
  2388. * @tid: TID
  2389. * @ba_window_size: BlockAck window size
  2390. * @start_seq: Starting sequence number
  2391. *
  2392. * Return: QDF_STATUS code
  2393. */
  2394. QDF_STATUS dp_rx_tid_setup_wifi3(struct dp_peer *peer, int tid,
  2395. uint32_t ba_window_size, uint32_t start_seq)
  2396. {
  2397. struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
  2398. struct dp_vdev *vdev = peer->vdev;
  2399. struct dp_soc *soc = vdev->pdev->soc;
  2400. uint32_t hw_qdesc_size;
  2401. uint32_t hw_qdesc_align;
  2402. int hal_pn_type;
  2403. void *hw_qdesc_vaddr;
  2404. uint32_t alloc_tries = 0;
  2405. QDF_STATUS err = QDF_STATUS_SUCCESS;
  2406. if (!qdf_atomic_read(&peer->is_default_route_set))
  2407. return QDF_STATUS_E_FAILURE;
  2408. rx_tid->ba_win_size = ba_window_size;
  2409. if (rx_tid->hw_qdesc_vaddr_unaligned)
  2410. return dp_rx_tid_update_wifi3(peer, tid, ba_window_size,
  2411. start_seq, false);
  2412. rx_tid->delba_tx_status = 0;
  2413. rx_tid->ppdu_id_2k = 0;
  2414. rx_tid->num_of_addba_req = 0;
  2415. rx_tid->num_of_delba_req = 0;
  2416. rx_tid->num_of_addba_resp = 0;
  2417. rx_tid->num_addba_rsp_failed = 0;
  2418. rx_tid->num_addba_rsp_success = 0;
  2419. rx_tid->delba_tx_success_cnt = 0;
  2420. rx_tid->delba_tx_fail_cnt = 0;
  2421. rx_tid->statuscode = 0;
  2422. /* TODO: Allocating HW queue descriptors based on max BA window size
  2423. * for all QOS TIDs so that same descriptor can be used later when
  2424. * ADDBA request is recevied. This should be changed to allocate HW
  2425. * queue descriptors based on BA window size being negotiated (0 for
  2426. * non BA cases), and reallocate when BA window size changes and also
  2427. * send WMI message to FW to change the REO queue descriptor in Rx
  2428. * peer entry as part of dp_rx_tid_update.
  2429. */
  2430. if (tid != DP_NON_QOS_TID)
  2431. hw_qdesc_size = hal_get_reo_qdesc_size(soc->hal_soc,
  2432. HAL_RX_MAX_BA_WINDOW, tid);
  2433. else
  2434. hw_qdesc_size = hal_get_reo_qdesc_size(soc->hal_soc,
  2435. ba_window_size, tid);
  2436. hw_qdesc_align = hal_get_reo_qdesc_align(soc->hal_soc);
  2437. /* To avoid unnecessary extra allocation for alignment, try allocating
  2438. * exact size and see if we already have aligned address.
  2439. */
  2440. rx_tid->hw_qdesc_alloc_size = hw_qdesc_size;
  2441. try_desc_alloc:
  2442. rx_tid->hw_qdesc_vaddr_unaligned =
  2443. qdf_mem_malloc(rx_tid->hw_qdesc_alloc_size);
  2444. if (!rx_tid->hw_qdesc_vaddr_unaligned) {
  2445. dp_peer_err("%pK: Rx tid HW desc alloc failed: tid %d",
  2446. soc, tid);
  2447. return QDF_STATUS_E_NOMEM;
  2448. }
  2449. if ((unsigned long)(rx_tid->hw_qdesc_vaddr_unaligned) %
  2450. hw_qdesc_align) {
  2451. /* Address allocated above is not alinged. Allocate extra
  2452. * memory for alignment
  2453. */
  2454. qdf_mem_free(rx_tid->hw_qdesc_vaddr_unaligned);
  2455. rx_tid->hw_qdesc_vaddr_unaligned =
  2456. qdf_mem_malloc(rx_tid->hw_qdesc_alloc_size +
  2457. hw_qdesc_align - 1);
  2458. if (!rx_tid->hw_qdesc_vaddr_unaligned) {
  2459. dp_peer_err("%pK: Rx tid HW desc alloc failed: tid %d",
  2460. soc, tid);
  2461. return QDF_STATUS_E_NOMEM;
  2462. }
  2463. hw_qdesc_vaddr = (void *)qdf_align((unsigned long)
  2464. rx_tid->hw_qdesc_vaddr_unaligned,
  2465. hw_qdesc_align);
  2466. dp_peer_debug("%pK: Total Size %d Aligned Addr %pK",
  2467. soc, rx_tid->hw_qdesc_alloc_size,
  2468. hw_qdesc_vaddr);
  2469. } else {
  2470. hw_qdesc_vaddr = rx_tid->hw_qdesc_vaddr_unaligned;
  2471. }
  2472. rx_tid->hw_qdesc_vaddr_aligned = hw_qdesc_vaddr;
  2473. /* TODO: Ensure that sec_type is set before ADDBA is received.
  2474. * Currently this is set based on htt indication
  2475. * HTT_T2H_MSG_TYPE_SEC_IND from target
  2476. */
  2477. switch (peer->security[dp_sec_ucast].sec_type) {
  2478. case cdp_sec_type_tkip_nomic:
  2479. case cdp_sec_type_aes_ccmp:
  2480. case cdp_sec_type_aes_ccmp_256:
  2481. case cdp_sec_type_aes_gcmp:
  2482. case cdp_sec_type_aes_gcmp_256:
  2483. hal_pn_type = HAL_PN_WPA;
  2484. break;
  2485. case cdp_sec_type_wapi:
  2486. if (vdev->opmode == wlan_op_mode_ap)
  2487. hal_pn_type = HAL_PN_WAPI_EVEN;
  2488. else
  2489. hal_pn_type = HAL_PN_WAPI_UNEVEN;
  2490. break;
  2491. default:
  2492. hal_pn_type = HAL_PN_NONE;
  2493. break;
  2494. }
  2495. hal_reo_qdesc_setup(soc->hal_soc, tid, ba_window_size, start_seq,
  2496. hw_qdesc_vaddr, rx_tid->hw_qdesc_paddr, hal_pn_type);
  2497. qdf_mem_map_nbytes_single(soc->osdev, hw_qdesc_vaddr,
  2498. QDF_DMA_BIDIRECTIONAL, rx_tid->hw_qdesc_alloc_size,
  2499. &(rx_tid->hw_qdesc_paddr));
  2500. if (dp_reo_desc_addr_chk(rx_tid->hw_qdesc_paddr) !=
  2501. QDF_STATUS_SUCCESS) {
  2502. if (alloc_tries++ < 10) {
  2503. qdf_mem_free(rx_tid->hw_qdesc_vaddr_unaligned);
  2504. rx_tid->hw_qdesc_vaddr_unaligned = NULL;
  2505. goto try_desc_alloc;
  2506. } else {
  2507. dp_peer_err("%pK: Rx tid HW desc alloc failed (lowmem): tid %d",
  2508. soc, tid);
  2509. err = QDF_STATUS_E_NOMEM;
  2510. goto error;
  2511. }
  2512. }
  2513. if (dp_get_peer_vdev_roaming_in_progress(peer)) {
  2514. err = QDF_STATUS_E_PERM;
  2515. goto error;
  2516. }
  2517. if (soc->cdp_soc.ol_ops->peer_rx_reorder_queue_setup) {
  2518. if (soc->cdp_soc.ol_ops->peer_rx_reorder_queue_setup(
  2519. soc->ctrl_psoc,
  2520. peer->vdev->pdev->pdev_id,
  2521. peer->vdev->vdev_id,
  2522. peer->mac_addr.raw, rx_tid->hw_qdesc_paddr, tid, tid,
  2523. 1, ba_window_size)) {
  2524. dp_peer_err("%pK: Failed to send reo queue setup to FW - tid %d\n",
  2525. soc, tid);
  2526. err = QDF_STATUS_E_FAILURE;
  2527. goto error;
  2528. }
  2529. }
  2530. return 0;
  2531. error:
  2532. if (rx_tid->hw_qdesc_vaddr_unaligned) {
  2533. if (dp_reo_desc_addr_chk(rx_tid->hw_qdesc_paddr) ==
  2534. QDF_STATUS_SUCCESS)
  2535. qdf_mem_unmap_nbytes_single(
  2536. soc->osdev,
  2537. rx_tid->hw_qdesc_paddr,
  2538. QDF_DMA_BIDIRECTIONAL,
  2539. rx_tid->hw_qdesc_alloc_size);
  2540. qdf_mem_free(rx_tid->hw_qdesc_vaddr_unaligned);
  2541. rx_tid->hw_qdesc_vaddr_unaligned = NULL;
  2542. }
  2543. return err;
  2544. }
  2545. #ifdef REO_DESC_DEFER_FREE
  2546. /*
  2547. * dp_reo_desc_clean_up() - If cmd to flush base desc fails add
  2548. * desc back to freelist and defer the deletion
  2549. *
  2550. * @soc: DP SOC handle
  2551. * @desc: Base descriptor to be freed
  2552. * @reo_status: REO command status
  2553. */
  2554. static void dp_reo_desc_clean_up(struct dp_soc *soc,
  2555. struct reo_desc_list_node *desc,
  2556. union hal_reo_status *reo_status)
  2557. {
  2558. desc->free_ts = qdf_get_system_timestamp();
  2559. DP_STATS_INC(soc, rx.err.reo_cmd_send_fail, 1);
  2560. qdf_list_insert_back(&soc->reo_desc_freelist,
  2561. (qdf_list_node_t *)desc);
  2562. }
  2563. /*
  2564. * dp_reo_limit_clean_batch_sz() - Limit number REO CMD queued to cmd
  2565. * ring in aviod of REO hang
  2566. *
  2567. * @list_size: REO desc list size to be cleaned
  2568. */
  2569. static inline void dp_reo_limit_clean_batch_sz(uint32_t *list_size)
  2570. {
  2571. unsigned long curr_ts = qdf_get_system_timestamp();
  2572. if ((*list_size) > REO_DESC_FREELIST_SIZE) {
  2573. dp_err_log("%lu:freedesc number %d in freelist",
  2574. curr_ts, *list_size);
  2575. /* limit the batch queue size */
  2576. *list_size = REO_DESC_FREELIST_SIZE;
  2577. }
  2578. }
  2579. #else
  2580. /*
  2581. * dp_reo_desc_clean_up() - If send cmd to REO inorder to flush
  2582. * cache fails free the base REO desc anyway
  2583. *
  2584. * @soc: DP SOC handle
  2585. * @desc: Base descriptor to be freed
  2586. * @reo_status: REO command status
  2587. */
  2588. static void dp_reo_desc_clean_up(struct dp_soc *soc,
  2589. struct reo_desc_list_node *desc,
  2590. union hal_reo_status *reo_status)
  2591. {
  2592. if (reo_status) {
  2593. qdf_mem_zero(reo_status, sizeof(*reo_status));
  2594. reo_status->fl_cache_status.header.status = 0;
  2595. dp_reo_desc_free(soc, (void *)desc, reo_status);
  2596. }
  2597. }
  2598. /*
  2599. * dp_reo_limit_clean_batch_sz() - Limit number REO CMD queued to cmd
  2600. * ring in aviod of REO hang
  2601. *
  2602. * @list_size: REO desc list size to be cleaned
  2603. */
  2604. static inline void dp_reo_limit_clean_batch_sz(uint32_t *list_size)
  2605. {
  2606. }
  2607. #endif
  2608. /*
  2609. * dp_resend_update_reo_cmd() - Resend the UPDATE_REO_QUEUE
  2610. * cmd and re-insert desc into free list if send fails.
  2611. *
  2612. * @soc: DP SOC handle
  2613. * @desc: desc with resend update cmd flag set
  2614. * @rx_tid: Desc RX tid associated with update cmd for resetting
  2615. * valid field to 0 in h/w
  2616. *
  2617. * Return: QDF status
  2618. */
  2619. static QDF_STATUS
  2620. dp_resend_update_reo_cmd(struct dp_soc *soc,
  2621. struct reo_desc_list_node *desc,
  2622. struct dp_rx_tid *rx_tid)
  2623. {
  2624. struct hal_reo_cmd_params params;
  2625. qdf_mem_zero(&params, sizeof(params));
  2626. params.std.need_status = 1;
  2627. params.std.addr_lo =
  2628. rx_tid->hw_qdesc_paddr & 0xffffffff;
  2629. params.std.addr_hi =
  2630. (uint64_t)(rx_tid->hw_qdesc_paddr) >> 32;
  2631. params.u.upd_queue_params.update_vld = 1;
  2632. params.u.upd_queue_params.vld = 0;
  2633. desc->resend_update_reo_cmd = false;
  2634. /*
  2635. * If the cmd send fails then set resend_update_reo_cmd flag
  2636. * and insert the desc at the end of the free list to retry.
  2637. */
  2638. if (dp_reo_send_cmd(soc,
  2639. CMD_UPDATE_RX_REO_QUEUE,
  2640. &params,
  2641. dp_rx_tid_delete_cb,
  2642. (void *)desc)
  2643. != QDF_STATUS_SUCCESS) {
  2644. desc->resend_update_reo_cmd = true;
  2645. desc->free_ts = qdf_get_system_timestamp();
  2646. qdf_list_insert_back(&soc->reo_desc_freelist,
  2647. (qdf_list_node_t *)desc);
  2648. dp_err_log("failed to send reo cmd CMD_UPDATE_RX_REO_QUEUE");
  2649. DP_STATS_INC(soc, rx.err.reo_cmd_send_fail, 1);
  2650. return QDF_STATUS_E_FAILURE;
  2651. }
  2652. return QDF_STATUS_SUCCESS;
  2653. }
  2654. /*
  2655. * dp_rx_tid_delete_cb() - Callback to flush reo descriptor HW cache
  2656. * after deleting the entries (ie., setting valid=0)
  2657. *
  2658. * @soc: DP SOC handle
  2659. * @cb_ctxt: Callback context
  2660. * @reo_status: REO command status
  2661. */
  2662. void dp_rx_tid_delete_cb(struct dp_soc *soc, void *cb_ctxt,
  2663. union hal_reo_status *reo_status)
  2664. {
  2665. struct reo_desc_list_node *freedesc =
  2666. (struct reo_desc_list_node *)cb_ctxt;
  2667. uint32_t list_size;
  2668. struct reo_desc_list_node *desc;
  2669. unsigned long curr_ts = qdf_get_system_timestamp();
  2670. uint32_t desc_size, tot_desc_size;
  2671. struct hal_reo_cmd_params params;
  2672. bool flush_failure = false;
  2673. DP_RX_REO_QDESC_UPDATE_EVT(freedesc);
  2674. if (reo_status->rx_queue_status.header.status == HAL_REO_CMD_DRAIN) {
  2675. qdf_mem_zero(reo_status, sizeof(*reo_status));
  2676. reo_status->fl_cache_status.header.status = HAL_REO_CMD_DRAIN;
  2677. dp_reo_desc_free(soc, (void *)freedesc, reo_status);
  2678. DP_STATS_INC(soc, rx.err.reo_cmd_send_drain, 1);
  2679. return;
  2680. } else if (reo_status->rx_queue_status.header.status !=
  2681. HAL_REO_CMD_SUCCESS) {
  2682. /* Should not happen normally. Just print error for now */
  2683. dp_info_rl("Rx tid HW desc deletion failed(%d): tid %d",
  2684. reo_status->rx_queue_status.header.status,
  2685. freedesc->rx_tid.tid);
  2686. }
  2687. dp_peer_info("%pK: rx_tid: %d status: %d",
  2688. soc, freedesc->rx_tid.tid,
  2689. reo_status->rx_queue_status.header.status);
  2690. qdf_spin_lock_bh(&soc->reo_desc_freelist_lock);
  2691. freedesc->free_ts = curr_ts;
  2692. qdf_list_insert_back_size(&soc->reo_desc_freelist,
  2693. (qdf_list_node_t *)freedesc, &list_size);
  2694. /* MCL path add the desc back to reo_desc_freelist when REO FLUSH
  2695. * failed. it may cause the number of REO queue pending in free
  2696. * list is even larger than REO_CMD_RING max size and lead REO CMD
  2697. * flood then cause REO HW in an unexpected condition. So it's
  2698. * needed to limit the number REO cmds in a batch operation.
  2699. */
  2700. dp_reo_limit_clean_batch_sz(&list_size);
  2701. while ((qdf_list_peek_front(&soc->reo_desc_freelist,
  2702. (qdf_list_node_t **)&desc) == QDF_STATUS_SUCCESS) &&
  2703. ((list_size >= REO_DESC_FREELIST_SIZE) ||
  2704. (curr_ts > (desc->free_ts + REO_DESC_FREE_DEFER_MS)) ||
  2705. (desc->resend_update_reo_cmd && list_size))) {
  2706. struct dp_rx_tid *rx_tid;
  2707. qdf_list_remove_front(&soc->reo_desc_freelist,
  2708. (qdf_list_node_t **)&desc);
  2709. list_size--;
  2710. rx_tid = &desc->rx_tid;
  2711. /* First process descs with resend_update_reo_cmd set */
  2712. if (desc->resend_update_reo_cmd) {
  2713. if (dp_resend_update_reo_cmd(soc, desc, rx_tid) !=
  2714. QDF_STATUS_SUCCESS)
  2715. break;
  2716. else
  2717. continue;
  2718. }
  2719. /* Flush and invalidate REO descriptor from HW cache: Base and
  2720. * extension descriptors should be flushed separately */
  2721. if (desc->pending_ext_desc_size)
  2722. tot_desc_size = desc->pending_ext_desc_size;
  2723. else
  2724. tot_desc_size = rx_tid->hw_qdesc_alloc_size;
  2725. /* Get base descriptor size by passing non-qos TID */
  2726. desc_size = hal_get_reo_qdesc_size(soc->hal_soc, 0,
  2727. DP_NON_QOS_TID);
  2728. /* Flush reo extension descriptors */
  2729. while ((tot_desc_size -= desc_size) > 0) {
  2730. qdf_mem_zero(&params, sizeof(params));
  2731. params.std.addr_lo =
  2732. ((uint64_t)(rx_tid->hw_qdesc_paddr) +
  2733. tot_desc_size) & 0xffffffff;
  2734. params.std.addr_hi =
  2735. (uint64_t)(rx_tid->hw_qdesc_paddr) >> 32;
  2736. if (QDF_STATUS_SUCCESS != dp_reo_send_cmd(soc,
  2737. CMD_FLUSH_CACHE,
  2738. &params,
  2739. NULL,
  2740. NULL)) {
  2741. dp_info_rl("fail to send CMD_CACHE_FLUSH:"
  2742. "tid %d desc %pK", rx_tid->tid,
  2743. (void *)(rx_tid->hw_qdesc_paddr));
  2744. desc->pending_ext_desc_size = tot_desc_size +
  2745. desc_size;
  2746. dp_reo_desc_clean_up(soc, desc, reo_status);
  2747. flush_failure = true;
  2748. break;
  2749. }
  2750. }
  2751. if (flush_failure)
  2752. break;
  2753. else
  2754. desc->pending_ext_desc_size = desc_size;
  2755. /* Flush base descriptor */
  2756. qdf_mem_zero(&params, sizeof(params));
  2757. params.std.need_status = 1;
  2758. params.std.addr_lo =
  2759. (uint64_t)(rx_tid->hw_qdesc_paddr) & 0xffffffff;
  2760. params.std.addr_hi = (uint64_t)(rx_tid->hw_qdesc_paddr) >> 32;
  2761. if (QDF_STATUS_SUCCESS != dp_reo_send_cmd(soc,
  2762. CMD_FLUSH_CACHE,
  2763. &params,
  2764. dp_reo_desc_free,
  2765. (void *)desc)) {
  2766. union hal_reo_status reo_status;
  2767. /*
  2768. * If dp_reo_send_cmd return failure, related TID queue desc
  2769. * should be unmapped. Also locally reo_desc, together with
  2770. * TID queue desc also need to be freed accordingly.
  2771. *
  2772. * Here invoke desc_free function directly to do clean up.
  2773. *
  2774. * In case of MCL path add the desc back to the free
  2775. * desc list and defer deletion.
  2776. */
  2777. dp_info_rl("fail to send REO cmd to flush cache: tid %d",
  2778. rx_tid->tid);
  2779. dp_reo_desc_clean_up(soc, desc, &reo_status);
  2780. DP_STATS_INC(soc, rx.err.reo_cmd_send_fail, 1);
  2781. break;
  2782. }
  2783. }
  2784. qdf_spin_unlock_bh(&soc->reo_desc_freelist_lock);
  2785. dp_reo_desc_defer_free(soc);
  2786. }
  2787. /*
  2788. * dp_rx_tid_delete_wifi3() – Delete receive TID queue
  2789. * @peer: Datapath peer handle
  2790. * @tid: TID
  2791. *
  2792. * Return: 0 on success, error code on failure
  2793. */
  2794. static int dp_rx_tid_delete_wifi3(struct dp_peer *peer, int tid)
  2795. {
  2796. struct dp_rx_tid *rx_tid = &(peer->rx_tid[tid]);
  2797. struct dp_soc *soc = peer->vdev->pdev->soc;
  2798. struct hal_reo_cmd_params params;
  2799. struct reo_desc_list_node *freedesc =
  2800. qdf_mem_malloc(sizeof(*freedesc));
  2801. if (!freedesc) {
  2802. dp_peer_err("%pK: malloc failed for freedesc: tid %d",
  2803. soc, tid);
  2804. return -ENOMEM;
  2805. }
  2806. freedesc->rx_tid = *rx_tid;
  2807. freedesc->resend_update_reo_cmd = false;
  2808. qdf_mem_zero(&params, sizeof(params));
  2809. DP_RX_REO_QDESC_GET_MAC(freedesc, peer);
  2810. params.std.need_status = 1;
  2811. params.std.addr_lo = rx_tid->hw_qdesc_paddr & 0xffffffff;
  2812. params.std.addr_hi = (uint64_t)(rx_tid->hw_qdesc_paddr) >> 32;
  2813. params.u.upd_queue_params.update_vld = 1;
  2814. params.u.upd_queue_params.vld = 0;
  2815. if (dp_reo_send_cmd(soc, CMD_UPDATE_RX_REO_QUEUE, &params,
  2816. dp_rx_tid_delete_cb, (void *)freedesc)
  2817. != QDF_STATUS_SUCCESS) {
  2818. /* Defer the clean up to the call back context */
  2819. qdf_spin_lock_bh(&soc->reo_desc_freelist_lock);
  2820. freedesc->free_ts = qdf_get_system_timestamp();
  2821. freedesc->resend_update_reo_cmd = true;
  2822. qdf_list_insert_front(&soc->reo_desc_freelist,
  2823. (qdf_list_node_t *)freedesc);
  2824. DP_STATS_INC(soc, rx.err.reo_cmd_send_fail, 1);
  2825. qdf_spin_unlock_bh(&soc->reo_desc_freelist_lock);
  2826. dp_info("Failed to send CMD_UPDATE_RX_REO_QUEUE");
  2827. }
  2828. rx_tid->hw_qdesc_vaddr_unaligned = NULL;
  2829. rx_tid->hw_qdesc_alloc_size = 0;
  2830. rx_tid->hw_qdesc_paddr = 0;
  2831. return 0;
  2832. }
  2833. #ifdef DP_LFR
  2834. static void dp_peer_setup_remaining_tids(struct dp_peer *peer)
  2835. {
  2836. int tid;
  2837. for (tid = 1; tid < DP_MAX_TIDS-1; tid++) {
  2838. dp_rx_tid_setup_wifi3(peer, tid, 1, 0);
  2839. dp_peer_debug("Setting up TID %d for peer %pK peer->local_id %d",
  2840. tid, peer, peer->local_id);
  2841. }
  2842. }
  2843. #else
  2844. static void dp_peer_setup_remaining_tids(struct dp_peer *peer) {};
  2845. #endif
  2846. /*
  2847. * dp_peer_rx_init() – Initialize receive TID state
  2848. * @pdev: Datapath pdev
  2849. * @peer: Datapath peer
  2850. *
  2851. */
  2852. void dp_peer_rx_init(struct dp_pdev *pdev, struct dp_peer *peer)
  2853. {
  2854. int tid;
  2855. struct dp_rx_tid *rx_tid;
  2856. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  2857. rx_tid = &peer->rx_tid[tid];
  2858. rx_tid->array = &rx_tid->base;
  2859. rx_tid->base.head = rx_tid->base.tail = NULL;
  2860. rx_tid->tid = tid;
  2861. rx_tid->defrag_timeout_ms = 0;
  2862. rx_tid->ba_win_size = 0;
  2863. rx_tid->ba_status = DP_RX_BA_INACTIVE;
  2864. rx_tid->defrag_waitlist_elem.tqe_next = NULL;
  2865. rx_tid->defrag_waitlist_elem.tqe_prev = NULL;
  2866. }
  2867. peer->active_ba_session_cnt = 0;
  2868. peer->hw_buffer_size = 0;
  2869. peer->kill_256_sessions = 0;
  2870. /* Setup default (non-qos) rx tid queue */
  2871. dp_rx_tid_setup_wifi3(peer, DP_NON_QOS_TID, 1, 0);
  2872. /* Setup rx tid queue for TID 0.
  2873. * Other queues will be setup on receiving first packet, which will cause
  2874. * NULL REO queue error
  2875. */
  2876. dp_rx_tid_setup_wifi3(peer, 0, 1, 0);
  2877. /*
  2878. * Setup the rest of TID's to handle LFR
  2879. */
  2880. dp_peer_setup_remaining_tids(peer);
  2881. /*
  2882. * Set security defaults: no PN check, no security. The target may
  2883. * send a HTT SEC_IND message to overwrite these defaults.
  2884. */
  2885. peer->security[dp_sec_ucast].sec_type =
  2886. peer->security[dp_sec_mcast].sec_type = cdp_sec_type_none;
  2887. }
  2888. /*
  2889. * dp_peer_rx_cleanup() – Cleanup receive TID state
  2890. * @vdev: Datapath vdev
  2891. * @peer: Datapath peer
  2892. *
  2893. */
  2894. void dp_peer_rx_cleanup(struct dp_vdev *vdev, struct dp_peer *peer)
  2895. {
  2896. int tid;
  2897. uint32_t tid_delete_mask = 0;
  2898. dp_info("Remove tids for peer: %pK", peer);
  2899. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  2900. struct dp_rx_tid *rx_tid = &peer->rx_tid[tid];
  2901. qdf_spin_lock_bh(&rx_tid->tid_lock);
  2902. if (!peer->bss_peer || peer->vdev->opmode == wlan_op_mode_sta) {
  2903. /* Cleanup defrag related resource */
  2904. dp_rx_defrag_waitlist_remove(peer, tid);
  2905. dp_rx_reorder_flush_frag(peer, tid);
  2906. }
  2907. if (peer->rx_tid[tid].hw_qdesc_vaddr_unaligned) {
  2908. dp_rx_tid_delete_wifi3(peer, tid);
  2909. tid_delete_mask |= (1 << tid);
  2910. }
  2911. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  2912. }
  2913. #ifdef notyet /* See if FW can remove queues as part of peer cleanup */
  2914. if (soc->ol_ops->peer_rx_reorder_queue_remove) {
  2915. soc->ol_ops->peer_rx_reorder_queue_remove(soc->ctrl_psoc,
  2916. peer->vdev->pdev->pdev_id,
  2917. peer->vdev->vdev_id, peer->mac_addr.raw,
  2918. tid_delete_mask);
  2919. }
  2920. #endif
  2921. }
  2922. /*
  2923. * dp_peer_cleanup() – Cleanup peer information
  2924. * @vdev: Datapath vdev
  2925. * @peer: Datapath peer
  2926. *
  2927. */
  2928. void dp_peer_cleanup(struct dp_vdev *vdev, struct dp_peer *peer)
  2929. {
  2930. enum wlan_op_mode vdev_opmode;
  2931. uint8_t vdev_mac_addr[QDF_MAC_ADDR_SIZE];
  2932. struct dp_pdev *pdev = vdev->pdev;
  2933. struct dp_soc *soc = pdev->soc;
  2934. /* save vdev related member in case vdev freed */
  2935. vdev_opmode = vdev->opmode;
  2936. dp_monitor_peer_tx_cleanup(vdev, peer);
  2937. if (vdev_opmode != wlan_op_mode_monitor)
  2938. /* cleanup the Rx reorder queues for this peer */
  2939. dp_peer_rx_cleanup(vdev, peer);
  2940. qdf_mem_copy(vdev_mac_addr, vdev->mac_addr.raw,
  2941. QDF_MAC_ADDR_SIZE);
  2942. if (soc->cdp_soc.ol_ops->peer_unref_delete)
  2943. soc->cdp_soc.ol_ops->peer_unref_delete(
  2944. soc->ctrl_psoc,
  2945. vdev->pdev->pdev_id,
  2946. peer->mac_addr.raw, vdev_mac_addr,
  2947. vdev_opmode);
  2948. }
  2949. /* dp_teardown_256_ba_session() - Teardown sessions using 256
  2950. * window size when a request with
  2951. * 64 window size is received.
  2952. * This is done as a WAR since HW can
  2953. * have only one setting per peer (64 or 256).
  2954. * For HKv2, we use per tid buffersize setting
  2955. * for 0 to per_tid_basize_max_tid. For tid
  2956. * more than per_tid_basize_max_tid we use HKv1
  2957. * method.
  2958. * @peer: Datapath peer
  2959. *
  2960. * Return: void
  2961. */
  2962. static void dp_teardown_256_ba_sessions(struct dp_peer *peer)
  2963. {
  2964. uint8_t delba_rcode = 0;
  2965. int tid;
  2966. struct dp_rx_tid *rx_tid = NULL;
  2967. tid = peer->vdev->pdev->soc->per_tid_basize_max_tid;
  2968. for (; tid < DP_MAX_TIDS; tid++) {
  2969. rx_tid = &peer->rx_tid[tid];
  2970. qdf_spin_lock_bh(&rx_tid->tid_lock);
  2971. if (rx_tid->ba_win_size <= 64) {
  2972. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  2973. continue;
  2974. } else {
  2975. if (rx_tid->ba_status == DP_RX_BA_ACTIVE ||
  2976. rx_tid->ba_status == DP_RX_BA_IN_PROGRESS) {
  2977. /* send delba */
  2978. if (!rx_tid->delba_tx_status) {
  2979. rx_tid->delba_tx_retry++;
  2980. rx_tid->delba_tx_status = 1;
  2981. rx_tid->delba_rcode =
  2982. IEEE80211_REASON_QOS_SETUP_REQUIRED;
  2983. delba_rcode = rx_tid->delba_rcode;
  2984. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  2985. if (peer->vdev->pdev->soc->cdp_soc.ol_ops->send_delba)
  2986. peer->vdev->pdev->soc->cdp_soc.ol_ops->send_delba(
  2987. peer->vdev->pdev->soc->ctrl_psoc,
  2988. peer->vdev->vdev_id,
  2989. peer->mac_addr.raw,
  2990. tid, delba_rcode,
  2991. CDP_DELBA_REASON_NONE);
  2992. } else {
  2993. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  2994. }
  2995. } else {
  2996. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  2997. }
  2998. }
  2999. }
  3000. }
  3001. /*
  3002. * dp_rx_addba_resp_tx_completion_wifi3() – Update Rx Tid State
  3003. *
  3004. * @soc: Datapath soc handle
  3005. * @peer_mac: Datapath peer mac address
  3006. * @vdev_id: id of atapath vdev
  3007. * @tid: TID number
  3008. * @status: tx completion status
  3009. * Return: 0 on success, error code on failure
  3010. */
  3011. int dp_addba_resp_tx_completion_wifi3(struct cdp_soc_t *cdp_soc,
  3012. uint8_t *peer_mac,
  3013. uint16_t vdev_id,
  3014. uint8_t tid, int status)
  3015. {
  3016. struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)cdp_soc,
  3017. peer_mac, 0, vdev_id,
  3018. DP_MOD_ID_CDP);
  3019. struct dp_rx_tid *rx_tid = NULL;
  3020. if (!peer) {
  3021. dp_peer_debug("%pK: Peer is NULL!\n", cdp_soc);
  3022. goto fail;
  3023. }
  3024. rx_tid = &peer->rx_tid[tid];
  3025. qdf_spin_lock_bh(&rx_tid->tid_lock);
  3026. if (status) {
  3027. rx_tid->num_addba_rsp_failed++;
  3028. dp_rx_tid_update_wifi3(peer, tid, 1,
  3029. IEEE80211_SEQ_MAX, false);
  3030. rx_tid->ba_status = DP_RX_BA_INACTIVE;
  3031. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3032. dp_err("RxTid- %d addba rsp tx completion failed", tid);
  3033. goto success;
  3034. }
  3035. rx_tid->num_addba_rsp_success++;
  3036. if (rx_tid->ba_status == DP_RX_BA_INACTIVE) {
  3037. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3038. dp_peer_err("%pK: Rx Tid- %d hw qdesc is not in IN_PROGRESS",
  3039. cdp_soc, tid);
  3040. goto fail;
  3041. }
  3042. if (!qdf_atomic_read(&peer->is_default_route_set)) {
  3043. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3044. dp_peer_debug("%pK: default route is not set for peer: " QDF_MAC_ADDR_FMT,
  3045. cdp_soc, QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  3046. goto fail;
  3047. }
  3048. if (dp_rx_tid_update_wifi3(peer, tid,
  3049. rx_tid->ba_win_size,
  3050. rx_tid->startseqnum,
  3051. false)) {
  3052. dp_err("Failed update REO SSN");
  3053. }
  3054. dp_info("tid %u window_size %u start_seq_num %u",
  3055. tid, rx_tid->ba_win_size,
  3056. rx_tid->startseqnum);
  3057. /* First Session */
  3058. if (peer->active_ba_session_cnt == 0) {
  3059. if (rx_tid->ba_win_size > 64 && rx_tid->ba_win_size <= 256)
  3060. peer->hw_buffer_size = 256;
  3061. else
  3062. peer->hw_buffer_size = 64;
  3063. }
  3064. rx_tid->ba_status = DP_RX_BA_ACTIVE;
  3065. peer->active_ba_session_cnt++;
  3066. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3067. /* Kill any session having 256 buffer size
  3068. * when 64 buffer size request is received.
  3069. * Also, latch on to 64 as new buffer size.
  3070. */
  3071. if (peer->kill_256_sessions) {
  3072. dp_teardown_256_ba_sessions(peer);
  3073. peer->kill_256_sessions = 0;
  3074. }
  3075. success:
  3076. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3077. return QDF_STATUS_SUCCESS;
  3078. fail:
  3079. if (peer)
  3080. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3081. return QDF_STATUS_E_FAILURE;
  3082. }
  3083. /*
  3084. * dp_rx_addba_responsesetup_wifi3() – Process ADDBA request from peer
  3085. *
  3086. * @soc: Datapath soc handle
  3087. * @peer_mac: Datapath peer mac address
  3088. * @vdev_id: id of atapath vdev
  3089. * @tid: TID number
  3090. * @dialogtoken: output dialogtoken
  3091. * @statuscode: output dialogtoken
  3092. * @buffersize: Output BA window size
  3093. * @batimeout: Output BA timeout
  3094. */
  3095. QDF_STATUS
  3096. dp_addba_responsesetup_wifi3(struct cdp_soc_t *cdp_soc, uint8_t *peer_mac,
  3097. uint16_t vdev_id, uint8_t tid,
  3098. uint8_t *dialogtoken, uint16_t *statuscode,
  3099. uint16_t *buffersize, uint16_t *batimeout)
  3100. {
  3101. struct dp_rx_tid *rx_tid = NULL;
  3102. QDF_STATUS status = QDF_STATUS_SUCCESS;
  3103. struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)cdp_soc,
  3104. peer_mac, 0, vdev_id,
  3105. DP_MOD_ID_CDP);
  3106. if (!peer) {
  3107. dp_peer_debug("%pK: Peer is NULL!\n", cdp_soc);
  3108. return QDF_STATUS_E_FAILURE;
  3109. }
  3110. rx_tid = &peer->rx_tid[tid];
  3111. qdf_spin_lock_bh(&rx_tid->tid_lock);
  3112. rx_tid->num_of_addba_resp++;
  3113. /* setup ADDBA response parameters */
  3114. *dialogtoken = rx_tid->dialogtoken;
  3115. *statuscode = rx_tid->statuscode;
  3116. *buffersize = rx_tid->ba_win_size;
  3117. *batimeout = 0;
  3118. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3119. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3120. return status;
  3121. }
  3122. /* dp_check_ba_buffersize() - Check buffer size in request
  3123. * and latch onto this size based on
  3124. * size used in first active session.
  3125. * @peer: Datapath peer
  3126. * @tid: Tid
  3127. * @buffersize: Block ack window size
  3128. *
  3129. * Return: void
  3130. */
  3131. static void dp_check_ba_buffersize(struct dp_peer *peer,
  3132. uint16_t tid,
  3133. uint16_t buffersize)
  3134. {
  3135. struct dp_rx_tid *rx_tid = NULL;
  3136. rx_tid = &peer->rx_tid[tid];
  3137. if (peer->vdev->pdev->soc->per_tid_basize_max_tid &&
  3138. tid < peer->vdev->pdev->soc->per_tid_basize_max_tid) {
  3139. rx_tid->ba_win_size = buffersize;
  3140. return;
  3141. } else {
  3142. if (peer->active_ba_session_cnt == 0) {
  3143. rx_tid->ba_win_size = buffersize;
  3144. } else {
  3145. if (peer->hw_buffer_size == 64) {
  3146. if (buffersize <= 64)
  3147. rx_tid->ba_win_size = buffersize;
  3148. else
  3149. rx_tid->ba_win_size = peer->hw_buffer_size;
  3150. } else if (peer->hw_buffer_size == 256) {
  3151. if (buffersize > 64) {
  3152. rx_tid->ba_win_size = buffersize;
  3153. } else {
  3154. rx_tid->ba_win_size = buffersize;
  3155. peer->hw_buffer_size = 64;
  3156. peer->kill_256_sessions = 1;
  3157. }
  3158. }
  3159. }
  3160. }
  3161. }
  3162. #define DP_RX_BA_SESSION_DISABLE 1
  3163. /*
  3164. * dp_addba_requestprocess_wifi3() - Process ADDBA request from peer
  3165. *
  3166. * @soc: Datapath soc handle
  3167. * @peer_mac: Datapath peer mac address
  3168. * @vdev_id: id of atapath vdev
  3169. * @dialogtoken: dialogtoken from ADDBA frame
  3170. * @tid: TID number
  3171. * @batimeout: BA timeout
  3172. * @buffersize: BA window size
  3173. * @startseqnum: Start seq. number received in BA sequence control
  3174. *
  3175. * Return: 0 on success, error code on failure
  3176. */
  3177. int dp_addba_requestprocess_wifi3(struct cdp_soc_t *cdp_soc,
  3178. uint8_t *peer_mac,
  3179. uint16_t vdev_id,
  3180. uint8_t dialogtoken,
  3181. uint16_t tid, uint16_t batimeout,
  3182. uint16_t buffersize,
  3183. uint16_t startseqnum)
  3184. {
  3185. QDF_STATUS status = QDF_STATUS_SUCCESS;
  3186. struct dp_rx_tid *rx_tid = NULL;
  3187. struct dp_soc *soc = (struct dp_soc *)cdp_soc;
  3188. struct dp_peer *peer = dp_peer_find_hash_find(soc,
  3189. peer_mac, 0, vdev_id,
  3190. DP_MOD_ID_CDP);
  3191. if (!peer) {
  3192. dp_peer_debug("%pK: Peer is NULL!\n", cdp_soc);
  3193. return QDF_STATUS_E_FAILURE;
  3194. }
  3195. rx_tid = &peer->rx_tid[tid];
  3196. qdf_spin_lock_bh(&rx_tid->tid_lock);
  3197. rx_tid->num_of_addba_req++;
  3198. if ((rx_tid->ba_status == DP_RX_BA_ACTIVE &&
  3199. rx_tid->hw_qdesc_vaddr_unaligned)) {
  3200. dp_rx_tid_update_wifi3(peer, tid, 1, IEEE80211_SEQ_MAX, false);
  3201. rx_tid->ba_status = DP_RX_BA_INACTIVE;
  3202. peer->active_ba_session_cnt--;
  3203. dp_peer_debug("%pK: Rx Tid- %d hw qdesc is already setup",
  3204. cdp_soc, tid);
  3205. }
  3206. if (rx_tid->ba_status == DP_RX_BA_IN_PROGRESS) {
  3207. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3208. status = QDF_STATUS_E_FAILURE;
  3209. goto fail;
  3210. }
  3211. if (wlan_cfg_is_dp_force_rx_64_ba(soc->wlan_cfg_ctx)) {
  3212. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_INFO,
  3213. "force use BA64 scheme");
  3214. buffersize = qdf_min((uint16_t)64, buffersize);
  3215. }
  3216. if (rx_tid->rx_ba_win_size_override == DP_RX_BA_SESSION_DISABLE) {
  3217. dp_peer_info("%pK: disable BA session",
  3218. cdp_soc);
  3219. buffersize = 1;
  3220. } else if (rx_tid->rx_ba_win_size_override) {
  3221. dp_peer_info("%pK: override BA win to %d", cdp_soc,
  3222. rx_tid->rx_ba_win_size_override);
  3223. buffersize = rx_tid->rx_ba_win_size_override;
  3224. } else {
  3225. dp_peer_info("%pK: restore BA win %d based on addba req", cdp_soc,
  3226. buffersize);
  3227. }
  3228. dp_check_ba_buffersize(peer, tid, buffersize);
  3229. if (dp_rx_tid_setup_wifi3(peer, tid,
  3230. rx_tid->ba_win_size, startseqnum)) {
  3231. rx_tid->ba_status = DP_RX_BA_INACTIVE;
  3232. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3233. status = QDF_STATUS_E_FAILURE;
  3234. goto fail;
  3235. }
  3236. rx_tid->ba_status = DP_RX_BA_IN_PROGRESS;
  3237. rx_tid->dialogtoken = dialogtoken;
  3238. rx_tid->startseqnum = startseqnum;
  3239. if (rx_tid->userstatuscode != IEEE80211_STATUS_SUCCESS)
  3240. rx_tid->statuscode = rx_tid->userstatuscode;
  3241. else
  3242. rx_tid->statuscode = IEEE80211_STATUS_SUCCESS;
  3243. if (rx_tid->rx_ba_win_size_override == DP_RX_BA_SESSION_DISABLE)
  3244. rx_tid->statuscode = IEEE80211_STATUS_REFUSED;
  3245. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3246. fail:
  3247. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3248. return status;
  3249. }
  3250. /*
  3251. * dp_set_addba_response() – Set a user defined ADDBA response status code
  3252. *
  3253. * @soc: Datapath soc handle
  3254. * @peer_mac: Datapath peer mac address
  3255. * @vdev_id: id of atapath vdev
  3256. * @tid: TID number
  3257. * @statuscode: response status code to be set
  3258. */
  3259. QDF_STATUS
  3260. dp_set_addba_response(struct cdp_soc_t *cdp_soc, uint8_t *peer_mac,
  3261. uint16_t vdev_id, uint8_t tid, uint16_t statuscode)
  3262. {
  3263. struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)cdp_soc,
  3264. peer_mac, 0, vdev_id,
  3265. DP_MOD_ID_CDP);
  3266. struct dp_rx_tid *rx_tid;
  3267. if (!peer) {
  3268. dp_peer_debug("%pK: Peer is NULL!\n", cdp_soc);
  3269. return QDF_STATUS_E_FAILURE;
  3270. }
  3271. rx_tid = &peer->rx_tid[tid];
  3272. qdf_spin_lock_bh(&rx_tid->tid_lock);
  3273. rx_tid->userstatuscode = statuscode;
  3274. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3275. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3276. return QDF_STATUS_SUCCESS;
  3277. }
  3278. /*
  3279. * dp_rx_delba_process_wifi3() – Process DELBA from peer
  3280. * @soc: Datapath soc handle
  3281. * @peer_mac: Datapath peer mac address
  3282. * @vdev_id: id of atapath vdev
  3283. * @tid: TID number
  3284. * @reasoncode: Reason code received in DELBA frame
  3285. *
  3286. * Return: 0 on success, error code on failure
  3287. */
  3288. int dp_delba_process_wifi3(struct cdp_soc_t *cdp_soc, uint8_t *peer_mac,
  3289. uint16_t vdev_id, int tid, uint16_t reasoncode)
  3290. {
  3291. QDF_STATUS status = QDF_STATUS_SUCCESS;
  3292. struct dp_rx_tid *rx_tid;
  3293. struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)cdp_soc,
  3294. peer_mac, 0, vdev_id,
  3295. DP_MOD_ID_CDP);
  3296. if (!peer) {
  3297. dp_peer_debug("%pK: Peer is NULL!\n", cdp_soc);
  3298. return QDF_STATUS_E_FAILURE;
  3299. }
  3300. rx_tid = &peer->rx_tid[tid];
  3301. qdf_spin_lock_bh(&rx_tid->tid_lock);
  3302. if (rx_tid->ba_status == DP_RX_BA_INACTIVE ||
  3303. rx_tid->ba_status == DP_RX_BA_IN_PROGRESS) {
  3304. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3305. status = QDF_STATUS_E_FAILURE;
  3306. goto fail;
  3307. }
  3308. /* TODO: See if we can delete the existing REO queue descriptor and
  3309. * replace with a new one without queue extenstion descript to save
  3310. * memory
  3311. */
  3312. rx_tid->delba_rcode = reasoncode;
  3313. rx_tid->num_of_delba_req++;
  3314. dp_rx_tid_update_wifi3(peer, tid, 1, IEEE80211_SEQ_MAX, false);
  3315. rx_tid->ba_status = DP_RX_BA_INACTIVE;
  3316. peer->active_ba_session_cnt--;
  3317. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3318. fail:
  3319. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3320. return status;
  3321. }
  3322. /*
  3323. * dp_rx_delba_tx_completion_wifi3() – Send Delba Request
  3324. *
  3325. * @soc: Datapath soc handle
  3326. * @peer_mac: Datapath peer mac address
  3327. * @vdev_id: id of atapath vdev
  3328. * @tid: TID number
  3329. * @status: tx completion status
  3330. * Return: 0 on success, error code on failure
  3331. */
  3332. int dp_delba_tx_completion_wifi3(struct cdp_soc_t *cdp_soc, uint8_t *peer_mac,
  3333. uint16_t vdev_id,
  3334. uint8_t tid, int status)
  3335. {
  3336. QDF_STATUS ret = QDF_STATUS_SUCCESS;
  3337. struct dp_rx_tid *rx_tid = NULL;
  3338. struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)cdp_soc,
  3339. peer_mac, 0, vdev_id,
  3340. DP_MOD_ID_CDP);
  3341. if (!peer) {
  3342. dp_peer_debug("%pK: Peer is NULL!", cdp_soc);
  3343. return QDF_STATUS_E_FAILURE;
  3344. }
  3345. rx_tid = &peer->rx_tid[tid];
  3346. qdf_spin_lock_bh(&rx_tid->tid_lock);
  3347. if (status) {
  3348. rx_tid->delba_tx_fail_cnt++;
  3349. if (rx_tid->delba_tx_retry >= DP_MAX_DELBA_RETRY) {
  3350. rx_tid->delba_tx_retry = 0;
  3351. rx_tid->delba_tx_status = 0;
  3352. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3353. } else {
  3354. rx_tid->delba_tx_retry++;
  3355. rx_tid->delba_tx_status = 1;
  3356. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3357. if (peer->vdev->pdev->soc->cdp_soc.ol_ops->send_delba)
  3358. peer->vdev->pdev->soc->cdp_soc.ol_ops->send_delba(
  3359. peer->vdev->pdev->soc->ctrl_psoc,
  3360. peer->vdev->vdev_id,
  3361. peer->mac_addr.raw, tid,
  3362. rx_tid->delba_rcode,
  3363. CDP_DELBA_REASON_NONE);
  3364. }
  3365. goto end;
  3366. } else {
  3367. rx_tid->delba_tx_success_cnt++;
  3368. rx_tid->delba_tx_retry = 0;
  3369. rx_tid->delba_tx_status = 0;
  3370. }
  3371. if (rx_tid->ba_status == DP_RX_BA_ACTIVE) {
  3372. dp_rx_tid_update_wifi3(peer, tid, 1, IEEE80211_SEQ_MAX, false);
  3373. rx_tid->ba_status = DP_RX_BA_INACTIVE;
  3374. peer->active_ba_session_cnt--;
  3375. }
  3376. if (rx_tid->ba_status == DP_RX_BA_IN_PROGRESS) {
  3377. dp_rx_tid_update_wifi3(peer, tid, 1, IEEE80211_SEQ_MAX, false);
  3378. rx_tid->ba_status = DP_RX_BA_INACTIVE;
  3379. }
  3380. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3381. end:
  3382. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3383. return ret;
  3384. }
  3385. /**
  3386. * dp_set_pn_check_wifi3() - enable PN check in REO for security
  3387. * @soc: Datapath soc handle
  3388. * @peer_mac: Datapath peer mac address
  3389. * @vdev_id: id of atapath vdev
  3390. * @vdev: Datapath vdev
  3391. * @pdev - data path device instance
  3392. * @sec_type - security type
  3393. * @rx_pn - Receive pn starting number
  3394. *
  3395. */
  3396. QDF_STATUS
  3397. dp_set_pn_check_wifi3(struct cdp_soc_t *soc, uint8_t vdev_id,
  3398. uint8_t *peer_mac, enum cdp_sec_type sec_type,
  3399. uint32_t *rx_pn)
  3400. {
  3401. struct dp_pdev *pdev;
  3402. int i;
  3403. uint8_t pn_size;
  3404. struct hal_reo_cmd_params params;
  3405. struct dp_peer *peer = NULL;
  3406. struct dp_vdev *vdev = NULL;
  3407. peer = dp_peer_find_hash_find((struct dp_soc *)soc,
  3408. peer_mac, 0, vdev_id,
  3409. DP_MOD_ID_CDP);
  3410. if (!peer) {
  3411. dp_peer_debug("%pK: Peer is NULL!\n", soc);
  3412. return QDF_STATUS_E_FAILURE;
  3413. }
  3414. vdev = peer->vdev;
  3415. if (!vdev) {
  3416. dp_peer_debug("%pK: VDEV is NULL!\n", soc);
  3417. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3418. return QDF_STATUS_E_FAILURE;
  3419. }
  3420. pdev = vdev->pdev;
  3421. qdf_mem_zero(&params, sizeof(params));
  3422. params.std.need_status = 1;
  3423. params.u.upd_queue_params.update_pn_valid = 1;
  3424. params.u.upd_queue_params.update_pn_size = 1;
  3425. params.u.upd_queue_params.update_pn = 1;
  3426. params.u.upd_queue_params.update_pn_check_needed = 1;
  3427. params.u.upd_queue_params.update_svld = 1;
  3428. params.u.upd_queue_params.svld = 0;
  3429. switch (sec_type) {
  3430. case cdp_sec_type_tkip_nomic:
  3431. case cdp_sec_type_aes_ccmp:
  3432. case cdp_sec_type_aes_ccmp_256:
  3433. case cdp_sec_type_aes_gcmp:
  3434. case cdp_sec_type_aes_gcmp_256:
  3435. params.u.upd_queue_params.pn_check_needed = 1;
  3436. params.u.upd_queue_params.pn_size = 48;
  3437. pn_size = 48;
  3438. break;
  3439. case cdp_sec_type_wapi:
  3440. params.u.upd_queue_params.pn_check_needed = 1;
  3441. params.u.upd_queue_params.pn_size = 128;
  3442. pn_size = 128;
  3443. if (vdev->opmode == wlan_op_mode_ap) {
  3444. params.u.upd_queue_params.pn_even = 1;
  3445. params.u.upd_queue_params.update_pn_even = 1;
  3446. } else {
  3447. params.u.upd_queue_params.pn_uneven = 1;
  3448. params.u.upd_queue_params.update_pn_uneven = 1;
  3449. }
  3450. break;
  3451. default:
  3452. params.u.upd_queue_params.pn_check_needed = 0;
  3453. pn_size = 0;
  3454. break;
  3455. }
  3456. for (i = 0; i < DP_MAX_TIDS; i++) {
  3457. struct dp_rx_tid *rx_tid = &peer->rx_tid[i];
  3458. qdf_spin_lock_bh(&rx_tid->tid_lock);
  3459. if (rx_tid->hw_qdesc_vaddr_unaligned) {
  3460. params.std.addr_lo =
  3461. rx_tid->hw_qdesc_paddr & 0xffffffff;
  3462. params.std.addr_hi =
  3463. (uint64_t)(rx_tid->hw_qdesc_paddr) >> 32;
  3464. if (pn_size) {
  3465. dp_peer_info("%pK: PN set for TID:%d pn:%x:%x:%x:%x",
  3466. soc, i, rx_pn[3], rx_pn[2],
  3467. rx_pn[1], rx_pn[0]);
  3468. params.u.upd_queue_params.update_pn_valid = 1;
  3469. params.u.upd_queue_params.pn_31_0 = rx_pn[0];
  3470. params.u.upd_queue_params.pn_63_32 = rx_pn[1];
  3471. params.u.upd_queue_params.pn_95_64 = rx_pn[2];
  3472. params.u.upd_queue_params.pn_127_96 = rx_pn[3];
  3473. }
  3474. rx_tid->pn_size = pn_size;
  3475. if (dp_reo_send_cmd(cdp_soc_t_to_dp_soc(soc),
  3476. CMD_UPDATE_RX_REO_QUEUE,
  3477. &params, dp_rx_tid_update_cb,
  3478. rx_tid)) {
  3479. dp_err_log("fail to send CMD_UPDATE_RX_REO_QUEUE"
  3480. "tid %d desc %pK", rx_tid->tid,
  3481. (void *)(rx_tid->hw_qdesc_paddr));
  3482. DP_STATS_INC(cdp_soc_t_to_dp_soc(soc),
  3483. rx.err.reo_cmd_send_fail, 1);
  3484. }
  3485. } else {
  3486. dp_peer_info("%pK: PN Check not setup for TID :%d ", soc, i);
  3487. }
  3488. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3489. }
  3490. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3491. return QDF_STATUS_SUCCESS;
  3492. }
  3493. /**
  3494. * dp_set_key_sec_type_wifi3() - set security mode of key
  3495. * @soc: Datapath soc handle
  3496. * @peer_mac: Datapath peer mac address
  3497. * @vdev_id: id of atapath vdev
  3498. * @vdev: Datapath vdev
  3499. * @pdev - data path device instance
  3500. * @sec_type - security type
  3501. * #is_unicast - key type
  3502. *
  3503. */
  3504. QDF_STATUS
  3505. dp_set_key_sec_type_wifi3(struct cdp_soc_t *soc, uint8_t vdev_id,
  3506. uint8_t *peer_mac, enum cdp_sec_type sec_type,
  3507. bool is_unicast)
  3508. {
  3509. struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc,
  3510. peer_mac, 0, vdev_id,
  3511. DP_MOD_ID_CDP);
  3512. int sec_index;
  3513. if (!peer) {
  3514. dp_peer_debug("%pK: Peer is NULL!\n", soc);
  3515. return QDF_STATUS_E_FAILURE;
  3516. }
  3517. dp_peer_info("%pK: key sec spec for peer %pK " QDF_MAC_ADDR_FMT ": %s key of type %d",
  3518. soc, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  3519. is_unicast ? "ucast" : "mcast", sec_type);
  3520. sec_index = is_unicast ? dp_sec_ucast : dp_sec_mcast;
  3521. peer->security[sec_index].sec_type = sec_type;
  3522. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3523. return QDF_STATUS_SUCCESS;
  3524. }
  3525. void
  3526. dp_rx_sec_ind_handler(struct dp_soc *soc, uint16_t peer_id,
  3527. enum cdp_sec_type sec_type, int is_unicast,
  3528. u_int32_t *michael_key,
  3529. u_int32_t *rx_pn)
  3530. {
  3531. struct dp_peer *peer;
  3532. int sec_index;
  3533. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_HTT);
  3534. if (!peer) {
  3535. dp_peer_err("Couldn't find peer from ID %d - skipping security inits",
  3536. peer_id);
  3537. return;
  3538. }
  3539. dp_peer_info("%pK: sec spec for peer %pK " QDF_MAC_ADDR_FMT ": %s key of type %d",
  3540. soc, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  3541. is_unicast ? "ucast" : "mcast", sec_type);
  3542. sec_index = is_unicast ? dp_sec_ucast : dp_sec_mcast;
  3543. peer->security[sec_index].sec_type = sec_type;
  3544. #ifdef notyet /* TODO: See if this is required for defrag support */
  3545. /* michael key only valid for TKIP, but for simplicity,
  3546. * copy it anyway
  3547. */
  3548. qdf_mem_copy(
  3549. &peer->security[sec_index].michael_key[0],
  3550. michael_key,
  3551. sizeof(peer->security[sec_index].michael_key));
  3552. #ifdef BIG_ENDIAN_HOST
  3553. OL_IF_SWAPBO(peer->security[sec_index].michael_key[0],
  3554. sizeof(peer->security[sec_index].michael_key));
  3555. #endif /* BIG_ENDIAN_HOST */
  3556. #endif
  3557. #ifdef notyet /* TODO: Check if this is required for wifi3.0 */
  3558. if (sec_type != cdp_sec_type_wapi) {
  3559. qdf_mem_zero(peer->tids_last_pn_valid, _EXT_TIDS);
  3560. } else {
  3561. for (i = 0; i < DP_MAX_TIDS; i++) {
  3562. /*
  3563. * Setting PN valid bit for WAPI sec_type,
  3564. * since WAPI PN has to be started with predefined value
  3565. */
  3566. peer->tids_last_pn_valid[i] = 1;
  3567. qdf_mem_copy(
  3568. (u_int8_t *) &peer->tids_last_pn[i],
  3569. (u_int8_t *) rx_pn, sizeof(union htt_rx_pn_t));
  3570. peer->tids_last_pn[i].pn128[1] =
  3571. qdf_cpu_to_le64(peer->tids_last_pn[i].pn128[1]);
  3572. peer->tids_last_pn[i].pn128[0] =
  3573. qdf_cpu_to_le64(peer->tids_last_pn[i].pn128[0]);
  3574. }
  3575. }
  3576. #endif
  3577. /* TODO: Update HW TID queue with PN check parameters (pn type for
  3578. * all security types and last pn for WAPI) once REO command API
  3579. * is available
  3580. */
  3581. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  3582. }
  3583. #ifdef QCA_PEER_EXT_STATS
  3584. /*
  3585. * dp_peer_ext_stats_ctx_alloc() - Allocate peer ext
  3586. * stats content
  3587. * @soc: DP SoC context
  3588. * @peer: DP peer context
  3589. *
  3590. * Allocate the peer extended stats context
  3591. *
  3592. * Return: QDF_STATUS_SUCCESS if allocation is
  3593. * successful
  3594. */
  3595. QDF_STATUS dp_peer_ext_stats_ctx_alloc(struct dp_soc *soc,
  3596. struct dp_peer *peer)
  3597. {
  3598. uint8_t tid, ctx_id;
  3599. if (!soc || !peer) {
  3600. dp_warn("Null soc%pK or peer%pK", soc, peer);
  3601. return QDF_STATUS_E_INVAL;
  3602. }
  3603. if (!wlan_cfg_is_peer_ext_stats_enabled(soc->wlan_cfg_ctx))
  3604. return QDF_STATUS_SUCCESS;
  3605. /*
  3606. * Allocate memory for peer extended stats.
  3607. */
  3608. peer->pext_stats = qdf_mem_malloc(sizeof(struct cdp_peer_ext_stats));
  3609. if (!peer->pext_stats) {
  3610. dp_err("Peer extended stats obj alloc failed!!");
  3611. return QDF_STATUS_E_NOMEM;
  3612. }
  3613. for (tid = 0; tid < CDP_MAX_DATA_TIDS; tid++) {
  3614. for (ctx_id = 0; ctx_id < CDP_MAX_TXRX_CTX; ctx_id++) {
  3615. struct cdp_delay_tx_stats *tx_delay =
  3616. &peer->pext_stats->delay_stats[tid][ctx_id].tx_delay;
  3617. struct cdp_delay_rx_stats *rx_delay =
  3618. &peer->pext_stats->delay_stats[tid][ctx_id].rx_delay;
  3619. dp_hist_init(&tx_delay->tx_swq_delay,
  3620. CDP_HIST_TYPE_SW_ENQEUE_DELAY);
  3621. dp_hist_init(&tx_delay->hwtx_delay,
  3622. CDP_HIST_TYPE_HW_COMP_DELAY);
  3623. dp_hist_init(&rx_delay->to_stack_delay,
  3624. CDP_HIST_TYPE_REAP_STACK);
  3625. }
  3626. }
  3627. return QDF_STATUS_SUCCESS;
  3628. }
  3629. /*
  3630. * dp_peer_ext_stats_ctx_dealloc() - Dealloc the peer context
  3631. * @peer: DP peer context
  3632. *
  3633. * Free the peer extended stats context
  3634. *
  3635. * Return: Void
  3636. */
  3637. void dp_peer_ext_stats_ctx_dealloc(struct dp_soc *soc, struct dp_peer *peer)
  3638. {
  3639. if (!peer) {
  3640. dp_warn("peer_ext dealloc failed due to NULL peer object");
  3641. return;
  3642. }
  3643. if (!wlan_cfg_is_peer_ext_stats_enabled(soc->wlan_cfg_ctx))
  3644. return;
  3645. if (!peer->pext_stats)
  3646. return;
  3647. qdf_mem_free(peer->pext_stats);
  3648. peer->pext_stats = NULL;
  3649. }
  3650. #endif
  3651. QDF_STATUS
  3652. dp_rx_delba_ind_handler(void *soc_handle, uint16_t peer_id,
  3653. uint8_t tid, uint16_t win_sz)
  3654. {
  3655. struct dp_soc *soc = (struct dp_soc *)soc_handle;
  3656. struct dp_peer *peer;
  3657. struct dp_rx_tid *rx_tid;
  3658. QDF_STATUS status = QDF_STATUS_SUCCESS;
  3659. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_HTT);
  3660. if (!peer) {
  3661. dp_peer_err("%pK: Couldn't find peer from ID %d",
  3662. soc, peer_id);
  3663. return QDF_STATUS_E_FAILURE;
  3664. }
  3665. qdf_assert_always(tid < DP_MAX_TIDS);
  3666. rx_tid = &peer->rx_tid[tid];
  3667. if (rx_tid->hw_qdesc_vaddr_unaligned) {
  3668. if (!rx_tid->delba_tx_status) {
  3669. dp_peer_info("%pK: PEER_ID: %d TID: %d, BA win: %d ",
  3670. soc, peer_id, tid, win_sz);
  3671. qdf_spin_lock_bh(&rx_tid->tid_lock);
  3672. rx_tid->delba_tx_status = 1;
  3673. rx_tid->rx_ba_win_size_override =
  3674. qdf_min((uint16_t)63, win_sz);
  3675. rx_tid->delba_rcode =
  3676. IEEE80211_REASON_QOS_SETUP_REQUIRED;
  3677. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  3678. if (soc->cdp_soc.ol_ops->send_delba)
  3679. soc->cdp_soc.ol_ops->send_delba(
  3680. peer->vdev->pdev->soc->ctrl_psoc,
  3681. peer->vdev->vdev_id,
  3682. peer->mac_addr.raw,
  3683. tid,
  3684. rx_tid->delba_rcode,
  3685. CDP_DELBA_REASON_NONE);
  3686. }
  3687. } else {
  3688. dp_peer_err("%pK: BA session is not setup for TID:%d ", soc, tid);
  3689. status = QDF_STATUS_E_FAILURE;
  3690. }
  3691. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  3692. return status;
  3693. }
  3694. #ifdef DP_PEER_EXTENDED_API
  3695. QDF_STATUS dp_register_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
  3696. struct ol_txrx_desc_type *sta_desc)
  3697. {
  3698. struct dp_peer *peer;
  3699. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3700. peer = dp_peer_find_hash_find(soc, sta_desc->peer_addr.bytes,
  3701. 0, DP_VDEV_ALL, DP_MOD_ID_CDP);
  3702. if (!peer)
  3703. return QDF_STATUS_E_FAULT;
  3704. qdf_spin_lock_bh(&peer->peer_info_lock);
  3705. peer->state = OL_TXRX_PEER_STATE_CONN;
  3706. qdf_spin_unlock_bh(&peer->peer_info_lock);
  3707. dp_rx_flush_rx_cached(peer, false);
  3708. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3709. return QDF_STATUS_SUCCESS;
  3710. }
  3711. QDF_STATUS
  3712. dp_clear_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
  3713. struct qdf_mac_addr peer_addr)
  3714. {
  3715. struct dp_peer *peer;
  3716. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3717. peer = dp_peer_find_hash_find(soc, peer_addr.bytes,
  3718. 0, DP_VDEV_ALL, DP_MOD_ID_CDP);
  3719. if (!peer || !peer->valid)
  3720. return QDF_STATUS_E_FAULT;
  3721. dp_clear_peer_internal(soc, peer);
  3722. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3723. return QDF_STATUS_SUCCESS;
  3724. }
  3725. QDF_STATUS dp_peer_state_update(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac,
  3726. enum ol_txrx_peer_state state)
  3727. {
  3728. struct dp_peer *peer;
  3729. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3730. peer = dp_peer_find_hash_find(soc, peer_mac, 0, DP_VDEV_ALL,
  3731. DP_MOD_ID_CDP);
  3732. if (!peer) {
  3733. dp_peer_err("%pK: Failed to find peer for: [" QDF_MAC_ADDR_FMT "]",
  3734. soc, QDF_MAC_ADDR_REF(peer_mac));
  3735. return QDF_STATUS_E_FAILURE;
  3736. }
  3737. peer->state = state;
  3738. peer->authorize = (state == OL_TXRX_PEER_STATE_AUTH) ? 1 : 0;
  3739. dp_info("peer %pK state %d", peer, peer->state);
  3740. /* ref_cnt is incremented inside dp_peer_find_hash_find().
  3741. * Decrement it here.
  3742. */
  3743. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3744. return QDF_STATUS_SUCCESS;
  3745. }
  3746. QDF_STATUS dp_get_vdevid(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac,
  3747. uint8_t *vdev_id)
  3748. {
  3749. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3750. struct dp_peer *peer =
  3751. dp_peer_find_hash_find(soc, peer_mac, 0, DP_VDEV_ALL,
  3752. DP_MOD_ID_CDP);
  3753. if (!peer)
  3754. return QDF_STATUS_E_FAILURE;
  3755. dp_info("peer %pK vdev %pK vdev id %d",
  3756. peer, peer->vdev, peer->vdev->vdev_id);
  3757. *vdev_id = peer->vdev->vdev_id;
  3758. /* ref_cnt is incremented inside dp_peer_find_hash_find().
  3759. * Decrement it here.
  3760. */
  3761. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3762. return QDF_STATUS_SUCCESS;
  3763. }
  3764. struct cdp_vdev *
  3765. dp_get_vdev_by_peer_addr(struct cdp_pdev *pdev_handle,
  3766. struct qdf_mac_addr peer_addr)
  3767. {
  3768. struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
  3769. struct dp_peer *peer = NULL;
  3770. struct cdp_vdev *vdev = NULL;
  3771. if (!pdev) {
  3772. dp_peer_info("PDEV not found for peer_addr: " QDF_MAC_ADDR_FMT,
  3773. QDF_MAC_ADDR_REF(peer_addr.bytes));
  3774. return NULL;
  3775. }
  3776. peer = dp_peer_find_hash_find(pdev->soc, peer_addr.bytes, 0,
  3777. DP_VDEV_ALL, DP_MOD_ID_CDP);
  3778. if (!peer) {
  3779. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_INFO_HIGH,
  3780. "PDEV not found for peer_addr: "QDF_MAC_ADDR_FMT,
  3781. QDF_MAC_ADDR_REF(peer_addr.bytes));
  3782. return NULL;
  3783. }
  3784. vdev = (struct cdp_vdev *)peer->vdev;
  3785. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3786. return vdev;
  3787. }
  3788. /**
  3789. * dp_get_vdev_for_peer() - Get virtual interface instance which peer belongs
  3790. * @peer - peer instance
  3791. *
  3792. * Get virtual interface instance which peer belongs
  3793. *
  3794. * Return: virtual interface instance pointer
  3795. * NULL in case cannot find
  3796. */
  3797. struct cdp_vdev *dp_get_vdev_for_peer(void *peer_handle)
  3798. {
  3799. struct dp_peer *peer = peer_handle;
  3800. DP_TRACE(DEBUG, "peer %pK vdev %pK", peer, peer->vdev);
  3801. return (struct cdp_vdev *)peer->vdev;
  3802. }
  3803. /**
  3804. * dp_peer_get_peer_mac_addr() - Get peer mac address
  3805. * @peer - peer instance
  3806. *
  3807. * Get peer mac address
  3808. *
  3809. * Return: peer mac address pointer
  3810. * NULL in case cannot find
  3811. */
  3812. uint8_t *dp_peer_get_peer_mac_addr(void *peer_handle)
  3813. {
  3814. struct dp_peer *peer = peer_handle;
  3815. uint8_t *mac;
  3816. mac = peer->mac_addr.raw;
  3817. dp_info("peer %pK mac 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x",
  3818. peer, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
  3819. return peer->mac_addr.raw;
  3820. }
  3821. int dp_get_peer_state(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
  3822. uint8_t *peer_mac)
  3823. {
  3824. enum ol_txrx_peer_state peer_state;
  3825. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3826. struct dp_peer *peer = dp_peer_find_hash_find(soc, peer_mac, 0,
  3827. vdev_id, DP_MOD_ID_CDP);
  3828. if (!peer)
  3829. return QDF_STATUS_E_FAILURE;
  3830. DP_TRACE(DEBUG, "peer %pK stats %d", peer, peer->state);
  3831. peer_state = peer->state;
  3832. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3833. return peer_state;
  3834. }
  3835. /**
  3836. * dp_local_peer_id_pool_init() - local peer id pool alloc for physical device
  3837. * @pdev - data path device instance
  3838. *
  3839. * local peer id pool alloc for physical device
  3840. *
  3841. * Return: none
  3842. */
  3843. void dp_local_peer_id_pool_init(struct dp_pdev *pdev)
  3844. {
  3845. int i;
  3846. /* point the freelist to the first ID */
  3847. pdev->local_peer_ids.freelist = 0;
  3848. /* link each ID to the next one */
  3849. for (i = 0; i < OL_TXRX_NUM_LOCAL_PEER_IDS; i++) {
  3850. pdev->local_peer_ids.pool[i] = i + 1;
  3851. pdev->local_peer_ids.map[i] = NULL;
  3852. }
  3853. /* link the last ID to itself, to mark the end of the list */
  3854. i = OL_TXRX_NUM_LOCAL_PEER_IDS;
  3855. pdev->local_peer_ids.pool[i] = i;
  3856. qdf_spinlock_create(&pdev->local_peer_ids.lock);
  3857. DP_TRACE(INFO, "Peer pool init");
  3858. }
  3859. /**
  3860. * dp_local_peer_id_alloc() - allocate local peer id
  3861. * @pdev - data path device instance
  3862. * @peer - new peer instance
  3863. *
  3864. * allocate local peer id
  3865. *
  3866. * Return: none
  3867. */
  3868. void dp_local_peer_id_alloc(struct dp_pdev *pdev, struct dp_peer *peer)
  3869. {
  3870. int i;
  3871. qdf_spin_lock_bh(&pdev->local_peer_ids.lock);
  3872. i = pdev->local_peer_ids.freelist;
  3873. if (pdev->local_peer_ids.pool[i] == i) {
  3874. /* the list is empty, except for the list-end marker */
  3875. peer->local_id = OL_TXRX_INVALID_LOCAL_PEER_ID;
  3876. } else {
  3877. /* take the head ID and advance the freelist */
  3878. peer->local_id = i;
  3879. pdev->local_peer_ids.freelist = pdev->local_peer_ids.pool[i];
  3880. pdev->local_peer_ids.map[i] = peer;
  3881. }
  3882. qdf_spin_unlock_bh(&pdev->local_peer_ids.lock);
  3883. dp_info("peer %pK, local id %d", peer, peer->local_id);
  3884. }
  3885. /**
  3886. * dp_local_peer_id_free() - remove local peer id
  3887. * @pdev - data path device instance
  3888. * @peer - peer instance should be removed
  3889. *
  3890. * remove local peer id
  3891. *
  3892. * Return: none
  3893. */
  3894. void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer)
  3895. {
  3896. int i = peer->local_id;
  3897. if ((i == OL_TXRX_INVALID_LOCAL_PEER_ID) ||
  3898. (i >= OL_TXRX_NUM_LOCAL_PEER_IDS)) {
  3899. return;
  3900. }
  3901. /* put this ID on the head of the freelist */
  3902. qdf_spin_lock_bh(&pdev->local_peer_ids.lock);
  3903. pdev->local_peer_ids.pool[i] = pdev->local_peer_ids.freelist;
  3904. pdev->local_peer_ids.freelist = i;
  3905. pdev->local_peer_ids.map[i] = NULL;
  3906. qdf_spin_unlock_bh(&pdev->local_peer_ids.lock);
  3907. }
  3908. bool dp_find_peer_exist_on_vdev(struct cdp_soc_t *soc_hdl,
  3909. uint8_t vdev_id, uint8_t *peer_addr)
  3910. {
  3911. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3912. struct dp_peer *peer = NULL;
  3913. peer = dp_peer_find_hash_find(soc, peer_addr, 0, vdev_id,
  3914. DP_MOD_ID_CDP);
  3915. if (!peer)
  3916. return false;
  3917. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3918. return true;
  3919. }
  3920. bool dp_find_peer_exist_on_other_vdev(struct cdp_soc_t *soc_hdl,
  3921. uint8_t vdev_id, uint8_t *peer_addr,
  3922. uint16_t max_bssid)
  3923. {
  3924. int i;
  3925. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3926. struct dp_peer *peer = NULL;
  3927. for (i = 0; i < max_bssid; i++) {
  3928. /* Need to check vdevs other than the vdev_id */
  3929. if (vdev_id == i)
  3930. continue;
  3931. peer = dp_peer_find_hash_find(soc, peer_addr, 0, i,
  3932. DP_MOD_ID_CDP);
  3933. if (peer) {
  3934. dp_err("Duplicate peer "QDF_MAC_ADDR_FMT" already exist on vdev %d",
  3935. QDF_MAC_ADDR_REF(peer_addr), i);
  3936. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3937. return true;
  3938. }
  3939. }
  3940. return false;
  3941. }
  3942. bool dp_find_peer_exist(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
  3943. uint8_t *peer_addr)
  3944. {
  3945. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3946. struct dp_peer *peer = NULL;
  3947. peer = dp_peer_find_hash_find(soc, peer_addr, 0, DP_VDEV_ALL,
  3948. DP_MOD_ID_CDP);
  3949. if (peer) {
  3950. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3951. return true;
  3952. }
  3953. return false;
  3954. }
  3955. #endif
  3956. /**
  3957. * dp_peer_rxtid_stats: Retried Rx TID (REO queue) stats from HW
  3958. * @peer: DP peer handle
  3959. * @dp_stats_cmd_cb: REO command callback function
  3960. * @cb_ctxt: Callback context
  3961. *
  3962. * Return: count of tid stats cmd send succeeded
  3963. */
  3964. int dp_peer_rxtid_stats(struct dp_peer *peer,
  3965. dp_rxtid_stats_cmd_cb dp_stats_cmd_cb,
  3966. void *cb_ctxt)
  3967. {
  3968. struct dp_soc *soc = peer->vdev->pdev->soc;
  3969. struct hal_reo_cmd_params params;
  3970. int i;
  3971. int stats_cmd_sent_cnt = 0;
  3972. QDF_STATUS status;
  3973. if (!dp_stats_cmd_cb)
  3974. return stats_cmd_sent_cnt;
  3975. qdf_mem_zero(&params, sizeof(params));
  3976. for (i = 0; i < DP_MAX_TIDS; i++) {
  3977. struct dp_rx_tid *rx_tid = &peer->rx_tid[i];
  3978. if (rx_tid->hw_qdesc_vaddr_unaligned) {
  3979. params.std.need_status = 1;
  3980. params.std.addr_lo =
  3981. rx_tid->hw_qdesc_paddr & 0xffffffff;
  3982. params.std.addr_hi =
  3983. (uint64_t)(rx_tid->hw_qdesc_paddr) >> 32;
  3984. if (cb_ctxt) {
  3985. status = dp_reo_send_cmd(
  3986. soc, CMD_GET_QUEUE_STATS,
  3987. &params, dp_stats_cmd_cb,
  3988. cb_ctxt);
  3989. } else {
  3990. status = dp_reo_send_cmd(
  3991. soc, CMD_GET_QUEUE_STATS,
  3992. &params, dp_stats_cmd_cb,
  3993. rx_tid);
  3994. }
  3995. if (QDF_IS_STATUS_SUCCESS(status))
  3996. stats_cmd_sent_cnt++;
  3997. /* Flush REO descriptor from HW cache to update stats
  3998. * in descriptor memory. This is to help debugging */
  3999. qdf_mem_zero(&params, sizeof(params));
  4000. params.std.need_status = 0;
  4001. params.std.addr_lo =
  4002. rx_tid->hw_qdesc_paddr & 0xffffffff;
  4003. params.std.addr_hi =
  4004. (uint64_t)(rx_tid->hw_qdesc_paddr) >> 32;
  4005. params.u.fl_cache_params.flush_no_inval = 1;
  4006. dp_reo_send_cmd(soc, CMD_FLUSH_CACHE, &params, NULL,
  4007. NULL);
  4008. }
  4009. }
  4010. return stats_cmd_sent_cnt;
  4011. }
  4012. QDF_STATUS
  4013. dp_set_michael_key(struct cdp_soc_t *soc,
  4014. uint8_t vdev_id,
  4015. uint8_t *peer_mac,
  4016. bool is_unicast, uint32_t *key)
  4017. {
  4018. uint8_t sec_index = is_unicast ? 1 : 0;
  4019. struct dp_peer *peer = dp_peer_find_hash_find((struct dp_soc *)soc,
  4020. peer_mac, 0, vdev_id,
  4021. DP_MOD_ID_CDP);
  4022. if (!peer) {
  4023. dp_peer_err("%pK: peer not found ", soc);
  4024. return QDF_STATUS_E_FAILURE;
  4025. }
  4026. qdf_mem_copy(&peer->security[sec_index].michael_key[0],
  4027. key, IEEE80211_WEP_MICLEN);
  4028. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  4029. return QDF_STATUS_SUCCESS;
  4030. }
  4031. /**
  4032. * dp_vdev_bss_peer_ref_n_get: Get bss peer of a vdev
  4033. * @soc: DP soc
  4034. * @vdev: vdev
  4035. * @mod_id: id of module requesting reference
  4036. *
  4037. * Return: VDEV BSS peer
  4038. */
  4039. struct dp_peer *dp_vdev_bss_peer_ref_n_get(struct dp_soc *soc,
  4040. struct dp_vdev *vdev,
  4041. enum dp_mod_id mod_id)
  4042. {
  4043. struct dp_peer *peer = NULL;
  4044. qdf_spin_lock_bh(&vdev->peer_list_lock);
  4045. TAILQ_FOREACH(peer, &vdev->peer_list, peer_list_elem) {
  4046. if (peer->bss_peer)
  4047. break;
  4048. }
  4049. if (!peer) {
  4050. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  4051. return NULL;
  4052. }
  4053. if (dp_peer_get_ref(soc, peer, mod_id) == QDF_STATUS_SUCCESS) {
  4054. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  4055. return peer;
  4056. }
  4057. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  4058. return peer;
  4059. }
  4060. /**
  4061. * dp_sta_vdev_self_peer_ref_n_get: Get self peer of sta vdev
  4062. * @soc: DP soc
  4063. * @vdev: vdev
  4064. * @mod_id: id of module requesting reference
  4065. *
  4066. * Return: VDEV self peer
  4067. */
  4068. struct dp_peer *dp_sta_vdev_self_peer_ref_n_get(struct dp_soc *soc,
  4069. struct dp_vdev *vdev,
  4070. enum dp_mod_id mod_id)
  4071. {
  4072. struct dp_peer *peer;
  4073. if (vdev->opmode != wlan_op_mode_sta)
  4074. return NULL;
  4075. qdf_spin_lock_bh(&vdev->peer_list_lock);
  4076. TAILQ_FOREACH(peer, &vdev->peer_list, peer_list_elem) {
  4077. if (peer->sta_self_peer)
  4078. break;
  4079. }
  4080. if (!peer) {
  4081. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  4082. return NULL;
  4083. }
  4084. if (dp_peer_get_ref(soc, peer, mod_id) == QDF_STATUS_SUCCESS) {
  4085. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  4086. return peer;
  4087. }
  4088. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  4089. return peer;
  4090. }
  4091. #ifdef DUMP_REO_QUEUE_INFO_IN_DDR
  4092. void dp_dump_rx_reo_queue_info(
  4093. struct dp_soc *soc, void *cb_ctxt, union hal_reo_status *reo_status)
  4094. {
  4095. struct dp_rx_tid *rx_tid = (struct dp_rx_tid *)cb_ctxt;
  4096. if (!rx_tid)
  4097. return;
  4098. if (reo_status->fl_cache_status.header.status !=
  4099. HAL_REO_CMD_SUCCESS) {
  4100. dp_err_rl("Rx tid REO HW desc flush failed(%d)",
  4101. reo_status->rx_queue_status.header.status);
  4102. return;
  4103. }
  4104. qdf_spin_lock_bh(&rx_tid->tid_lock);
  4105. hal_dump_rx_reo_queue_desc(rx_tid->hw_qdesc_vaddr_aligned);
  4106. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  4107. }
  4108. void dp_send_cache_flush_for_rx_tid(
  4109. struct dp_soc *soc, struct dp_peer *peer)
  4110. {
  4111. int i;
  4112. struct dp_rx_tid *rx_tid;
  4113. struct hal_reo_cmd_params params;
  4114. if (!peer) {
  4115. dp_err_rl("Peer is NULL");
  4116. return;
  4117. }
  4118. for (i = 0; i < DP_MAX_TIDS; i++) {
  4119. rx_tid = &peer->rx_tid[i];
  4120. if (!rx_tid)
  4121. continue;
  4122. qdf_spin_lock_bh(&rx_tid->tid_lock);
  4123. if (rx_tid->hw_qdesc_vaddr_aligned) {
  4124. qdf_mem_zero(&params, sizeof(params));
  4125. params.std.need_status = 1;
  4126. params.std.addr_lo =
  4127. rx_tid->hw_qdesc_paddr & 0xffffffff;
  4128. params.std.addr_hi =
  4129. (uint64_t)(rx_tid->hw_qdesc_paddr) >> 32;
  4130. params.u.fl_cache_params.flush_no_inval = 0;
  4131. if (QDF_STATUS_SUCCESS !=
  4132. dp_reo_send_cmd(
  4133. soc, CMD_FLUSH_CACHE,
  4134. &params, dp_dump_rx_reo_queue_info,
  4135. (void *)rx_tid)) {
  4136. dp_err_rl("cache flush send failed tid %d",
  4137. rx_tid->tid);
  4138. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  4139. break;
  4140. }
  4141. }
  4142. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  4143. }
  4144. }
  4145. void dp_get_rx_reo_queue_info(
  4146. struct cdp_soc_t *soc_hdl, uint8_t vdev_id)
  4147. {
  4148. struct dp_soc *soc = (struct dp_soc *)soc_hdl;
  4149. struct dp_vdev *vdev = dp_vdev_get_ref_by_id(soc, vdev_id,
  4150. DP_MOD_ID_GENERIC_STATS);
  4151. struct dp_peer *peer = NULL;
  4152. if (!vdev) {
  4153. dp_err_rl("vdev is null for vdev_id: %u", vdev_id);
  4154. goto failed;
  4155. }
  4156. peer = dp_vdev_bss_peer_ref_n_get(soc, vdev, DP_MOD_ID_GENERIC_STATS);
  4157. if (!peer) {
  4158. dp_err_rl("Peer is NULL");
  4159. goto failed;
  4160. }
  4161. dp_send_cache_flush_for_rx_tid(soc, peer);
  4162. failed:
  4163. if (peer)
  4164. dp_peer_unref_delete(peer, DP_MOD_ID_GENERIC_STATS);
  4165. if (vdev)
  4166. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_GENERIC_STATS);
  4167. }
  4168. #endif /* DUMP_REO_QUEUE_INFO_IN_DDR */
  4169. void dp_peer_flush_frags(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
  4170. uint8_t *peer_mac)
  4171. {
  4172. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  4173. struct dp_peer *peer = dp_peer_find_hash_find(soc, peer_mac, 0,
  4174. vdev_id, DP_MOD_ID_CDP);
  4175. struct dp_rx_tid *rx_tid;
  4176. uint8_t tid;
  4177. if (!peer)
  4178. return;
  4179. dp_info("Flushing fragments for peer " QDF_MAC_ADDR_FMT,
  4180. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  4181. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  4182. rx_tid = &peer->rx_tid[tid];
  4183. qdf_spin_lock_bh(&rx_tid->tid_lock);
  4184. dp_rx_defrag_waitlist_remove(peer, tid);
  4185. dp_rx_reorder_flush_frag(peer, tid);
  4186. qdf_spin_unlock_bh(&rx_tid->tid_lock);
  4187. }
  4188. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  4189. }