dp_peer.c 116 KB

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