dp_peer.c 127 KB

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