dp_peer.c 117 KB

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