dp_peer.c 105 KB

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