dp_peer.c 109 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174317531763177317831793180318131823183318431853186318731883189319031913192319331943195319631973198319932003201320232033204320532063207320832093210321132123213321432153216321732183219322032213222322332243225322632273228322932303231323232333234323532363237323832393240324132423243324432453246324732483249325032513252325332543255325632573258325932603261326232633264326532663267326832693270327132723273327432753276327732783279328032813282328332843285328632873288328932903291329232933294329532963297329832993300330133023303330433053306330733083309331033113312331333143315331633173318331933203321332233233324332533263327332833293330333133323333333433353336333733383339334033413342334333443345334633473348334933503351335233533354335533563357335833593360336133623363336433653366336733683369337033713372337333743375337633773378337933803381338233833384338533863387338833893390339133923393339433953396339733983399340034013402340334043405340634073408340934103411341234133414341534163417341834193420342134223423342434253426342734283429343034313432343334343435343634373438343934403441344234433444344534463447344834493450345134523453345434553456345734583459346034613462346334643465346634673468346934703471347234733474347534763477347834793480348134823483348434853486348734883489349034913492349334943495349634973498349935003501350235033504350535063507350835093510351135123513351435153516351735183519352035213522352335243525352635273528352935303531353235333534353535363537353835393540354135423543354435453546354735483549355035513552355335543555355635573558355935603561356235633564356535663567356835693570357135723573357435753576357735783579358035813582358335843585358635873588358935903591359235933594359535963597359835993600360136023603360436053606360736083609361036113612361336143615361636173618361936203621362236233624362536263627362836293630363136323633363436353636363736383639364036413642364336443645364636473648364936503651365236533654365536563657365836593660366136623663366436653666366736683669367036713672367336743675367636773678367936803681368236833684368536863687368836893690369136923693369436953696369736983699370037013702370337043705370637073708370937103711371237133714371537163717371837193720372137223723372437253726372737283729373037313732373337343735373637373738373937403741374237433744374537463747374837493750375137523753375437553756375737583759376037613762376337643765376637673768376937703771377237733774377537763777377837793780378137823783378437853786378737883789379037913792379337943795379637973798379938003801380238033804380538063807380838093810381138123813381438153816381738183819382038213822382338243825382638273828382938303831383238333834383538363837383838393840384138423843384438453846384738483849385038513852385338543855385638573858385938603861386238633864386538663867386838693870387138723873387438753876387738783879388038813882388338843885388638873888388938903891389238933894389538963897389838993900390139023903390439053906390739083909391039113912391339143915391639173918391939203921392239233924392539263927392839293930393139323933393439353936393739383939394039413942394339443945394639473948394939503951395239533954395539563957395839593960396139623963396439653966396739683969397039713972397339743975397639773978397939803981398239833984398539863987398839893990399139923993399439953996399739983999400040014002400340044005400640074008400940104011401240134014401540164017401840194020402140224023402440254026402740284029403040314032403340344035403640374038403940404041404240434044404540464047404840494050405140524053405440554056405740584059406040614062406340644065406640674068406940704071407240734074407540764077407840794080408140824083408440854086408740884089409040914092409340944095409640974098409941004101410241034104410541064107410841094110411141124113411441154116411741184119412041214122412341244125412641274128412941304131413241334134413541364137413841394140414141424143414441454146414741484149415041514152415341544155415641574158415941604161416241634164416541664167416841694170417141724173417441754176417741784179
  1. /*
  2. * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
  3. * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
  4. *
  5. * Permission to use, copy, modify, and/or distribute this software for
  6. * any purpose with or without fee is hereby granted, provided that the
  7. * above copyright notice and this permission notice appear in all
  8. * copies.
  9. *
  10. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
  11. * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
  12. * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
  13. * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
  14. * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  15. * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  16. * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  17. * PERFORMANCE OF THIS SOFTWARE.
  18. */
  19. #include <qdf_types.h>
  20. #include <qdf_lock.h>
  21. #include <hal_hw_headers.h>
  22. #include "dp_htt.h"
  23. #include "dp_types.h"
  24. #include "dp_internal.h"
  25. #include "dp_peer.h"
  26. #include "dp_rx_defrag.h"
  27. #include "dp_rx.h"
  28. #include <hal_api.h>
  29. #include <hal_reo.h>
  30. #include <cdp_txrx_handle.h>
  31. #include <wlan_cfg.h>
  32. #ifdef WIFI_MONITOR_SUPPORT
  33. #include <dp_mon.h>
  34. #endif
  35. #ifdef FEATURE_WDS
  36. #include "dp_txrx_wds.h"
  37. #endif
  38. #include <qdf_module.h>
  39. #ifdef QCA_PEER_EXT_STATS
  40. #include "dp_hist.h"
  41. #endif
  42. #ifdef BYPASS_OL_OPS
  43. #include <target_if_dp.h>
  44. #endif
  45. #if defined(WLAN_FEATURE_11BE_MLO) && defined(DP_MLO_LINK_STATS_SUPPORT)
  46. #include "reg_services_common.h"
  47. #endif
  48. #ifdef FEATURE_AST
  49. #ifdef BYPASS_OL_OPS
  50. /**
  51. * dp_add_wds_entry_wrapper() - Add new AST entry for the wds station
  52. * @soc: DP soc structure pointer
  53. * @peer: dp peer structure
  54. * @dest_macaddr: MAC address of ast node
  55. * @flags: wds or hmwds
  56. * @type: type from enum cdp_txrx_ast_entry_type
  57. *
  58. * This API is used by WDS source port learning function to
  59. * add a new AST entry in the fw.
  60. *
  61. * Return: 0 on success, error code otherwise.
  62. */
  63. static int dp_add_wds_entry_wrapper(struct dp_soc *soc,
  64. struct dp_peer *peer,
  65. const uint8_t *dest_macaddr,
  66. uint32_t flags,
  67. uint8_t type)
  68. {
  69. QDF_STATUS status;
  70. status = target_if_add_wds_entry(soc->ctrl_psoc,
  71. peer->vdev->vdev_id,
  72. peer->mac_addr.raw,
  73. dest_macaddr,
  74. WMI_HOST_WDS_FLAG_STATIC,
  75. type);
  76. return qdf_status_to_os_return(status);
  77. }
  78. /**
  79. * dp_update_wds_entry_wrapper() - update an existing wds entry with new peer
  80. * @soc: DP soc structure pointer
  81. * @peer: dp peer structure
  82. * @dest_macaddr: MAC address of ast node
  83. * @flags: wds or hmwds
  84. *
  85. * This API is used by update the peer mac address for the ast
  86. * in the fw.
  87. *
  88. * Return: 0 on success, error code otherwise.
  89. */
  90. static int dp_update_wds_entry_wrapper(struct dp_soc *soc,
  91. struct dp_peer *peer,
  92. uint8_t *dest_macaddr,
  93. uint32_t flags)
  94. {
  95. QDF_STATUS status;
  96. status = target_if_update_wds_entry(soc->ctrl_psoc,
  97. peer->vdev->vdev_id,
  98. dest_macaddr,
  99. peer->mac_addr.raw,
  100. WMI_HOST_WDS_FLAG_STATIC);
  101. return qdf_status_to_os_return(status);
  102. }
  103. /**
  104. * dp_del_wds_entry_wrapper() - delete a WSD AST entry
  105. * @soc: DP soc structure pointer
  106. * @vdev_id: vdev_id
  107. * @wds_macaddr: MAC address of ast node
  108. * @type: type from enum cdp_txrx_ast_entry_type
  109. * @delete_in_fw: Flag to indicate if entry needs to be deleted in fw
  110. *
  111. * This API is used to delete an AST entry from fw
  112. *
  113. * Return: None
  114. */
  115. void dp_del_wds_entry_wrapper(struct dp_soc *soc,
  116. uint8_t vdev_id,
  117. uint8_t *wds_macaddr,
  118. uint8_t type,
  119. uint8_t delete_in_fw)
  120. {
  121. target_if_del_wds_entry(soc->ctrl_psoc, vdev_id,
  122. wds_macaddr, type, delete_in_fw);
  123. }
  124. #else
  125. static int dp_add_wds_entry_wrapper(struct dp_soc *soc,
  126. struct dp_peer *peer,
  127. const uint8_t *dest_macaddr,
  128. uint32_t flags,
  129. uint8_t type)
  130. {
  131. int status;
  132. status = soc->cdp_soc.ol_ops->peer_add_wds_entry(
  133. soc->ctrl_psoc,
  134. peer->vdev->vdev_id,
  135. peer->mac_addr.raw,
  136. peer->peer_id,
  137. dest_macaddr,
  138. peer->mac_addr.raw,
  139. flags,
  140. type);
  141. return status;
  142. }
  143. static int dp_update_wds_entry_wrapper(struct dp_soc *soc,
  144. struct dp_peer *peer,
  145. uint8_t *dest_macaddr,
  146. uint32_t flags)
  147. {
  148. int status;
  149. status = soc->cdp_soc.ol_ops->peer_update_wds_entry(
  150. soc->ctrl_psoc,
  151. peer->vdev->vdev_id,
  152. dest_macaddr,
  153. peer->mac_addr.raw,
  154. flags);
  155. return status;
  156. }
  157. void dp_del_wds_entry_wrapper(struct dp_soc *soc,
  158. uint8_t vdev_id,
  159. uint8_t *wds_macaddr,
  160. uint8_t type,
  161. uint8_t delete_in_fw)
  162. {
  163. soc->cdp_soc.ol_ops->peer_del_wds_entry(soc->ctrl_psoc,
  164. vdev_id,
  165. wds_macaddr,
  166. type,
  167. delete_in_fw);
  168. }
  169. #endif /* BYPASS_OL_OPS */
  170. #else
  171. void dp_del_wds_entry_wrapper(struct dp_soc *soc,
  172. uint8_t vdev_id,
  173. uint8_t *wds_macaddr,
  174. uint8_t type,
  175. uint8_t delete_in_fw)
  176. {
  177. }
  178. #endif /* FEATURE_AST */
  179. #ifdef FEATURE_WDS
  180. static inline bool
  181. dp_peer_ast_free_in_unmap_supported(struct dp_soc *soc,
  182. struct dp_ast_entry *ast_entry)
  183. {
  184. /* if peer map v2 is enabled we are not freeing ast entry
  185. * here and it is supposed to be freed in unmap event (after
  186. * we receive delete confirmation from target)
  187. *
  188. * if peer_id is invalid we did not get the peer map event
  189. * for the peer free ast entry from here only in this case
  190. */
  191. if ((ast_entry->type != CDP_TXRX_AST_TYPE_WDS_HM_SEC) &&
  192. (ast_entry->type != CDP_TXRX_AST_TYPE_SELF))
  193. return true;
  194. return false;
  195. }
  196. #else
  197. static inline bool
  198. dp_peer_ast_free_in_unmap_supported(struct dp_soc *soc,
  199. struct dp_ast_entry *ast_entry)
  200. {
  201. return false;
  202. }
  203. void dp_soc_wds_attach(struct dp_soc *soc)
  204. {
  205. }
  206. void dp_soc_wds_detach(struct dp_soc *soc)
  207. {
  208. }
  209. #endif
  210. #ifdef QCA_SUPPORT_WDS_EXTENDED
  211. bool dp_peer_check_wds_ext_peer(struct dp_peer *peer)
  212. {
  213. struct dp_vdev *vdev = peer->vdev;
  214. struct dp_txrx_peer *txrx_peer;
  215. if (!vdev->wds_ext_enabled)
  216. return false;
  217. txrx_peer = dp_get_txrx_peer(peer);
  218. if (!txrx_peer)
  219. return false;
  220. if (qdf_atomic_test_bit(WDS_EXT_PEER_INIT_BIT,
  221. &txrx_peer->wds_ext.init))
  222. return true;
  223. return false;
  224. }
  225. #else
  226. bool dp_peer_check_wds_ext_peer(struct dp_peer *peer)
  227. {
  228. return false;
  229. }
  230. #endif
  231. QDF_STATUS dp_peer_ast_table_attach(struct dp_soc *soc)
  232. {
  233. uint32_t max_ast_index;
  234. max_ast_index = wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx);
  235. /* allocate ast_table for ast entry to ast_index map */
  236. dp_peer_info("\n%pK:<=== cfg max ast idx %d ====>", soc, max_ast_index);
  237. soc->ast_table = qdf_mem_malloc(max_ast_index *
  238. sizeof(struct dp_ast_entry *));
  239. if (!soc->ast_table) {
  240. dp_peer_err("%pK: ast_table memory allocation failed", soc);
  241. return QDF_STATUS_E_NOMEM;
  242. }
  243. return QDF_STATUS_SUCCESS; /* success */
  244. }
  245. /**
  246. * dp_find_peer_by_macaddr() - Finding the peer from mac address provided.
  247. * @soc: soc handle
  248. * @mac_addr: MAC address to be used to find peer
  249. * @vdev_id: VDEV id
  250. * @mod_id: MODULE ID
  251. *
  252. * Return: struct dp_peer
  253. */
  254. struct dp_peer *dp_find_peer_by_macaddr(struct dp_soc *soc, uint8_t *mac_addr,
  255. uint8_t vdev_id, enum dp_mod_id mod_id)
  256. {
  257. bool ast_ind_disable = wlan_cfg_get_ast_indication_disable(
  258. soc->wlan_cfg_ctx);
  259. struct cdp_peer_info peer_info = {0};
  260. if ((!soc->ast_offload_support) || (!ast_ind_disable)) {
  261. struct dp_ast_entry *ast_entry = NULL;
  262. uint16_t peer_id;
  263. qdf_spin_lock_bh(&soc->ast_lock);
  264. if (vdev_id == DP_VDEV_ALL)
  265. ast_entry = dp_peer_ast_hash_find_soc(soc, mac_addr);
  266. else
  267. ast_entry = dp_peer_ast_hash_find_by_vdevid
  268. (soc, mac_addr, vdev_id);
  269. if (!ast_entry) {
  270. qdf_spin_unlock_bh(&soc->ast_lock);
  271. dp_err("NULL ast entry");
  272. return NULL;
  273. }
  274. peer_id = ast_entry->peer_id;
  275. qdf_spin_unlock_bh(&soc->ast_lock);
  276. if (peer_id == HTT_INVALID_PEER)
  277. return NULL;
  278. return dp_peer_get_ref_by_id(soc, peer_id, mod_id);
  279. }
  280. DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, mac_addr, false,
  281. CDP_WILD_PEER_TYPE);
  282. return dp_peer_hash_find_wrapper(soc, &peer_info, mod_id);
  283. }
  284. /**
  285. * dp_peer_find_map_attach() - allocate memory for peer_id_to_obj_map
  286. * @soc: soc handle
  287. *
  288. * return: QDF_STATUS
  289. */
  290. static QDF_STATUS dp_peer_find_map_attach(struct dp_soc *soc)
  291. {
  292. uint32_t max_peers, peer_map_size;
  293. max_peers = soc->max_peer_id;
  294. /* allocate the peer ID -> peer object map */
  295. dp_peer_info("\n%pK:<=== cfg max peer id %d ====>", soc, max_peers);
  296. peer_map_size = max_peers * sizeof(soc->peer_id_to_obj_map[0]);
  297. soc->peer_id_to_obj_map = qdf_mem_malloc(peer_map_size);
  298. if (!soc->peer_id_to_obj_map) {
  299. dp_peer_err("%pK: peer map memory allocation failed", soc);
  300. return QDF_STATUS_E_NOMEM;
  301. }
  302. /*
  303. * The peer_id_to_obj_map doesn't really need to be initialized,
  304. * since elements are only used after they have been individually
  305. * initialized.
  306. * However, it is convenient for debugging to have all elements
  307. * that are not in use set to 0.
  308. */
  309. qdf_mem_zero(soc->peer_id_to_obj_map, peer_map_size);
  310. qdf_spinlock_create(&soc->peer_map_lock);
  311. return QDF_STATUS_SUCCESS; /* success */
  312. }
  313. #define DP_AST_HASH_LOAD_MULT 2
  314. #define DP_AST_HASH_LOAD_SHIFT 0
  315. static inline uint32_t
  316. dp_peer_find_hash_index(struct dp_soc *soc,
  317. union dp_align_mac_addr *mac_addr)
  318. {
  319. uint32_t index;
  320. index =
  321. mac_addr->align2.bytes_ab ^
  322. mac_addr->align2.bytes_cd ^
  323. mac_addr->align2.bytes_ef;
  324. index ^= index >> soc->peer_hash.idx_bits;
  325. index &= soc->peer_hash.mask;
  326. return index;
  327. }
  328. struct dp_peer *dp_peer_find_hash_find(
  329. struct dp_soc *soc, uint8_t *peer_mac_addr,
  330. int mac_addr_is_aligned, uint8_t vdev_id,
  331. enum dp_mod_id mod_id)
  332. {
  333. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  334. uint32_t index;
  335. struct dp_peer *peer;
  336. if (!soc->peer_hash.bins)
  337. return NULL;
  338. if (mac_addr_is_aligned) {
  339. mac_addr = (union dp_align_mac_addr *)peer_mac_addr;
  340. } else {
  341. qdf_mem_copy(
  342. &local_mac_addr_aligned.raw[0],
  343. peer_mac_addr, QDF_MAC_ADDR_SIZE);
  344. mac_addr = &local_mac_addr_aligned;
  345. }
  346. index = dp_peer_find_hash_index(soc, mac_addr);
  347. qdf_spin_lock_bh(&soc->peer_hash_lock);
  348. TAILQ_FOREACH(peer, &soc->peer_hash.bins[index], hash_list_elem) {
  349. if (dp_peer_find_mac_addr_cmp(mac_addr, &peer->mac_addr) == 0 &&
  350. ((peer->vdev->vdev_id == vdev_id) ||
  351. (vdev_id == DP_VDEV_ALL))) {
  352. /* take peer reference before returning */
  353. if (dp_peer_get_ref(soc, peer, mod_id) !=
  354. QDF_STATUS_SUCCESS)
  355. peer = NULL;
  356. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  357. return peer;
  358. }
  359. }
  360. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  361. return NULL; /* failure */
  362. }
  363. qdf_export_symbol(dp_peer_find_hash_find);
  364. #ifdef WLAN_FEATURE_11BE_MLO
  365. /**
  366. * dp_peer_find_hash_detach() - cleanup memory for peer_hash table
  367. * @soc: soc handle
  368. *
  369. * return: none
  370. */
  371. static void dp_peer_find_hash_detach(struct dp_soc *soc)
  372. {
  373. if (soc->peer_hash.bins) {
  374. qdf_mem_free(soc->peer_hash.bins);
  375. soc->peer_hash.bins = NULL;
  376. qdf_spinlock_destroy(&soc->peer_hash_lock);
  377. }
  378. if (soc->arch_ops.mlo_peer_find_hash_detach)
  379. soc->arch_ops.mlo_peer_find_hash_detach(soc);
  380. }
  381. /**
  382. * dp_peer_find_hash_attach() - allocate memory for peer_hash table
  383. * @soc: soc handle
  384. *
  385. * return: QDF_STATUS
  386. */
  387. static QDF_STATUS dp_peer_find_hash_attach(struct dp_soc *soc)
  388. {
  389. int i, hash_elems, log2;
  390. /* allocate the peer MAC address -> peer object hash table */
  391. hash_elems = soc->max_peers;
  392. hash_elems *= DP_PEER_HASH_LOAD_MULT;
  393. hash_elems >>= DP_PEER_HASH_LOAD_SHIFT;
  394. log2 = dp_log2_ceil(hash_elems);
  395. hash_elems = 1 << log2;
  396. soc->peer_hash.mask = hash_elems - 1;
  397. soc->peer_hash.idx_bits = log2;
  398. /* allocate an array of TAILQ peer object lists */
  399. soc->peer_hash.bins = qdf_mem_malloc(
  400. hash_elems * sizeof(TAILQ_HEAD(anonymous_tail_q, dp_peer)));
  401. if (!soc->peer_hash.bins)
  402. return QDF_STATUS_E_NOMEM;
  403. for (i = 0; i < hash_elems; i++)
  404. TAILQ_INIT(&soc->peer_hash.bins[i]);
  405. qdf_spinlock_create(&soc->peer_hash_lock);
  406. if (soc->arch_ops.mlo_peer_find_hash_attach &&
  407. (soc->arch_ops.mlo_peer_find_hash_attach(soc) !=
  408. QDF_STATUS_SUCCESS)) {
  409. dp_peer_find_hash_detach(soc);
  410. return QDF_STATUS_E_NOMEM;
  411. }
  412. return QDF_STATUS_SUCCESS;
  413. }
  414. void dp_peer_find_hash_add(struct dp_soc *soc, struct dp_peer *peer)
  415. {
  416. unsigned index;
  417. index = dp_peer_find_hash_index(soc, &peer->mac_addr);
  418. if (peer->peer_type == CDP_LINK_PEER_TYPE) {
  419. qdf_spin_lock_bh(&soc->peer_hash_lock);
  420. if (QDF_IS_STATUS_ERROR(dp_peer_get_ref(soc, peer,
  421. DP_MOD_ID_CONFIG))) {
  422. dp_err("fail to get peer ref:" QDF_MAC_ADDR_FMT,
  423. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  424. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  425. return;
  426. }
  427. /*
  428. * It is important to add the new peer at the tail of
  429. * peer list with the bin index. Together with having
  430. * the hash_find function search from head to tail,
  431. * this ensures that if two entries with the same MAC address
  432. * are stored, the one added first will be found first.
  433. */
  434. TAILQ_INSERT_TAIL(&soc->peer_hash.bins[index], peer,
  435. hash_list_elem);
  436. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  437. } else if (peer->peer_type == CDP_MLD_PEER_TYPE) {
  438. if (soc->arch_ops.mlo_peer_find_hash_add)
  439. soc->arch_ops.mlo_peer_find_hash_add(soc, peer);
  440. } else {
  441. dp_err("unknown peer type %d", peer->peer_type);
  442. }
  443. }
  444. void dp_peer_find_hash_remove(struct dp_soc *soc, struct dp_peer *peer)
  445. {
  446. unsigned index;
  447. struct dp_peer *tmppeer = NULL;
  448. int found = 0;
  449. index = dp_peer_find_hash_index(soc, &peer->mac_addr);
  450. if (peer->peer_type == CDP_LINK_PEER_TYPE) {
  451. /* Check if tail is not empty before delete*/
  452. QDF_ASSERT(!TAILQ_EMPTY(&soc->peer_hash.bins[index]));
  453. qdf_spin_lock_bh(&soc->peer_hash_lock);
  454. TAILQ_FOREACH(tmppeer, &soc->peer_hash.bins[index],
  455. hash_list_elem) {
  456. if (tmppeer == peer) {
  457. found = 1;
  458. break;
  459. }
  460. }
  461. QDF_ASSERT(found);
  462. TAILQ_REMOVE(&soc->peer_hash.bins[index], peer,
  463. hash_list_elem);
  464. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  465. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  466. } else if (peer->peer_type == CDP_MLD_PEER_TYPE) {
  467. if (soc->arch_ops.mlo_peer_find_hash_remove)
  468. soc->arch_ops.mlo_peer_find_hash_remove(soc, peer);
  469. } else {
  470. dp_err("unknown peer type %d", peer->peer_type);
  471. }
  472. }
  473. uint8_t dp_get_peer_link_id(struct dp_peer *peer)
  474. {
  475. uint8_t link_id;
  476. link_id = IS_MLO_DP_LINK_PEER(peer) ? peer->link_id + 1 : 0;
  477. if (link_id < 1 || link_id > DP_MAX_MLO_LINKS)
  478. link_id = 0;
  479. return link_id;
  480. }
  481. #else
  482. static QDF_STATUS dp_peer_find_hash_attach(struct dp_soc *soc)
  483. {
  484. int i, hash_elems, log2;
  485. /* allocate the peer MAC address -> peer object hash table */
  486. hash_elems = soc->max_peers;
  487. hash_elems *= DP_PEER_HASH_LOAD_MULT;
  488. hash_elems >>= DP_PEER_HASH_LOAD_SHIFT;
  489. log2 = dp_log2_ceil(hash_elems);
  490. hash_elems = 1 << log2;
  491. soc->peer_hash.mask = hash_elems - 1;
  492. soc->peer_hash.idx_bits = log2;
  493. /* allocate an array of TAILQ peer object lists */
  494. soc->peer_hash.bins = qdf_mem_malloc(
  495. hash_elems * sizeof(TAILQ_HEAD(anonymous_tail_q, dp_peer)));
  496. if (!soc->peer_hash.bins)
  497. return QDF_STATUS_E_NOMEM;
  498. for (i = 0; i < hash_elems; i++)
  499. TAILQ_INIT(&soc->peer_hash.bins[i]);
  500. qdf_spinlock_create(&soc->peer_hash_lock);
  501. return QDF_STATUS_SUCCESS;
  502. }
  503. static void dp_peer_find_hash_detach(struct dp_soc *soc)
  504. {
  505. if (soc->peer_hash.bins) {
  506. qdf_mem_free(soc->peer_hash.bins);
  507. soc->peer_hash.bins = NULL;
  508. qdf_spinlock_destroy(&soc->peer_hash_lock);
  509. }
  510. }
  511. void dp_peer_find_hash_add(struct dp_soc *soc, struct dp_peer *peer)
  512. {
  513. unsigned index;
  514. index = dp_peer_find_hash_index(soc, &peer->mac_addr);
  515. qdf_spin_lock_bh(&soc->peer_hash_lock);
  516. if (QDF_IS_STATUS_ERROR(dp_peer_get_ref(soc, peer, DP_MOD_ID_CONFIG))) {
  517. dp_err("unable to get peer ref at MAP mac: "QDF_MAC_ADDR_FMT,
  518. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  519. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  520. return;
  521. }
  522. /*
  523. * It is important to add the new peer at the tail of the peer list
  524. * with the bin index. Together with having the hash_find function
  525. * search from head to tail, this ensures that if two entries with
  526. * the same MAC address are stored, the one added first will be
  527. * found first.
  528. */
  529. TAILQ_INSERT_TAIL(&soc->peer_hash.bins[index], peer, hash_list_elem);
  530. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  531. }
  532. void dp_peer_find_hash_remove(struct dp_soc *soc, struct dp_peer *peer)
  533. {
  534. unsigned index;
  535. struct dp_peer *tmppeer = NULL;
  536. int found = 0;
  537. index = dp_peer_find_hash_index(soc, &peer->mac_addr);
  538. /* Check if tail is not empty before delete*/
  539. QDF_ASSERT(!TAILQ_EMPTY(&soc->peer_hash.bins[index]));
  540. qdf_spin_lock_bh(&soc->peer_hash_lock);
  541. TAILQ_FOREACH(tmppeer, &soc->peer_hash.bins[index], hash_list_elem) {
  542. if (tmppeer == peer) {
  543. found = 1;
  544. break;
  545. }
  546. }
  547. QDF_ASSERT(found);
  548. TAILQ_REMOVE(&soc->peer_hash.bins[index], peer, hash_list_elem);
  549. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  550. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  551. }
  552. #endif/* WLAN_FEATURE_11BE_MLO */
  553. void dp_peer_vdev_list_add(struct dp_soc *soc, struct dp_vdev *vdev,
  554. struct dp_peer *peer)
  555. {
  556. /* only link peer will be added to vdev peer list */
  557. if (IS_MLO_DP_MLD_PEER(peer))
  558. return;
  559. qdf_spin_lock_bh(&vdev->peer_list_lock);
  560. if (QDF_IS_STATUS_ERROR(dp_peer_get_ref(soc, peer, DP_MOD_ID_CONFIG))) {
  561. dp_err("unable to get peer ref at MAP mac: "QDF_MAC_ADDR_FMT,
  562. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  563. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  564. return;
  565. }
  566. /* add this peer into the vdev's list */
  567. if (wlan_op_mode_sta == vdev->opmode)
  568. TAILQ_INSERT_HEAD(&vdev->peer_list, peer, peer_list_elem);
  569. else
  570. TAILQ_INSERT_TAIL(&vdev->peer_list, peer, peer_list_elem);
  571. vdev->num_peers++;
  572. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  573. }
  574. void dp_peer_vdev_list_remove(struct dp_soc *soc, struct dp_vdev *vdev,
  575. struct dp_peer *peer)
  576. {
  577. uint8_t found = 0;
  578. struct dp_peer *tmppeer = NULL;
  579. /* only link peer will be added to vdev peer list */
  580. if (IS_MLO_DP_MLD_PEER(peer))
  581. return;
  582. qdf_spin_lock_bh(&vdev->peer_list_lock);
  583. TAILQ_FOREACH(tmppeer, &peer->vdev->peer_list, peer_list_elem) {
  584. if (tmppeer == peer) {
  585. found = 1;
  586. break;
  587. }
  588. }
  589. if (found) {
  590. TAILQ_REMOVE(&peer->vdev->peer_list, peer,
  591. peer_list_elem);
  592. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  593. vdev->num_peers--;
  594. } else {
  595. /*Ignoring the remove operation as peer not found*/
  596. dp_peer_debug("%pK: peer:%pK not found in vdev:%pK peerlist:%pK"
  597. , soc, peer, vdev, &peer->vdev->peer_list);
  598. }
  599. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  600. }
  601. void dp_txrx_peer_attach_add(struct dp_soc *soc,
  602. struct dp_peer *peer,
  603. struct dp_txrx_peer *txrx_peer)
  604. {
  605. qdf_spin_lock_bh(&soc->peer_map_lock);
  606. peer->txrx_peer = txrx_peer;
  607. txrx_peer->bss_peer = peer->bss_peer;
  608. if (peer->peer_id == HTT_INVALID_PEER) {
  609. qdf_spin_unlock_bh(&soc->peer_map_lock);
  610. return;
  611. }
  612. txrx_peer->peer_id = peer->peer_id;
  613. QDF_ASSERT(soc->peer_id_to_obj_map[peer->peer_id]);
  614. qdf_spin_unlock_bh(&soc->peer_map_lock);
  615. }
  616. void dp_peer_find_id_to_obj_add(struct dp_soc *soc,
  617. struct dp_peer *peer,
  618. uint16_t peer_id)
  619. {
  620. QDF_ASSERT(peer_id <= soc->max_peer_id);
  621. qdf_spin_lock_bh(&soc->peer_map_lock);
  622. peer->peer_id = peer_id;
  623. if (QDF_IS_STATUS_ERROR(dp_peer_get_ref(soc, peer, DP_MOD_ID_CONFIG))) {
  624. dp_err("unable to get peer ref at MAP mac: "QDF_MAC_ADDR_FMT" peer_id %u",
  625. QDF_MAC_ADDR_REF(peer->mac_addr.raw), peer_id);
  626. qdf_spin_unlock_bh(&soc->peer_map_lock);
  627. return;
  628. }
  629. if (!soc->peer_id_to_obj_map[peer_id]) {
  630. soc->peer_id_to_obj_map[peer_id] = peer;
  631. if (peer->txrx_peer)
  632. peer->txrx_peer->peer_id = peer_id;
  633. } else {
  634. /* Peer map event came for peer_id which
  635. * is already mapped, this is not expected
  636. */
  637. dp_err("peer %pK(" QDF_MAC_ADDR_FMT ")map failed, id %d mapped to peer %pK",
  638. peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw), peer_id,
  639. soc->peer_id_to_obj_map[peer_id]);
  640. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  641. qdf_assert_always(0);
  642. }
  643. qdf_spin_unlock_bh(&soc->peer_map_lock);
  644. }
  645. void dp_peer_find_id_to_obj_remove(struct dp_soc *soc,
  646. uint16_t peer_id)
  647. {
  648. struct dp_peer *peer = NULL;
  649. QDF_ASSERT(peer_id <= soc->max_peer_id);
  650. qdf_spin_lock_bh(&soc->peer_map_lock);
  651. peer = soc->peer_id_to_obj_map[peer_id];
  652. if (!peer) {
  653. dp_err("unable to get peer during peer id obj map remove");
  654. qdf_spin_unlock_bh(&soc->peer_map_lock);
  655. return;
  656. }
  657. peer->peer_id = HTT_INVALID_PEER;
  658. if (peer->txrx_peer)
  659. peer->txrx_peer->peer_id = HTT_INVALID_PEER;
  660. soc->peer_id_to_obj_map[peer_id] = NULL;
  661. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  662. qdf_spin_unlock_bh(&soc->peer_map_lock);
  663. }
  664. #ifdef FEATURE_MEC
  665. QDF_STATUS dp_peer_mec_hash_attach(struct dp_soc *soc)
  666. {
  667. int log2, hash_elems, i;
  668. log2 = dp_log2_ceil(DP_PEER_MAX_MEC_IDX);
  669. hash_elems = 1 << log2;
  670. soc->mec_hash.mask = hash_elems - 1;
  671. soc->mec_hash.idx_bits = log2;
  672. dp_peer_info("%pK: max mec index: %d",
  673. soc, DP_PEER_MAX_MEC_IDX);
  674. /* allocate an array of TAILQ mec object lists */
  675. soc->mec_hash.bins = qdf_mem_malloc(hash_elems *
  676. sizeof(TAILQ_HEAD(anonymous_tail_q,
  677. dp_mec_entry)));
  678. if (!soc->mec_hash.bins)
  679. return QDF_STATUS_E_NOMEM;
  680. for (i = 0; i < hash_elems; i++)
  681. TAILQ_INIT(&soc->mec_hash.bins[i]);
  682. return QDF_STATUS_SUCCESS;
  683. }
  684. /**
  685. * dp_peer_mec_hash_index() - Compute the MEC hash from MAC address
  686. * @soc: SoC handle
  687. * @mac_addr: MAC address
  688. *
  689. * Return: MEC hash
  690. */
  691. static inline uint32_t dp_peer_mec_hash_index(struct dp_soc *soc,
  692. union dp_align_mac_addr *mac_addr)
  693. {
  694. uint32_t index;
  695. index =
  696. mac_addr->align2.bytes_ab ^
  697. mac_addr->align2.bytes_cd ^
  698. mac_addr->align2.bytes_ef;
  699. index ^= index >> soc->mec_hash.idx_bits;
  700. index &= soc->mec_hash.mask;
  701. return index;
  702. }
  703. struct dp_mec_entry *dp_peer_mec_hash_find_by_pdevid(struct dp_soc *soc,
  704. uint8_t pdev_id,
  705. uint8_t *mec_mac_addr)
  706. {
  707. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  708. uint32_t index;
  709. struct dp_mec_entry *mecentry;
  710. qdf_mem_copy(&local_mac_addr_aligned.raw[0],
  711. mec_mac_addr, QDF_MAC_ADDR_SIZE);
  712. mac_addr = &local_mac_addr_aligned;
  713. index = dp_peer_mec_hash_index(soc, mac_addr);
  714. TAILQ_FOREACH(mecentry, &soc->mec_hash.bins[index], hash_list_elem) {
  715. if ((pdev_id == mecentry->pdev_id) &&
  716. !dp_peer_find_mac_addr_cmp(mac_addr, &mecentry->mac_addr))
  717. return mecentry;
  718. }
  719. return NULL;
  720. }
  721. /**
  722. * dp_peer_mec_hash_add() - Add MEC entry into hash table
  723. * @soc: SoC handle
  724. * @mecentry: MEC entry
  725. *
  726. * This function adds the MEC entry into SoC MEC hash table
  727. *
  728. * Return: None
  729. */
  730. static inline void dp_peer_mec_hash_add(struct dp_soc *soc,
  731. struct dp_mec_entry *mecentry)
  732. {
  733. uint32_t index;
  734. index = dp_peer_mec_hash_index(soc, &mecentry->mac_addr);
  735. qdf_spin_lock_bh(&soc->mec_lock);
  736. TAILQ_INSERT_TAIL(&soc->mec_hash.bins[index], mecentry, hash_list_elem);
  737. qdf_spin_unlock_bh(&soc->mec_lock);
  738. }
  739. QDF_STATUS dp_peer_mec_add_entry(struct dp_soc *soc,
  740. struct dp_vdev *vdev,
  741. uint8_t *mac_addr)
  742. {
  743. struct dp_mec_entry *mecentry = NULL;
  744. struct dp_pdev *pdev = NULL;
  745. if (!vdev) {
  746. dp_peer_err("%pK: Peers vdev is NULL", soc);
  747. return QDF_STATUS_E_INVAL;
  748. }
  749. pdev = vdev->pdev;
  750. if (qdf_unlikely(qdf_atomic_read(&soc->mec_cnt) >=
  751. DP_PEER_MAX_MEC_ENTRY)) {
  752. dp_peer_warn("%pK: max MEC entry limit reached mac_addr: "
  753. QDF_MAC_ADDR_FMT, soc, QDF_MAC_ADDR_REF(mac_addr));
  754. return QDF_STATUS_E_NOMEM;
  755. }
  756. qdf_spin_lock_bh(&soc->mec_lock);
  757. mecentry = dp_peer_mec_hash_find_by_pdevid(soc, pdev->pdev_id,
  758. mac_addr);
  759. if (qdf_likely(mecentry)) {
  760. mecentry->is_active = TRUE;
  761. qdf_spin_unlock_bh(&soc->mec_lock);
  762. return QDF_STATUS_E_ALREADY;
  763. }
  764. qdf_spin_unlock_bh(&soc->mec_lock);
  765. dp_peer_debug("%pK: pdevid: %u vdev: %u type: MEC mac_addr: "
  766. QDF_MAC_ADDR_FMT,
  767. soc, pdev->pdev_id, vdev->vdev_id,
  768. QDF_MAC_ADDR_REF(mac_addr));
  769. mecentry = (struct dp_mec_entry *)
  770. qdf_mem_malloc(sizeof(struct dp_mec_entry));
  771. if (qdf_unlikely(!mecentry)) {
  772. dp_peer_err("%pK: fail to allocate mecentry", soc);
  773. return QDF_STATUS_E_NOMEM;
  774. }
  775. qdf_copy_macaddr((struct qdf_mac_addr *)&mecentry->mac_addr.raw[0],
  776. (struct qdf_mac_addr *)mac_addr);
  777. mecentry->pdev_id = pdev->pdev_id;
  778. mecentry->vdev_id = vdev->vdev_id;
  779. mecentry->is_active = TRUE;
  780. dp_peer_mec_hash_add(soc, mecentry);
  781. qdf_atomic_inc(&soc->mec_cnt);
  782. DP_STATS_INC(soc, mec.added, 1);
  783. return QDF_STATUS_SUCCESS;
  784. }
  785. void dp_peer_mec_detach_entry(struct dp_soc *soc, struct dp_mec_entry *mecentry,
  786. void *ptr)
  787. {
  788. uint32_t index = dp_peer_mec_hash_index(soc, &mecentry->mac_addr);
  789. TAILQ_HEAD(, dp_mec_entry) * free_list = ptr;
  790. TAILQ_REMOVE(&soc->mec_hash.bins[index], mecentry,
  791. hash_list_elem);
  792. TAILQ_INSERT_TAIL(free_list, mecentry, hash_list_elem);
  793. }
  794. void dp_peer_mec_free_list(struct dp_soc *soc, void *ptr)
  795. {
  796. struct dp_mec_entry *mecentry, *mecentry_next;
  797. TAILQ_HEAD(, dp_mec_entry) * free_list = ptr;
  798. TAILQ_FOREACH_SAFE(mecentry, free_list, hash_list_elem,
  799. mecentry_next) {
  800. dp_peer_debug("%pK: MEC delete for mac_addr " QDF_MAC_ADDR_FMT,
  801. soc, QDF_MAC_ADDR_REF(&mecentry->mac_addr));
  802. qdf_mem_free(mecentry);
  803. qdf_atomic_dec(&soc->mec_cnt);
  804. DP_STATS_INC(soc, mec.deleted, 1);
  805. }
  806. }
  807. void dp_peer_mec_hash_detach(struct dp_soc *soc)
  808. {
  809. dp_peer_mec_flush_entries(soc);
  810. qdf_mem_free(soc->mec_hash.bins);
  811. soc->mec_hash.bins = NULL;
  812. }
  813. void dp_peer_mec_spinlock_destroy(struct dp_soc *soc)
  814. {
  815. qdf_spinlock_destroy(&soc->mec_lock);
  816. }
  817. void dp_peer_mec_spinlock_create(struct dp_soc *soc)
  818. {
  819. qdf_spinlock_create(&soc->mec_lock);
  820. }
  821. #else
  822. QDF_STATUS dp_peer_mec_hash_attach(struct dp_soc *soc)
  823. {
  824. return QDF_STATUS_SUCCESS;
  825. }
  826. void dp_peer_mec_hash_detach(struct dp_soc *soc)
  827. {
  828. }
  829. #endif
  830. #ifdef FEATURE_AST
  831. #ifdef WLAN_FEATURE_11BE_MLO
  832. /**
  833. * dp_peer_exist_on_pdev() - check if peer with mac address exist on pdev
  834. *
  835. * @soc: Datapath SOC handle
  836. * @peer_mac_addr: peer mac address
  837. * @mac_addr_is_aligned: is mac address aligned
  838. * @pdev: Datapath PDEV handle
  839. *
  840. * Return: true if peer found else return false
  841. */
  842. static bool dp_peer_exist_on_pdev(struct dp_soc *soc,
  843. uint8_t *peer_mac_addr,
  844. int mac_addr_is_aligned,
  845. struct dp_pdev *pdev)
  846. {
  847. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  848. unsigned int index;
  849. struct dp_peer *peer;
  850. bool found = false;
  851. if (mac_addr_is_aligned) {
  852. mac_addr = (union dp_align_mac_addr *)peer_mac_addr;
  853. } else {
  854. qdf_mem_copy(
  855. &local_mac_addr_aligned.raw[0],
  856. peer_mac_addr, QDF_MAC_ADDR_SIZE);
  857. mac_addr = &local_mac_addr_aligned;
  858. }
  859. index = dp_peer_find_hash_index(soc, mac_addr);
  860. qdf_spin_lock_bh(&soc->peer_hash_lock);
  861. TAILQ_FOREACH(peer, &soc->peer_hash.bins[index], hash_list_elem) {
  862. if (dp_peer_find_mac_addr_cmp(mac_addr, &peer->mac_addr) == 0 &&
  863. (peer->vdev->pdev == pdev)) {
  864. found = true;
  865. break;
  866. }
  867. }
  868. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  869. if (found)
  870. return found;
  871. peer = dp_mld_peer_find_hash_find(soc, peer_mac_addr,
  872. mac_addr_is_aligned, DP_VDEV_ALL,
  873. DP_MOD_ID_CDP);
  874. if (peer) {
  875. if (peer->vdev->pdev == pdev)
  876. found = true;
  877. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  878. }
  879. return found;
  880. }
  881. #else
  882. static bool dp_peer_exist_on_pdev(struct dp_soc *soc,
  883. uint8_t *peer_mac_addr,
  884. int mac_addr_is_aligned,
  885. struct dp_pdev *pdev)
  886. {
  887. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  888. unsigned int index;
  889. struct dp_peer *peer;
  890. bool found = false;
  891. if (mac_addr_is_aligned) {
  892. mac_addr = (union dp_align_mac_addr *)peer_mac_addr;
  893. } else {
  894. qdf_mem_copy(
  895. &local_mac_addr_aligned.raw[0],
  896. peer_mac_addr, QDF_MAC_ADDR_SIZE);
  897. mac_addr = &local_mac_addr_aligned;
  898. }
  899. index = dp_peer_find_hash_index(soc, mac_addr);
  900. qdf_spin_lock_bh(&soc->peer_hash_lock);
  901. TAILQ_FOREACH(peer, &soc->peer_hash.bins[index], hash_list_elem) {
  902. if (dp_peer_find_mac_addr_cmp(mac_addr, &peer->mac_addr) == 0 &&
  903. (peer->vdev->pdev == pdev)) {
  904. found = true;
  905. break;
  906. }
  907. }
  908. qdf_spin_unlock_bh(&soc->peer_hash_lock);
  909. return found;
  910. }
  911. #endif /* WLAN_FEATURE_11BE_MLO */
  912. QDF_STATUS dp_peer_ast_hash_attach(struct dp_soc *soc)
  913. {
  914. int i, hash_elems, log2;
  915. unsigned int max_ast_idx = wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx);
  916. hash_elems = ((max_ast_idx * DP_AST_HASH_LOAD_MULT) >>
  917. DP_AST_HASH_LOAD_SHIFT);
  918. log2 = dp_log2_ceil(hash_elems);
  919. hash_elems = 1 << log2;
  920. soc->ast_hash.mask = hash_elems - 1;
  921. soc->ast_hash.idx_bits = log2;
  922. dp_peer_info("%pK: ast hash_elems: %d, max_ast_idx: %d",
  923. soc, hash_elems, max_ast_idx);
  924. /* allocate an array of TAILQ peer object lists */
  925. soc->ast_hash.bins = qdf_mem_malloc(
  926. hash_elems * sizeof(TAILQ_HEAD(anonymous_tail_q,
  927. dp_ast_entry)));
  928. if (!soc->ast_hash.bins)
  929. return QDF_STATUS_E_NOMEM;
  930. for (i = 0; i < hash_elems; i++)
  931. TAILQ_INIT(&soc->ast_hash.bins[i]);
  932. return QDF_STATUS_SUCCESS;
  933. }
  934. /**
  935. * dp_peer_ast_cleanup() - cleanup the references
  936. * @soc: SoC handle
  937. * @ast: ast entry
  938. *
  939. * Return: None
  940. */
  941. static inline void dp_peer_ast_cleanup(struct dp_soc *soc,
  942. struct dp_ast_entry *ast)
  943. {
  944. txrx_ast_free_cb cb = ast->callback;
  945. void *cookie = ast->cookie;
  946. dp_peer_debug("mac_addr: " QDF_MAC_ADDR_FMT ", cb: %pK, cookie: %pK",
  947. QDF_MAC_ADDR_REF(ast->mac_addr.raw), cb, cookie);
  948. /* Call the callbacks to free up the cookie */
  949. if (cb) {
  950. ast->callback = NULL;
  951. ast->cookie = NULL;
  952. cb(soc->ctrl_psoc,
  953. dp_soc_to_cdp_soc(soc),
  954. cookie,
  955. CDP_TXRX_AST_DELETE_IN_PROGRESS);
  956. }
  957. }
  958. void dp_peer_ast_hash_detach(struct dp_soc *soc)
  959. {
  960. unsigned int index;
  961. struct dp_ast_entry *ast, *ast_next;
  962. if (!soc->ast_hash.mask)
  963. return;
  964. if (!soc->ast_hash.bins)
  965. return;
  966. dp_peer_debug("%pK: num_ast_entries: %u", soc, soc->num_ast_entries);
  967. qdf_spin_lock_bh(&soc->ast_lock);
  968. for (index = 0; index <= soc->ast_hash.mask; index++) {
  969. if (!TAILQ_EMPTY(&soc->ast_hash.bins[index])) {
  970. TAILQ_FOREACH_SAFE(ast, &soc->ast_hash.bins[index],
  971. hash_list_elem, ast_next) {
  972. TAILQ_REMOVE(&soc->ast_hash.bins[index], ast,
  973. hash_list_elem);
  974. dp_peer_ast_cleanup(soc, ast);
  975. soc->num_ast_entries--;
  976. qdf_mem_free(ast);
  977. }
  978. }
  979. }
  980. qdf_spin_unlock_bh(&soc->ast_lock);
  981. qdf_mem_free(soc->ast_hash.bins);
  982. soc->ast_hash.bins = NULL;
  983. }
  984. /**
  985. * dp_peer_ast_hash_index() - Compute the AST hash from MAC address
  986. * @soc: SoC handle
  987. * @mac_addr: MAC address
  988. *
  989. * Return: AST hash
  990. */
  991. static inline uint32_t dp_peer_ast_hash_index(struct dp_soc *soc,
  992. union dp_align_mac_addr *mac_addr)
  993. {
  994. uint32_t index;
  995. index =
  996. mac_addr->align2.bytes_ab ^
  997. mac_addr->align2.bytes_cd ^
  998. mac_addr->align2.bytes_ef;
  999. index ^= index >> soc->ast_hash.idx_bits;
  1000. index &= soc->ast_hash.mask;
  1001. return index;
  1002. }
  1003. /**
  1004. * dp_peer_ast_hash_add() - Add AST entry into hash table
  1005. * @soc: SoC handle
  1006. * @ase: AST entry
  1007. *
  1008. * This function adds the AST entry into SoC AST hash table
  1009. * It assumes caller has taken the ast lock to protect the access to this table
  1010. *
  1011. * Return: None
  1012. */
  1013. static inline void dp_peer_ast_hash_add(struct dp_soc *soc,
  1014. struct dp_ast_entry *ase)
  1015. {
  1016. uint32_t index;
  1017. index = dp_peer_ast_hash_index(soc, &ase->mac_addr);
  1018. TAILQ_INSERT_TAIL(&soc->ast_hash.bins[index], ase, hash_list_elem);
  1019. }
  1020. void dp_peer_ast_hash_remove(struct dp_soc *soc,
  1021. struct dp_ast_entry *ase)
  1022. {
  1023. unsigned index;
  1024. struct dp_ast_entry *tmpase;
  1025. int found = 0;
  1026. if (soc->ast_offload_support && !soc->host_ast_db_enable)
  1027. return;
  1028. index = dp_peer_ast_hash_index(soc, &ase->mac_addr);
  1029. /* Check if tail is not empty before delete*/
  1030. QDF_ASSERT(!TAILQ_EMPTY(&soc->ast_hash.bins[index]));
  1031. dp_peer_debug("ID: %u idx: %u mac_addr: " QDF_MAC_ADDR_FMT,
  1032. ase->peer_id, index, QDF_MAC_ADDR_REF(ase->mac_addr.raw));
  1033. TAILQ_FOREACH(tmpase, &soc->ast_hash.bins[index], hash_list_elem) {
  1034. if (tmpase == ase) {
  1035. found = 1;
  1036. break;
  1037. }
  1038. }
  1039. QDF_ASSERT(found);
  1040. if (found)
  1041. TAILQ_REMOVE(&soc->ast_hash.bins[index], ase, hash_list_elem);
  1042. }
  1043. struct dp_ast_entry *dp_peer_ast_hash_find_by_vdevid(struct dp_soc *soc,
  1044. uint8_t *ast_mac_addr,
  1045. uint8_t vdev_id)
  1046. {
  1047. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  1048. uint32_t index;
  1049. struct dp_ast_entry *ase;
  1050. qdf_mem_copy(&local_mac_addr_aligned.raw[0],
  1051. ast_mac_addr, QDF_MAC_ADDR_SIZE);
  1052. mac_addr = &local_mac_addr_aligned;
  1053. index = dp_peer_ast_hash_index(soc, mac_addr);
  1054. TAILQ_FOREACH(ase, &soc->ast_hash.bins[index], hash_list_elem) {
  1055. if ((vdev_id == ase->vdev_id) &&
  1056. !dp_peer_find_mac_addr_cmp(mac_addr, &ase->mac_addr)) {
  1057. return ase;
  1058. }
  1059. }
  1060. return NULL;
  1061. }
  1062. struct dp_ast_entry *dp_peer_ast_hash_find_by_pdevid(struct dp_soc *soc,
  1063. uint8_t *ast_mac_addr,
  1064. uint8_t pdev_id)
  1065. {
  1066. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  1067. uint32_t index;
  1068. struct dp_ast_entry *ase;
  1069. qdf_mem_copy(&local_mac_addr_aligned.raw[0],
  1070. ast_mac_addr, QDF_MAC_ADDR_SIZE);
  1071. mac_addr = &local_mac_addr_aligned;
  1072. index = dp_peer_ast_hash_index(soc, mac_addr);
  1073. TAILQ_FOREACH(ase, &soc->ast_hash.bins[index], hash_list_elem) {
  1074. if ((pdev_id == ase->pdev_id) &&
  1075. !dp_peer_find_mac_addr_cmp(mac_addr, &ase->mac_addr)) {
  1076. return ase;
  1077. }
  1078. }
  1079. return NULL;
  1080. }
  1081. struct dp_ast_entry *dp_peer_ast_hash_find_soc(struct dp_soc *soc,
  1082. uint8_t *ast_mac_addr)
  1083. {
  1084. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  1085. unsigned index;
  1086. struct dp_ast_entry *ase;
  1087. if (!soc->ast_hash.bins)
  1088. return NULL;
  1089. qdf_mem_copy(&local_mac_addr_aligned.raw[0],
  1090. ast_mac_addr, QDF_MAC_ADDR_SIZE);
  1091. mac_addr = &local_mac_addr_aligned;
  1092. index = dp_peer_ast_hash_index(soc, mac_addr);
  1093. TAILQ_FOREACH(ase, &soc->ast_hash.bins[index], hash_list_elem) {
  1094. if (dp_peer_find_mac_addr_cmp(mac_addr, &ase->mac_addr) == 0) {
  1095. return ase;
  1096. }
  1097. }
  1098. return NULL;
  1099. }
  1100. struct dp_ast_entry *dp_peer_ast_hash_find_soc_by_type(
  1101. struct dp_soc *soc,
  1102. uint8_t *ast_mac_addr,
  1103. enum cdp_txrx_ast_entry_type type)
  1104. {
  1105. union dp_align_mac_addr local_mac_addr_aligned, *mac_addr;
  1106. unsigned index;
  1107. struct dp_ast_entry *ase;
  1108. if (!soc->ast_hash.bins)
  1109. return NULL;
  1110. qdf_mem_copy(&local_mac_addr_aligned.raw[0],
  1111. ast_mac_addr, QDF_MAC_ADDR_SIZE);
  1112. mac_addr = &local_mac_addr_aligned;
  1113. index = dp_peer_ast_hash_index(soc, mac_addr);
  1114. TAILQ_FOREACH(ase, &soc->ast_hash.bins[index], hash_list_elem) {
  1115. if (dp_peer_find_mac_addr_cmp(mac_addr, &ase->mac_addr) == 0 &&
  1116. ase->type == type) {
  1117. return ase;
  1118. }
  1119. }
  1120. return NULL;
  1121. }
  1122. /**
  1123. * dp_peer_map_ipa_evt() - Send peer map event to IPA
  1124. * @soc: SoC handle
  1125. * @peer: peer to which ast node belongs
  1126. * @ast_entry: AST entry
  1127. * @mac_addr: MAC address of ast node
  1128. *
  1129. * Return: None
  1130. */
  1131. #if defined(IPA_OFFLOAD) && defined(QCA_IPA_LL_TX_FLOW_CONTROL)
  1132. static inline
  1133. void dp_peer_map_ipa_evt(struct dp_soc *soc, struct dp_peer *peer,
  1134. struct dp_ast_entry *ast_entry, uint8_t *mac_addr)
  1135. {
  1136. if (ast_entry || (peer->vdev && peer->vdev->proxysta_vdev)) {
  1137. if (soc->cdp_soc.ol_ops->peer_map_event) {
  1138. soc->cdp_soc.ol_ops->peer_map_event(
  1139. soc->ctrl_psoc, ast_entry->peer_id,
  1140. ast_entry->ast_idx, ast_entry->vdev_id,
  1141. mac_addr, ast_entry->type, ast_entry->ast_hash_value);
  1142. }
  1143. } else {
  1144. dp_peer_info("%pK: AST entry not found", soc);
  1145. }
  1146. }
  1147. /**
  1148. * dp_peer_unmap_ipa_evt() - Send peer unmap event to IPA
  1149. * @soc: SoC handle
  1150. * @peer_id: Peerid
  1151. * @vdev_id: Vdev id
  1152. * @mac_addr: Peer mac address
  1153. *
  1154. * Return: None
  1155. */
  1156. static inline
  1157. void dp_peer_unmap_ipa_evt(struct dp_soc *soc, uint16_t peer_id,
  1158. uint8_t vdev_id, uint8_t *mac_addr)
  1159. {
  1160. if (soc->cdp_soc.ol_ops->peer_unmap_event) {
  1161. soc->cdp_soc.ol_ops->peer_unmap_event(soc->ctrl_psoc,
  1162. peer_id, vdev_id,
  1163. mac_addr);
  1164. }
  1165. }
  1166. #else
  1167. static inline
  1168. void dp_peer_unmap_ipa_evt(struct dp_soc *soc, uint16_t peer_id,
  1169. uint8_t vdev_id, uint8_t *mac_addr)
  1170. {
  1171. }
  1172. static inline
  1173. void dp_peer_map_ipa_evt(struct dp_soc *soc, struct dp_peer *peer,
  1174. struct dp_ast_entry *ast_entry, uint8_t *mac_addr)
  1175. {
  1176. }
  1177. #endif
  1178. QDF_STATUS dp_peer_host_add_map_ast(struct dp_soc *soc, uint16_t peer_id,
  1179. uint8_t *mac_addr, uint16_t hw_peer_id,
  1180. uint8_t vdev_id, uint16_t ast_hash,
  1181. uint8_t is_wds)
  1182. {
  1183. struct dp_vdev *vdev;
  1184. struct dp_ast_entry *ast_entry;
  1185. enum cdp_txrx_ast_entry_type type;
  1186. struct dp_peer *peer;
  1187. struct dp_peer *old_peer;
  1188. QDF_STATUS status = QDF_STATUS_SUCCESS;
  1189. if (is_wds)
  1190. type = CDP_TXRX_AST_TYPE_WDS;
  1191. else
  1192. type = CDP_TXRX_AST_TYPE_STATIC;
  1193. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_HTT);
  1194. if (!peer) {
  1195. dp_peer_info("Peer not found soc:%pK: peer_id %d, peer_mac " QDF_MAC_ADDR_FMT ", vdev_id %d",
  1196. soc, peer_id,
  1197. QDF_MAC_ADDR_REF(mac_addr), vdev_id);
  1198. return QDF_STATUS_E_INVAL;
  1199. }
  1200. if (!is_wds && IS_MLO_DP_MLD_PEER(peer))
  1201. type = CDP_TXRX_AST_TYPE_MLD;
  1202. vdev = peer->vdev;
  1203. if (!vdev) {
  1204. dp_peer_err("%pK: Peers vdev is NULL", soc);
  1205. status = QDF_STATUS_E_INVAL;
  1206. goto fail;
  1207. }
  1208. if (!dp_peer_state_cmp(peer, DP_PEER_STATE_ACTIVE)) {
  1209. if (type != CDP_TXRX_AST_TYPE_STATIC &&
  1210. type != CDP_TXRX_AST_TYPE_MLD &&
  1211. type != CDP_TXRX_AST_TYPE_SELF) {
  1212. status = QDF_STATUS_E_BUSY;
  1213. goto fail;
  1214. }
  1215. }
  1216. dp_peer_debug("%pK: vdev: %u ast_entry->type: %d peer_mac: " QDF_MAC_ADDR_FMT " peer: %pK mac " QDF_MAC_ADDR_FMT,
  1217. soc, vdev->vdev_id, type,
  1218. QDF_MAC_ADDR_REF(peer->mac_addr.raw), peer,
  1219. QDF_MAC_ADDR_REF(mac_addr));
  1220. /*
  1221. * In MLO scenario, there is possibility for same mac address
  1222. * on both link mac address and MLD mac address.
  1223. * Duplicate AST map needs to be handled for non-mld type.
  1224. */
  1225. qdf_spin_lock_bh(&soc->ast_lock);
  1226. ast_entry = dp_peer_ast_hash_find_soc(soc, mac_addr);
  1227. if (ast_entry && type != CDP_TXRX_AST_TYPE_MLD) {
  1228. dp_peer_debug("AST present ID %d vid %d mac " QDF_MAC_ADDR_FMT,
  1229. hw_peer_id, vdev_id,
  1230. QDF_MAC_ADDR_REF(mac_addr));
  1231. old_peer = __dp_peer_get_ref_by_id(soc, ast_entry->peer_id,
  1232. DP_MOD_ID_AST);
  1233. if (!old_peer) {
  1234. dp_peer_info("Peer not found soc:%pK: peer_id %d, peer_mac " QDF_MAC_ADDR_FMT ", vdev_id %d",
  1235. soc, ast_entry->peer_id,
  1236. QDF_MAC_ADDR_REF(mac_addr), vdev_id);
  1237. qdf_spin_unlock_bh(&soc->ast_lock);
  1238. status = QDF_STATUS_E_INVAL;
  1239. goto fail;
  1240. }
  1241. dp_peer_unlink_ast_entry(soc, ast_entry, old_peer);
  1242. dp_peer_free_ast_entry(soc, ast_entry);
  1243. if (old_peer)
  1244. dp_peer_unref_delete(old_peer, DP_MOD_ID_AST);
  1245. }
  1246. ast_entry = (struct dp_ast_entry *)
  1247. qdf_mem_malloc(sizeof(struct dp_ast_entry));
  1248. if (!ast_entry) {
  1249. dp_peer_err("%pK: fail to allocate ast_entry", soc);
  1250. qdf_spin_unlock_bh(&soc->ast_lock);
  1251. QDF_ASSERT(0);
  1252. status = QDF_STATUS_E_NOMEM;
  1253. goto fail;
  1254. }
  1255. qdf_mem_copy(&ast_entry->mac_addr.raw[0], mac_addr, QDF_MAC_ADDR_SIZE);
  1256. ast_entry->pdev_id = vdev->pdev->pdev_id;
  1257. ast_entry->is_mapped = false;
  1258. ast_entry->delete_in_progress = false;
  1259. ast_entry->next_hop = 0;
  1260. ast_entry->vdev_id = vdev->vdev_id;
  1261. ast_entry->type = type;
  1262. switch (type) {
  1263. case CDP_TXRX_AST_TYPE_STATIC:
  1264. if (peer->vdev->opmode == wlan_op_mode_sta)
  1265. ast_entry->type = CDP_TXRX_AST_TYPE_STA_BSS;
  1266. break;
  1267. case CDP_TXRX_AST_TYPE_WDS:
  1268. ast_entry->next_hop = 1;
  1269. break;
  1270. case CDP_TXRX_AST_TYPE_MLD:
  1271. break;
  1272. default:
  1273. dp_peer_alert("%pK: Incorrect AST entry type", soc);
  1274. }
  1275. ast_entry->is_active = TRUE;
  1276. DP_STATS_INC(soc, ast.added, 1);
  1277. soc->num_ast_entries++;
  1278. dp_peer_ast_hash_add(soc, ast_entry);
  1279. ast_entry->ast_idx = hw_peer_id;
  1280. ast_entry->ast_hash_value = ast_hash;
  1281. ast_entry->peer_id = peer_id;
  1282. TAILQ_INSERT_TAIL(&peer->ast_entry_list, ast_entry,
  1283. ase_list_elem);
  1284. dp_peer_map_ipa_evt(soc, peer, ast_entry, mac_addr);
  1285. qdf_spin_unlock_bh(&soc->ast_lock);
  1286. fail:
  1287. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  1288. return status;
  1289. }
  1290. /**
  1291. * dp_peer_map_ast() - Map the ast entry with HW AST Index
  1292. * @soc: SoC handle
  1293. * @peer: peer to which ast node belongs
  1294. * @mac_addr: MAC address of ast node
  1295. * @hw_peer_id: HW AST Index returned by target in peer map event
  1296. * @vdev_id: vdev id for VAP to which the peer belongs to
  1297. * @ast_hash: ast hash value in HW
  1298. * @is_wds: flag to indicate peer map event for WDS ast entry
  1299. *
  1300. * Return: QDF_STATUS code
  1301. */
  1302. static inline QDF_STATUS dp_peer_map_ast(struct dp_soc *soc,
  1303. struct dp_peer *peer,
  1304. uint8_t *mac_addr,
  1305. uint16_t hw_peer_id,
  1306. uint8_t vdev_id,
  1307. uint16_t ast_hash,
  1308. uint8_t is_wds)
  1309. {
  1310. struct dp_ast_entry *ast_entry = NULL;
  1311. enum cdp_txrx_ast_entry_type peer_type = CDP_TXRX_AST_TYPE_STATIC;
  1312. void *cookie = NULL;
  1313. txrx_ast_free_cb cb = NULL;
  1314. QDF_STATUS err = QDF_STATUS_SUCCESS;
  1315. if (soc->ast_offload_support)
  1316. return QDF_STATUS_SUCCESS;
  1317. if (!peer) {
  1318. return QDF_STATUS_E_INVAL;
  1319. }
  1320. dp_peer_err("%pK: peer %pK ID %d vid %d mac " QDF_MAC_ADDR_FMT,
  1321. soc, peer, hw_peer_id, vdev_id,
  1322. QDF_MAC_ADDR_REF(mac_addr));
  1323. qdf_spin_lock_bh(&soc->ast_lock);
  1324. ast_entry = dp_peer_ast_hash_find_by_vdevid(soc, mac_addr, vdev_id);
  1325. if (is_wds) {
  1326. /*
  1327. * In certain cases like Auth attack on a repeater
  1328. * can result in the number of ast_entries falling
  1329. * in the same hash bucket to exceed the max_skid
  1330. * length supported by HW in root AP. In these cases
  1331. * the FW will return the hw_peer_id (ast_index) as
  1332. * 0xffff indicating HW could not add the entry in
  1333. * its table. Host has to delete the entry from its
  1334. * table in these cases.
  1335. */
  1336. if (hw_peer_id == HTT_INVALID_PEER) {
  1337. DP_STATS_INC(soc, ast.map_err, 1);
  1338. if (ast_entry) {
  1339. if (ast_entry->is_mapped) {
  1340. soc->ast_table[ast_entry->ast_idx] =
  1341. NULL;
  1342. }
  1343. cb = ast_entry->callback;
  1344. cookie = ast_entry->cookie;
  1345. peer_type = ast_entry->type;
  1346. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  1347. dp_peer_free_ast_entry(soc, ast_entry);
  1348. qdf_spin_unlock_bh(&soc->ast_lock);
  1349. if (cb) {
  1350. cb(soc->ctrl_psoc,
  1351. dp_soc_to_cdp_soc(soc),
  1352. cookie,
  1353. CDP_TXRX_AST_DELETED);
  1354. }
  1355. } else {
  1356. qdf_spin_unlock_bh(&soc->ast_lock);
  1357. dp_peer_alert("AST entry not found with peer %pK peer_id %u peer_mac " QDF_MAC_ADDR_FMT " mac_addr " QDF_MAC_ADDR_FMT " vdev_id %u next_hop %u",
  1358. peer, peer->peer_id,
  1359. QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  1360. QDF_MAC_ADDR_REF(mac_addr),
  1361. vdev_id, is_wds);
  1362. }
  1363. err = QDF_STATUS_E_INVAL;
  1364. dp_hmwds_ast_add_notify(peer, mac_addr,
  1365. peer_type, err, true);
  1366. return err;
  1367. }
  1368. }
  1369. if (ast_entry) {
  1370. ast_entry->ast_idx = hw_peer_id;
  1371. soc->ast_table[hw_peer_id] = ast_entry;
  1372. ast_entry->is_active = TRUE;
  1373. peer_type = ast_entry->type;
  1374. ast_entry->ast_hash_value = ast_hash;
  1375. ast_entry->is_mapped = TRUE;
  1376. qdf_assert_always(ast_entry->peer_id == HTT_INVALID_PEER);
  1377. ast_entry->peer_id = peer->peer_id;
  1378. TAILQ_INSERT_TAIL(&peer->ast_entry_list, ast_entry,
  1379. ase_list_elem);
  1380. }
  1381. if (ast_entry || (peer->vdev && peer->vdev->proxysta_vdev)) {
  1382. if (soc->cdp_soc.ol_ops->peer_map_event) {
  1383. soc->cdp_soc.ol_ops->peer_map_event(
  1384. soc->ctrl_psoc, peer->peer_id,
  1385. hw_peer_id, vdev_id,
  1386. mac_addr, peer_type, ast_hash);
  1387. }
  1388. } else {
  1389. dp_peer_err("%pK: AST entry not found", soc);
  1390. err = QDF_STATUS_E_NOENT;
  1391. }
  1392. qdf_spin_unlock_bh(&soc->ast_lock);
  1393. dp_hmwds_ast_add_notify(peer, mac_addr,
  1394. peer_type, err, true);
  1395. return err;
  1396. }
  1397. void dp_peer_free_hmwds_cb(struct cdp_ctrl_objmgr_psoc *ctrl_psoc,
  1398. struct cdp_soc *dp_soc,
  1399. void *cookie,
  1400. enum cdp_ast_free_status status)
  1401. {
  1402. struct dp_ast_free_cb_params *param =
  1403. (struct dp_ast_free_cb_params *)cookie;
  1404. struct dp_soc *soc = (struct dp_soc *)dp_soc;
  1405. struct dp_peer *peer = NULL;
  1406. QDF_STATUS err = QDF_STATUS_SUCCESS;
  1407. if (status != CDP_TXRX_AST_DELETED) {
  1408. qdf_mem_free(cookie);
  1409. return;
  1410. }
  1411. peer = dp_peer_find_hash_find(soc, &param->peer_mac_addr.raw[0],
  1412. 0, param->vdev_id, DP_MOD_ID_AST);
  1413. if (peer) {
  1414. err = dp_peer_add_ast(soc, peer,
  1415. &param->mac_addr.raw[0],
  1416. param->type,
  1417. param->flags);
  1418. dp_hmwds_ast_add_notify(peer, &param->mac_addr.raw[0],
  1419. param->type, err, false);
  1420. dp_peer_unref_delete(peer, DP_MOD_ID_AST);
  1421. }
  1422. qdf_mem_free(cookie);
  1423. }
  1424. QDF_STATUS dp_peer_add_ast(struct dp_soc *soc,
  1425. struct dp_peer *peer,
  1426. uint8_t *mac_addr,
  1427. enum cdp_txrx_ast_entry_type type,
  1428. uint32_t flags)
  1429. {
  1430. struct dp_ast_entry *ast_entry = NULL;
  1431. struct dp_vdev *vdev = NULL;
  1432. struct dp_pdev *pdev = NULL;
  1433. txrx_ast_free_cb cb = NULL;
  1434. void *cookie = NULL;
  1435. struct dp_peer *vap_bss_peer = NULL;
  1436. bool is_peer_found = false;
  1437. int status = 0;
  1438. if (soc->ast_offload_support)
  1439. return QDF_STATUS_E_INVAL;
  1440. vdev = peer->vdev;
  1441. if (!vdev) {
  1442. dp_peer_err("%pK: Peers vdev is NULL", soc);
  1443. QDF_ASSERT(0);
  1444. return QDF_STATUS_E_INVAL;
  1445. }
  1446. pdev = vdev->pdev;
  1447. is_peer_found = dp_peer_exist_on_pdev(soc, mac_addr, 0, pdev);
  1448. qdf_spin_lock_bh(&soc->ast_lock);
  1449. if (!dp_peer_state_cmp(peer, DP_PEER_STATE_ACTIVE)) {
  1450. if ((type != CDP_TXRX_AST_TYPE_STATIC) &&
  1451. (type != CDP_TXRX_AST_TYPE_SELF)) {
  1452. qdf_spin_unlock_bh(&soc->ast_lock);
  1453. return QDF_STATUS_E_BUSY;
  1454. }
  1455. }
  1456. dp_peer_debug("%pK: pdevid: %u vdev: %u ast_entry->type: %d flags: 0x%x peer_mac: " QDF_MAC_ADDR_FMT " peer: %pK mac " QDF_MAC_ADDR_FMT,
  1457. soc, pdev->pdev_id, vdev->vdev_id, type, flags,
  1458. QDF_MAC_ADDR_REF(peer->mac_addr.raw), peer,
  1459. QDF_MAC_ADDR_REF(mac_addr));
  1460. /* fw supports only 2 times the max_peers ast entries */
  1461. if (soc->num_ast_entries >=
  1462. wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)) {
  1463. qdf_spin_unlock_bh(&soc->ast_lock);
  1464. dp_peer_err("%pK: Max ast entries reached", soc);
  1465. return QDF_STATUS_E_RESOURCES;
  1466. }
  1467. /* If AST entry already exists , just return from here
  1468. * ast entry with same mac address can exist on different radios
  1469. * if ast_override support is enabled use search by pdev in this
  1470. * case
  1471. */
  1472. if (soc->ast_override_support) {
  1473. ast_entry = dp_peer_ast_hash_find_by_pdevid(soc, mac_addr,
  1474. pdev->pdev_id);
  1475. if (ast_entry) {
  1476. qdf_spin_unlock_bh(&soc->ast_lock);
  1477. return QDF_STATUS_E_ALREADY;
  1478. }
  1479. if (is_peer_found) {
  1480. /* During WDS to static roaming, peer is added
  1481. * to the list before static AST entry create.
  1482. * So, allow AST entry for STATIC type
  1483. * even if peer is present
  1484. */
  1485. if (type != CDP_TXRX_AST_TYPE_STATIC) {
  1486. qdf_spin_unlock_bh(&soc->ast_lock);
  1487. return QDF_STATUS_E_ALREADY;
  1488. }
  1489. }
  1490. } else {
  1491. /* For HWMWDS_SEC entries can be added for same mac address
  1492. * do not check for existing entry
  1493. */
  1494. if (type == CDP_TXRX_AST_TYPE_WDS_HM_SEC)
  1495. goto add_ast_entry;
  1496. ast_entry = dp_peer_ast_hash_find_soc(soc, mac_addr);
  1497. if (ast_entry) {
  1498. if ((ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM) &&
  1499. !ast_entry->delete_in_progress) {
  1500. qdf_spin_unlock_bh(&soc->ast_lock);
  1501. return QDF_STATUS_E_ALREADY;
  1502. }
  1503. /* Add for HMWDS entry we cannot be ignored if there
  1504. * is AST entry with same mac address
  1505. *
  1506. * if ast entry exists with the requested mac address
  1507. * send a delete command and register callback which
  1508. * can take care of adding HMWDS ast entry on delete
  1509. * confirmation from target
  1510. */
  1511. if (type == CDP_TXRX_AST_TYPE_WDS_HM) {
  1512. struct dp_ast_free_cb_params *param = NULL;
  1513. if (ast_entry->type ==
  1514. CDP_TXRX_AST_TYPE_WDS_HM_SEC)
  1515. goto add_ast_entry;
  1516. /* save existing callback */
  1517. if (ast_entry->callback) {
  1518. cb = ast_entry->callback;
  1519. cookie = ast_entry->cookie;
  1520. }
  1521. param = qdf_mem_malloc(sizeof(*param));
  1522. if (!param) {
  1523. QDF_TRACE(QDF_MODULE_ID_TXRX,
  1524. QDF_TRACE_LEVEL_ERROR,
  1525. "Allocation failed");
  1526. qdf_spin_unlock_bh(&soc->ast_lock);
  1527. return QDF_STATUS_E_NOMEM;
  1528. }
  1529. qdf_mem_copy(&param->mac_addr.raw[0], mac_addr,
  1530. QDF_MAC_ADDR_SIZE);
  1531. qdf_mem_copy(&param->peer_mac_addr.raw[0],
  1532. &peer->mac_addr.raw[0],
  1533. QDF_MAC_ADDR_SIZE);
  1534. param->type = type;
  1535. param->flags = flags;
  1536. param->vdev_id = vdev->vdev_id;
  1537. ast_entry->callback = dp_peer_free_hmwds_cb;
  1538. ast_entry->pdev_id = vdev->pdev->pdev_id;
  1539. ast_entry->type = type;
  1540. ast_entry->cookie = (void *)param;
  1541. if (!ast_entry->delete_in_progress)
  1542. dp_peer_del_ast(soc, ast_entry);
  1543. qdf_spin_unlock_bh(&soc->ast_lock);
  1544. /* Call the saved callback*/
  1545. if (cb) {
  1546. cb(soc->ctrl_psoc,
  1547. dp_soc_to_cdp_soc(soc),
  1548. cookie,
  1549. CDP_TXRX_AST_DELETE_IN_PROGRESS);
  1550. }
  1551. return QDF_STATUS_E_AGAIN;
  1552. }
  1553. qdf_spin_unlock_bh(&soc->ast_lock);
  1554. return QDF_STATUS_E_ALREADY;
  1555. }
  1556. }
  1557. add_ast_entry:
  1558. ast_entry = (struct dp_ast_entry *)
  1559. qdf_mem_malloc(sizeof(struct dp_ast_entry));
  1560. if (!ast_entry) {
  1561. qdf_spin_unlock_bh(&soc->ast_lock);
  1562. dp_peer_err("%pK: fail to allocate ast_entry", soc);
  1563. QDF_ASSERT(0);
  1564. return QDF_STATUS_E_NOMEM;
  1565. }
  1566. qdf_mem_copy(&ast_entry->mac_addr.raw[0], mac_addr, QDF_MAC_ADDR_SIZE);
  1567. ast_entry->pdev_id = vdev->pdev->pdev_id;
  1568. ast_entry->is_mapped = false;
  1569. ast_entry->delete_in_progress = false;
  1570. ast_entry->peer_id = HTT_INVALID_PEER;
  1571. ast_entry->next_hop = 0;
  1572. ast_entry->vdev_id = vdev->vdev_id;
  1573. switch (type) {
  1574. case CDP_TXRX_AST_TYPE_STATIC:
  1575. peer->self_ast_entry = ast_entry;
  1576. ast_entry->type = CDP_TXRX_AST_TYPE_STATIC;
  1577. if (peer->vdev->opmode == wlan_op_mode_sta)
  1578. ast_entry->type = CDP_TXRX_AST_TYPE_STA_BSS;
  1579. break;
  1580. case CDP_TXRX_AST_TYPE_SELF:
  1581. peer->self_ast_entry = ast_entry;
  1582. ast_entry->type = CDP_TXRX_AST_TYPE_SELF;
  1583. break;
  1584. case CDP_TXRX_AST_TYPE_WDS:
  1585. ast_entry->next_hop = 1;
  1586. ast_entry->type = CDP_TXRX_AST_TYPE_WDS;
  1587. break;
  1588. case CDP_TXRX_AST_TYPE_WDS_HM:
  1589. ast_entry->next_hop = 1;
  1590. ast_entry->type = CDP_TXRX_AST_TYPE_WDS_HM;
  1591. break;
  1592. case CDP_TXRX_AST_TYPE_WDS_HM_SEC:
  1593. ast_entry->next_hop = 1;
  1594. ast_entry->type = CDP_TXRX_AST_TYPE_WDS_HM_SEC;
  1595. ast_entry->peer_id = peer->peer_id;
  1596. TAILQ_INSERT_TAIL(&peer->ast_entry_list, ast_entry,
  1597. ase_list_elem);
  1598. break;
  1599. case CDP_TXRX_AST_TYPE_DA:
  1600. vap_bss_peer = dp_vdev_bss_peer_ref_n_get(soc, vdev,
  1601. DP_MOD_ID_AST);
  1602. if (!vap_bss_peer) {
  1603. qdf_spin_unlock_bh(&soc->ast_lock);
  1604. qdf_mem_free(ast_entry);
  1605. return QDF_STATUS_E_FAILURE;
  1606. }
  1607. peer = vap_bss_peer;
  1608. ast_entry->next_hop = 1;
  1609. ast_entry->type = CDP_TXRX_AST_TYPE_DA;
  1610. break;
  1611. default:
  1612. dp_peer_err("%pK: Incorrect AST entry type", soc);
  1613. }
  1614. ast_entry->is_active = TRUE;
  1615. DP_STATS_INC(soc, ast.added, 1);
  1616. soc->num_ast_entries++;
  1617. dp_peer_ast_hash_add(soc, ast_entry);
  1618. if ((ast_entry->type != CDP_TXRX_AST_TYPE_STATIC) &&
  1619. (ast_entry->type != CDP_TXRX_AST_TYPE_SELF) &&
  1620. (ast_entry->type != CDP_TXRX_AST_TYPE_STA_BSS) &&
  1621. (ast_entry->type != CDP_TXRX_AST_TYPE_WDS_HM_SEC))
  1622. status = dp_add_wds_entry_wrapper(soc,
  1623. peer,
  1624. mac_addr,
  1625. flags,
  1626. ast_entry->type);
  1627. if (vap_bss_peer)
  1628. dp_peer_unref_delete(vap_bss_peer, DP_MOD_ID_AST);
  1629. qdf_spin_unlock_bh(&soc->ast_lock);
  1630. return qdf_status_from_os_return(status);
  1631. }
  1632. qdf_export_symbol(dp_peer_add_ast);
  1633. void dp_peer_free_ast_entry(struct dp_soc *soc,
  1634. struct dp_ast_entry *ast_entry)
  1635. {
  1636. /*
  1637. * NOTE: Ensure that call to this API is done
  1638. * after soc->ast_lock is taken
  1639. */
  1640. dp_peer_debug("type: %d ID: %u vid: %u mac_addr: " QDF_MAC_ADDR_FMT,
  1641. ast_entry->type, ast_entry->peer_id, ast_entry->vdev_id,
  1642. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw));
  1643. ast_entry->callback = NULL;
  1644. ast_entry->cookie = NULL;
  1645. DP_STATS_INC(soc, ast.deleted, 1);
  1646. dp_peer_ast_hash_remove(soc, ast_entry);
  1647. dp_peer_ast_cleanup(soc, ast_entry);
  1648. qdf_mem_free(ast_entry);
  1649. soc->num_ast_entries--;
  1650. }
  1651. void dp_peer_unlink_ast_entry(struct dp_soc *soc,
  1652. struct dp_ast_entry *ast_entry,
  1653. struct dp_peer *peer)
  1654. {
  1655. if (!peer) {
  1656. dp_info_rl("NULL peer");
  1657. return;
  1658. }
  1659. if (ast_entry->peer_id == HTT_INVALID_PEER) {
  1660. dp_info_rl("Invalid peer id in AST entry mac addr:"QDF_MAC_ADDR_FMT" type:%d",
  1661. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw),
  1662. ast_entry->type);
  1663. return;
  1664. }
  1665. /*
  1666. * NOTE: Ensure that call to this API is done
  1667. * after soc->ast_lock is taken
  1668. */
  1669. qdf_assert_always(ast_entry->peer_id == peer->peer_id);
  1670. TAILQ_REMOVE(&peer->ast_entry_list, ast_entry, ase_list_elem);
  1671. if (ast_entry == peer->self_ast_entry)
  1672. peer->self_ast_entry = NULL;
  1673. /*
  1674. * release the reference only if it is mapped
  1675. * to ast_table
  1676. */
  1677. if (ast_entry->is_mapped)
  1678. soc->ast_table[ast_entry->ast_idx] = NULL;
  1679. ast_entry->peer_id = HTT_INVALID_PEER;
  1680. }
  1681. void dp_peer_del_ast(struct dp_soc *soc, struct dp_ast_entry *ast_entry)
  1682. {
  1683. struct dp_peer *peer = NULL;
  1684. if (soc->ast_offload_support)
  1685. return;
  1686. if (!ast_entry) {
  1687. dp_info_rl("NULL AST entry");
  1688. return;
  1689. }
  1690. if (ast_entry->delete_in_progress) {
  1691. dp_info_rl("AST entry deletion in progress mac addr:"QDF_MAC_ADDR_FMT" type:%d",
  1692. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw),
  1693. ast_entry->type);
  1694. return;
  1695. }
  1696. dp_peer_debug("call by %ps: ID: %u vid: %u mac_addr: " QDF_MAC_ADDR_FMT,
  1697. (void *)_RET_IP_, ast_entry->peer_id, ast_entry->vdev_id,
  1698. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw));
  1699. ast_entry->delete_in_progress = true;
  1700. /* In teardown del ast is called after setting logical delete state
  1701. * use __dp_peer_get_ref_by_id to get the reference irrespective of
  1702. * state
  1703. */
  1704. peer = __dp_peer_get_ref_by_id(soc, ast_entry->peer_id,
  1705. DP_MOD_ID_AST);
  1706. dp_peer_ast_send_wds_del(soc, ast_entry, peer);
  1707. /* Remove SELF and STATIC entries in teardown itself */
  1708. if (!ast_entry->next_hop)
  1709. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  1710. if (ast_entry->is_mapped)
  1711. soc->ast_table[ast_entry->ast_idx] = NULL;
  1712. /* if peer map v2 is enabled we are not freeing ast entry
  1713. * here and it is supposed to be freed in unmap event (after
  1714. * we receive delete confirmation from target)
  1715. *
  1716. * if peer_id is invalid we did not get the peer map event
  1717. * for the peer free ast entry from here only in this case
  1718. */
  1719. if (dp_peer_ast_free_in_unmap_supported(soc, ast_entry))
  1720. goto end;
  1721. /* for WDS secondary entry ast_entry->next_hop would be set so
  1722. * unlinking has to be done explicitly here.
  1723. * As this entry is not a mapped entry unmap notification from
  1724. * FW will not come. Hence unlinkling is done right here.
  1725. */
  1726. if (ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM_SEC)
  1727. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  1728. dp_peer_free_ast_entry(soc, ast_entry);
  1729. end:
  1730. if (peer)
  1731. dp_peer_unref_delete(peer, DP_MOD_ID_AST);
  1732. }
  1733. int dp_peer_update_ast(struct dp_soc *soc, struct dp_peer *peer,
  1734. struct dp_ast_entry *ast_entry, uint32_t flags)
  1735. {
  1736. int ret = -1;
  1737. struct dp_peer *old_peer;
  1738. if (soc->ast_offload_support)
  1739. return QDF_STATUS_E_INVAL;
  1740. dp_peer_debug("%pK: ast_entry->type: %d pdevid: %u vdevid: %u flags: 0x%x mac_addr: " QDF_MAC_ADDR_FMT " peer_mac: " QDF_MAC_ADDR_FMT "\n",
  1741. soc, ast_entry->type, peer->vdev->pdev->pdev_id,
  1742. peer->vdev->vdev_id, flags,
  1743. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw),
  1744. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  1745. /* Do not send AST update in below cases
  1746. * 1) Ast entry delete has already triggered
  1747. * 2) Peer delete is already triggered
  1748. * 3) We did not get the HTT map for create event
  1749. */
  1750. if (ast_entry->delete_in_progress ||
  1751. !dp_peer_state_cmp(peer, DP_PEER_STATE_ACTIVE) ||
  1752. !ast_entry->is_mapped)
  1753. return ret;
  1754. if ((ast_entry->type == CDP_TXRX_AST_TYPE_STATIC) ||
  1755. (ast_entry->type == CDP_TXRX_AST_TYPE_SELF) ||
  1756. (ast_entry->type == CDP_TXRX_AST_TYPE_STA_BSS) ||
  1757. (ast_entry->type == CDP_TXRX_AST_TYPE_WDS_HM_SEC))
  1758. return 0;
  1759. /*
  1760. * Avoids flood of WMI update messages sent to FW for same peer.
  1761. */
  1762. if (qdf_unlikely(ast_entry->peer_id == peer->peer_id) &&
  1763. (ast_entry->type == CDP_TXRX_AST_TYPE_WDS) &&
  1764. (ast_entry->vdev_id == peer->vdev->vdev_id) &&
  1765. (ast_entry->is_active))
  1766. return 0;
  1767. old_peer = dp_peer_get_ref_by_id(soc, ast_entry->peer_id,
  1768. DP_MOD_ID_AST);
  1769. if (!old_peer)
  1770. return 0;
  1771. TAILQ_REMOVE(&old_peer->ast_entry_list, ast_entry, ase_list_elem);
  1772. dp_peer_unref_delete(old_peer, DP_MOD_ID_AST);
  1773. ast_entry->peer_id = peer->peer_id;
  1774. ast_entry->type = CDP_TXRX_AST_TYPE_WDS;
  1775. ast_entry->pdev_id = peer->vdev->pdev->pdev_id;
  1776. ast_entry->vdev_id = peer->vdev->vdev_id;
  1777. ast_entry->is_active = TRUE;
  1778. TAILQ_INSERT_TAIL(&peer->ast_entry_list, ast_entry, ase_list_elem);
  1779. ret = dp_update_wds_entry_wrapper(soc,
  1780. peer,
  1781. ast_entry->mac_addr.raw,
  1782. flags);
  1783. return ret;
  1784. }
  1785. uint8_t dp_peer_ast_get_pdev_id(struct dp_soc *soc,
  1786. struct dp_ast_entry *ast_entry)
  1787. {
  1788. return ast_entry->pdev_id;
  1789. }
  1790. uint8_t dp_peer_ast_get_next_hop(struct dp_soc *soc,
  1791. struct dp_ast_entry *ast_entry)
  1792. {
  1793. return ast_entry->next_hop;
  1794. }
  1795. void dp_peer_ast_set_type(struct dp_soc *soc,
  1796. struct dp_ast_entry *ast_entry,
  1797. enum cdp_txrx_ast_entry_type type)
  1798. {
  1799. ast_entry->type = type;
  1800. }
  1801. void dp_peer_ast_send_wds_del(struct dp_soc *soc,
  1802. struct dp_ast_entry *ast_entry,
  1803. struct dp_peer *peer)
  1804. {
  1805. bool delete_in_fw = false;
  1806. QDF_TRACE(QDF_MODULE_ID_DP, QDF_TRACE_LEVEL_TRACE,
  1807. "%s: ast_entry->type: %d pdevid: %u vdev: %u mac_addr: "QDF_MAC_ADDR_FMT" next_hop: %u peer_id: %uM\n",
  1808. __func__, ast_entry->type, ast_entry->pdev_id,
  1809. ast_entry->vdev_id,
  1810. QDF_MAC_ADDR_REF(ast_entry->mac_addr.raw),
  1811. ast_entry->next_hop, ast_entry->peer_id);
  1812. /*
  1813. * If peer state is logical delete, the peer is about to get
  1814. * teared down with a peer delete command to firmware,
  1815. * which will cleanup all the wds ast entries.
  1816. * So, no need to send explicit wds ast delete to firmware.
  1817. */
  1818. if (ast_entry->next_hop) {
  1819. if (peer && dp_peer_state_cmp(peer,
  1820. DP_PEER_STATE_LOGICAL_DELETE))
  1821. delete_in_fw = false;
  1822. else
  1823. delete_in_fw = true;
  1824. dp_del_wds_entry_wrapper(soc,
  1825. ast_entry->vdev_id,
  1826. ast_entry->mac_addr.raw,
  1827. ast_entry->type,
  1828. delete_in_fw);
  1829. }
  1830. }
  1831. #else
  1832. void dp_peer_free_ast_entry(struct dp_soc *soc,
  1833. struct dp_ast_entry *ast_entry)
  1834. {
  1835. }
  1836. void dp_peer_unlink_ast_entry(struct dp_soc *soc,
  1837. struct dp_ast_entry *ast_entry,
  1838. struct dp_peer *peer)
  1839. {
  1840. }
  1841. void dp_peer_ast_hash_remove(struct dp_soc *soc,
  1842. struct dp_ast_entry *ase)
  1843. {
  1844. }
  1845. struct dp_ast_entry *dp_peer_ast_hash_find_by_vdevid(struct dp_soc *soc,
  1846. uint8_t *ast_mac_addr,
  1847. uint8_t vdev_id)
  1848. {
  1849. return NULL;
  1850. }
  1851. QDF_STATUS dp_peer_add_ast(struct dp_soc *soc,
  1852. struct dp_peer *peer,
  1853. uint8_t *mac_addr,
  1854. enum cdp_txrx_ast_entry_type type,
  1855. uint32_t flags)
  1856. {
  1857. return QDF_STATUS_E_FAILURE;
  1858. }
  1859. void dp_peer_del_ast(struct dp_soc *soc, struct dp_ast_entry *ast_entry)
  1860. {
  1861. }
  1862. int dp_peer_update_ast(struct dp_soc *soc, struct dp_peer *peer,
  1863. struct dp_ast_entry *ast_entry, uint32_t flags)
  1864. {
  1865. return 1;
  1866. }
  1867. struct dp_ast_entry *dp_peer_ast_hash_find_soc(struct dp_soc *soc,
  1868. uint8_t *ast_mac_addr)
  1869. {
  1870. return NULL;
  1871. }
  1872. struct dp_ast_entry *dp_peer_ast_hash_find_soc_by_type(
  1873. struct dp_soc *soc,
  1874. uint8_t *ast_mac_addr,
  1875. enum cdp_txrx_ast_entry_type type)
  1876. {
  1877. return NULL;
  1878. }
  1879. static inline
  1880. QDF_STATUS dp_peer_host_add_map_ast(struct dp_soc *soc, uint16_t peer_id,
  1881. uint8_t *mac_addr, uint16_t hw_peer_id,
  1882. uint8_t vdev_id, uint16_t ast_hash,
  1883. uint8_t is_wds)
  1884. {
  1885. return QDF_STATUS_SUCCESS;
  1886. }
  1887. struct dp_ast_entry *dp_peer_ast_hash_find_by_pdevid(struct dp_soc *soc,
  1888. uint8_t *ast_mac_addr,
  1889. uint8_t pdev_id)
  1890. {
  1891. return NULL;
  1892. }
  1893. QDF_STATUS dp_peer_ast_hash_attach(struct dp_soc *soc)
  1894. {
  1895. return QDF_STATUS_SUCCESS;
  1896. }
  1897. static inline QDF_STATUS dp_peer_map_ast(struct dp_soc *soc,
  1898. struct dp_peer *peer,
  1899. uint8_t *mac_addr,
  1900. uint16_t hw_peer_id,
  1901. uint8_t vdev_id,
  1902. uint16_t ast_hash,
  1903. uint8_t is_wds)
  1904. {
  1905. return QDF_STATUS_SUCCESS;
  1906. }
  1907. void dp_peer_ast_hash_detach(struct dp_soc *soc)
  1908. {
  1909. }
  1910. void dp_peer_ast_set_type(struct dp_soc *soc,
  1911. struct dp_ast_entry *ast_entry,
  1912. enum cdp_txrx_ast_entry_type type)
  1913. {
  1914. }
  1915. uint8_t dp_peer_ast_get_pdev_id(struct dp_soc *soc,
  1916. struct dp_ast_entry *ast_entry)
  1917. {
  1918. return 0xff;
  1919. }
  1920. uint8_t dp_peer_ast_get_next_hop(struct dp_soc *soc,
  1921. struct dp_ast_entry *ast_entry)
  1922. {
  1923. return 0xff;
  1924. }
  1925. void dp_peer_ast_send_wds_del(struct dp_soc *soc,
  1926. struct dp_ast_entry *ast_entry,
  1927. struct dp_peer *peer)
  1928. {
  1929. }
  1930. static inline
  1931. void dp_peer_unmap_ipa_evt(struct dp_soc *soc, uint16_t peer_id,
  1932. uint8_t vdev_id, uint8_t *mac_addr)
  1933. {
  1934. }
  1935. #endif
  1936. #ifdef WLAN_FEATURE_MULTI_AST_DEL
  1937. void dp_peer_ast_send_multi_wds_del(
  1938. struct dp_soc *soc, uint8_t vdev_id,
  1939. struct peer_del_multi_wds_entries *wds_list)
  1940. {
  1941. struct cdp_soc_t *cdp_soc = &soc->cdp_soc;
  1942. if (cdp_soc && cdp_soc->ol_ops &&
  1943. cdp_soc->ol_ops->peer_del_multi_wds_entry)
  1944. cdp_soc->ol_ops->peer_del_multi_wds_entry(soc->ctrl_psoc,
  1945. vdev_id, wds_list);
  1946. }
  1947. #endif
  1948. #ifdef FEATURE_WDS
  1949. /**
  1950. * dp_peer_ast_free_wds_entries() - Free wds ast entries associated with peer
  1951. * @soc: soc handle
  1952. * @peer: peer handle
  1953. *
  1954. * Free all the wds ast entries associated with peer
  1955. *
  1956. * Return: Number of wds ast entries freed
  1957. */
  1958. static uint32_t dp_peer_ast_free_wds_entries(struct dp_soc *soc,
  1959. struct dp_peer *peer)
  1960. {
  1961. TAILQ_HEAD(, dp_ast_entry) ast_local_list = {0};
  1962. struct dp_ast_entry *ast_entry, *temp_ast_entry;
  1963. uint32_t num_ast = 0;
  1964. TAILQ_INIT(&ast_local_list);
  1965. qdf_spin_lock_bh(&soc->ast_lock);
  1966. DP_PEER_ITERATE_ASE_LIST(peer, ast_entry, temp_ast_entry) {
  1967. if (ast_entry->next_hop)
  1968. num_ast++;
  1969. if (ast_entry->is_mapped)
  1970. soc->ast_table[ast_entry->ast_idx] = NULL;
  1971. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  1972. DP_STATS_INC(soc, ast.deleted, 1);
  1973. dp_peer_ast_hash_remove(soc, ast_entry);
  1974. TAILQ_INSERT_TAIL(&ast_local_list, ast_entry,
  1975. ase_list_elem);
  1976. soc->num_ast_entries--;
  1977. }
  1978. qdf_spin_unlock_bh(&soc->ast_lock);
  1979. TAILQ_FOREACH_SAFE(ast_entry, &ast_local_list, ase_list_elem,
  1980. temp_ast_entry) {
  1981. if (ast_entry->callback)
  1982. ast_entry->callback(soc->ctrl_psoc,
  1983. dp_soc_to_cdp_soc(soc),
  1984. ast_entry->cookie,
  1985. CDP_TXRX_AST_DELETED);
  1986. qdf_mem_free(ast_entry);
  1987. }
  1988. return num_ast;
  1989. }
  1990. /**
  1991. * dp_peer_clean_wds_entries() - Clean wds ast entries and compare
  1992. * @soc: soc handle
  1993. * @peer: peer handle
  1994. * @free_wds_count: number of wds entries freed by FW with peer delete
  1995. *
  1996. * Free all the wds ast entries associated with peer and compare with
  1997. * the value received from firmware
  1998. *
  1999. * Return: Number of wds ast entries freed
  2000. */
  2001. static void
  2002. dp_peer_clean_wds_entries(struct dp_soc *soc, struct dp_peer *peer,
  2003. uint32_t free_wds_count)
  2004. {
  2005. uint32_t wds_deleted = 0;
  2006. if (soc->ast_offload_support && !soc->host_ast_db_enable)
  2007. return;
  2008. wds_deleted = dp_peer_ast_free_wds_entries(soc, peer);
  2009. if ((DP_PEER_WDS_COUNT_INVALID != free_wds_count) &&
  2010. (free_wds_count != wds_deleted)) {
  2011. DP_STATS_INC(soc, ast.ast_mismatch, 1);
  2012. 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",
  2013. peer, peer->mac_addr.raw, free_wds_count,
  2014. wds_deleted);
  2015. }
  2016. }
  2017. #else
  2018. static void
  2019. dp_peer_clean_wds_entries(struct dp_soc *soc, struct dp_peer *peer,
  2020. uint32_t free_wds_count)
  2021. {
  2022. struct dp_ast_entry *ast_entry, *temp_ast_entry;
  2023. qdf_spin_lock_bh(&soc->ast_lock);
  2024. DP_PEER_ITERATE_ASE_LIST(peer, ast_entry, temp_ast_entry) {
  2025. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  2026. if (ast_entry->is_mapped)
  2027. soc->ast_table[ast_entry->ast_idx] = NULL;
  2028. dp_peer_free_ast_entry(soc, ast_entry);
  2029. }
  2030. peer->self_ast_entry = NULL;
  2031. qdf_spin_unlock_bh(&soc->ast_lock);
  2032. }
  2033. #endif
  2034. /**
  2035. * dp_peer_ast_free_entry_by_mac() - find ast entry by MAC address and delete
  2036. * @soc: soc handle
  2037. * @peer: peer handle
  2038. * @vdev_id: vdev_id
  2039. * @mac_addr: mac address of the AST entry to searc and delete
  2040. *
  2041. * find the ast entry from the peer list using the mac address and free
  2042. * the entry.
  2043. *
  2044. * Return: SUCCESS or NOENT
  2045. */
  2046. static int dp_peer_ast_free_entry_by_mac(struct dp_soc *soc,
  2047. struct dp_peer *peer,
  2048. uint8_t vdev_id,
  2049. uint8_t *mac_addr)
  2050. {
  2051. struct dp_ast_entry *ast_entry;
  2052. void *cookie = NULL;
  2053. txrx_ast_free_cb cb = NULL;
  2054. /*
  2055. * release the reference only if it is mapped
  2056. * to ast_table
  2057. */
  2058. qdf_spin_lock_bh(&soc->ast_lock);
  2059. ast_entry = dp_peer_ast_hash_find_by_vdevid(soc, mac_addr, vdev_id);
  2060. if (!ast_entry) {
  2061. qdf_spin_unlock_bh(&soc->ast_lock);
  2062. return QDF_STATUS_E_NOENT;
  2063. } else if (ast_entry->is_mapped) {
  2064. soc->ast_table[ast_entry->ast_idx] = NULL;
  2065. }
  2066. cb = ast_entry->callback;
  2067. cookie = ast_entry->cookie;
  2068. dp_peer_unlink_ast_entry(soc, ast_entry, peer);
  2069. dp_peer_free_ast_entry(soc, ast_entry);
  2070. qdf_spin_unlock_bh(&soc->ast_lock);
  2071. if (cb) {
  2072. cb(soc->ctrl_psoc,
  2073. dp_soc_to_cdp_soc(soc),
  2074. cookie,
  2075. CDP_TXRX_AST_DELETED);
  2076. }
  2077. return QDF_STATUS_SUCCESS;
  2078. }
  2079. void dp_peer_find_hash_erase(struct dp_soc *soc)
  2080. {
  2081. int i;
  2082. /*
  2083. * Not really necessary to take peer_ref_mutex lock - by this point,
  2084. * it's known that the soc is no longer in use.
  2085. */
  2086. for (i = 0; i <= soc->peer_hash.mask; i++) {
  2087. if (!TAILQ_EMPTY(&soc->peer_hash.bins[i])) {
  2088. struct dp_peer *peer, *peer_next;
  2089. /*
  2090. * TAILQ_FOREACH_SAFE must be used here to avoid any
  2091. * memory access violation after peer is freed
  2092. */
  2093. TAILQ_FOREACH_SAFE(peer, &soc->peer_hash.bins[i],
  2094. hash_list_elem, peer_next) {
  2095. /*
  2096. * Don't remove the peer from the hash table -
  2097. * that would modify the list we are currently
  2098. * traversing, and it's not necessary anyway.
  2099. */
  2100. /*
  2101. * Artificially adjust the peer's ref count to
  2102. * 1, so it will get deleted by
  2103. * dp_peer_unref_delete.
  2104. */
  2105. /* set to zero */
  2106. qdf_atomic_init(&peer->ref_cnt);
  2107. for (i = 0; i < DP_MOD_ID_MAX; i++)
  2108. qdf_atomic_init(&peer->mod_refs[i]);
  2109. /* incr to one */
  2110. qdf_atomic_inc(&peer->ref_cnt);
  2111. qdf_atomic_inc(&peer->mod_refs
  2112. [DP_MOD_ID_CONFIG]);
  2113. dp_peer_unref_delete(peer,
  2114. DP_MOD_ID_CONFIG);
  2115. }
  2116. }
  2117. }
  2118. }
  2119. void dp_peer_ast_table_detach(struct dp_soc *soc)
  2120. {
  2121. if (soc->ast_table) {
  2122. qdf_mem_free(soc->ast_table);
  2123. soc->ast_table = NULL;
  2124. }
  2125. }
  2126. void dp_peer_find_map_detach(struct dp_soc *soc)
  2127. {
  2128. struct dp_peer *peer = NULL;
  2129. uint32_t i = 0;
  2130. if (soc->peer_id_to_obj_map) {
  2131. for (i = 0; i < soc->max_peer_id; i++) {
  2132. peer = soc->peer_id_to_obj_map[i];
  2133. if (peer)
  2134. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  2135. }
  2136. qdf_mem_free(soc->peer_id_to_obj_map);
  2137. soc->peer_id_to_obj_map = NULL;
  2138. qdf_spinlock_destroy(&soc->peer_map_lock);
  2139. }
  2140. }
  2141. #ifndef AST_OFFLOAD_ENABLE
  2142. QDF_STATUS dp_peer_find_attach(struct dp_soc *soc)
  2143. {
  2144. QDF_STATUS status;
  2145. status = dp_peer_find_map_attach(soc);
  2146. if (!QDF_IS_STATUS_SUCCESS(status))
  2147. return status;
  2148. status = dp_peer_find_hash_attach(soc);
  2149. if (!QDF_IS_STATUS_SUCCESS(status))
  2150. goto map_detach;
  2151. status = dp_peer_ast_table_attach(soc);
  2152. if (!QDF_IS_STATUS_SUCCESS(status))
  2153. goto hash_detach;
  2154. status = dp_peer_ast_hash_attach(soc);
  2155. if (!QDF_IS_STATUS_SUCCESS(status))
  2156. goto ast_table_detach;
  2157. status = dp_peer_mec_hash_attach(soc);
  2158. if (QDF_IS_STATUS_SUCCESS(status)) {
  2159. dp_soc_wds_attach(soc);
  2160. return status;
  2161. }
  2162. dp_peer_ast_hash_detach(soc);
  2163. ast_table_detach:
  2164. dp_peer_ast_table_detach(soc);
  2165. hash_detach:
  2166. dp_peer_find_hash_detach(soc);
  2167. map_detach:
  2168. dp_peer_find_map_detach(soc);
  2169. return status;
  2170. }
  2171. #else
  2172. QDF_STATUS dp_peer_find_attach(struct dp_soc *soc)
  2173. {
  2174. QDF_STATUS status;
  2175. status = dp_peer_find_map_attach(soc);
  2176. if (!QDF_IS_STATUS_SUCCESS(status))
  2177. return status;
  2178. status = dp_peer_find_hash_attach(soc);
  2179. if (!QDF_IS_STATUS_SUCCESS(status))
  2180. goto map_detach;
  2181. return status;
  2182. map_detach:
  2183. dp_peer_find_map_detach(soc);
  2184. return status;
  2185. }
  2186. #endif
  2187. #ifdef REO_SHARED_QREF_TABLE_EN
  2188. void dp_peer_rx_reo_shared_qaddr_delete(struct dp_soc *soc,
  2189. struct dp_peer *peer)
  2190. {
  2191. uint8_t tid;
  2192. uint16_t peer_id;
  2193. uint32_t max_list_size;
  2194. max_list_size = soc->wlan_cfg_ctx->qref_control_size;
  2195. peer_id = peer->peer_id;
  2196. if (peer_id > soc->max_peer_id)
  2197. return;
  2198. if (IS_MLO_DP_LINK_PEER(peer))
  2199. return;
  2200. if (max_list_size) {
  2201. unsigned long curr_ts = qdf_get_system_timestamp();
  2202. struct dp_peer *primary_peer = peer;
  2203. uint16_t chip_id = 0xFFFF;
  2204. uint32_t qref_index;
  2205. qref_index = soc->shared_qaddr_del_idx;
  2206. soc->list_shared_qaddr_del[qref_index].peer_id =
  2207. primary_peer->peer_id;
  2208. soc->list_shared_qaddr_del[qref_index].ts_qaddr_del = curr_ts;
  2209. soc->list_shared_qaddr_del[qref_index].chip_id = chip_id;
  2210. soc->shared_qaddr_del_idx++;
  2211. if (soc->shared_qaddr_del_idx == max_list_size)
  2212. soc->shared_qaddr_del_idx = 0;
  2213. }
  2214. if (hal_reo_shared_qaddr_is_enable(soc->hal_soc)) {
  2215. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  2216. hal_reo_shared_qaddr_write(soc->hal_soc,
  2217. peer_id, tid, 0);
  2218. }
  2219. }
  2220. }
  2221. #endif
  2222. /**
  2223. * dp_peer_find_add_id() - map peer_id with peer
  2224. * @soc: soc handle
  2225. * @peer_mac_addr: peer mac address
  2226. * @peer_id: peer id to be mapped
  2227. * @hw_peer_id: HW ast index
  2228. * @vdev_id: vdev_id
  2229. * @peer_type: peer type (link or MLD)
  2230. *
  2231. * return: peer in success
  2232. * NULL in failure
  2233. */
  2234. static inline struct dp_peer *dp_peer_find_add_id(struct dp_soc *soc,
  2235. uint8_t *peer_mac_addr, uint16_t peer_id, uint16_t hw_peer_id,
  2236. uint8_t vdev_id, enum cdp_peer_type peer_type)
  2237. {
  2238. struct dp_peer *peer;
  2239. struct cdp_peer_info peer_info = { 0 };
  2240. QDF_ASSERT(peer_id <= soc->max_peer_id);
  2241. /* check if there's already a peer object with this MAC address */
  2242. DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac_addr,
  2243. false, peer_type);
  2244. peer = dp_peer_hash_find_wrapper(soc, &peer_info, DP_MOD_ID_CONFIG);
  2245. dp_peer_debug("%pK: peer %pK ID %d vid %d mac " QDF_MAC_ADDR_FMT,
  2246. soc, peer, peer_id, vdev_id,
  2247. QDF_MAC_ADDR_REF(peer_mac_addr));
  2248. if (peer) {
  2249. /* peer's ref count was already incremented by
  2250. * peer_find_hash_find
  2251. */
  2252. dp_peer_info("%pK: ref_cnt: %d", soc,
  2253. qdf_atomic_read(&peer->ref_cnt));
  2254. /*
  2255. * if peer is in logical delete CP triggered delete before map
  2256. * is received ignore this event
  2257. */
  2258. if (dp_peer_state_cmp(peer, DP_PEER_STATE_LOGICAL_DELETE)) {
  2259. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  2260. dp_alert("Peer %pK["QDF_MAC_ADDR_FMT"] logical delete state vid %d",
  2261. peer, QDF_MAC_ADDR_REF(peer_mac_addr),
  2262. vdev_id);
  2263. return NULL;
  2264. }
  2265. if (peer->peer_id == HTT_INVALID_PEER) {
  2266. if (!IS_MLO_DP_MLD_PEER(peer))
  2267. dp_monitor_peer_tid_peer_id_update(soc, peer,
  2268. peer_id);
  2269. } else {
  2270. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  2271. QDF_ASSERT(0);
  2272. return NULL;
  2273. }
  2274. dp_peer_find_id_to_obj_add(soc, peer, peer_id);
  2275. if (soc->arch_ops.dp_partner_chips_map)
  2276. soc->arch_ops.dp_partner_chips_map(soc, peer, peer_id);
  2277. dp_peer_update_state(soc, peer, DP_PEER_STATE_ACTIVE);
  2278. return peer;
  2279. }
  2280. return NULL;
  2281. }
  2282. #ifdef WLAN_FEATURE_11BE_MLO
  2283. #ifdef DP_USE_REDUCED_PEER_ID_FIELD_WIDTH
  2284. uint16_t dp_gen_ml_peer_id(struct dp_soc *soc, uint16_t peer_id)
  2285. {
  2286. return ((peer_id & soc->peer_id_mask) | (1 << soc->peer_id_shift));
  2287. }
  2288. #else
  2289. uint16_t dp_gen_ml_peer_id(struct dp_soc *soc, uint16_t peer_id)
  2290. {
  2291. return (peer_id | (1 << HTT_RX_PEER_META_DATA_V1_ML_PEER_VALID_S));
  2292. }
  2293. #endif
  2294. QDF_STATUS
  2295. dp_rx_mlo_peer_map_handler(struct dp_soc *soc, uint16_t peer_id,
  2296. uint8_t *peer_mac_addr,
  2297. struct dp_mlo_flow_override_info *mlo_flow_info,
  2298. struct dp_mlo_link_info *mlo_link_info)
  2299. {
  2300. struct dp_peer *peer = NULL;
  2301. uint16_t hw_peer_id = mlo_flow_info[0].ast_idx;
  2302. uint16_t ast_hash = mlo_flow_info[0].cache_set_num;
  2303. uint8_t vdev_id = 0;
  2304. uint8_t is_wds = 0;
  2305. int i;
  2306. uint16_t ml_peer_id = dp_gen_ml_peer_id(soc, peer_id);
  2307. enum cdp_txrx_ast_entry_type type = CDP_TXRX_AST_TYPE_STATIC;
  2308. QDF_STATUS err = QDF_STATUS_SUCCESS;
  2309. struct dp_soc *primary_soc = NULL;
  2310. dp_cfg_event_record_peer_map_unmap_evt(soc, DP_CFG_EVENT_MLO_PEER_MAP,
  2311. NULL, peer_mac_addr,
  2312. 1, peer_id, ml_peer_id, 0,
  2313. vdev_id);
  2314. dp_info("mlo_peer_map_event (soc:%pK): peer_id %d ml_peer_id %d, peer_mac "QDF_MAC_ADDR_FMT,
  2315. soc, peer_id, ml_peer_id,
  2316. QDF_MAC_ADDR_REF(peer_mac_addr));
  2317. /* Get corresponding vdev ID for the peer based
  2318. * on chip ID obtained from mlo peer_map event
  2319. */
  2320. for (i = 0; i < DP_MAX_MLO_LINKS; i++) {
  2321. if (mlo_link_info[i].peer_chip_id == dp_get_chip_id(soc)) {
  2322. vdev_id = mlo_link_info[i].vdev_id;
  2323. break;
  2324. }
  2325. }
  2326. peer = dp_peer_find_add_id(soc, peer_mac_addr, ml_peer_id,
  2327. hw_peer_id, vdev_id, CDP_MLD_PEER_TYPE);
  2328. if (peer) {
  2329. if (wlan_op_mode_sta == peer->vdev->opmode &&
  2330. qdf_mem_cmp(peer->mac_addr.raw,
  2331. peer->vdev->mld_mac_addr.raw,
  2332. QDF_MAC_ADDR_SIZE) != 0) {
  2333. dp_peer_info("%pK: STA vdev bss_peer!!!!", soc);
  2334. peer->bss_peer = 1;
  2335. if (peer->txrx_peer)
  2336. peer->txrx_peer->bss_peer = 1;
  2337. }
  2338. if (peer->vdev->opmode == wlan_op_mode_sta) {
  2339. peer->vdev->bss_ast_hash = ast_hash;
  2340. peer->vdev->bss_ast_idx = hw_peer_id;
  2341. }
  2342. /* Add ast entry incase self ast entry is
  2343. * deleted due to DP CP sync issue
  2344. *
  2345. * self_ast_entry is modified in peer create
  2346. * and peer unmap path which cannot run in
  2347. * parllel with peer map, no lock need before
  2348. * referring it
  2349. */
  2350. if (!peer->self_ast_entry) {
  2351. dp_info("Add self ast from map "QDF_MAC_ADDR_FMT,
  2352. QDF_MAC_ADDR_REF(peer_mac_addr));
  2353. dp_peer_add_ast(soc, peer,
  2354. peer_mac_addr,
  2355. type, 0);
  2356. }
  2357. /* If peer setup and hence rx_tid setup got called
  2358. * before htt peer map then Qref write to LUT did not
  2359. * happen in rx_tid setup as peer_id was invalid.
  2360. * So defer Qref write to peer map handler. Check if
  2361. * rx_tid qdesc for tid 0 is already setup and perform
  2362. * qref write to LUT for Tid 0 and 16.
  2363. *
  2364. * Peer map could be obtained on assoc link, hence
  2365. * change to primary link's soc.
  2366. */
  2367. primary_soc = peer->vdev->pdev->soc;
  2368. if (hal_reo_shared_qaddr_is_enable(primary_soc->hal_soc) &&
  2369. peer->rx_tid[0].hw_qdesc_vaddr_unaligned) {
  2370. hal_reo_shared_qaddr_write(primary_soc->hal_soc,
  2371. ml_peer_id,
  2372. 0,
  2373. peer->rx_tid[0].hw_qdesc_paddr);
  2374. hal_reo_shared_qaddr_write(primary_soc->hal_soc,
  2375. ml_peer_id,
  2376. DP_NON_QOS_TID,
  2377. peer->rx_tid[DP_NON_QOS_TID].hw_qdesc_paddr);
  2378. }
  2379. }
  2380. if (!primary_soc)
  2381. primary_soc = soc;
  2382. err = dp_peer_map_ast(soc, peer, peer_mac_addr, hw_peer_id,
  2383. vdev_id, ast_hash, is_wds);
  2384. /*
  2385. * If AST offload and host AST DB is enabled, populate AST entries on
  2386. * host based on mlo peer map event from FW
  2387. */
  2388. if (peer && soc->ast_offload_support && soc->host_ast_db_enable) {
  2389. dp_peer_host_add_map_ast(primary_soc, ml_peer_id, peer_mac_addr,
  2390. hw_peer_id, vdev_id,
  2391. ast_hash, is_wds);
  2392. }
  2393. return err;
  2394. }
  2395. #endif
  2396. #ifdef DP_RX_UDP_OVER_PEER_ROAM
  2397. void dp_rx_reset_roaming_peer(struct dp_soc *soc, uint8_t vdev_id,
  2398. uint8_t *peer_mac_addr)
  2399. {
  2400. struct dp_vdev *vdev = NULL;
  2401. vdev = dp_vdev_get_ref_by_id(soc, vdev_id, DP_MOD_ID_HTT);
  2402. if (vdev) {
  2403. if (qdf_mem_cmp(vdev->roaming_peer_mac.raw, peer_mac_addr,
  2404. QDF_MAC_ADDR_SIZE) == 0) {
  2405. vdev->roaming_peer_status =
  2406. WLAN_ROAM_PEER_AUTH_STATUS_NONE;
  2407. qdf_mem_zero(vdev->roaming_peer_mac.raw,
  2408. QDF_MAC_ADDR_SIZE);
  2409. }
  2410. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_HTT);
  2411. }
  2412. }
  2413. #endif
  2414. #ifdef WLAN_SUPPORT_PPEDS
  2415. static void
  2416. dp_tx_ppeds_cfg_astidx_cache_mapping(struct dp_soc *soc, struct dp_vdev *vdev,
  2417. bool peer_map)
  2418. {
  2419. if (soc->arch_ops.dp_tx_ppeds_cfg_astidx_cache_mapping)
  2420. soc->arch_ops.dp_tx_ppeds_cfg_astidx_cache_mapping(soc, vdev,
  2421. peer_map);
  2422. }
  2423. #else
  2424. static void
  2425. dp_tx_ppeds_cfg_astidx_cache_mapping(struct dp_soc *soc, struct dp_vdev *vdev,
  2426. bool peer_map)
  2427. {
  2428. }
  2429. #endif
  2430. QDF_STATUS
  2431. dp_rx_peer_map_handler(struct dp_soc *soc, uint16_t peer_id,
  2432. uint16_t hw_peer_id, uint8_t vdev_id,
  2433. uint8_t *peer_mac_addr, uint16_t ast_hash,
  2434. uint8_t is_wds)
  2435. {
  2436. struct dp_peer *peer = NULL;
  2437. struct dp_vdev *vdev = NULL;
  2438. enum cdp_txrx_ast_entry_type type = CDP_TXRX_AST_TYPE_STATIC;
  2439. QDF_STATUS err = QDF_STATUS_SUCCESS;
  2440. dp_cfg_event_record_peer_map_unmap_evt(soc, DP_CFG_EVENT_PEER_MAP,
  2441. NULL, peer_mac_addr, 1, peer_id,
  2442. 0, 0, vdev_id);
  2443. dp_info("peer_map_event (soc:%pK): peer_id %d, hw_peer_id %d, peer_mac "QDF_MAC_ADDR_FMT", vdev_id %d",
  2444. soc, peer_id, hw_peer_id,
  2445. QDF_MAC_ADDR_REF(peer_mac_addr), vdev_id);
  2446. /* Peer map event for WDS ast entry get the peer from
  2447. * obj map
  2448. */
  2449. if (is_wds) {
  2450. if (!soc->ast_offload_support) {
  2451. peer = dp_peer_get_ref_by_id(soc, peer_id,
  2452. DP_MOD_ID_HTT);
  2453. err = dp_peer_map_ast(soc, peer, peer_mac_addr,
  2454. hw_peer_id,
  2455. vdev_id, ast_hash, is_wds);
  2456. if (peer)
  2457. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  2458. }
  2459. } else {
  2460. /*
  2461. * It's the responsibility of the CP and FW to ensure
  2462. * that peer is created successfully. Ideally DP should
  2463. * not hit the below condition for directly associated
  2464. * peers.
  2465. */
  2466. if ((!soc->ast_offload_support) && ((hw_peer_id < 0) ||
  2467. (hw_peer_id >=
  2468. wlan_cfg_get_max_ast_idx(soc->wlan_cfg_ctx)))) {
  2469. dp_peer_err("%pK: invalid hw_peer_id: %d", soc, hw_peer_id);
  2470. qdf_assert_always(0);
  2471. }
  2472. peer = dp_peer_find_add_id(soc, peer_mac_addr, peer_id,
  2473. hw_peer_id, vdev_id,
  2474. CDP_LINK_PEER_TYPE);
  2475. if (peer) {
  2476. bool peer_map = true;
  2477. /* Updating ast_hash and ast_idx in peer level */
  2478. peer->ast_hash = ast_hash;
  2479. peer->ast_idx = hw_peer_id;
  2480. vdev = peer->vdev;
  2481. /* Only check for STA Vdev and peer is not for TDLS */
  2482. if (wlan_op_mode_sta == vdev->opmode &&
  2483. !peer->is_tdls_peer) {
  2484. if (qdf_mem_cmp(peer->mac_addr.raw,
  2485. vdev->mac_addr.raw,
  2486. QDF_MAC_ADDR_SIZE) != 0) {
  2487. dp_info("%pK: STA vdev bss_peer", soc);
  2488. peer->bss_peer = 1;
  2489. if (peer->txrx_peer)
  2490. peer->txrx_peer->bss_peer = 1;
  2491. }
  2492. dp_info("bss ast_hash 0x%x, ast_index 0x%x",
  2493. ast_hash, hw_peer_id);
  2494. vdev->bss_ast_hash = ast_hash;
  2495. vdev->bss_ast_idx = hw_peer_id;
  2496. dp_tx_ppeds_cfg_astidx_cache_mapping(soc, vdev,
  2497. peer_map);
  2498. }
  2499. /* Add ast entry incase self ast entry is
  2500. * deleted due to DP CP sync issue
  2501. *
  2502. * self_ast_entry is modified in peer create
  2503. * and peer unmap path which cannot run in
  2504. * parllel with peer map, no lock need before
  2505. * referring it
  2506. */
  2507. if (!soc->ast_offload_support &&
  2508. !peer->self_ast_entry) {
  2509. dp_info("Add self ast from map "QDF_MAC_ADDR_FMT,
  2510. QDF_MAC_ADDR_REF(peer_mac_addr));
  2511. dp_peer_add_ast(soc, peer,
  2512. peer_mac_addr,
  2513. type, 0);
  2514. }
  2515. /* If peer setup and hence rx_tid setup got called
  2516. * before htt peer map then Qref write to LUT did
  2517. * not happen in rx_tid setup as peer_id was invalid.
  2518. * So defer Qref write to peer map handler. Check if
  2519. * rx_tid qdesc for tid 0 is already setup perform qref
  2520. * write to LUT for Tid 0 and 16.
  2521. */
  2522. if (hal_reo_shared_qaddr_is_enable(soc->hal_soc) &&
  2523. peer->rx_tid[0].hw_qdesc_vaddr_unaligned &&
  2524. !IS_MLO_DP_LINK_PEER(peer)) {
  2525. add_entry_write_list(soc, peer, 0);
  2526. hal_reo_shared_qaddr_write(soc->hal_soc,
  2527. peer_id,
  2528. 0,
  2529. peer->rx_tid[0].hw_qdesc_paddr);
  2530. add_entry_write_list(soc, peer, DP_NON_QOS_TID);
  2531. hal_reo_shared_qaddr_write(soc->hal_soc,
  2532. peer_id,
  2533. DP_NON_QOS_TID,
  2534. peer->rx_tid[DP_NON_QOS_TID].hw_qdesc_paddr);
  2535. }
  2536. }
  2537. err = dp_peer_map_ast(soc, peer, peer_mac_addr, hw_peer_id,
  2538. vdev_id, ast_hash, is_wds);
  2539. }
  2540. dp_rx_reset_roaming_peer(soc, vdev_id, peer_mac_addr);
  2541. /*
  2542. * If AST offload and host AST DB is enabled, populate AST entries on
  2543. * host based on peer map event from FW
  2544. */
  2545. if (soc->ast_offload_support && soc->host_ast_db_enable) {
  2546. dp_peer_host_add_map_ast(soc, peer_id, peer_mac_addr,
  2547. hw_peer_id, vdev_id,
  2548. ast_hash, is_wds);
  2549. }
  2550. return err;
  2551. }
  2552. void
  2553. dp_rx_peer_unmap_handler(struct dp_soc *soc, uint16_t peer_id,
  2554. uint8_t vdev_id, uint8_t *mac_addr,
  2555. uint8_t is_wds, uint32_t free_wds_count)
  2556. {
  2557. struct dp_peer *peer;
  2558. struct dp_vdev *vdev = NULL;
  2559. /*
  2560. * If FW AST offload is enabled and host AST DB is enabled,
  2561. * the AST entries are created during peer map from FW.
  2562. */
  2563. if (soc->ast_offload_support && is_wds) {
  2564. if (!soc->host_ast_db_enable)
  2565. return;
  2566. }
  2567. peer = __dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_HTT);
  2568. /*
  2569. * Currently peer IDs are assigned for vdevs as well as peers.
  2570. * If the peer ID is for a vdev, then the peer pointer stored
  2571. * in peer_id_to_obj_map will be NULL.
  2572. */
  2573. if (!peer) {
  2574. dp_err("Received unmap event for invalid peer_id %u",
  2575. peer_id);
  2576. return;
  2577. }
  2578. vdev = peer->vdev;
  2579. if (peer->txrx_peer) {
  2580. struct cdp_txrx_peer_params_update params = {0};
  2581. params.vdev_id = vdev->vdev_id;
  2582. params.peer_mac = peer->mac_addr.raw;
  2583. params.chip_id = dp_get_chip_id(soc);
  2584. params.pdev_id = vdev->pdev->pdev_id;
  2585. dp_wdi_event_handler(WDI_EVENT_PEER_UNMAP, soc,
  2586. (void *)&params, peer_id,
  2587. WDI_NO_VAL, vdev->pdev->pdev_id);
  2588. }
  2589. /*
  2590. * In scenario where assoc peer soc id is different from
  2591. * primary soc id, reset the soc to point to primary psoc.
  2592. * Since map is received on primary soc, the unmap should
  2593. * also delete ast on primary soc.
  2594. */
  2595. soc = peer->vdev->pdev->soc;
  2596. /* If V2 Peer map messages are enabled AST entry has to be
  2597. * freed here
  2598. */
  2599. if (is_wds) {
  2600. if (!dp_peer_ast_free_entry_by_mac(soc, peer, vdev_id,
  2601. mac_addr)) {
  2602. dp_peer_unmap_ipa_evt(soc, peer_id, vdev_id, mac_addr);
  2603. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  2604. return;
  2605. }
  2606. 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",
  2607. peer, peer->peer_id,
  2608. QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  2609. QDF_MAC_ADDR_REF(mac_addr), vdev_id,
  2610. is_wds);
  2611. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  2612. return;
  2613. }
  2614. dp_peer_clean_wds_entries(soc, peer, free_wds_count);
  2615. dp_cfg_event_record_peer_map_unmap_evt(soc, DP_CFG_EVENT_PEER_UNMAP,
  2616. peer, mac_addr, 0, peer_id,
  2617. 0, 0, vdev_id);
  2618. dp_info("peer_unmap_event (soc:%pK) peer_id %d peer %pK",
  2619. soc, peer_id, peer);
  2620. /* Clear entries in Qref LUT */
  2621. /* TODO: Check if this is to be called from
  2622. * dp_peer_delete for MLO case if there is race between
  2623. * new peer id assignment and still not having received
  2624. * peer unmap for MLD peer with same peer id.
  2625. */
  2626. dp_peer_rx_reo_shared_qaddr_delete(soc, peer);
  2627. vdev = peer->vdev;
  2628. /* only if peer is in STA mode and not tdls peer */
  2629. if (wlan_op_mode_sta == vdev->opmode && !peer->is_tdls_peer) {
  2630. bool peer_map = false;
  2631. dp_tx_ppeds_cfg_astidx_cache_mapping(soc, vdev, peer_map);
  2632. }
  2633. dp_peer_find_id_to_obj_remove(soc, peer_id);
  2634. if (soc->arch_ops.dp_partner_chips_unmap)
  2635. soc->arch_ops.dp_partner_chips_unmap(soc, peer_id);
  2636. peer->peer_id = HTT_INVALID_PEER;
  2637. /*
  2638. * Reset ast flow mapping table
  2639. */
  2640. if (!soc->ast_offload_support)
  2641. dp_peer_reset_flowq_map(peer);
  2642. if (soc->cdp_soc.ol_ops->peer_unmap_event) {
  2643. soc->cdp_soc.ol_ops->peer_unmap_event(soc->ctrl_psoc,
  2644. peer_id, vdev_id, mac_addr);
  2645. }
  2646. dp_update_vdev_stats_on_peer_unmap(vdev, peer);
  2647. dp_peer_update_state(soc, peer, DP_PEER_STATE_INACTIVE);
  2648. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  2649. /*
  2650. * Remove a reference to the peer.
  2651. * If there are no more references, delete the peer object.
  2652. */
  2653. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  2654. }
  2655. #if defined(WLAN_FEATURE_11BE_MLO) && defined(DP_MLO_LINK_STATS_SUPPORT)
  2656. /**
  2657. * dp_freq_to_band() - Convert frequency to band
  2658. * @freq: peer frequency
  2659. *
  2660. * Return: band for input frequency
  2661. */
  2662. static inline
  2663. enum dp_bands dp_freq_to_band(qdf_freq_t freq)
  2664. {
  2665. if (REG_IS_24GHZ_CH_FREQ(freq))
  2666. return DP_BAND_2GHZ;
  2667. else if (REG_IS_5GHZ_FREQ(freq) || REG_IS_49GHZ_FREQ(freq))
  2668. return DP_BAND_5GHZ;
  2669. else if (REG_IS_6GHZ_FREQ(freq))
  2670. return DP_BAND_6GHZ;
  2671. return DP_BAND_INVALID;
  2672. }
  2673. void dp_map_link_id_band(struct dp_peer *peer)
  2674. {
  2675. struct dp_txrx_peer *txrx_peer = NULL;
  2676. enum dp_bands band;
  2677. txrx_peer = dp_get_txrx_peer(peer);
  2678. if (txrx_peer) {
  2679. band = dp_freq_to_band(peer->freq);
  2680. txrx_peer->band[peer->link_id + 1] = band;
  2681. dp_info("Band(Freq: %u): %u mapped to Link ID: %u",
  2682. peer->freq, band, peer->link_id);
  2683. } else {
  2684. dp_info("txrx_peer NULL for peer: " QDF_MAC_ADDR_FMT,
  2685. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  2686. }
  2687. }
  2688. QDF_STATUS
  2689. dp_rx_peer_ext_evt(struct dp_soc *soc, struct dp_peer_ext_evt_info *info)
  2690. {
  2691. struct dp_peer *peer = NULL;
  2692. struct cdp_peer_info peer_info = { 0 };
  2693. QDF_ASSERT(info->peer_id <= soc->max_peer_id);
  2694. DP_PEER_INFO_PARAMS_INIT(&peer_info, info->vdev_id, info->peer_mac_addr,
  2695. false, CDP_LINK_PEER_TYPE);
  2696. peer = dp_peer_hash_find_wrapper(soc, &peer_info, DP_MOD_ID_CONFIG);
  2697. if (!peer) {
  2698. dp_err("peer NULL, id %u, MAC " QDF_MAC_ADDR_FMT ", vdev_id %u",
  2699. info->peer_id, QDF_MAC_ADDR_REF(info->peer_mac_addr),
  2700. info->vdev_id);
  2701. return QDF_STATUS_E_FAILURE;
  2702. }
  2703. peer->link_id = info->link_id;
  2704. peer->link_id_valid = info->link_id_valid;
  2705. if (peer->freq)
  2706. dp_map_link_id_band(peer);
  2707. dp_peer_unref_delete(peer, DP_MOD_ID_CONFIG);
  2708. return QDF_STATUS_SUCCESS;
  2709. }
  2710. #endif
  2711. #ifdef WLAN_FEATURE_11BE_MLO
  2712. void dp_rx_mlo_peer_unmap_handler(struct dp_soc *soc, uint16_t peer_id)
  2713. {
  2714. uint16_t ml_peer_id = dp_gen_ml_peer_id(soc, peer_id);
  2715. uint8_t mac_addr[QDF_MAC_ADDR_SIZE] = {0};
  2716. uint8_t vdev_id = DP_VDEV_ALL;
  2717. uint8_t is_wds = 0;
  2718. dp_cfg_event_record_peer_map_unmap_evt(soc, DP_CFG_EVENT_MLO_PEER_UNMAP,
  2719. NULL, mac_addr, 0, peer_id,
  2720. 0, 0, vdev_id);
  2721. dp_info("MLO peer_unmap_event (soc:%pK) peer_id %d",
  2722. soc, peer_id);
  2723. dp_rx_peer_unmap_handler(soc, ml_peer_id, vdev_id,
  2724. mac_addr, is_wds,
  2725. DP_PEER_WDS_COUNT_INVALID);
  2726. }
  2727. #endif
  2728. #ifndef AST_OFFLOAD_ENABLE
  2729. void
  2730. dp_peer_find_detach(struct dp_soc *soc)
  2731. {
  2732. dp_soc_wds_detach(soc);
  2733. dp_peer_find_map_detach(soc);
  2734. dp_peer_find_hash_detach(soc);
  2735. dp_peer_ast_hash_detach(soc);
  2736. dp_peer_ast_table_detach(soc);
  2737. dp_peer_mec_hash_detach(soc);
  2738. }
  2739. #else
  2740. void
  2741. dp_peer_find_detach(struct dp_soc *soc)
  2742. {
  2743. dp_peer_find_map_detach(soc);
  2744. dp_peer_find_hash_detach(soc);
  2745. }
  2746. #endif
  2747. void dp_peer_rx_init(struct dp_pdev *pdev, struct dp_peer *peer)
  2748. {
  2749. dp_peer_rx_tid_setup(peer);
  2750. peer->active_ba_session_cnt = 0;
  2751. peer->hw_buffer_size = 0;
  2752. peer->kill_256_sessions = 0;
  2753. /*
  2754. * Set security defaults: no PN check, no security. The target may
  2755. * send a HTT SEC_IND message to overwrite these defaults.
  2756. */
  2757. if (peer->txrx_peer)
  2758. peer->txrx_peer->security[dp_sec_ucast].sec_type =
  2759. peer->txrx_peer->security[dp_sec_mcast].sec_type =
  2760. cdp_sec_type_none;
  2761. }
  2762. void dp_peer_cleanup(struct dp_vdev *vdev, struct dp_peer *peer)
  2763. {
  2764. enum wlan_op_mode vdev_opmode;
  2765. uint8_t vdev_mac_addr[QDF_MAC_ADDR_SIZE];
  2766. struct dp_pdev *pdev = vdev->pdev;
  2767. struct dp_soc *soc = pdev->soc;
  2768. /* save vdev related member in case vdev freed */
  2769. vdev_opmode = vdev->opmode;
  2770. if (!IS_MLO_DP_MLD_PEER(peer))
  2771. dp_monitor_peer_tx_cleanup(vdev, peer);
  2772. if (vdev_opmode != wlan_op_mode_monitor)
  2773. /* cleanup the Rx reorder queues for this peer */
  2774. dp_peer_rx_cleanup(vdev, peer);
  2775. dp_peer_rx_tids_destroy(peer);
  2776. if (IS_MLO_DP_LINK_PEER(peer))
  2777. dp_link_peer_del_mld_peer(peer);
  2778. if (IS_MLO_DP_MLD_PEER(peer))
  2779. dp_mld_peer_deinit_link_peers_info(peer);
  2780. qdf_mem_copy(vdev_mac_addr, vdev->mac_addr.raw,
  2781. QDF_MAC_ADDR_SIZE);
  2782. if (soc->cdp_soc.ol_ops->peer_unref_delete)
  2783. soc->cdp_soc.ol_ops->peer_unref_delete(
  2784. soc->ctrl_psoc,
  2785. vdev->pdev->pdev_id,
  2786. peer->mac_addr.raw, vdev_mac_addr,
  2787. vdev_opmode);
  2788. }
  2789. QDF_STATUS
  2790. dp_set_key_sec_type_wifi3(struct cdp_soc_t *soc, uint8_t vdev_id,
  2791. uint8_t *peer_mac, enum cdp_sec_type sec_type,
  2792. bool is_unicast)
  2793. {
  2794. struct dp_peer *peer =
  2795. dp_peer_get_tgt_peer_hash_find((struct dp_soc *)soc,
  2796. peer_mac, 0, vdev_id,
  2797. DP_MOD_ID_CDP);
  2798. int sec_index;
  2799. if (!peer) {
  2800. dp_peer_debug("%pK: Peer is NULL!\n", soc);
  2801. return QDF_STATUS_E_FAILURE;
  2802. }
  2803. if (!peer->txrx_peer) {
  2804. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  2805. dp_peer_debug("%pK: txrx peer is NULL!\n", soc);
  2806. return QDF_STATUS_E_FAILURE;
  2807. }
  2808. dp_peer_info("%pK: key sec spec for peer %pK " QDF_MAC_ADDR_FMT ": %s key of type %d",
  2809. soc, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  2810. is_unicast ? "ucast" : "mcast", sec_type);
  2811. sec_index = is_unicast ? dp_sec_ucast : dp_sec_mcast;
  2812. peer->txrx_peer->security[sec_index].sec_type = sec_type;
  2813. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  2814. return QDF_STATUS_SUCCESS;
  2815. }
  2816. void
  2817. dp_rx_sec_ind_handler(struct dp_soc *soc, uint16_t peer_id,
  2818. enum cdp_sec_type sec_type, int is_unicast,
  2819. u_int32_t *michael_key,
  2820. u_int32_t *rx_pn)
  2821. {
  2822. struct dp_peer *peer;
  2823. struct dp_txrx_peer *txrx_peer;
  2824. int sec_index;
  2825. peer = dp_peer_get_ref_by_id(soc, peer_id, DP_MOD_ID_HTT);
  2826. if (!peer) {
  2827. dp_peer_err("Couldn't find peer from ID %d - skipping security inits",
  2828. peer_id);
  2829. return;
  2830. }
  2831. txrx_peer = dp_get_txrx_peer(peer);
  2832. if (!txrx_peer) {
  2833. dp_peer_err("Couldn't find txrx peer from ID %d - skipping security inits",
  2834. peer_id);
  2835. return;
  2836. }
  2837. dp_peer_info("%pK: sec spec for peer %pK " QDF_MAC_ADDR_FMT ": %s key of type %d",
  2838. soc, peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  2839. is_unicast ? "ucast" : "mcast", sec_type);
  2840. sec_index = is_unicast ? dp_sec_ucast : dp_sec_mcast;
  2841. peer->txrx_peer->security[sec_index].sec_type = sec_type;
  2842. #ifdef notyet /* TODO: See if this is required for defrag support */
  2843. /* michael key only valid for TKIP, but for simplicity,
  2844. * copy it anyway
  2845. */
  2846. qdf_mem_copy(
  2847. &peer->txrx_peer->security[sec_index].michael_key[0],
  2848. michael_key,
  2849. sizeof(peer->txrx_peer->security[sec_index].michael_key));
  2850. #ifdef BIG_ENDIAN_HOST
  2851. OL_IF_SWAPBO(peer->txrx_peer->security[sec_index].michael_key[0],
  2852. sizeof(peer->txrx_peer->security[sec_index].michael_key));
  2853. #endif /* BIG_ENDIAN_HOST */
  2854. #endif
  2855. #ifdef notyet /* TODO: Check if this is required for wifi3.0 */
  2856. if (sec_type != cdp_sec_type_wapi) {
  2857. qdf_mem_zero(peer->tids_last_pn_valid, _EXT_TIDS);
  2858. } else {
  2859. for (i = 0; i < DP_MAX_TIDS; i++) {
  2860. /*
  2861. * Setting PN valid bit for WAPI sec_type,
  2862. * since WAPI PN has to be started with predefined value
  2863. */
  2864. peer->tids_last_pn_valid[i] = 1;
  2865. qdf_mem_copy(
  2866. (u_int8_t *) &peer->tids_last_pn[i],
  2867. (u_int8_t *) rx_pn, sizeof(union htt_rx_pn_t));
  2868. peer->tids_last_pn[i].pn128[1] =
  2869. qdf_cpu_to_le64(peer->tids_last_pn[i].pn128[1]);
  2870. peer->tids_last_pn[i].pn128[0] =
  2871. qdf_cpu_to_le64(peer->tids_last_pn[i].pn128[0]);
  2872. }
  2873. }
  2874. #endif
  2875. /* TODO: Update HW TID queue with PN check parameters (pn type for
  2876. * all security types and last pn for WAPI) once REO command API
  2877. * is available
  2878. */
  2879. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  2880. }
  2881. #ifdef QCA_PEER_EXT_STATS
  2882. QDF_STATUS dp_peer_delay_stats_ctx_alloc(struct dp_soc *soc,
  2883. struct dp_txrx_peer *txrx_peer)
  2884. {
  2885. uint8_t tid, ctx_id;
  2886. if (!soc || !txrx_peer) {
  2887. dp_warn("Null soc%pK or peer%pK", soc, txrx_peer);
  2888. return QDF_STATUS_E_INVAL;
  2889. }
  2890. if (!wlan_cfg_is_peer_ext_stats_enabled(soc->wlan_cfg_ctx))
  2891. return QDF_STATUS_SUCCESS;
  2892. /*
  2893. * Allocate memory for peer extended stats.
  2894. */
  2895. txrx_peer->delay_stats =
  2896. qdf_mem_malloc(sizeof(struct dp_peer_delay_stats));
  2897. if (!txrx_peer->delay_stats) {
  2898. dp_err("Peer extended stats obj alloc failed!!");
  2899. return QDF_STATUS_E_NOMEM;
  2900. }
  2901. for (tid = 0; tid < CDP_MAX_DATA_TIDS; tid++) {
  2902. for (ctx_id = 0; ctx_id < CDP_MAX_TXRX_CTX; ctx_id++) {
  2903. struct cdp_delay_tx_stats *tx_delay =
  2904. &txrx_peer->delay_stats->delay_tid_stats[tid][ctx_id].tx_delay;
  2905. struct cdp_delay_rx_stats *rx_delay =
  2906. &txrx_peer->delay_stats->delay_tid_stats[tid][ctx_id].rx_delay;
  2907. dp_hist_init(&tx_delay->tx_swq_delay,
  2908. CDP_HIST_TYPE_SW_ENQEUE_DELAY);
  2909. dp_hist_init(&tx_delay->hwtx_delay,
  2910. CDP_HIST_TYPE_HW_COMP_DELAY);
  2911. dp_hist_init(&rx_delay->to_stack_delay,
  2912. CDP_HIST_TYPE_REAP_STACK);
  2913. }
  2914. }
  2915. return QDF_STATUS_SUCCESS;
  2916. }
  2917. void dp_peer_delay_stats_ctx_dealloc(struct dp_soc *soc,
  2918. struct dp_txrx_peer *txrx_peer)
  2919. {
  2920. if (!txrx_peer) {
  2921. dp_warn("peer_ext dealloc failed due to NULL peer object");
  2922. return;
  2923. }
  2924. if (!wlan_cfg_is_peer_ext_stats_enabled(soc->wlan_cfg_ctx))
  2925. return;
  2926. if (!txrx_peer->delay_stats)
  2927. return;
  2928. qdf_mem_free(txrx_peer->delay_stats);
  2929. txrx_peer->delay_stats = NULL;
  2930. }
  2931. void dp_peer_delay_stats_ctx_clr(struct dp_txrx_peer *txrx_peer)
  2932. {
  2933. if (txrx_peer->delay_stats)
  2934. qdf_mem_zero(txrx_peer->delay_stats,
  2935. sizeof(struct dp_peer_delay_stats));
  2936. }
  2937. #endif
  2938. #ifdef WLAN_PEER_JITTER
  2939. QDF_STATUS dp_peer_jitter_stats_ctx_alloc(struct dp_pdev *pdev,
  2940. struct dp_txrx_peer *txrx_peer)
  2941. {
  2942. if (!pdev || !txrx_peer) {
  2943. dp_warn("Null pdev or peer");
  2944. return QDF_STATUS_E_INVAL;
  2945. }
  2946. if (!wlan_cfg_is_peer_jitter_stats_enabled(pdev->soc->wlan_cfg_ctx))
  2947. return QDF_STATUS_SUCCESS;
  2948. if (wlan_cfg_get_dp_pdev_nss_enabled(pdev->wlan_cfg_ctx)) {
  2949. /*
  2950. * Allocate memory on per tid basis when nss is enabled
  2951. */
  2952. txrx_peer->jitter_stats =
  2953. qdf_mem_malloc(sizeof(struct cdp_peer_tid_stats)
  2954. * DP_MAX_TIDS);
  2955. } else {
  2956. /*
  2957. * Allocate memory on per tid per ring basis
  2958. */
  2959. txrx_peer->jitter_stats =
  2960. qdf_mem_malloc(sizeof(struct cdp_peer_tid_stats)
  2961. * DP_MAX_TIDS * CDP_MAX_TXRX_CTX);
  2962. }
  2963. if (!txrx_peer->jitter_stats) {
  2964. dp_warn("Jitter stats obj alloc failed!!");
  2965. return QDF_STATUS_E_NOMEM;
  2966. }
  2967. return QDF_STATUS_SUCCESS;
  2968. }
  2969. void dp_peer_jitter_stats_ctx_dealloc(struct dp_pdev *pdev,
  2970. struct dp_txrx_peer *txrx_peer)
  2971. {
  2972. if (!pdev || !txrx_peer) {
  2973. dp_warn("Null pdev or peer");
  2974. return;
  2975. }
  2976. if (!wlan_cfg_is_peer_jitter_stats_enabled(pdev->soc->wlan_cfg_ctx))
  2977. return;
  2978. if (txrx_peer->jitter_stats) {
  2979. qdf_mem_free(txrx_peer->jitter_stats);
  2980. txrx_peer->jitter_stats = NULL;
  2981. }
  2982. }
  2983. void dp_peer_jitter_stats_ctx_clr(struct dp_txrx_peer *txrx_peer)
  2984. {
  2985. struct cdp_peer_tid_stats *jitter_stats = NULL;
  2986. if (!txrx_peer) {
  2987. dp_warn("Null peer");
  2988. return;
  2989. }
  2990. if (!wlan_cfg_is_peer_jitter_stats_enabled(txrx_peer->
  2991. vdev->
  2992. pdev->soc->wlan_cfg_ctx))
  2993. return;
  2994. jitter_stats = txrx_peer->jitter_stats;
  2995. if (!jitter_stats)
  2996. return;
  2997. if (wlan_cfg_get_dp_pdev_nss_enabled(txrx_peer->
  2998. vdev->pdev->wlan_cfg_ctx))
  2999. qdf_mem_zero(jitter_stats,
  3000. sizeof(struct cdp_peer_tid_stats) *
  3001. DP_MAX_TIDS);
  3002. else
  3003. qdf_mem_zero(jitter_stats,
  3004. sizeof(struct cdp_peer_tid_stats) *
  3005. DP_MAX_TIDS * CDP_MAX_TXRX_CTX);
  3006. }
  3007. #endif
  3008. #ifdef DP_PEER_EXTENDED_API
  3009. /**
  3010. * dp_peer_set_bw() - Set bandwidth and mpdu retry count threshold for peer
  3011. * @soc: DP soc handle
  3012. * @txrx_peer: Core txrx_peer handle
  3013. * @set_bw: enum of bandwidth to be set for this peer connection
  3014. *
  3015. * Return: None
  3016. */
  3017. static void dp_peer_set_bw(struct dp_soc *soc, struct dp_txrx_peer *txrx_peer,
  3018. enum cdp_peer_bw set_bw)
  3019. {
  3020. if (!txrx_peer)
  3021. return;
  3022. txrx_peer->bw = set_bw;
  3023. switch (set_bw) {
  3024. case CDP_160_MHZ:
  3025. case CDP_320_MHZ:
  3026. txrx_peer->mpdu_retry_threshold =
  3027. soc->wlan_cfg_ctx->mpdu_retry_threshold_2;
  3028. break;
  3029. case CDP_20_MHZ:
  3030. case CDP_40_MHZ:
  3031. case CDP_80_MHZ:
  3032. default:
  3033. txrx_peer->mpdu_retry_threshold =
  3034. soc->wlan_cfg_ctx->mpdu_retry_threshold_1;
  3035. break;
  3036. }
  3037. dp_info("Peer id: %u: BW: %u, mpdu retry threshold: %u",
  3038. txrx_peer->peer_id, txrx_peer->bw,
  3039. txrx_peer->mpdu_retry_threshold);
  3040. }
  3041. #ifdef WLAN_FEATURE_11BE_MLO
  3042. QDF_STATUS dp_register_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
  3043. struct ol_txrx_desc_type *sta_desc)
  3044. {
  3045. struct dp_peer *peer;
  3046. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3047. peer = dp_peer_find_hash_find(soc, sta_desc->peer_addr.bytes,
  3048. 0, DP_VDEV_ALL, DP_MOD_ID_CDP);
  3049. if (!peer)
  3050. return QDF_STATUS_E_FAULT;
  3051. qdf_spin_lock_bh(&peer->peer_info_lock);
  3052. peer->state = OL_TXRX_PEER_STATE_CONN;
  3053. qdf_spin_unlock_bh(&peer->peer_info_lock);
  3054. dp_peer_set_bw(soc, peer->txrx_peer, sta_desc->bw);
  3055. dp_rx_flush_rx_cached(peer, false);
  3056. if (IS_MLO_DP_LINK_PEER(peer) && peer->first_link) {
  3057. dp_peer_info("register for mld peer" QDF_MAC_ADDR_FMT,
  3058. QDF_MAC_ADDR_REF(peer->mld_peer->mac_addr.raw));
  3059. qdf_spin_lock_bh(&peer->mld_peer->peer_info_lock);
  3060. peer->mld_peer->state = peer->state;
  3061. qdf_spin_unlock_bh(&peer->mld_peer->peer_info_lock);
  3062. dp_rx_flush_rx_cached(peer->mld_peer, false);
  3063. }
  3064. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3065. return QDF_STATUS_SUCCESS;
  3066. }
  3067. QDF_STATUS dp_peer_state_update(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac,
  3068. enum ol_txrx_peer_state state)
  3069. {
  3070. struct dp_peer *peer;
  3071. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3072. peer = dp_peer_find_hash_find(soc, peer_mac, 0, DP_VDEV_ALL,
  3073. DP_MOD_ID_CDP);
  3074. if (!peer) {
  3075. dp_peer_err("%pK: Failed to find peer[" QDF_MAC_ADDR_FMT "]",
  3076. soc, QDF_MAC_ADDR_REF(peer_mac));
  3077. return QDF_STATUS_E_FAILURE;
  3078. }
  3079. peer->state = state;
  3080. peer->authorize = (state == OL_TXRX_PEER_STATE_AUTH) ? 1 : 0;
  3081. if (peer->txrx_peer)
  3082. peer->txrx_peer->authorize = peer->authorize;
  3083. dp_peer_info("peer %pK MAC " QDF_MAC_ADDR_FMT " state %d",
  3084. peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  3085. peer->state);
  3086. if (IS_MLO_DP_LINK_PEER(peer) && peer->first_link) {
  3087. peer->mld_peer->state = peer->state;
  3088. peer->mld_peer->txrx_peer->authorize = peer->authorize;
  3089. dp_peer_info("mld peer %pK MAC " QDF_MAC_ADDR_FMT " state %d",
  3090. peer->mld_peer,
  3091. QDF_MAC_ADDR_REF(peer->mld_peer->mac_addr.raw),
  3092. peer->mld_peer->state);
  3093. }
  3094. /* ref_cnt is incremented inside dp_peer_find_hash_find().
  3095. * Decrement it here.
  3096. */
  3097. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3098. return QDF_STATUS_SUCCESS;
  3099. }
  3100. #else
  3101. QDF_STATUS dp_register_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
  3102. struct ol_txrx_desc_type *sta_desc)
  3103. {
  3104. struct dp_peer *peer;
  3105. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3106. peer = dp_peer_find_hash_find(soc, sta_desc->peer_addr.bytes,
  3107. 0, DP_VDEV_ALL, DP_MOD_ID_CDP);
  3108. if (!peer)
  3109. return QDF_STATUS_E_FAULT;
  3110. qdf_spin_lock_bh(&peer->peer_info_lock);
  3111. peer->state = OL_TXRX_PEER_STATE_CONN;
  3112. qdf_spin_unlock_bh(&peer->peer_info_lock);
  3113. dp_peer_set_bw(soc, peer->txrx_peer, sta_desc->bw);
  3114. dp_rx_flush_rx_cached(peer, false);
  3115. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3116. return QDF_STATUS_SUCCESS;
  3117. }
  3118. QDF_STATUS dp_peer_state_update(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac,
  3119. enum ol_txrx_peer_state state)
  3120. {
  3121. struct dp_peer *peer;
  3122. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3123. peer = dp_peer_find_hash_find(soc, peer_mac, 0, DP_VDEV_ALL,
  3124. DP_MOD_ID_CDP);
  3125. if (!peer) {
  3126. dp_peer_err("%pK: Failed to find peer for: [" QDF_MAC_ADDR_FMT "]",
  3127. soc, QDF_MAC_ADDR_REF(peer_mac));
  3128. return QDF_STATUS_E_FAILURE;
  3129. }
  3130. peer->state = state;
  3131. peer->authorize = (state == OL_TXRX_PEER_STATE_AUTH) ? 1 : 0;
  3132. if (peer->txrx_peer)
  3133. peer->txrx_peer->authorize = peer->authorize;
  3134. dp_info("peer %pK state %d", peer, peer->state);
  3135. /* ref_cnt is incremented inside dp_peer_find_hash_find().
  3136. * Decrement it here.
  3137. */
  3138. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3139. return QDF_STATUS_SUCCESS;
  3140. }
  3141. #endif
  3142. QDF_STATUS
  3143. dp_clear_peer(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
  3144. struct qdf_mac_addr peer_addr)
  3145. {
  3146. struct dp_peer *peer;
  3147. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3148. peer = dp_peer_find_hash_find(soc, peer_addr.bytes,
  3149. 0, DP_VDEV_ALL, DP_MOD_ID_CDP);
  3150. if (!peer)
  3151. return QDF_STATUS_E_FAULT;
  3152. if (!peer->valid) {
  3153. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3154. return QDF_STATUS_E_FAULT;
  3155. }
  3156. dp_clear_peer_internal(soc, peer);
  3157. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3158. return QDF_STATUS_SUCCESS;
  3159. }
  3160. QDF_STATUS dp_get_vdevid(struct cdp_soc_t *soc_hdl, uint8_t *peer_mac,
  3161. uint8_t *vdev_id)
  3162. {
  3163. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3164. struct dp_peer *peer =
  3165. dp_peer_find_hash_find(soc, peer_mac, 0, DP_VDEV_ALL,
  3166. DP_MOD_ID_CDP);
  3167. if (!peer)
  3168. return QDF_STATUS_E_FAILURE;
  3169. dp_info("peer %pK vdev %pK vdev id %d",
  3170. peer, peer->vdev, peer->vdev->vdev_id);
  3171. *vdev_id = peer->vdev->vdev_id;
  3172. /* ref_cnt is incremented inside dp_peer_find_hash_find().
  3173. * Decrement it here.
  3174. */
  3175. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3176. return QDF_STATUS_SUCCESS;
  3177. }
  3178. struct cdp_vdev *
  3179. dp_get_vdev_by_peer_addr(struct cdp_pdev *pdev_handle,
  3180. struct qdf_mac_addr peer_addr)
  3181. {
  3182. struct dp_pdev *pdev = (struct dp_pdev *)pdev_handle;
  3183. struct dp_peer *peer = NULL;
  3184. struct cdp_vdev *vdev = NULL;
  3185. if (!pdev) {
  3186. dp_peer_info("PDEV not found for peer_addr: " QDF_MAC_ADDR_FMT,
  3187. QDF_MAC_ADDR_REF(peer_addr.bytes));
  3188. return NULL;
  3189. }
  3190. peer = dp_peer_find_hash_find(pdev->soc, peer_addr.bytes, 0,
  3191. DP_VDEV_ALL, DP_MOD_ID_CDP);
  3192. if (!peer) {
  3193. QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_INFO_HIGH,
  3194. "PDEV not found for peer_addr: "QDF_MAC_ADDR_FMT,
  3195. QDF_MAC_ADDR_REF(peer_addr.bytes));
  3196. return NULL;
  3197. }
  3198. vdev = (struct cdp_vdev *)peer->vdev;
  3199. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3200. return vdev;
  3201. }
  3202. struct cdp_vdev *dp_get_vdev_for_peer(void *peer_handle)
  3203. {
  3204. struct dp_peer *peer = peer_handle;
  3205. DP_TRACE(DEBUG, "peer %pK vdev %pK", peer, peer->vdev);
  3206. return (struct cdp_vdev *)peer->vdev;
  3207. }
  3208. uint8_t *dp_peer_get_peer_mac_addr(void *peer_handle)
  3209. {
  3210. struct dp_peer *peer = peer_handle;
  3211. uint8_t *mac;
  3212. mac = peer->mac_addr.raw;
  3213. dp_info("peer %pK mac 0x%x 0x%x 0x%x 0x%x 0x%x 0x%x",
  3214. peer, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
  3215. return peer->mac_addr.raw;
  3216. }
  3217. int dp_get_peer_state(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
  3218. uint8_t *peer_mac)
  3219. {
  3220. enum ol_txrx_peer_state peer_state;
  3221. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3222. struct cdp_peer_info peer_info = { 0 };
  3223. struct dp_peer *peer;
  3224. struct dp_peer *tgt_peer;
  3225. DP_PEER_INFO_PARAMS_INIT(&peer_info, vdev_id, peer_mac,
  3226. false, CDP_WILD_PEER_TYPE);
  3227. peer = dp_peer_hash_find_wrapper(soc, &peer_info, DP_MOD_ID_CDP);
  3228. if (!peer)
  3229. return OL_TXRX_PEER_STATE_INVALID;
  3230. tgt_peer = dp_get_tgt_peer_from_peer(peer);
  3231. peer_state = tgt_peer->state;
  3232. dp_peer_debug("peer %pK tgt_peer: %pK peer MAC "
  3233. QDF_MAC_ADDR_FMT " tgt peer MAC "
  3234. QDF_MAC_ADDR_FMT " tgt peer state %d",
  3235. peer, tgt_peer, QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  3236. QDF_MAC_ADDR_REF(tgt_peer->mac_addr.raw),
  3237. tgt_peer->state);
  3238. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3239. return peer_state;
  3240. }
  3241. void dp_local_peer_id_pool_init(struct dp_pdev *pdev)
  3242. {
  3243. int i;
  3244. /* point the freelist to the first ID */
  3245. pdev->local_peer_ids.freelist = 0;
  3246. /* link each ID to the next one */
  3247. for (i = 0; i < OL_TXRX_NUM_LOCAL_PEER_IDS; i++) {
  3248. pdev->local_peer_ids.pool[i] = i + 1;
  3249. pdev->local_peer_ids.map[i] = NULL;
  3250. }
  3251. /* link the last ID to itself, to mark the end of the list */
  3252. i = OL_TXRX_NUM_LOCAL_PEER_IDS;
  3253. pdev->local_peer_ids.pool[i] = i;
  3254. qdf_spinlock_create(&pdev->local_peer_ids.lock);
  3255. dp_info("Peer pool init");
  3256. }
  3257. void dp_local_peer_id_alloc(struct dp_pdev *pdev, struct dp_peer *peer)
  3258. {
  3259. int i;
  3260. qdf_spin_lock_bh(&pdev->local_peer_ids.lock);
  3261. i = pdev->local_peer_ids.freelist;
  3262. if (pdev->local_peer_ids.pool[i] == i) {
  3263. /* the list is empty, except for the list-end marker */
  3264. peer->local_id = OL_TXRX_INVALID_LOCAL_PEER_ID;
  3265. } else {
  3266. /* take the head ID and advance the freelist */
  3267. peer->local_id = i;
  3268. pdev->local_peer_ids.freelist = pdev->local_peer_ids.pool[i];
  3269. pdev->local_peer_ids.map[i] = peer;
  3270. }
  3271. qdf_spin_unlock_bh(&pdev->local_peer_ids.lock);
  3272. dp_info("peer %pK, local id %d", peer, peer->local_id);
  3273. }
  3274. void dp_local_peer_id_free(struct dp_pdev *pdev, struct dp_peer *peer)
  3275. {
  3276. int i = peer->local_id;
  3277. if ((i == OL_TXRX_INVALID_LOCAL_PEER_ID) ||
  3278. (i >= OL_TXRX_NUM_LOCAL_PEER_IDS)) {
  3279. return;
  3280. }
  3281. /* put this ID on the head of the freelist */
  3282. qdf_spin_lock_bh(&pdev->local_peer_ids.lock);
  3283. pdev->local_peer_ids.pool[i] = pdev->local_peer_ids.freelist;
  3284. pdev->local_peer_ids.freelist = i;
  3285. pdev->local_peer_ids.map[i] = NULL;
  3286. qdf_spin_unlock_bh(&pdev->local_peer_ids.lock);
  3287. }
  3288. bool dp_find_peer_exist_on_vdev(struct cdp_soc_t *soc_hdl,
  3289. uint8_t vdev_id, uint8_t *peer_addr)
  3290. {
  3291. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3292. struct dp_peer *peer = NULL;
  3293. peer = dp_peer_find_hash_find(soc, peer_addr, 0, vdev_id,
  3294. DP_MOD_ID_CDP);
  3295. if (!peer)
  3296. return false;
  3297. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3298. return true;
  3299. }
  3300. bool dp_find_peer_exist_on_other_vdev(struct cdp_soc_t *soc_hdl,
  3301. uint8_t vdev_id, uint8_t *peer_addr,
  3302. uint16_t max_bssid)
  3303. {
  3304. int i;
  3305. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3306. struct dp_peer *peer = NULL;
  3307. for (i = 0; i < max_bssid; i++) {
  3308. /* Need to check vdevs other than the vdev_id */
  3309. if (vdev_id == i)
  3310. continue;
  3311. peer = dp_peer_find_hash_find(soc, peer_addr, 0, i,
  3312. DP_MOD_ID_CDP);
  3313. if (peer) {
  3314. dp_err("Duplicate peer "QDF_MAC_ADDR_FMT" already exist on vdev %d",
  3315. QDF_MAC_ADDR_REF(peer_addr), i);
  3316. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3317. return true;
  3318. }
  3319. }
  3320. return false;
  3321. }
  3322. void dp_set_peer_as_tdls_peer(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
  3323. uint8_t *peer_mac, bool val)
  3324. {
  3325. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3326. struct dp_peer *peer = NULL;
  3327. peer = dp_peer_find_hash_find(soc, peer_mac, 0, vdev_id,
  3328. DP_MOD_ID_CDP);
  3329. if (!peer) {
  3330. dp_err("Failed to find peer for:" QDF_MAC_ADDR_FMT,
  3331. QDF_MAC_ADDR_REF(peer_mac));
  3332. return;
  3333. }
  3334. dp_info("Set tdls flag %d for peer:" QDF_MAC_ADDR_FMT,
  3335. val, QDF_MAC_ADDR_REF(peer_mac));
  3336. peer->is_tdls_peer = val;
  3337. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3338. }
  3339. #endif
  3340. bool dp_find_peer_exist(struct cdp_soc_t *soc_hdl, uint8_t pdev_id,
  3341. uint8_t *peer_addr)
  3342. {
  3343. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3344. struct dp_peer *peer = NULL;
  3345. peer = dp_peer_find_hash_find(soc, peer_addr, 0, DP_VDEV_ALL,
  3346. DP_MOD_ID_CDP);
  3347. if (peer) {
  3348. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3349. return true;
  3350. }
  3351. return false;
  3352. }
  3353. QDF_STATUS
  3354. dp_set_michael_key(struct cdp_soc_t *soc,
  3355. uint8_t vdev_id,
  3356. uint8_t *peer_mac,
  3357. bool is_unicast, uint32_t *key)
  3358. {
  3359. uint8_t sec_index = is_unicast ? 1 : 0;
  3360. struct dp_peer *peer =
  3361. dp_peer_get_tgt_peer_hash_find((struct dp_soc *)soc,
  3362. peer_mac, 0, vdev_id,
  3363. DP_MOD_ID_CDP);
  3364. if (!peer) {
  3365. dp_peer_err("%pK: peer not found ", soc);
  3366. return QDF_STATUS_E_FAILURE;
  3367. }
  3368. qdf_mem_copy(&peer->txrx_peer->security[sec_index].michael_key[0],
  3369. key, IEEE80211_WEP_MICLEN);
  3370. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3371. return QDF_STATUS_SUCCESS;
  3372. }
  3373. struct dp_peer *dp_vdev_bss_peer_ref_n_get(struct dp_soc *soc,
  3374. struct dp_vdev *vdev,
  3375. enum dp_mod_id mod_id)
  3376. {
  3377. struct dp_peer *peer = NULL;
  3378. qdf_spin_lock_bh(&vdev->peer_list_lock);
  3379. TAILQ_FOREACH(peer, &vdev->peer_list, peer_list_elem) {
  3380. if (peer->bss_peer)
  3381. break;
  3382. }
  3383. if (!peer) {
  3384. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  3385. return NULL;
  3386. }
  3387. if (dp_peer_get_ref(soc, peer, mod_id) == QDF_STATUS_SUCCESS) {
  3388. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  3389. return peer;
  3390. }
  3391. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  3392. return peer;
  3393. }
  3394. struct dp_peer *dp_sta_vdev_self_peer_ref_n_get(struct dp_soc *soc,
  3395. struct dp_vdev *vdev,
  3396. enum dp_mod_id mod_id)
  3397. {
  3398. struct dp_peer *peer;
  3399. if (vdev->opmode != wlan_op_mode_sta)
  3400. return NULL;
  3401. qdf_spin_lock_bh(&vdev->peer_list_lock);
  3402. TAILQ_FOREACH(peer, &vdev->peer_list, peer_list_elem) {
  3403. if (peer->sta_self_peer)
  3404. break;
  3405. }
  3406. if (!peer) {
  3407. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  3408. return NULL;
  3409. }
  3410. if (dp_peer_get_ref(soc, peer, mod_id) == QDF_STATUS_SUCCESS) {
  3411. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  3412. return peer;
  3413. }
  3414. qdf_spin_unlock_bh(&vdev->peer_list_lock);
  3415. return peer;
  3416. }
  3417. void dp_peer_flush_frags(struct cdp_soc_t *soc_hdl, uint8_t vdev_id,
  3418. uint8_t *peer_mac)
  3419. {
  3420. struct dp_soc *soc = cdp_soc_t_to_dp_soc(soc_hdl);
  3421. struct dp_peer *peer = dp_peer_get_tgt_peer_hash_find(soc, peer_mac, 0,
  3422. vdev_id,
  3423. DP_MOD_ID_CDP);
  3424. struct dp_txrx_peer *txrx_peer;
  3425. uint8_t tid;
  3426. struct dp_rx_tid_defrag *defrag_rx_tid;
  3427. if (!peer)
  3428. return;
  3429. if (!peer->txrx_peer)
  3430. goto fail;
  3431. dp_info("Flushing fragments for peer " QDF_MAC_ADDR_FMT,
  3432. QDF_MAC_ADDR_REF(peer->mac_addr.raw));
  3433. txrx_peer = peer->txrx_peer;
  3434. for (tid = 0; tid < DP_MAX_TIDS; tid++) {
  3435. defrag_rx_tid = &txrx_peer->rx_tid[tid];
  3436. qdf_spin_lock_bh(&defrag_rx_tid->defrag_tid_lock);
  3437. dp_rx_defrag_waitlist_remove(txrx_peer, tid);
  3438. dp_rx_reorder_flush_frag(txrx_peer, tid);
  3439. qdf_spin_unlock_bh(&defrag_rx_tid->defrag_tid_lock);
  3440. }
  3441. fail:
  3442. dp_peer_unref_delete(peer, DP_MOD_ID_CDP);
  3443. }
  3444. bool dp_peer_find_by_id_valid(struct dp_soc *soc, uint16_t peer_id)
  3445. {
  3446. struct dp_peer *peer = dp_peer_get_ref_by_id(soc, peer_id,
  3447. DP_MOD_ID_HTT);
  3448. if (peer) {
  3449. /*
  3450. * Decrement the peer ref which is taken as part of
  3451. * dp_peer_get_ref_by_id if PEER_LOCK_REF_PROTECT is enabled
  3452. */
  3453. dp_peer_unref_delete(peer, DP_MOD_ID_HTT);
  3454. return true;
  3455. }
  3456. return false;
  3457. }
  3458. qdf_export_symbol(dp_peer_find_by_id_valid);
  3459. #ifdef QCA_MULTIPASS_SUPPORT
  3460. void dp_peer_multipass_list_remove(struct dp_peer *peer)
  3461. {
  3462. struct dp_vdev *vdev = peer->vdev;
  3463. struct dp_txrx_peer *tpeer = NULL;
  3464. bool found = 0;
  3465. qdf_spin_lock_bh(&vdev->mpass_peer_mutex);
  3466. TAILQ_FOREACH(tpeer, &vdev->mpass_peer_list, mpass_peer_list_elem) {
  3467. if (tpeer == peer->txrx_peer) {
  3468. found = 1;
  3469. TAILQ_REMOVE(&vdev->mpass_peer_list, peer->txrx_peer,
  3470. mpass_peer_list_elem);
  3471. break;
  3472. }
  3473. }
  3474. qdf_spin_unlock_bh(&vdev->mpass_peer_mutex);
  3475. if (found)
  3476. dp_peer_unref_delete(peer, DP_MOD_ID_TX_MULTIPASS);
  3477. }
  3478. /**
  3479. * dp_peer_multipass_list_add() - add to new multipass list
  3480. * @soc: soc handle
  3481. * @peer_mac: mac address
  3482. * @vdev_id: vdev id for peer
  3483. * @vlan_id: vlan_id
  3484. *
  3485. * return: void
  3486. */
  3487. static void dp_peer_multipass_list_add(struct dp_soc *soc, uint8_t *peer_mac,
  3488. uint8_t vdev_id, uint16_t vlan_id)
  3489. {
  3490. struct dp_peer *peer =
  3491. dp_peer_get_tgt_peer_hash_find(soc, peer_mac, 0,
  3492. vdev_id,
  3493. DP_MOD_ID_TX_MULTIPASS);
  3494. if (qdf_unlikely(!peer)) {
  3495. qdf_err("NULL peer");
  3496. return;
  3497. }
  3498. if (qdf_unlikely(!peer->txrx_peer))
  3499. goto fail;
  3500. /* If peer already exists in vdev multipass list, do not add it.
  3501. * This may happen if key install comes twice or re-key
  3502. * happens for a peer.
  3503. */
  3504. if (peer->txrx_peer->vlan_id) {
  3505. dp_debug("peer already added to vdev multipass list"
  3506. "MAC: "QDF_MAC_ADDR_FMT" vlan: %d ",
  3507. QDF_MAC_ADDR_REF(peer->mac_addr.raw),
  3508. peer->txrx_peer->vlan_id);
  3509. goto fail;
  3510. }
  3511. /*
  3512. * Ref_cnt is incremented inside dp_peer_find_hash_find().
  3513. * Decrement it when element is deleted from the list.
  3514. */
  3515. peer->txrx_peer->vlan_id = vlan_id;
  3516. qdf_spin_lock_bh(&peer->txrx_peer->vdev->mpass_peer_mutex);
  3517. TAILQ_INSERT_HEAD(&peer->txrx_peer->vdev->mpass_peer_list,
  3518. peer->txrx_peer,
  3519. mpass_peer_list_elem);
  3520. qdf_spin_unlock_bh(&peer->txrx_peer->vdev->mpass_peer_mutex);
  3521. return;
  3522. fail:
  3523. dp_peer_unref_delete(peer, DP_MOD_ID_TX_MULTIPASS);
  3524. }
  3525. void dp_peer_set_vlan_id(struct cdp_soc_t *cdp_soc,
  3526. uint8_t vdev_id, uint8_t *peer_mac,
  3527. uint16_t vlan_id)
  3528. {
  3529. struct dp_soc *soc = (struct dp_soc *)cdp_soc;
  3530. struct dp_vdev *vdev =
  3531. dp_vdev_get_ref_by_id((struct dp_soc *)soc, vdev_id,
  3532. DP_MOD_ID_TX_MULTIPASS);
  3533. dp_info("vdev_id %d, vdev %pK, multipass_en %d, peer_mac " QDF_MAC_ADDR_FMT " vlan %d",
  3534. vdev_id, vdev, vdev ? vdev->multipass_en : 0,
  3535. QDF_MAC_ADDR_REF(peer_mac), vlan_id);
  3536. if (vdev && vdev->multipass_en) {
  3537. dp_peer_multipass_list_add(soc, peer_mac, vdev_id, vlan_id);
  3538. dp_vdev_unref_delete(soc, vdev, DP_MOD_ID_TX_MULTIPASS);
  3539. }
  3540. }
  3541. #endif /* QCA_MULTIPASS_SUPPORT */