dp_peer.c 116 KB

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