dp_peer.c 103 KB

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