mlme.c 105 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472347334743475347634773478347934803481348234833484348534863487348834893490349134923493349434953496349734983499350035013502350335043505350635073508350935103511351235133514351535163517351835193520352135223523352435253526352735283529353035313532353335343535353635373538353935403541354235433544354535463547354835493550355135523553355435553556355735583559356035613562356335643565356635673568356935703571357235733574357535763577357835793580358135823583358435853586358735883589359035913592359335943595359635973598359936003601360236033604360536063607360836093610361136123613361436153616361736183619362036213622362336243625362636273628362936303631363236333634363536363637363836393640364136423643364436453646364736483649365036513652365336543655365636573658365936603661366236633664366536663667366836693670367136723673367436753676367736783679368036813682368336843685368636873688368936903691369236933694369536963697369836993700370137023703370437053706370737083709371037113712371337143715371637173718371937203721372237233724372537263727372837293730373137323733373437353736373737383739374037413742374337443745374637473748374937503751375237533754375537563757375837593760376137623763376437653766376737683769377037713772377337743775377637773778377937803781378237833784378537863787378837893790379137923793379437953796379737983799380038013802380338043805380638073808380938103811381238133814
  1. /*
  2. * BSS client mode implementation
  3. * Copyright 2003-2008, Jouni Malinen <j@w1.fi>
  4. * Copyright 2004, Instant802 Networks, Inc.
  5. * Copyright 2005, Devicescape Software, Inc.
  6. * Copyright 2006-2007 Jiri Benc <jbenc@suse.cz>
  7. * Copyright 2007, Michael Wu <flamingice@sourmilk.net>
  8. *
  9. * This program is free software; you can redistribute it and/or modify
  10. * it under the terms of the GNU General Public License version 2 as
  11. * published by the Free Software Foundation.
  12. */
  13. #include <linux/delay.h>
  14. #include <linux/if_ether.h>
  15. #include <linux/skbuff.h>
  16. #include <linux/if_arp.h>
  17. #include <linux/etherdevice.h>
  18. #include <linux/moduleparam.h>
  19. #include <linux/rtnetlink.h>
  20. #include <linux/pm_qos.h>
  21. #include <linux/crc32.h>
  22. #include <linux/slab.h>
  23. #include <linux/export.h>
  24. #include <net/mac80211.h>
  25. #include <asm/unaligned.h>
  26. #include "ieee80211_i.h"
  27. #include "driver-ops.h"
  28. #include "rate.h"
  29. #include "led.h"
  30. #define IEEE80211_AUTH_TIMEOUT (HZ / 5)
  31. #define IEEE80211_AUTH_MAX_TRIES 3
  32. #define IEEE80211_AUTH_WAIT_ASSOC (HZ * 5)
  33. #define IEEE80211_ASSOC_TIMEOUT (HZ / 5)
  34. #define IEEE80211_ASSOC_MAX_TRIES 3
  35. static int max_nullfunc_tries = 2;
  36. module_param(max_nullfunc_tries, int, 0644);
  37. MODULE_PARM_DESC(max_nullfunc_tries,
  38. "Maximum nullfunc tx tries before disconnecting (reason 4).");
  39. static int max_probe_tries = 5;
  40. module_param(max_probe_tries, int, 0644);
  41. MODULE_PARM_DESC(max_probe_tries,
  42. "Maximum probe tries before disconnecting (reason 4).");
  43. /*
  44. * Beacon loss timeout is calculated as N frames times the
  45. * advertised beacon interval. This may need to be somewhat
  46. * higher than what hardware might detect to account for
  47. * delays in the host processing frames. But since we also
  48. * probe on beacon miss before declaring the connection lost
  49. * default to what we want.
  50. */
  51. #define IEEE80211_BEACON_LOSS_COUNT 7
  52. /*
  53. * Time the connection can be idle before we probe
  54. * it to see if we can still talk to the AP.
  55. */
  56. #define IEEE80211_CONNECTION_IDLE_TIME (30 * HZ)
  57. /*
  58. * Time we wait for a probe response after sending
  59. * a probe request because of beacon loss or for
  60. * checking the connection still works.
  61. */
  62. static int probe_wait_ms = 500;
  63. module_param(probe_wait_ms, int, 0644);
  64. MODULE_PARM_DESC(probe_wait_ms,
  65. "Maximum time(ms) to wait for probe response"
  66. " before disconnecting (reason 4).");
  67. /*
  68. * Weight given to the latest Beacon frame when calculating average signal
  69. * strength for Beacon frames received in the current BSS. This must be
  70. * between 1 and 15.
  71. */
  72. #define IEEE80211_SIGNAL_AVE_WEIGHT 3
  73. /*
  74. * How many Beacon frames need to have been used in average signal strength
  75. * before starting to indicate signal change events.
  76. */
  77. #define IEEE80211_SIGNAL_AVE_MIN_COUNT 4
  78. #define TMR_RUNNING_TIMER 0
  79. #define TMR_RUNNING_CHANSW 1
  80. /*
  81. * All cfg80211 functions have to be called outside a locked
  82. * section so that they can acquire a lock themselves... This
  83. * is much simpler than queuing up things in cfg80211, but we
  84. * do need some indirection for that here.
  85. */
  86. enum rx_mgmt_action {
  87. /* no action required */
  88. RX_MGMT_NONE,
  89. /* caller must call cfg80211_send_deauth() */
  90. RX_MGMT_CFG80211_DEAUTH,
  91. /* caller must call cfg80211_send_disassoc() */
  92. RX_MGMT_CFG80211_DISASSOC,
  93. /* caller must call cfg80211_send_rx_auth() */
  94. RX_MGMT_CFG80211_RX_AUTH,
  95. /* caller must call cfg80211_send_rx_assoc() */
  96. RX_MGMT_CFG80211_RX_ASSOC,
  97. /* caller must call cfg80211_send_assoc_timeout() */
  98. RX_MGMT_CFG80211_ASSOC_TIMEOUT,
  99. };
  100. /* utils */
  101. static inline void ASSERT_MGD_MTX(struct ieee80211_if_managed *ifmgd)
  102. {
  103. lockdep_assert_held(&ifmgd->mtx);
  104. }
  105. /*
  106. * We can have multiple work items (and connection probing)
  107. * scheduling this timer, but we need to take care to only
  108. * reschedule it when it should fire _earlier_ than it was
  109. * asked for before, or if it's not pending right now. This
  110. * function ensures that. Note that it then is required to
  111. * run this function for all timeouts after the first one
  112. * has happened -- the work that runs from this timer will
  113. * do that.
  114. */
  115. static void run_again(struct ieee80211_if_managed *ifmgd, unsigned long timeout)
  116. {
  117. ASSERT_MGD_MTX(ifmgd);
  118. if (!timer_pending(&ifmgd->timer) ||
  119. time_before(timeout, ifmgd->timer.expires))
  120. mod_timer(&ifmgd->timer, timeout);
  121. }
  122. void ieee80211_sta_reset_beacon_monitor(struct ieee80211_sub_if_data *sdata)
  123. {
  124. if (sdata->vif.driver_flags & IEEE80211_VIF_BEACON_FILTER)
  125. return;
  126. if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
  127. return;
  128. mod_timer(&sdata->u.mgd.bcn_mon_timer,
  129. round_jiffies_up(jiffies + sdata->u.mgd.beacon_timeout));
  130. }
  131. void ieee80211_sta_reset_conn_monitor(struct ieee80211_sub_if_data *sdata)
  132. {
  133. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  134. if (unlikely(!sdata->u.mgd.associated))
  135. return;
  136. if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
  137. return;
  138. mod_timer(&sdata->u.mgd.conn_mon_timer,
  139. round_jiffies_up(jiffies + IEEE80211_CONNECTION_IDLE_TIME));
  140. ifmgd->probe_send_count = 0;
  141. }
  142. static int ecw2cw(int ecw)
  143. {
  144. return (1 << ecw) - 1;
  145. }
  146. static u32 ieee80211_config_ht_tx(struct ieee80211_sub_if_data *sdata,
  147. struct ieee80211_ht_operation *ht_oper,
  148. const u8 *bssid, bool reconfig)
  149. {
  150. struct ieee80211_local *local = sdata->local;
  151. struct ieee80211_supported_band *sband;
  152. struct ieee80211_chanctx_conf *chanctx_conf;
  153. struct ieee80211_channel *chan;
  154. struct sta_info *sta;
  155. u32 changed = 0;
  156. u16 ht_opmode;
  157. bool disable_40 = false;
  158. rcu_read_lock();
  159. chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
  160. if (WARN_ON(!chanctx_conf)) {
  161. rcu_read_unlock();
  162. return 0;
  163. }
  164. chan = chanctx_conf->channel;
  165. rcu_read_unlock();
  166. sband = local->hw.wiphy->bands[chan->band];
  167. switch (sdata->vif.bss_conf.channel_type) {
  168. case NL80211_CHAN_HT40PLUS:
  169. if (chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
  170. disable_40 = true;
  171. break;
  172. case NL80211_CHAN_HT40MINUS:
  173. if (chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
  174. disable_40 = true;
  175. break;
  176. default:
  177. break;
  178. }
  179. /* This can change during the lifetime of the BSS */
  180. if (!(ht_oper->ht_param & IEEE80211_HT_PARAM_CHAN_WIDTH_ANY))
  181. disable_40 = true;
  182. mutex_lock(&local->sta_mtx);
  183. sta = sta_info_get(sdata, bssid);
  184. WARN_ON_ONCE(!sta);
  185. if (sta && !sta->supports_40mhz)
  186. disable_40 = true;
  187. if (sta && (!reconfig ||
  188. (disable_40 != !(sta->sta.ht_cap.cap &
  189. IEEE80211_HT_CAP_SUP_WIDTH_20_40)))) {
  190. if (disable_40)
  191. sta->sta.ht_cap.cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
  192. else
  193. sta->sta.ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
  194. rate_control_rate_update(local, sband, sta,
  195. IEEE80211_RC_BW_CHANGED);
  196. }
  197. mutex_unlock(&local->sta_mtx);
  198. ht_opmode = le16_to_cpu(ht_oper->operation_mode);
  199. /* if bss configuration changed store the new one */
  200. if (!reconfig || (sdata->vif.bss_conf.ht_operation_mode != ht_opmode)) {
  201. changed |= BSS_CHANGED_HT;
  202. sdata->vif.bss_conf.ht_operation_mode = ht_opmode;
  203. }
  204. return changed;
  205. }
  206. /* frame sending functions */
  207. static int ieee80211_compatible_rates(const u8 *supp_rates, int supp_rates_len,
  208. struct ieee80211_supported_band *sband,
  209. u32 *rates)
  210. {
  211. int i, j, count;
  212. *rates = 0;
  213. count = 0;
  214. for (i = 0; i < supp_rates_len; i++) {
  215. int rate = (supp_rates[i] & 0x7F) * 5;
  216. for (j = 0; j < sband->n_bitrates; j++)
  217. if (sband->bitrates[j].bitrate == rate) {
  218. *rates |= BIT(j);
  219. count++;
  220. break;
  221. }
  222. }
  223. return count;
  224. }
  225. static void ieee80211_add_ht_ie(struct ieee80211_sub_if_data *sdata,
  226. struct sk_buff *skb, u8 ap_ht_param,
  227. struct ieee80211_supported_band *sband,
  228. struct ieee80211_channel *channel,
  229. enum ieee80211_smps_mode smps)
  230. {
  231. u8 *pos;
  232. u32 flags = channel->flags;
  233. u16 cap;
  234. struct ieee80211_sta_ht_cap ht_cap;
  235. BUILD_BUG_ON(sizeof(ht_cap) != sizeof(sband->ht_cap));
  236. memcpy(&ht_cap, &sband->ht_cap, sizeof(ht_cap));
  237. ieee80211_apply_htcap_overrides(sdata, &ht_cap);
  238. /* determine capability flags */
  239. cap = ht_cap.cap;
  240. switch (ap_ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
  241. case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
  242. if (flags & IEEE80211_CHAN_NO_HT40PLUS) {
  243. cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
  244. cap &= ~IEEE80211_HT_CAP_SGI_40;
  245. }
  246. break;
  247. case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
  248. if (flags & IEEE80211_CHAN_NO_HT40MINUS) {
  249. cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
  250. cap &= ~IEEE80211_HT_CAP_SGI_40;
  251. }
  252. break;
  253. }
  254. /*
  255. * If 40 MHz was disabled associate as though we weren't
  256. * capable of 40 MHz -- some broken APs will never fall
  257. * back to trying to transmit in 20 MHz.
  258. */
  259. if (sdata->u.mgd.flags & IEEE80211_STA_DISABLE_40MHZ) {
  260. cap &= ~IEEE80211_HT_CAP_SUP_WIDTH_20_40;
  261. cap &= ~IEEE80211_HT_CAP_SGI_40;
  262. }
  263. /* set SM PS mode properly */
  264. cap &= ~IEEE80211_HT_CAP_SM_PS;
  265. switch (smps) {
  266. case IEEE80211_SMPS_AUTOMATIC:
  267. case IEEE80211_SMPS_NUM_MODES:
  268. WARN_ON(1);
  269. case IEEE80211_SMPS_OFF:
  270. cap |= WLAN_HT_CAP_SM_PS_DISABLED <<
  271. IEEE80211_HT_CAP_SM_PS_SHIFT;
  272. break;
  273. case IEEE80211_SMPS_STATIC:
  274. cap |= WLAN_HT_CAP_SM_PS_STATIC <<
  275. IEEE80211_HT_CAP_SM_PS_SHIFT;
  276. break;
  277. case IEEE80211_SMPS_DYNAMIC:
  278. cap |= WLAN_HT_CAP_SM_PS_DYNAMIC <<
  279. IEEE80211_HT_CAP_SM_PS_SHIFT;
  280. break;
  281. }
  282. /* reserve and fill IE */
  283. pos = skb_put(skb, sizeof(struct ieee80211_ht_cap) + 2);
  284. ieee80211_ie_build_ht_cap(pos, &ht_cap, cap);
  285. }
  286. static void ieee80211_add_vht_ie(struct ieee80211_sub_if_data *sdata,
  287. struct sk_buff *skb,
  288. struct ieee80211_supported_band *sband)
  289. {
  290. u8 *pos;
  291. u32 cap;
  292. struct ieee80211_sta_vht_cap vht_cap;
  293. BUILD_BUG_ON(sizeof(vht_cap) != sizeof(sband->vht_cap));
  294. memcpy(&vht_cap, &sband->vht_cap, sizeof(vht_cap));
  295. /* determine capability flags */
  296. cap = vht_cap.cap;
  297. /* reserve and fill IE */
  298. pos = skb_put(skb, sizeof(struct ieee80211_vht_cap) + 2);
  299. ieee80211_ie_build_vht_cap(pos, &vht_cap, cap);
  300. }
  301. static void ieee80211_send_assoc(struct ieee80211_sub_if_data *sdata)
  302. {
  303. struct ieee80211_local *local = sdata->local;
  304. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  305. struct ieee80211_mgd_assoc_data *assoc_data = ifmgd->assoc_data;
  306. struct sk_buff *skb;
  307. struct ieee80211_mgmt *mgmt;
  308. u8 *pos, qos_info;
  309. size_t offset = 0, noffset;
  310. int i, count, rates_len, supp_rates_len;
  311. u16 capab;
  312. struct ieee80211_supported_band *sband;
  313. struct ieee80211_chanctx_conf *chanctx_conf;
  314. struct ieee80211_channel *chan;
  315. u32 rates = 0;
  316. lockdep_assert_held(&ifmgd->mtx);
  317. rcu_read_lock();
  318. chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
  319. if (WARN_ON(!chanctx_conf)) {
  320. rcu_read_unlock();
  321. return;
  322. }
  323. chan = chanctx_conf->channel;
  324. rcu_read_unlock();
  325. sband = local->hw.wiphy->bands[chan->band];
  326. if (assoc_data->supp_rates_len) {
  327. /*
  328. * Get all rates supported by the device and the AP as
  329. * some APs don't like getting a superset of their rates
  330. * in the association request (e.g. D-Link DAP 1353 in
  331. * b-only mode)...
  332. */
  333. rates_len = ieee80211_compatible_rates(assoc_data->supp_rates,
  334. assoc_data->supp_rates_len,
  335. sband, &rates);
  336. } else {
  337. /*
  338. * In case AP not provide any supported rates information
  339. * before association, we send information element(s) with
  340. * all rates that we support.
  341. */
  342. rates = ~0;
  343. rates_len = sband->n_bitrates;
  344. }
  345. skb = alloc_skb(local->hw.extra_tx_headroom +
  346. sizeof(*mgmt) + /* bit too much but doesn't matter */
  347. 2 + assoc_data->ssid_len + /* SSID */
  348. 4 + rates_len + /* (extended) rates */
  349. 4 + /* power capability */
  350. 2 + 2 * sband->n_channels + /* supported channels */
  351. 2 + sizeof(struct ieee80211_ht_cap) + /* HT */
  352. 2 + sizeof(struct ieee80211_vht_cap) + /* VHT */
  353. assoc_data->ie_len + /* extra IEs */
  354. 9, /* WMM */
  355. GFP_KERNEL);
  356. if (!skb)
  357. return;
  358. skb_reserve(skb, local->hw.extra_tx_headroom);
  359. capab = WLAN_CAPABILITY_ESS;
  360. if (sband->band == IEEE80211_BAND_2GHZ) {
  361. if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_SLOT_INCAPABLE))
  362. capab |= WLAN_CAPABILITY_SHORT_SLOT_TIME;
  363. if (!(local->hw.flags & IEEE80211_HW_2GHZ_SHORT_PREAMBLE_INCAPABLE))
  364. capab |= WLAN_CAPABILITY_SHORT_PREAMBLE;
  365. }
  366. if (assoc_data->capability & WLAN_CAPABILITY_PRIVACY)
  367. capab |= WLAN_CAPABILITY_PRIVACY;
  368. if ((assoc_data->capability & WLAN_CAPABILITY_SPECTRUM_MGMT) &&
  369. (local->hw.flags & IEEE80211_HW_SPECTRUM_MGMT))
  370. capab |= WLAN_CAPABILITY_SPECTRUM_MGMT;
  371. mgmt = (struct ieee80211_mgmt *) skb_put(skb, 24);
  372. memset(mgmt, 0, 24);
  373. memcpy(mgmt->da, assoc_data->bss->bssid, ETH_ALEN);
  374. memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
  375. memcpy(mgmt->bssid, assoc_data->bss->bssid, ETH_ALEN);
  376. if (!is_zero_ether_addr(assoc_data->prev_bssid)) {
  377. skb_put(skb, 10);
  378. mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
  379. IEEE80211_STYPE_REASSOC_REQ);
  380. mgmt->u.reassoc_req.capab_info = cpu_to_le16(capab);
  381. mgmt->u.reassoc_req.listen_interval =
  382. cpu_to_le16(local->hw.conf.listen_interval);
  383. memcpy(mgmt->u.reassoc_req.current_ap, assoc_data->prev_bssid,
  384. ETH_ALEN);
  385. } else {
  386. skb_put(skb, 4);
  387. mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
  388. IEEE80211_STYPE_ASSOC_REQ);
  389. mgmt->u.assoc_req.capab_info = cpu_to_le16(capab);
  390. mgmt->u.assoc_req.listen_interval =
  391. cpu_to_le16(local->hw.conf.listen_interval);
  392. }
  393. /* SSID */
  394. pos = skb_put(skb, 2 + assoc_data->ssid_len);
  395. *pos++ = WLAN_EID_SSID;
  396. *pos++ = assoc_data->ssid_len;
  397. memcpy(pos, assoc_data->ssid, assoc_data->ssid_len);
  398. /* add all rates which were marked to be used above */
  399. supp_rates_len = rates_len;
  400. if (supp_rates_len > 8)
  401. supp_rates_len = 8;
  402. pos = skb_put(skb, supp_rates_len + 2);
  403. *pos++ = WLAN_EID_SUPP_RATES;
  404. *pos++ = supp_rates_len;
  405. count = 0;
  406. for (i = 0; i < sband->n_bitrates; i++) {
  407. if (BIT(i) & rates) {
  408. int rate = sband->bitrates[i].bitrate;
  409. *pos++ = (u8) (rate / 5);
  410. if (++count == 8)
  411. break;
  412. }
  413. }
  414. if (rates_len > count) {
  415. pos = skb_put(skb, rates_len - count + 2);
  416. *pos++ = WLAN_EID_EXT_SUPP_RATES;
  417. *pos++ = rates_len - count;
  418. for (i++; i < sband->n_bitrates; i++) {
  419. if (BIT(i) & rates) {
  420. int rate = sband->bitrates[i].bitrate;
  421. *pos++ = (u8) (rate / 5);
  422. }
  423. }
  424. }
  425. if (capab & WLAN_CAPABILITY_SPECTRUM_MGMT) {
  426. /* 1. power capabilities */
  427. pos = skb_put(skb, 4);
  428. *pos++ = WLAN_EID_PWR_CAPABILITY;
  429. *pos++ = 2;
  430. *pos++ = 0; /* min tx power */
  431. *pos++ = chan->max_power; /* max tx power */
  432. /* 2. supported channels */
  433. /* TODO: get this in reg domain format */
  434. pos = skb_put(skb, 2 * sband->n_channels + 2);
  435. *pos++ = WLAN_EID_SUPPORTED_CHANNELS;
  436. *pos++ = 2 * sband->n_channels;
  437. for (i = 0; i < sband->n_channels; i++) {
  438. *pos++ = ieee80211_frequency_to_channel(
  439. sband->channels[i].center_freq);
  440. *pos++ = 1; /* one channel in the subband*/
  441. }
  442. }
  443. /* if present, add any custom IEs that go before HT */
  444. if (assoc_data->ie_len && assoc_data->ie) {
  445. static const u8 before_ht[] = {
  446. WLAN_EID_SSID,
  447. WLAN_EID_SUPP_RATES,
  448. WLAN_EID_EXT_SUPP_RATES,
  449. WLAN_EID_PWR_CAPABILITY,
  450. WLAN_EID_SUPPORTED_CHANNELS,
  451. WLAN_EID_RSN,
  452. WLAN_EID_QOS_CAPA,
  453. WLAN_EID_RRM_ENABLED_CAPABILITIES,
  454. WLAN_EID_MOBILITY_DOMAIN,
  455. WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
  456. };
  457. noffset = ieee80211_ie_split(assoc_data->ie, assoc_data->ie_len,
  458. before_ht, ARRAY_SIZE(before_ht),
  459. offset);
  460. pos = skb_put(skb, noffset - offset);
  461. memcpy(pos, assoc_data->ie + offset, noffset - offset);
  462. offset = noffset;
  463. }
  464. if (!(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
  465. ieee80211_add_ht_ie(sdata, skb, assoc_data->ap_ht_param,
  466. sband, chan, sdata->smps_mode);
  467. if (!(ifmgd->flags & IEEE80211_STA_DISABLE_VHT))
  468. ieee80211_add_vht_ie(sdata, skb, sband);
  469. /* if present, add any custom non-vendor IEs that go after HT */
  470. if (assoc_data->ie_len && assoc_data->ie) {
  471. noffset = ieee80211_ie_split_vendor(assoc_data->ie,
  472. assoc_data->ie_len,
  473. offset);
  474. pos = skb_put(skb, noffset - offset);
  475. memcpy(pos, assoc_data->ie + offset, noffset - offset);
  476. offset = noffset;
  477. }
  478. if (assoc_data->wmm) {
  479. if (assoc_data->uapsd) {
  480. qos_info = ifmgd->uapsd_queues;
  481. qos_info |= (ifmgd->uapsd_max_sp_len <<
  482. IEEE80211_WMM_IE_STA_QOSINFO_SP_SHIFT);
  483. } else {
  484. qos_info = 0;
  485. }
  486. pos = skb_put(skb, 9);
  487. *pos++ = WLAN_EID_VENDOR_SPECIFIC;
  488. *pos++ = 7; /* len */
  489. *pos++ = 0x00; /* Microsoft OUI 00:50:F2 */
  490. *pos++ = 0x50;
  491. *pos++ = 0xf2;
  492. *pos++ = 2; /* WME */
  493. *pos++ = 0; /* WME info */
  494. *pos++ = 1; /* WME ver */
  495. *pos++ = qos_info;
  496. }
  497. /* add any remaining custom (i.e. vendor specific here) IEs */
  498. if (assoc_data->ie_len && assoc_data->ie) {
  499. noffset = assoc_data->ie_len;
  500. pos = skb_put(skb, noffset - offset);
  501. memcpy(pos, assoc_data->ie + offset, noffset - offset);
  502. }
  503. drv_mgd_prepare_tx(local, sdata);
  504. IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
  505. ieee80211_tx_skb(sdata, skb);
  506. }
  507. void ieee80211_send_pspoll(struct ieee80211_local *local,
  508. struct ieee80211_sub_if_data *sdata)
  509. {
  510. struct ieee80211_pspoll *pspoll;
  511. struct sk_buff *skb;
  512. skb = ieee80211_pspoll_get(&local->hw, &sdata->vif);
  513. if (!skb)
  514. return;
  515. pspoll = (struct ieee80211_pspoll *) skb->data;
  516. pspoll->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
  517. IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
  518. ieee80211_tx_skb(sdata, skb);
  519. }
  520. void ieee80211_send_nullfunc(struct ieee80211_local *local,
  521. struct ieee80211_sub_if_data *sdata,
  522. int powersave)
  523. {
  524. struct sk_buff *skb;
  525. struct ieee80211_hdr_3addr *nullfunc;
  526. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  527. skb = ieee80211_nullfunc_get(&local->hw, &sdata->vif);
  528. if (!skb)
  529. return;
  530. nullfunc = (struct ieee80211_hdr_3addr *) skb->data;
  531. if (powersave)
  532. nullfunc->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
  533. IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
  534. if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
  535. IEEE80211_STA_CONNECTION_POLL))
  536. IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_CTL_USE_MINRATE;
  537. ieee80211_tx_skb(sdata, skb);
  538. }
  539. static void ieee80211_send_4addr_nullfunc(struct ieee80211_local *local,
  540. struct ieee80211_sub_if_data *sdata)
  541. {
  542. struct sk_buff *skb;
  543. struct ieee80211_hdr *nullfunc;
  544. __le16 fc;
  545. if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
  546. return;
  547. skb = dev_alloc_skb(local->hw.extra_tx_headroom + 30);
  548. if (!skb)
  549. return;
  550. skb_reserve(skb, local->hw.extra_tx_headroom);
  551. nullfunc = (struct ieee80211_hdr *) skb_put(skb, 30);
  552. memset(nullfunc, 0, 30);
  553. fc = cpu_to_le16(IEEE80211_FTYPE_DATA | IEEE80211_STYPE_NULLFUNC |
  554. IEEE80211_FCTL_FROMDS | IEEE80211_FCTL_TODS);
  555. nullfunc->frame_control = fc;
  556. memcpy(nullfunc->addr1, sdata->u.mgd.bssid, ETH_ALEN);
  557. memcpy(nullfunc->addr2, sdata->vif.addr, ETH_ALEN);
  558. memcpy(nullfunc->addr3, sdata->u.mgd.bssid, ETH_ALEN);
  559. memcpy(nullfunc->addr4, sdata->vif.addr, ETH_ALEN);
  560. IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
  561. ieee80211_tx_skb(sdata, skb);
  562. }
  563. /* spectrum management related things */
  564. static void ieee80211_chswitch_work(struct work_struct *work)
  565. {
  566. struct ieee80211_sub_if_data *sdata =
  567. container_of(work, struct ieee80211_sub_if_data, u.mgd.chswitch_work);
  568. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  569. if (!ieee80211_sdata_running(sdata))
  570. return;
  571. mutex_lock(&ifmgd->mtx);
  572. if (!ifmgd->associated)
  573. goto out;
  574. sdata->local->_oper_channel = sdata->local->csa_channel;
  575. if (!sdata->local->ops->channel_switch) {
  576. /* call "hw_config" only if doing sw channel switch */
  577. ieee80211_hw_config(sdata->local,
  578. IEEE80211_CONF_CHANGE_CHANNEL);
  579. } else {
  580. /* update the device channel directly */
  581. sdata->local->hw.conf.channel = sdata->local->_oper_channel;
  582. }
  583. /* XXX: shouldn't really modify cfg80211-owned data! */
  584. ifmgd->associated->channel = sdata->local->_oper_channel;
  585. /* XXX: wait for a beacon first? */
  586. ieee80211_wake_queues_by_reason(&sdata->local->hw,
  587. IEEE80211_QUEUE_STOP_REASON_CSA);
  588. out:
  589. ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
  590. mutex_unlock(&ifmgd->mtx);
  591. }
  592. void ieee80211_chswitch_done(struct ieee80211_vif *vif, bool success)
  593. {
  594. struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
  595. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  596. trace_api_chswitch_done(sdata, success);
  597. if (!success) {
  598. sdata_info(sdata,
  599. "driver channel switch failed, disconnecting\n");
  600. ieee80211_queue_work(&sdata->local->hw,
  601. &ifmgd->csa_connection_drop_work);
  602. } else {
  603. ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
  604. }
  605. }
  606. EXPORT_SYMBOL(ieee80211_chswitch_done);
  607. static void ieee80211_chswitch_timer(unsigned long data)
  608. {
  609. struct ieee80211_sub_if_data *sdata =
  610. (struct ieee80211_sub_if_data *) data;
  611. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  612. if (sdata->local->quiescing) {
  613. set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
  614. return;
  615. }
  616. ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
  617. }
  618. void ieee80211_sta_process_chanswitch(struct ieee80211_sub_if_data *sdata,
  619. struct ieee80211_channel_sw_ie *sw_elem,
  620. struct ieee80211_bss *bss,
  621. u64 timestamp)
  622. {
  623. struct cfg80211_bss *cbss =
  624. container_of((void *)bss, struct cfg80211_bss, priv);
  625. struct ieee80211_channel *new_ch;
  626. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  627. int new_freq = ieee80211_channel_to_frequency(sw_elem->new_ch_num,
  628. cbss->channel->band);
  629. struct ieee80211_chanctx *chanctx;
  630. ASSERT_MGD_MTX(ifmgd);
  631. if (!ifmgd->associated)
  632. return;
  633. if (sdata->local->scanning)
  634. return;
  635. /* Disregard subsequent beacons if we are already running a timer
  636. processing a CSA */
  637. if (ifmgd->flags & IEEE80211_STA_CSA_RECEIVED)
  638. return;
  639. new_ch = ieee80211_get_channel(sdata->local->hw.wiphy, new_freq);
  640. if (!new_ch || new_ch->flags & IEEE80211_CHAN_DISABLED) {
  641. sdata_info(sdata,
  642. "AP %pM switches to unsupported channel (%d MHz), disconnecting\n",
  643. ifmgd->associated->bssid, new_freq);
  644. ieee80211_queue_work(&sdata->local->hw,
  645. &ifmgd->csa_connection_drop_work);
  646. return;
  647. }
  648. ifmgd->flags |= IEEE80211_STA_CSA_RECEIVED;
  649. if (sdata->local->use_chanctx) {
  650. sdata_info(sdata,
  651. "not handling channel switch with channel contexts\n");
  652. ieee80211_queue_work(&sdata->local->hw,
  653. &ifmgd->csa_connection_drop_work);
  654. }
  655. mutex_lock(&sdata->local->chanctx_mtx);
  656. if (WARN_ON(!rcu_access_pointer(sdata->vif.chanctx_conf))) {
  657. mutex_unlock(&sdata->local->chanctx_mtx);
  658. return;
  659. }
  660. chanctx = container_of(rcu_access_pointer(sdata->vif.chanctx_conf),
  661. struct ieee80211_chanctx, conf);
  662. if (chanctx->refcount > 1) {
  663. sdata_info(sdata,
  664. "channel switch with multiple interfaces on the same channel, disconnecting\n");
  665. ieee80211_queue_work(&sdata->local->hw,
  666. &ifmgd->csa_connection_drop_work);
  667. mutex_unlock(&sdata->local->chanctx_mtx);
  668. return;
  669. }
  670. mutex_unlock(&sdata->local->chanctx_mtx);
  671. sdata->local->csa_channel = new_ch;
  672. if (sw_elem->mode)
  673. ieee80211_stop_queues_by_reason(&sdata->local->hw,
  674. IEEE80211_QUEUE_STOP_REASON_CSA);
  675. if (sdata->local->ops->channel_switch) {
  676. /* use driver's channel switch callback */
  677. struct ieee80211_channel_switch ch_switch = {
  678. .timestamp = timestamp,
  679. .block_tx = sw_elem->mode,
  680. .channel = new_ch,
  681. .count = sw_elem->count,
  682. };
  683. drv_channel_switch(sdata->local, &ch_switch);
  684. return;
  685. }
  686. /* channel switch handled in software */
  687. if (sw_elem->count <= 1)
  688. ieee80211_queue_work(&sdata->local->hw, &ifmgd->chswitch_work);
  689. else
  690. mod_timer(&ifmgd->chswitch_timer,
  691. TU_TO_EXP_TIME(sw_elem->count *
  692. cbss->beacon_interval));
  693. }
  694. static u32 ieee80211_handle_pwr_constr(struct ieee80211_sub_if_data *sdata,
  695. struct ieee80211_channel *channel,
  696. const u8 *country_ie, u8 country_ie_len,
  697. const u8 *pwr_constr_elem)
  698. {
  699. struct ieee80211_country_ie_triplet *triplet;
  700. int chan = ieee80211_frequency_to_channel(channel->center_freq);
  701. int i, chan_pwr, chan_increment, new_ap_level;
  702. bool have_chan_pwr = false;
  703. /* Invalid IE */
  704. if (country_ie_len % 2 || country_ie_len < IEEE80211_COUNTRY_IE_MIN_LEN)
  705. return 0;
  706. triplet = (void *)(country_ie + 3);
  707. country_ie_len -= 3;
  708. switch (channel->band) {
  709. default:
  710. WARN_ON_ONCE(1);
  711. /* fall through */
  712. case IEEE80211_BAND_2GHZ:
  713. case IEEE80211_BAND_60GHZ:
  714. chan_increment = 1;
  715. break;
  716. case IEEE80211_BAND_5GHZ:
  717. chan_increment = 4;
  718. break;
  719. }
  720. /* find channel */
  721. while (country_ie_len >= 3) {
  722. u8 first_channel = triplet->chans.first_channel;
  723. if (first_channel >= IEEE80211_COUNTRY_EXTENSION_ID)
  724. goto next;
  725. for (i = 0; i < triplet->chans.num_channels; i++) {
  726. if (first_channel + i * chan_increment == chan) {
  727. have_chan_pwr = true;
  728. chan_pwr = triplet->chans.max_power;
  729. break;
  730. }
  731. }
  732. if (have_chan_pwr)
  733. break;
  734. next:
  735. triplet++;
  736. country_ie_len -= 3;
  737. }
  738. if (!have_chan_pwr)
  739. return 0;
  740. new_ap_level = max_t(int, 0, chan_pwr - *pwr_constr_elem);
  741. if (sdata->ap_power_level == new_ap_level)
  742. return 0;
  743. sdata_info(sdata,
  744. "Limiting TX power to %d (%d - %d) dBm as advertised by %pM\n",
  745. new_ap_level, chan_pwr, *pwr_constr_elem,
  746. sdata->u.mgd.bssid);
  747. sdata->ap_power_level = new_ap_level;
  748. if (__ieee80211_recalc_txpower(sdata))
  749. return BSS_CHANGED_TXPOWER;
  750. return 0;
  751. }
  752. void ieee80211_enable_dyn_ps(struct ieee80211_vif *vif)
  753. {
  754. struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
  755. struct ieee80211_local *local = sdata->local;
  756. struct ieee80211_conf *conf = &local->hw.conf;
  757. WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION ||
  758. !(local->hw.flags & IEEE80211_HW_SUPPORTS_PS) ||
  759. (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS));
  760. local->disable_dynamic_ps = false;
  761. conf->dynamic_ps_timeout = local->dynamic_ps_user_timeout;
  762. }
  763. EXPORT_SYMBOL(ieee80211_enable_dyn_ps);
  764. void ieee80211_disable_dyn_ps(struct ieee80211_vif *vif)
  765. {
  766. struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
  767. struct ieee80211_local *local = sdata->local;
  768. struct ieee80211_conf *conf = &local->hw.conf;
  769. WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION ||
  770. !(local->hw.flags & IEEE80211_HW_SUPPORTS_PS) ||
  771. (local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS));
  772. local->disable_dynamic_ps = true;
  773. conf->dynamic_ps_timeout = 0;
  774. del_timer_sync(&local->dynamic_ps_timer);
  775. ieee80211_queue_work(&local->hw,
  776. &local->dynamic_ps_enable_work);
  777. }
  778. EXPORT_SYMBOL(ieee80211_disable_dyn_ps);
  779. /* powersave */
  780. static void ieee80211_enable_ps(struct ieee80211_local *local,
  781. struct ieee80211_sub_if_data *sdata)
  782. {
  783. struct ieee80211_conf *conf = &local->hw.conf;
  784. /*
  785. * If we are scanning right now then the parameters will
  786. * take effect when scan finishes.
  787. */
  788. if (local->scanning)
  789. return;
  790. if (conf->dynamic_ps_timeout > 0 &&
  791. !(local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_PS)) {
  792. mod_timer(&local->dynamic_ps_timer, jiffies +
  793. msecs_to_jiffies(conf->dynamic_ps_timeout));
  794. } else {
  795. if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
  796. ieee80211_send_nullfunc(local, sdata, 1);
  797. if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
  798. (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS))
  799. return;
  800. conf->flags |= IEEE80211_CONF_PS;
  801. ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
  802. }
  803. }
  804. static void ieee80211_change_ps(struct ieee80211_local *local)
  805. {
  806. struct ieee80211_conf *conf = &local->hw.conf;
  807. if (local->ps_sdata) {
  808. ieee80211_enable_ps(local, local->ps_sdata);
  809. } else if (conf->flags & IEEE80211_CONF_PS) {
  810. conf->flags &= ~IEEE80211_CONF_PS;
  811. ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
  812. del_timer_sync(&local->dynamic_ps_timer);
  813. cancel_work_sync(&local->dynamic_ps_enable_work);
  814. }
  815. }
  816. static bool ieee80211_powersave_allowed(struct ieee80211_sub_if_data *sdata)
  817. {
  818. struct ieee80211_if_managed *mgd = &sdata->u.mgd;
  819. struct sta_info *sta = NULL;
  820. bool authorized = false;
  821. if (!mgd->powersave)
  822. return false;
  823. if (mgd->broken_ap)
  824. return false;
  825. if (!mgd->associated)
  826. return false;
  827. if (mgd->flags & (IEEE80211_STA_BEACON_POLL |
  828. IEEE80211_STA_CONNECTION_POLL))
  829. return false;
  830. rcu_read_lock();
  831. sta = sta_info_get(sdata, mgd->bssid);
  832. if (sta)
  833. authorized = test_sta_flag(sta, WLAN_STA_AUTHORIZED);
  834. rcu_read_unlock();
  835. return authorized;
  836. }
  837. /* need to hold RTNL or interface lock */
  838. void ieee80211_recalc_ps(struct ieee80211_local *local, s32 latency)
  839. {
  840. struct ieee80211_sub_if_data *sdata, *found = NULL;
  841. int count = 0;
  842. int timeout;
  843. if (!(local->hw.flags & IEEE80211_HW_SUPPORTS_PS)) {
  844. local->ps_sdata = NULL;
  845. return;
  846. }
  847. list_for_each_entry(sdata, &local->interfaces, list) {
  848. if (!ieee80211_sdata_running(sdata))
  849. continue;
  850. if (sdata->vif.type == NL80211_IFTYPE_AP) {
  851. /* If an AP vif is found, then disable PS
  852. * by setting the count to zero thereby setting
  853. * ps_sdata to NULL.
  854. */
  855. count = 0;
  856. break;
  857. }
  858. if (sdata->vif.type != NL80211_IFTYPE_STATION)
  859. continue;
  860. found = sdata;
  861. count++;
  862. }
  863. if (count == 1 && ieee80211_powersave_allowed(found)) {
  864. struct ieee80211_conf *conf = &local->hw.conf;
  865. s32 beaconint_us;
  866. if (latency < 0)
  867. latency = pm_qos_request(PM_QOS_NETWORK_LATENCY);
  868. beaconint_us = ieee80211_tu_to_usec(
  869. found->vif.bss_conf.beacon_int);
  870. timeout = local->dynamic_ps_forced_timeout;
  871. if (timeout < 0) {
  872. /*
  873. * Go to full PSM if the user configures a very low
  874. * latency requirement.
  875. * The 2000 second value is there for compatibility
  876. * until the PM_QOS_NETWORK_LATENCY is configured
  877. * with real values.
  878. */
  879. if (latency > (1900 * USEC_PER_MSEC) &&
  880. latency != (2000 * USEC_PER_SEC))
  881. timeout = 0;
  882. else
  883. timeout = 100;
  884. }
  885. local->dynamic_ps_user_timeout = timeout;
  886. if (!local->disable_dynamic_ps)
  887. conf->dynamic_ps_timeout =
  888. local->dynamic_ps_user_timeout;
  889. if (beaconint_us > latency) {
  890. local->ps_sdata = NULL;
  891. } else {
  892. struct ieee80211_bss *bss;
  893. int maxslp = 1;
  894. u8 dtimper;
  895. bss = (void *)found->u.mgd.associated->priv;
  896. dtimper = bss->dtim_period;
  897. /* If the TIM IE is invalid, pretend the value is 1 */
  898. if (!dtimper)
  899. dtimper = 1;
  900. else if (dtimper > 1)
  901. maxslp = min_t(int, dtimper,
  902. latency / beaconint_us);
  903. local->hw.conf.max_sleep_period = maxslp;
  904. local->hw.conf.ps_dtim_period = dtimper;
  905. local->ps_sdata = found;
  906. }
  907. } else {
  908. local->ps_sdata = NULL;
  909. }
  910. ieee80211_change_ps(local);
  911. }
  912. void ieee80211_recalc_ps_vif(struct ieee80211_sub_if_data *sdata)
  913. {
  914. bool ps_allowed = ieee80211_powersave_allowed(sdata);
  915. if (sdata->vif.bss_conf.ps != ps_allowed) {
  916. sdata->vif.bss_conf.ps = ps_allowed;
  917. ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_PS);
  918. }
  919. }
  920. void ieee80211_dynamic_ps_disable_work(struct work_struct *work)
  921. {
  922. struct ieee80211_local *local =
  923. container_of(work, struct ieee80211_local,
  924. dynamic_ps_disable_work);
  925. if (local->hw.conf.flags & IEEE80211_CONF_PS) {
  926. local->hw.conf.flags &= ~IEEE80211_CONF_PS;
  927. ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
  928. }
  929. ieee80211_wake_queues_by_reason(&local->hw,
  930. IEEE80211_QUEUE_STOP_REASON_PS);
  931. }
  932. void ieee80211_dynamic_ps_enable_work(struct work_struct *work)
  933. {
  934. struct ieee80211_local *local =
  935. container_of(work, struct ieee80211_local,
  936. dynamic_ps_enable_work);
  937. struct ieee80211_sub_if_data *sdata = local->ps_sdata;
  938. struct ieee80211_if_managed *ifmgd;
  939. unsigned long flags;
  940. int q;
  941. /* can only happen when PS was just disabled anyway */
  942. if (!sdata)
  943. return;
  944. ifmgd = &sdata->u.mgd;
  945. if (local->hw.conf.flags & IEEE80211_CONF_PS)
  946. return;
  947. if (!local->disable_dynamic_ps &&
  948. local->hw.conf.dynamic_ps_timeout > 0) {
  949. /* don't enter PS if TX frames are pending */
  950. if (drv_tx_frames_pending(local)) {
  951. mod_timer(&local->dynamic_ps_timer, jiffies +
  952. msecs_to_jiffies(
  953. local->hw.conf.dynamic_ps_timeout));
  954. return;
  955. }
  956. /*
  957. * transmission can be stopped by others which leads to
  958. * dynamic_ps_timer expiry. Postpone the ps timer if it
  959. * is not the actual idle state.
  960. */
  961. spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
  962. for (q = 0; q < local->hw.queues; q++) {
  963. if (local->queue_stop_reasons[q]) {
  964. spin_unlock_irqrestore(&local->queue_stop_reason_lock,
  965. flags);
  966. mod_timer(&local->dynamic_ps_timer, jiffies +
  967. msecs_to_jiffies(
  968. local->hw.conf.dynamic_ps_timeout));
  969. return;
  970. }
  971. }
  972. spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
  973. }
  974. if ((local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) &&
  975. !(ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
  976. netif_tx_stop_all_queues(sdata->dev);
  977. if (drv_tx_frames_pending(local))
  978. mod_timer(&local->dynamic_ps_timer, jiffies +
  979. msecs_to_jiffies(
  980. local->hw.conf.dynamic_ps_timeout));
  981. else {
  982. ieee80211_send_nullfunc(local, sdata, 1);
  983. /* Flush to get the tx status of nullfunc frame */
  984. drv_flush(local, false);
  985. }
  986. }
  987. if (!((local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) &&
  988. (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)) ||
  989. (ifmgd->flags & IEEE80211_STA_NULLFUNC_ACKED)) {
  990. ifmgd->flags &= ~IEEE80211_STA_NULLFUNC_ACKED;
  991. local->hw.conf.flags |= IEEE80211_CONF_PS;
  992. ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
  993. }
  994. if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK)
  995. netif_tx_wake_all_queues(sdata->dev);
  996. }
  997. void ieee80211_dynamic_ps_timer(unsigned long data)
  998. {
  999. struct ieee80211_local *local = (void *) data;
  1000. if (local->quiescing || local->suspended)
  1001. return;
  1002. ieee80211_queue_work(&local->hw, &local->dynamic_ps_enable_work);
  1003. }
  1004. /* MLME */
  1005. static bool ieee80211_sta_wmm_params(struct ieee80211_local *local,
  1006. struct ieee80211_sub_if_data *sdata,
  1007. u8 *wmm_param, size_t wmm_param_len)
  1008. {
  1009. struct ieee80211_tx_queue_params params;
  1010. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1011. size_t left;
  1012. int count;
  1013. u8 *pos, uapsd_queues = 0;
  1014. if (!local->ops->conf_tx)
  1015. return false;
  1016. if (local->hw.queues < IEEE80211_NUM_ACS)
  1017. return false;
  1018. if (!wmm_param)
  1019. return false;
  1020. if (wmm_param_len < 8 || wmm_param[5] /* version */ != 1)
  1021. return false;
  1022. if (ifmgd->flags & IEEE80211_STA_UAPSD_ENABLED)
  1023. uapsd_queues = ifmgd->uapsd_queues;
  1024. count = wmm_param[6] & 0x0f;
  1025. if (count == ifmgd->wmm_last_param_set)
  1026. return false;
  1027. ifmgd->wmm_last_param_set = count;
  1028. pos = wmm_param + 8;
  1029. left = wmm_param_len - 8;
  1030. memset(&params, 0, sizeof(params));
  1031. sdata->wmm_acm = 0;
  1032. for (; left >= 4; left -= 4, pos += 4) {
  1033. int aci = (pos[0] >> 5) & 0x03;
  1034. int acm = (pos[0] >> 4) & 0x01;
  1035. bool uapsd = false;
  1036. int queue;
  1037. switch (aci) {
  1038. case 1: /* AC_BK */
  1039. queue = 3;
  1040. if (acm)
  1041. sdata->wmm_acm |= BIT(1) | BIT(2); /* BK/- */
  1042. if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
  1043. uapsd = true;
  1044. break;
  1045. case 2: /* AC_VI */
  1046. queue = 1;
  1047. if (acm)
  1048. sdata->wmm_acm |= BIT(4) | BIT(5); /* CL/VI */
  1049. if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
  1050. uapsd = true;
  1051. break;
  1052. case 3: /* AC_VO */
  1053. queue = 0;
  1054. if (acm)
  1055. sdata->wmm_acm |= BIT(6) | BIT(7); /* VO/NC */
  1056. if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
  1057. uapsd = true;
  1058. break;
  1059. case 0: /* AC_BE */
  1060. default:
  1061. queue = 2;
  1062. if (acm)
  1063. sdata->wmm_acm |= BIT(0) | BIT(3); /* BE/EE */
  1064. if (uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
  1065. uapsd = true;
  1066. break;
  1067. }
  1068. params.aifs = pos[0] & 0x0f;
  1069. params.cw_max = ecw2cw((pos[1] & 0xf0) >> 4);
  1070. params.cw_min = ecw2cw(pos[1] & 0x0f);
  1071. params.txop = get_unaligned_le16(pos + 2);
  1072. params.uapsd = uapsd;
  1073. mlme_dbg(sdata,
  1074. "WMM queue=%d aci=%d acm=%d aifs=%d cWmin=%d cWmax=%d txop=%d uapsd=%d\n",
  1075. queue, aci, acm,
  1076. params.aifs, params.cw_min, params.cw_max,
  1077. params.txop, params.uapsd);
  1078. sdata->tx_conf[queue] = params;
  1079. if (drv_conf_tx(local, sdata, queue, &params))
  1080. sdata_err(sdata,
  1081. "failed to set TX queue parameters for queue %d\n",
  1082. queue);
  1083. }
  1084. /* enable WMM or activate new settings */
  1085. sdata->vif.bss_conf.qos = true;
  1086. return true;
  1087. }
  1088. static void __ieee80211_stop_poll(struct ieee80211_sub_if_data *sdata)
  1089. {
  1090. lockdep_assert_held(&sdata->local->mtx);
  1091. sdata->u.mgd.flags &= ~(IEEE80211_STA_CONNECTION_POLL |
  1092. IEEE80211_STA_BEACON_POLL);
  1093. ieee80211_run_deferred_scan(sdata->local);
  1094. }
  1095. static void ieee80211_stop_poll(struct ieee80211_sub_if_data *sdata)
  1096. {
  1097. mutex_lock(&sdata->local->mtx);
  1098. __ieee80211_stop_poll(sdata);
  1099. mutex_unlock(&sdata->local->mtx);
  1100. }
  1101. static u32 ieee80211_handle_bss_capability(struct ieee80211_sub_if_data *sdata,
  1102. u16 capab, bool erp_valid, u8 erp)
  1103. {
  1104. struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
  1105. u32 changed = 0;
  1106. bool use_protection;
  1107. bool use_short_preamble;
  1108. bool use_short_slot;
  1109. if (erp_valid) {
  1110. use_protection = (erp & WLAN_ERP_USE_PROTECTION) != 0;
  1111. use_short_preamble = (erp & WLAN_ERP_BARKER_PREAMBLE) == 0;
  1112. } else {
  1113. use_protection = false;
  1114. use_short_preamble = !!(capab & WLAN_CAPABILITY_SHORT_PREAMBLE);
  1115. }
  1116. use_short_slot = !!(capab & WLAN_CAPABILITY_SHORT_SLOT_TIME);
  1117. if (ieee80211_get_sdata_band(sdata) == IEEE80211_BAND_5GHZ)
  1118. use_short_slot = true;
  1119. if (use_protection != bss_conf->use_cts_prot) {
  1120. bss_conf->use_cts_prot = use_protection;
  1121. changed |= BSS_CHANGED_ERP_CTS_PROT;
  1122. }
  1123. if (use_short_preamble != bss_conf->use_short_preamble) {
  1124. bss_conf->use_short_preamble = use_short_preamble;
  1125. changed |= BSS_CHANGED_ERP_PREAMBLE;
  1126. }
  1127. if (use_short_slot != bss_conf->use_short_slot) {
  1128. bss_conf->use_short_slot = use_short_slot;
  1129. changed |= BSS_CHANGED_ERP_SLOT;
  1130. }
  1131. return changed;
  1132. }
  1133. static void ieee80211_set_associated(struct ieee80211_sub_if_data *sdata,
  1134. struct cfg80211_bss *cbss,
  1135. u32 bss_info_changed)
  1136. {
  1137. struct ieee80211_bss *bss = (void *)cbss->priv;
  1138. struct ieee80211_local *local = sdata->local;
  1139. struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
  1140. bss_info_changed |= BSS_CHANGED_ASSOC;
  1141. bss_info_changed |= ieee80211_handle_bss_capability(sdata,
  1142. bss_conf->assoc_capability, bss->has_erp_value, bss->erp_value);
  1143. sdata->u.mgd.beacon_timeout = usecs_to_jiffies(ieee80211_tu_to_usec(
  1144. IEEE80211_BEACON_LOSS_COUNT * bss_conf->beacon_int));
  1145. sdata->u.mgd.associated = cbss;
  1146. memcpy(sdata->u.mgd.bssid, cbss->bssid, ETH_ALEN);
  1147. sdata->u.mgd.flags |= IEEE80211_STA_RESET_SIGNAL_AVE;
  1148. if (sdata->vif.p2p) {
  1149. u8 noa[2];
  1150. int ret;
  1151. ret = cfg80211_get_p2p_attr(cbss->information_elements,
  1152. cbss->len_information_elements,
  1153. IEEE80211_P2P_ATTR_ABSENCE_NOTICE,
  1154. noa, sizeof(noa));
  1155. if (ret >= 2) {
  1156. bss_conf->p2p_oppps = noa[1] & 0x80;
  1157. bss_conf->p2p_ctwindow = noa[1] & 0x7f;
  1158. bss_info_changed |= BSS_CHANGED_P2P_PS;
  1159. sdata->u.mgd.p2p_noa_index = noa[0];
  1160. }
  1161. }
  1162. /* just to be sure */
  1163. ieee80211_stop_poll(sdata);
  1164. ieee80211_led_assoc(local, 1);
  1165. if (local->hw.flags & IEEE80211_HW_NEED_DTIM_PERIOD)
  1166. bss_conf->dtim_period = bss->dtim_period;
  1167. else
  1168. bss_conf->dtim_period = 0;
  1169. bss_conf->assoc = 1;
  1170. /* Tell the driver to monitor connection quality (if supported) */
  1171. if (sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI &&
  1172. bss_conf->cqm_rssi_thold)
  1173. bss_info_changed |= BSS_CHANGED_CQM;
  1174. /* Enable ARP filtering */
  1175. if (bss_conf->arp_filter_enabled != sdata->arp_filter_state) {
  1176. bss_conf->arp_filter_enabled = sdata->arp_filter_state;
  1177. bss_info_changed |= BSS_CHANGED_ARP_FILTER;
  1178. }
  1179. ieee80211_bss_info_change_notify(sdata, bss_info_changed);
  1180. mutex_lock(&local->iflist_mtx);
  1181. ieee80211_recalc_ps(local, -1);
  1182. mutex_unlock(&local->iflist_mtx);
  1183. ieee80211_recalc_smps(sdata);
  1184. ieee80211_recalc_ps_vif(sdata);
  1185. netif_tx_start_all_queues(sdata->dev);
  1186. netif_carrier_on(sdata->dev);
  1187. }
  1188. static void ieee80211_set_disassoc(struct ieee80211_sub_if_data *sdata,
  1189. u16 stype, u16 reason, bool tx,
  1190. u8 *frame_buf)
  1191. {
  1192. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1193. struct ieee80211_local *local = sdata->local;
  1194. struct sta_info *sta;
  1195. u32 changed = 0;
  1196. ASSERT_MGD_MTX(ifmgd);
  1197. if (WARN_ON_ONCE(tx && !frame_buf))
  1198. return;
  1199. if (WARN_ON(!ifmgd->associated))
  1200. return;
  1201. ieee80211_stop_poll(sdata);
  1202. ifmgd->associated = NULL;
  1203. /*
  1204. * we need to commit the associated = NULL change because the
  1205. * scan code uses that to determine whether this iface should
  1206. * go to/wake up from powersave or not -- and could otherwise
  1207. * wake the queues erroneously.
  1208. */
  1209. smp_mb();
  1210. /*
  1211. * Thus, we can only afterwards stop the queues -- to account
  1212. * for the case where another CPU is finishing a scan at this
  1213. * time -- we don't want the scan code to enable queues.
  1214. */
  1215. netif_tx_stop_all_queues(sdata->dev);
  1216. netif_carrier_off(sdata->dev);
  1217. mutex_lock(&local->sta_mtx);
  1218. sta = sta_info_get(sdata, ifmgd->bssid);
  1219. if (sta) {
  1220. set_sta_flag(sta, WLAN_STA_BLOCK_BA);
  1221. ieee80211_sta_tear_down_BA_sessions(sta, false);
  1222. }
  1223. mutex_unlock(&local->sta_mtx);
  1224. /*
  1225. * if we want to get out of ps before disassoc (why?) we have
  1226. * to do it before sending disassoc, as otherwise the null-packet
  1227. * won't be valid.
  1228. */
  1229. if (local->hw.conf.flags & IEEE80211_CONF_PS) {
  1230. local->hw.conf.flags &= ~IEEE80211_CONF_PS;
  1231. ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_PS);
  1232. }
  1233. local->ps_sdata = NULL;
  1234. /* disable per-vif ps */
  1235. ieee80211_recalc_ps_vif(sdata);
  1236. /* flush out any pending frame (e.g. DELBA) before deauth/disassoc */
  1237. if (tx)
  1238. drv_flush(local, false);
  1239. /* deauthenticate/disassociate now */
  1240. if (tx || frame_buf)
  1241. ieee80211_send_deauth_disassoc(sdata, ifmgd->bssid, stype,
  1242. reason, tx, frame_buf);
  1243. /* flush out frame */
  1244. if (tx)
  1245. drv_flush(local, false);
  1246. /* clear bssid only after building the needed mgmt frames */
  1247. memset(ifmgd->bssid, 0, ETH_ALEN);
  1248. /* remove AP and TDLS peers */
  1249. sta_info_flush(local, sdata);
  1250. /* finally reset all BSS / config parameters */
  1251. changed |= ieee80211_reset_erp_info(sdata);
  1252. ieee80211_led_assoc(local, 0);
  1253. changed |= BSS_CHANGED_ASSOC;
  1254. sdata->vif.bss_conf.assoc = false;
  1255. sdata->vif.bss_conf.p2p_ctwindow = 0;
  1256. sdata->vif.bss_conf.p2p_oppps = false;
  1257. /* on the next assoc, re-program HT parameters */
  1258. memset(&ifmgd->ht_capa, 0, sizeof(ifmgd->ht_capa));
  1259. memset(&ifmgd->ht_capa_mask, 0, sizeof(ifmgd->ht_capa_mask));
  1260. sdata->ap_power_level = IEEE80211_UNSET_POWER_LEVEL;
  1261. del_timer_sync(&local->dynamic_ps_timer);
  1262. cancel_work_sync(&local->dynamic_ps_enable_work);
  1263. /* Disable ARP filtering */
  1264. if (sdata->vif.bss_conf.arp_filter_enabled) {
  1265. sdata->vif.bss_conf.arp_filter_enabled = false;
  1266. changed |= BSS_CHANGED_ARP_FILTER;
  1267. }
  1268. sdata->vif.bss_conf.qos = false;
  1269. changed |= BSS_CHANGED_QOS;
  1270. /* The BSSID (not really interesting) and HT changed */
  1271. changed |= BSS_CHANGED_BSSID | BSS_CHANGED_HT;
  1272. ieee80211_bss_info_change_notify(sdata, changed);
  1273. ieee80211_vif_release_channel(sdata);
  1274. /* disassociated - set to defaults now */
  1275. ieee80211_set_wmm_default(sdata, false);
  1276. del_timer_sync(&sdata->u.mgd.conn_mon_timer);
  1277. del_timer_sync(&sdata->u.mgd.bcn_mon_timer);
  1278. del_timer_sync(&sdata->u.mgd.timer);
  1279. del_timer_sync(&sdata->u.mgd.chswitch_timer);
  1280. sdata->u.mgd.timers_running = 0;
  1281. }
  1282. void ieee80211_sta_rx_notify(struct ieee80211_sub_if_data *sdata,
  1283. struct ieee80211_hdr *hdr)
  1284. {
  1285. /*
  1286. * We can postpone the mgd.timer whenever receiving unicast frames
  1287. * from AP because we know that the connection is working both ways
  1288. * at that time. But multicast frames (and hence also beacons) must
  1289. * be ignored here, because we need to trigger the timer during
  1290. * data idle periods for sending the periodic probe request to the
  1291. * AP we're connected to.
  1292. */
  1293. if (is_multicast_ether_addr(hdr->addr1))
  1294. return;
  1295. ieee80211_sta_reset_conn_monitor(sdata);
  1296. }
  1297. static void ieee80211_reset_ap_probe(struct ieee80211_sub_if_data *sdata)
  1298. {
  1299. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1300. struct ieee80211_local *local = sdata->local;
  1301. mutex_lock(&local->mtx);
  1302. if (!(ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
  1303. IEEE80211_STA_CONNECTION_POLL))) {
  1304. mutex_unlock(&local->mtx);
  1305. return;
  1306. }
  1307. __ieee80211_stop_poll(sdata);
  1308. mutex_lock(&local->iflist_mtx);
  1309. ieee80211_recalc_ps(local, -1);
  1310. mutex_unlock(&local->iflist_mtx);
  1311. if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR)
  1312. goto out;
  1313. /*
  1314. * We've received a probe response, but are not sure whether
  1315. * we have or will be receiving any beacons or data, so let's
  1316. * schedule the timers again, just in case.
  1317. */
  1318. ieee80211_sta_reset_beacon_monitor(sdata);
  1319. mod_timer(&ifmgd->conn_mon_timer,
  1320. round_jiffies_up(jiffies +
  1321. IEEE80211_CONNECTION_IDLE_TIME));
  1322. out:
  1323. mutex_unlock(&local->mtx);
  1324. }
  1325. void ieee80211_sta_tx_notify(struct ieee80211_sub_if_data *sdata,
  1326. struct ieee80211_hdr *hdr, bool ack)
  1327. {
  1328. if (!ieee80211_is_data(hdr->frame_control))
  1329. return;
  1330. if (ack)
  1331. ieee80211_sta_reset_conn_monitor(sdata);
  1332. if (ieee80211_is_nullfunc(hdr->frame_control) &&
  1333. sdata->u.mgd.probe_send_count > 0) {
  1334. if (ack)
  1335. sdata->u.mgd.probe_send_count = 0;
  1336. else
  1337. sdata->u.mgd.nullfunc_failed = true;
  1338. ieee80211_queue_work(&sdata->local->hw, &sdata->work);
  1339. }
  1340. }
  1341. static void ieee80211_mgd_probe_ap_send(struct ieee80211_sub_if_data *sdata)
  1342. {
  1343. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1344. const u8 *ssid;
  1345. u8 *dst = ifmgd->associated->bssid;
  1346. u8 unicast_limit = max(1, max_probe_tries - 3);
  1347. /*
  1348. * Try sending broadcast probe requests for the last three
  1349. * probe requests after the first ones failed since some
  1350. * buggy APs only support broadcast probe requests.
  1351. */
  1352. if (ifmgd->probe_send_count >= unicast_limit)
  1353. dst = NULL;
  1354. /*
  1355. * When the hardware reports an accurate Tx ACK status, it's
  1356. * better to send a nullfunc frame instead of a probe request,
  1357. * as it will kick us off the AP quickly if we aren't associated
  1358. * anymore. The timeout will be reset if the frame is ACKed by
  1359. * the AP.
  1360. */
  1361. ifmgd->probe_send_count++;
  1362. if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
  1363. ifmgd->nullfunc_failed = false;
  1364. ieee80211_send_nullfunc(sdata->local, sdata, 0);
  1365. } else {
  1366. int ssid_len;
  1367. ssid = ieee80211_bss_get_ie(ifmgd->associated, WLAN_EID_SSID);
  1368. if (WARN_ON_ONCE(ssid == NULL))
  1369. ssid_len = 0;
  1370. else
  1371. ssid_len = ssid[1];
  1372. ieee80211_send_probe_req(sdata, dst, ssid + 2, ssid_len, NULL,
  1373. 0, (u32) -1, true, false,
  1374. ifmgd->associated->channel, false);
  1375. }
  1376. ifmgd->probe_timeout = jiffies + msecs_to_jiffies(probe_wait_ms);
  1377. run_again(ifmgd, ifmgd->probe_timeout);
  1378. if (sdata->local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
  1379. drv_flush(sdata->local, false);
  1380. }
  1381. static void ieee80211_mgd_probe_ap(struct ieee80211_sub_if_data *sdata,
  1382. bool beacon)
  1383. {
  1384. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1385. bool already = false;
  1386. if (!ieee80211_sdata_running(sdata))
  1387. return;
  1388. mutex_lock(&ifmgd->mtx);
  1389. if (!ifmgd->associated)
  1390. goto out;
  1391. mutex_lock(&sdata->local->mtx);
  1392. if (sdata->local->tmp_channel || sdata->local->scanning) {
  1393. mutex_unlock(&sdata->local->mtx);
  1394. goto out;
  1395. }
  1396. if (beacon)
  1397. mlme_dbg_ratelimited(sdata,
  1398. "detected beacon loss from AP - sending probe request\n");
  1399. ieee80211_cqm_rssi_notify(&sdata->vif,
  1400. NL80211_CQM_RSSI_BEACON_LOSS_EVENT, GFP_KERNEL);
  1401. /*
  1402. * The driver/our work has already reported this event or the
  1403. * connection monitoring has kicked in and we have already sent
  1404. * a probe request. Or maybe the AP died and the driver keeps
  1405. * reporting until we disassociate...
  1406. *
  1407. * In either case we have to ignore the current call to this
  1408. * function (except for setting the correct probe reason bit)
  1409. * because otherwise we would reset the timer every time and
  1410. * never check whether we received a probe response!
  1411. */
  1412. if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
  1413. IEEE80211_STA_CONNECTION_POLL))
  1414. already = true;
  1415. if (beacon)
  1416. ifmgd->flags |= IEEE80211_STA_BEACON_POLL;
  1417. else
  1418. ifmgd->flags |= IEEE80211_STA_CONNECTION_POLL;
  1419. mutex_unlock(&sdata->local->mtx);
  1420. if (already)
  1421. goto out;
  1422. mutex_lock(&sdata->local->iflist_mtx);
  1423. ieee80211_recalc_ps(sdata->local, -1);
  1424. mutex_unlock(&sdata->local->iflist_mtx);
  1425. ifmgd->probe_send_count = 0;
  1426. ieee80211_mgd_probe_ap_send(sdata);
  1427. out:
  1428. mutex_unlock(&ifmgd->mtx);
  1429. }
  1430. struct sk_buff *ieee80211_ap_probereq_get(struct ieee80211_hw *hw,
  1431. struct ieee80211_vif *vif)
  1432. {
  1433. struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
  1434. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1435. struct cfg80211_bss *cbss;
  1436. struct sk_buff *skb;
  1437. const u8 *ssid;
  1438. int ssid_len;
  1439. if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
  1440. return NULL;
  1441. ASSERT_MGD_MTX(ifmgd);
  1442. if (ifmgd->associated)
  1443. cbss = ifmgd->associated;
  1444. else if (ifmgd->auth_data)
  1445. cbss = ifmgd->auth_data->bss;
  1446. else if (ifmgd->assoc_data)
  1447. cbss = ifmgd->assoc_data->bss;
  1448. else
  1449. return NULL;
  1450. ssid = ieee80211_bss_get_ie(cbss, WLAN_EID_SSID);
  1451. if (WARN_ON_ONCE(ssid == NULL))
  1452. ssid_len = 0;
  1453. else
  1454. ssid_len = ssid[1];
  1455. skb = ieee80211_build_probe_req(sdata, cbss->bssid,
  1456. (u32) -1, cbss->channel,
  1457. ssid + 2, ssid_len,
  1458. NULL, 0, true);
  1459. return skb;
  1460. }
  1461. EXPORT_SYMBOL(ieee80211_ap_probereq_get);
  1462. static void __ieee80211_disconnect(struct ieee80211_sub_if_data *sdata,
  1463. bool transmit_frame)
  1464. {
  1465. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1466. struct ieee80211_local *local = sdata->local;
  1467. u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
  1468. mutex_lock(&ifmgd->mtx);
  1469. if (!ifmgd->associated) {
  1470. mutex_unlock(&ifmgd->mtx);
  1471. return;
  1472. }
  1473. ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
  1474. WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY,
  1475. transmit_frame, frame_buf);
  1476. ifmgd->flags &= ~IEEE80211_STA_CSA_RECEIVED;
  1477. mutex_unlock(&ifmgd->mtx);
  1478. /*
  1479. * must be outside lock due to cfg80211,
  1480. * but that's not a problem.
  1481. */
  1482. cfg80211_send_deauth(sdata->dev, frame_buf, IEEE80211_DEAUTH_FRAME_LEN);
  1483. mutex_lock(&local->mtx);
  1484. ieee80211_recalc_idle(local);
  1485. mutex_unlock(&local->mtx);
  1486. }
  1487. static void ieee80211_beacon_connection_loss_work(struct work_struct *work)
  1488. {
  1489. struct ieee80211_sub_if_data *sdata =
  1490. container_of(work, struct ieee80211_sub_if_data,
  1491. u.mgd.beacon_connection_loss_work);
  1492. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1493. struct sta_info *sta;
  1494. if (ifmgd->associated) {
  1495. rcu_read_lock();
  1496. sta = sta_info_get(sdata, ifmgd->bssid);
  1497. if (sta)
  1498. sta->beacon_loss_count++;
  1499. rcu_read_unlock();
  1500. }
  1501. if (sdata->local->hw.flags & IEEE80211_HW_CONNECTION_MONITOR) {
  1502. sdata_info(sdata, "Connection to AP %pM lost\n",
  1503. ifmgd->bssid);
  1504. __ieee80211_disconnect(sdata, false);
  1505. } else {
  1506. ieee80211_mgd_probe_ap(sdata, true);
  1507. }
  1508. }
  1509. static void ieee80211_csa_connection_drop_work(struct work_struct *work)
  1510. {
  1511. struct ieee80211_sub_if_data *sdata =
  1512. container_of(work, struct ieee80211_sub_if_data,
  1513. u.mgd.csa_connection_drop_work);
  1514. ieee80211_wake_queues_by_reason(&sdata->local->hw,
  1515. IEEE80211_QUEUE_STOP_REASON_CSA);
  1516. __ieee80211_disconnect(sdata, true);
  1517. }
  1518. void ieee80211_beacon_loss(struct ieee80211_vif *vif)
  1519. {
  1520. struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
  1521. struct ieee80211_hw *hw = &sdata->local->hw;
  1522. trace_api_beacon_loss(sdata);
  1523. WARN_ON(hw->flags & IEEE80211_HW_CONNECTION_MONITOR);
  1524. ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work);
  1525. }
  1526. EXPORT_SYMBOL(ieee80211_beacon_loss);
  1527. void ieee80211_connection_loss(struct ieee80211_vif *vif)
  1528. {
  1529. struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
  1530. struct ieee80211_hw *hw = &sdata->local->hw;
  1531. trace_api_connection_loss(sdata);
  1532. WARN_ON(!(hw->flags & IEEE80211_HW_CONNECTION_MONITOR));
  1533. ieee80211_queue_work(hw, &sdata->u.mgd.beacon_connection_loss_work);
  1534. }
  1535. EXPORT_SYMBOL(ieee80211_connection_loss);
  1536. static void ieee80211_destroy_auth_data(struct ieee80211_sub_if_data *sdata,
  1537. bool assoc)
  1538. {
  1539. struct ieee80211_mgd_auth_data *auth_data = sdata->u.mgd.auth_data;
  1540. lockdep_assert_held(&sdata->u.mgd.mtx);
  1541. if (!assoc) {
  1542. sta_info_destroy_addr(sdata, auth_data->bss->bssid);
  1543. memset(sdata->u.mgd.bssid, 0, ETH_ALEN);
  1544. ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
  1545. ieee80211_vif_release_channel(sdata);
  1546. }
  1547. cfg80211_put_bss(auth_data->bss);
  1548. kfree(auth_data);
  1549. sdata->u.mgd.auth_data = NULL;
  1550. }
  1551. static void ieee80211_auth_challenge(struct ieee80211_sub_if_data *sdata,
  1552. struct ieee80211_mgmt *mgmt, size_t len)
  1553. {
  1554. struct ieee80211_mgd_auth_data *auth_data = sdata->u.mgd.auth_data;
  1555. u8 *pos;
  1556. struct ieee802_11_elems elems;
  1557. pos = mgmt->u.auth.variable;
  1558. ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
  1559. if (!elems.challenge)
  1560. return;
  1561. auth_data->expected_transaction = 4;
  1562. drv_mgd_prepare_tx(sdata->local, sdata);
  1563. ieee80211_send_auth(sdata, 3, auth_data->algorithm, 0,
  1564. elems.challenge - 2, elems.challenge_len + 2,
  1565. auth_data->bss->bssid, auth_data->bss->bssid,
  1566. auth_data->key, auth_data->key_len,
  1567. auth_data->key_idx);
  1568. }
  1569. static enum rx_mgmt_action __must_check
  1570. ieee80211_rx_mgmt_auth(struct ieee80211_sub_if_data *sdata,
  1571. struct ieee80211_mgmt *mgmt, size_t len)
  1572. {
  1573. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1574. u8 bssid[ETH_ALEN];
  1575. u16 auth_alg, auth_transaction, status_code;
  1576. struct sta_info *sta;
  1577. lockdep_assert_held(&ifmgd->mtx);
  1578. if (len < 24 + 6)
  1579. return RX_MGMT_NONE;
  1580. if (!ifmgd->auth_data || ifmgd->auth_data->done)
  1581. return RX_MGMT_NONE;
  1582. memcpy(bssid, ifmgd->auth_data->bss->bssid, ETH_ALEN);
  1583. if (!ether_addr_equal(bssid, mgmt->bssid))
  1584. return RX_MGMT_NONE;
  1585. auth_alg = le16_to_cpu(mgmt->u.auth.auth_alg);
  1586. auth_transaction = le16_to_cpu(mgmt->u.auth.auth_transaction);
  1587. status_code = le16_to_cpu(mgmt->u.auth.status_code);
  1588. if (auth_alg != ifmgd->auth_data->algorithm ||
  1589. auth_transaction != ifmgd->auth_data->expected_transaction) {
  1590. sdata_info(sdata, "%pM unexpected authentication state: alg %d (expected %d) transact %d (expected %d)\n",
  1591. mgmt->sa, auth_alg, ifmgd->auth_data->algorithm,
  1592. auth_transaction,
  1593. ifmgd->auth_data->expected_transaction);
  1594. return RX_MGMT_NONE;
  1595. }
  1596. if (status_code != WLAN_STATUS_SUCCESS) {
  1597. sdata_info(sdata, "%pM denied authentication (status %d)\n",
  1598. mgmt->sa, status_code);
  1599. ieee80211_destroy_auth_data(sdata, false);
  1600. return RX_MGMT_CFG80211_RX_AUTH;
  1601. }
  1602. switch (ifmgd->auth_data->algorithm) {
  1603. case WLAN_AUTH_OPEN:
  1604. case WLAN_AUTH_LEAP:
  1605. case WLAN_AUTH_FT:
  1606. case WLAN_AUTH_SAE:
  1607. break;
  1608. case WLAN_AUTH_SHARED_KEY:
  1609. if (ifmgd->auth_data->expected_transaction != 4) {
  1610. ieee80211_auth_challenge(sdata, mgmt, len);
  1611. /* need another frame */
  1612. return RX_MGMT_NONE;
  1613. }
  1614. break;
  1615. default:
  1616. WARN_ONCE(1, "invalid auth alg %d",
  1617. ifmgd->auth_data->algorithm);
  1618. return RX_MGMT_NONE;
  1619. }
  1620. sdata_info(sdata, "authenticated\n");
  1621. ifmgd->auth_data->done = true;
  1622. ifmgd->auth_data->timeout = jiffies + IEEE80211_AUTH_WAIT_ASSOC;
  1623. run_again(ifmgd, ifmgd->auth_data->timeout);
  1624. if (ifmgd->auth_data->algorithm == WLAN_AUTH_SAE &&
  1625. ifmgd->auth_data->expected_transaction != 2) {
  1626. /*
  1627. * Report auth frame to user space for processing since another
  1628. * round of Authentication frames is still needed.
  1629. */
  1630. return RX_MGMT_CFG80211_RX_AUTH;
  1631. }
  1632. /* move station state to auth */
  1633. mutex_lock(&sdata->local->sta_mtx);
  1634. sta = sta_info_get(sdata, bssid);
  1635. if (!sta) {
  1636. WARN_ONCE(1, "%s: STA %pM not found", sdata->name, bssid);
  1637. goto out_err;
  1638. }
  1639. if (sta_info_move_state(sta, IEEE80211_STA_AUTH)) {
  1640. sdata_info(sdata, "failed moving %pM to auth\n", bssid);
  1641. goto out_err;
  1642. }
  1643. mutex_unlock(&sdata->local->sta_mtx);
  1644. return RX_MGMT_CFG80211_RX_AUTH;
  1645. out_err:
  1646. mutex_unlock(&sdata->local->sta_mtx);
  1647. /* ignore frame -- wait for timeout */
  1648. return RX_MGMT_NONE;
  1649. }
  1650. static enum rx_mgmt_action __must_check
  1651. ieee80211_rx_mgmt_deauth(struct ieee80211_sub_if_data *sdata,
  1652. struct ieee80211_mgmt *mgmt, size_t len)
  1653. {
  1654. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1655. const u8 *bssid = NULL;
  1656. u16 reason_code;
  1657. lockdep_assert_held(&ifmgd->mtx);
  1658. if (len < 24 + 2)
  1659. return RX_MGMT_NONE;
  1660. if (!ifmgd->associated ||
  1661. !ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
  1662. return RX_MGMT_NONE;
  1663. bssid = ifmgd->associated->bssid;
  1664. reason_code = le16_to_cpu(mgmt->u.deauth.reason_code);
  1665. sdata_info(sdata, "deauthenticated from %pM (Reason: %u)\n",
  1666. bssid, reason_code);
  1667. ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
  1668. mutex_lock(&sdata->local->mtx);
  1669. ieee80211_recalc_idle(sdata->local);
  1670. mutex_unlock(&sdata->local->mtx);
  1671. return RX_MGMT_CFG80211_DEAUTH;
  1672. }
  1673. static enum rx_mgmt_action __must_check
  1674. ieee80211_rx_mgmt_disassoc(struct ieee80211_sub_if_data *sdata,
  1675. struct ieee80211_mgmt *mgmt, size_t len)
  1676. {
  1677. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1678. u16 reason_code;
  1679. lockdep_assert_held(&ifmgd->mtx);
  1680. if (len < 24 + 2)
  1681. return RX_MGMT_NONE;
  1682. if (!ifmgd->associated ||
  1683. !ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
  1684. return RX_MGMT_NONE;
  1685. reason_code = le16_to_cpu(mgmt->u.disassoc.reason_code);
  1686. sdata_info(sdata, "disassociated from %pM (Reason: %u)\n",
  1687. mgmt->sa, reason_code);
  1688. ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
  1689. mutex_lock(&sdata->local->mtx);
  1690. ieee80211_recalc_idle(sdata->local);
  1691. mutex_unlock(&sdata->local->mtx);
  1692. return RX_MGMT_CFG80211_DISASSOC;
  1693. }
  1694. static void ieee80211_get_rates(struct ieee80211_supported_band *sband,
  1695. u8 *supp_rates, unsigned int supp_rates_len,
  1696. u32 *rates, u32 *basic_rates,
  1697. bool *have_higher_than_11mbit,
  1698. int *min_rate, int *min_rate_index)
  1699. {
  1700. int i, j;
  1701. for (i = 0; i < supp_rates_len; i++) {
  1702. int rate = (supp_rates[i] & 0x7f) * 5;
  1703. bool is_basic = !!(supp_rates[i] & 0x80);
  1704. if (rate > 110)
  1705. *have_higher_than_11mbit = true;
  1706. /*
  1707. * BSS_MEMBERSHIP_SELECTOR_HT_PHY is defined in 802.11n-2009
  1708. * 7.3.2.2 as a magic value instead of a rate. Hence, skip it.
  1709. *
  1710. * Note: Even through the membership selector and the basic
  1711. * rate flag share the same bit, they are not exactly
  1712. * the same.
  1713. */
  1714. if (!!(supp_rates[i] & 0x80) &&
  1715. (supp_rates[i] & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
  1716. continue;
  1717. for (j = 0; j < sband->n_bitrates; j++) {
  1718. if (sband->bitrates[j].bitrate == rate) {
  1719. *rates |= BIT(j);
  1720. if (is_basic)
  1721. *basic_rates |= BIT(j);
  1722. if (rate < *min_rate) {
  1723. *min_rate = rate;
  1724. *min_rate_index = j;
  1725. }
  1726. break;
  1727. }
  1728. }
  1729. }
  1730. }
  1731. static void ieee80211_destroy_assoc_data(struct ieee80211_sub_if_data *sdata,
  1732. bool assoc)
  1733. {
  1734. struct ieee80211_mgd_assoc_data *assoc_data = sdata->u.mgd.assoc_data;
  1735. lockdep_assert_held(&sdata->u.mgd.mtx);
  1736. if (!assoc) {
  1737. sta_info_destroy_addr(sdata, assoc_data->bss->bssid);
  1738. memset(sdata->u.mgd.bssid, 0, ETH_ALEN);
  1739. ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
  1740. ieee80211_vif_release_channel(sdata);
  1741. }
  1742. kfree(assoc_data);
  1743. sdata->u.mgd.assoc_data = NULL;
  1744. }
  1745. static bool ieee80211_assoc_success(struct ieee80211_sub_if_data *sdata,
  1746. struct cfg80211_bss *cbss,
  1747. struct ieee80211_mgmt *mgmt, size_t len)
  1748. {
  1749. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1750. struct ieee80211_local *local = sdata->local;
  1751. struct ieee80211_supported_band *sband;
  1752. struct sta_info *sta;
  1753. u8 *pos;
  1754. u16 capab_info, aid;
  1755. struct ieee802_11_elems elems;
  1756. struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
  1757. u32 changed = 0;
  1758. int err;
  1759. /* AssocResp and ReassocResp have identical structure */
  1760. aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
  1761. capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
  1762. if ((aid & (BIT(15) | BIT(14))) != (BIT(15) | BIT(14)))
  1763. sdata_info(sdata, "invalid AID value 0x%x; bits 15:14 not set\n",
  1764. aid);
  1765. aid &= ~(BIT(15) | BIT(14));
  1766. ifmgd->broken_ap = false;
  1767. if (aid == 0 || aid > IEEE80211_MAX_AID) {
  1768. sdata_info(sdata, "invalid AID value %d (out of range), turn off PS\n",
  1769. aid);
  1770. aid = 0;
  1771. ifmgd->broken_ap = true;
  1772. }
  1773. pos = mgmt->u.assoc_resp.variable;
  1774. ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
  1775. if (!elems.supp_rates) {
  1776. sdata_info(sdata, "no SuppRates element in AssocResp\n");
  1777. return false;
  1778. }
  1779. ifmgd->aid = aid;
  1780. mutex_lock(&sdata->local->sta_mtx);
  1781. /*
  1782. * station info was already allocated and inserted before
  1783. * the association and should be available to us
  1784. */
  1785. sta = sta_info_get(sdata, cbss->bssid);
  1786. if (WARN_ON(!sta)) {
  1787. mutex_unlock(&sdata->local->sta_mtx);
  1788. return false;
  1789. }
  1790. sband = local->hw.wiphy->bands[ieee80211_get_sdata_band(sdata)];
  1791. if (elems.ht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
  1792. ieee80211_ht_cap_ie_to_sta_ht_cap(sdata, sband,
  1793. elems.ht_cap_elem, &sta->sta.ht_cap);
  1794. sta->supports_40mhz =
  1795. sta->sta.ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40;
  1796. if (elems.vht_cap_elem && !(ifmgd->flags & IEEE80211_STA_DISABLE_VHT))
  1797. ieee80211_vht_cap_ie_to_sta_vht_cap(sdata, sband,
  1798. elems.vht_cap_elem,
  1799. &sta->sta.vht_cap);
  1800. rate_control_rate_init(sta);
  1801. if (ifmgd->flags & IEEE80211_STA_MFP_ENABLED)
  1802. set_sta_flag(sta, WLAN_STA_MFP);
  1803. if (elems.wmm_param)
  1804. set_sta_flag(sta, WLAN_STA_WME);
  1805. err = sta_info_move_state(sta, IEEE80211_STA_AUTH);
  1806. if (!err)
  1807. err = sta_info_move_state(sta, IEEE80211_STA_ASSOC);
  1808. if (!err && !(ifmgd->flags & IEEE80211_STA_CONTROL_PORT))
  1809. err = sta_info_move_state(sta, IEEE80211_STA_AUTHORIZED);
  1810. if (err) {
  1811. sdata_info(sdata,
  1812. "failed to move station %pM to desired state\n",
  1813. sta->sta.addr);
  1814. WARN_ON(__sta_info_destroy(sta));
  1815. mutex_unlock(&sdata->local->sta_mtx);
  1816. return false;
  1817. }
  1818. mutex_unlock(&sdata->local->sta_mtx);
  1819. /*
  1820. * Always handle WMM once after association regardless
  1821. * of the first value the AP uses. Setting -1 here has
  1822. * that effect because the AP values is an unsigned
  1823. * 4-bit value.
  1824. */
  1825. ifmgd->wmm_last_param_set = -1;
  1826. if (elems.wmm_param)
  1827. ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
  1828. elems.wmm_param_len);
  1829. else
  1830. ieee80211_set_wmm_default(sdata, false);
  1831. changed |= BSS_CHANGED_QOS;
  1832. if (elems.ht_operation && elems.wmm_param &&
  1833. !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
  1834. changed |= ieee80211_config_ht_tx(sdata, elems.ht_operation,
  1835. cbss->bssid, false);
  1836. /* set AID and assoc capability,
  1837. * ieee80211_set_associated() will tell the driver */
  1838. bss_conf->aid = aid;
  1839. bss_conf->assoc_capability = capab_info;
  1840. ieee80211_set_associated(sdata, cbss, changed);
  1841. /*
  1842. * If we're using 4-addr mode, let the AP know that we're
  1843. * doing so, so that it can create the STA VLAN on its side
  1844. */
  1845. if (ifmgd->use_4addr)
  1846. ieee80211_send_4addr_nullfunc(local, sdata);
  1847. /*
  1848. * Start timer to probe the connection to the AP now.
  1849. * Also start the timer that will detect beacon loss.
  1850. */
  1851. ieee80211_sta_rx_notify(sdata, (struct ieee80211_hdr *)mgmt);
  1852. ieee80211_sta_reset_beacon_monitor(sdata);
  1853. return true;
  1854. }
  1855. static enum rx_mgmt_action __must_check
  1856. ieee80211_rx_mgmt_assoc_resp(struct ieee80211_sub_if_data *sdata,
  1857. struct ieee80211_mgmt *mgmt, size_t len,
  1858. struct cfg80211_bss **bss)
  1859. {
  1860. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  1861. struct ieee80211_mgd_assoc_data *assoc_data = ifmgd->assoc_data;
  1862. u16 capab_info, status_code, aid;
  1863. struct ieee802_11_elems elems;
  1864. u8 *pos;
  1865. bool reassoc;
  1866. lockdep_assert_held(&ifmgd->mtx);
  1867. if (!assoc_data)
  1868. return RX_MGMT_NONE;
  1869. if (!ether_addr_equal(assoc_data->bss->bssid, mgmt->bssid))
  1870. return RX_MGMT_NONE;
  1871. /*
  1872. * AssocResp and ReassocResp have identical structure, so process both
  1873. * of them in this function.
  1874. */
  1875. if (len < 24 + 6)
  1876. return RX_MGMT_NONE;
  1877. reassoc = ieee80211_is_reassoc_req(mgmt->frame_control);
  1878. capab_info = le16_to_cpu(mgmt->u.assoc_resp.capab_info);
  1879. status_code = le16_to_cpu(mgmt->u.assoc_resp.status_code);
  1880. aid = le16_to_cpu(mgmt->u.assoc_resp.aid);
  1881. sdata_info(sdata,
  1882. "RX %sssocResp from %pM (capab=0x%x status=%d aid=%d)\n",
  1883. reassoc ? "Rea" : "A", mgmt->sa,
  1884. capab_info, status_code, (u16)(aid & ~(BIT(15) | BIT(14))));
  1885. pos = mgmt->u.assoc_resp.variable;
  1886. ieee802_11_parse_elems(pos, len - (pos - (u8 *) mgmt), &elems);
  1887. if (status_code == WLAN_STATUS_ASSOC_REJECTED_TEMPORARILY &&
  1888. elems.timeout_int && elems.timeout_int_len == 5 &&
  1889. elems.timeout_int[0] == WLAN_TIMEOUT_ASSOC_COMEBACK) {
  1890. u32 tu, ms;
  1891. tu = get_unaligned_le32(elems.timeout_int + 1);
  1892. ms = tu * 1024 / 1000;
  1893. sdata_info(sdata,
  1894. "%pM rejected association temporarily; comeback duration %u TU (%u ms)\n",
  1895. mgmt->sa, tu, ms);
  1896. assoc_data->timeout = jiffies + msecs_to_jiffies(ms);
  1897. if (ms > IEEE80211_ASSOC_TIMEOUT)
  1898. run_again(ifmgd, assoc_data->timeout);
  1899. return RX_MGMT_NONE;
  1900. }
  1901. *bss = assoc_data->bss;
  1902. if (status_code != WLAN_STATUS_SUCCESS) {
  1903. sdata_info(sdata, "%pM denied association (code=%d)\n",
  1904. mgmt->sa, status_code);
  1905. ieee80211_destroy_assoc_data(sdata, false);
  1906. } else {
  1907. if (!ieee80211_assoc_success(sdata, *bss, mgmt, len)) {
  1908. /* oops -- internal error -- send timeout for now */
  1909. ieee80211_destroy_assoc_data(sdata, false);
  1910. cfg80211_put_bss(*bss);
  1911. return RX_MGMT_CFG80211_ASSOC_TIMEOUT;
  1912. }
  1913. sdata_info(sdata, "associated\n");
  1914. /*
  1915. * destroy assoc_data afterwards, as otherwise an idle
  1916. * recalc after assoc_data is NULL but before associated
  1917. * is set can cause the interface to go idle
  1918. */
  1919. ieee80211_destroy_assoc_data(sdata, true);
  1920. }
  1921. return RX_MGMT_CFG80211_RX_ASSOC;
  1922. }
  1923. static void ieee80211_rx_bss_info(struct ieee80211_sub_if_data *sdata,
  1924. struct ieee80211_mgmt *mgmt,
  1925. size_t len,
  1926. struct ieee80211_rx_status *rx_status,
  1927. struct ieee802_11_elems *elems,
  1928. bool beacon)
  1929. {
  1930. struct ieee80211_local *local = sdata->local;
  1931. int freq;
  1932. struct ieee80211_bss *bss;
  1933. struct ieee80211_channel *channel;
  1934. bool need_ps = false;
  1935. if (sdata->u.mgd.associated &&
  1936. ether_addr_equal(mgmt->bssid, sdata->u.mgd.associated->bssid)) {
  1937. bss = (void *)sdata->u.mgd.associated->priv;
  1938. /* not previously set so we may need to recalc */
  1939. need_ps = !bss->dtim_period;
  1940. }
  1941. if (elems->ds_params && elems->ds_params_len == 1)
  1942. freq = ieee80211_channel_to_frequency(elems->ds_params[0],
  1943. rx_status->band);
  1944. else
  1945. freq = rx_status->freq;
  1946. channel = ieee80211_get_channel(local->hw.wiphy, freq);
  1947. if (!channel || channel->flags & IEEE80211_CHAN_DISABLED)
  1948. return;
  1949. bss = ieee80211_bss_info_update(local, rx_status, mgmt, len, elems,
  1950. channel, beacon);
  1951. if (bss)
  1952. ieee80211_rx_bss_put(local, bss);
  1953. if (!sdata->u.mgd.associated)
  1954. return;
  1955. if (need_ps) {
  1956. mutex_lock(&local->iflist_mtx);
  1957. ieee80211_recalc_ps(local, -1);
  1958. mutex_unlock(&local->iflist_mtx);
  1959. }
  1960. if (elems->ch_switch_ie &&
  1961. memcmp(mgmt->bssid, sdata->u.mgd.associated->bssid, ETH_ALEN) == 0)
  1962. ieee80211_sta_process_chanswitch(sdata, elems->ch_switch_ie,
  1963. bss, rx_status->mactime);
  1964. }
  1965. static void ieee80211_rx_mgmt_probe_resp(struct ieee80211_sub_if_data *sdata,
  1966. struct sk_buff *skb)
  1967. {
  1968. struct ieee80211_mgmt *mgmt = (void *)skb->data;
  1969. struct ieee80211_if_managed *ifmgd;
  1970. struct ieee80211_rx_status *rx_status = (void *) skb->cb;
  1971. size_t baselen, len = skb->len;
  1972. struct ieee802_11_elems elems;
  1973. ifmgd = &sdata->u.mgd;
  1974. ASSERT_MGD_MTX(ifmgd);
  1975. if (!ether_addr_equal(mgmt->da, sdata->vif.addr))
  1976. return; /* ignore ProbeResp to foreign address */
  1977. baselen = (u8 *) mgmt->u.probe_resp.variable - (u8 *) mgmt;
  1978. if (baselen > len)
  1979. return;
  1980. ieee802_11_parse_elems(mgmt->u.probe_resp.variable, len - baselen,
  1981. &elems);
  1982. ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems, false);
  1983. if (ifmgd->associated &&
  1984. ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
  1985. ieee80211_reset_ap_probe(sdata);
  1986. if (ifmgd->auth_data && !ifmgd->auth_data->bss->proberesp_ies &&
  1987. ether_addr_equal(mgmt->bssid, ifmgd->auth_data->bss->bssid)) {
  1988. /* got probe response, continue with auth */
  1989. sdata_info(sdata, "direct probe responded\n");
  1990. ifmgd->auth_data->tries = 0;
  1991. ifmgd->auth_data->timeout = jiffies;
  1992. run_again(ifmgd, ifmgd->auth_data->timeout);
  1993. }
  1994. }
  1995. /*
  1996. * This is the canonical list of information elements we care about,
  1997. * the filter code also gives us all changes to the Microsoft OUI
  1998. * (00:50:F2) vendor IE which is used for WMM which we need to track.
  1999. *
  2000. * We implement beacon filtering in software since that means we can
  2001. * avoid processing the frame here and in cfg80211, and userspace
  2002. * will not be able to tell whether the hardware supports it or not.
  2003. *
  2004. * XXX: This list needs to be dynamic -- userspace needs to be able to
  2005. * add items it requires. It also needs to be able to tell us to
  2006. * look out for other vendor IEs.
  2007. */
  2008. static const u64 care_about_ies =
  2009. (1ULL << WLAN_EID_COUNTRY) |
  2010. (1ULL << WLAN_EID_ERP_INFO) |
  2011. (1ULL << WLAN_EID_CHANNEL_SWITCH) |
  2012. (1ULL << WLAN_EID_PWR_CONSTRAINT) |
  2013. (1ULL << WLAN_EID_HT_CAPABILITY) |
  2014. (1ULL << WLAN_EID_HT_OPERATION);
  2015. static void ieee80211_rx_mgmt_beacon(struct ieee80211_sub_if_data *sdata,
  2016. struct ieee80211_mgmt *mgmt,
  2017. size_t len,
  2018. struct ieee80211_rx_status *rx_status)
  2019. {
  2020. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2021. struct ieee80211_bss_conf *bss_conf = &sdata->vif.bss_conf;
  2022. size_t baselen;
  2023. struct ieee802_11_elems elems;
  2024. struct ieee80211_local *local = sdata->local;
  2025. struct ieee80211_chanctx_conf *chanctx_conf;
  2026. struct ieee80211_channel *chan;
  2027. u32 changed = 0;
  2028. bool erp_valid;
  2029. u8 erp_value = 0;
  2030. u32 ncrc;
  2031. u8 *bssid;
  2032. lockdep_assert_held(&ifmgd->mtx);
  2033. /* Process beacon from the current BSS */
  2034. baselen = (u8 *) mgmt->u.beacon.variable - (u8 *) mgmt;
  2035. if (baselen > len)
  2036. return;
  2037. rcu_read_lock();
  2038. chanctx_conf = rcu_dereference(sdata->vif.chanctx_conf);
  2039. if (!chanctx_conf) {
  2040. rcu_read_unlock();
  2041. return;
  2042. }
  2043. if (rx_status->freq != chanctx_conf->channel->center_freq) {
  2044. rcu_read_unlock();
  2045. return;
  2046. }
  2047. chan = chanctx_conf->channel;
  2048. rcu_read_unlock();
  2049. if (ifmgd->assoc_data && !ifmgd->assoc_data->have_beacon &&
  2050. ether_addr_equal(mgmt->bssid, ifmgd->assoc_data->bss->bssid)) {
  2051. ieee802_11_parse_elems(mgmt->u.beacon.variable,
  2052. len - baselen, &elems);
  2053. ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
  2054. false);
  2055. ifmgd->assoc_data->have_beacon = true;
  2056. ifmgd->assoc_data->sent_assoc = false;
  2057. /* continue assoc process */
  2058. ifmgd->assoc_data->timeout = jiffies;
  2059. run_again(ifmgd, ifmgd->assoc_data->timeout);
  2060. return;
  2061. }
  2062. if (!ifmgd->associated ||
  2063. !ether_addr_equal(mgmt->bssid, ifmgd->associated->bssid))
  2064. return;
  2065. bssid = ifmgd->associated->bssid;
  2066. /* Track average RSSI from the Beacon frames of the current AP */
  2067. ifmgd->last_beacon_signal = rx_status->signal;
  2068. if (ifmgd->flags & IEEE80211_STA_RESET_SIGNAL_AVE) {
  2069. ifmgd->flags &= ~IEEE80211_STA_RESET_SIGNAL_AVE;
  2070. ifmgd->ave_beacon_signal = rx_status->signal * 16;
  2071. ifmgd->last_cqm_event_signal = 0;
  2072. ifmgd->count_beacon_signal = 1;
  2073. ifmgd->last_ave_beacon_signal = 0;
  2074. } else {
  2075. ifmgd->ave_beacon_signal =
  2076. (IEEE80211_SIGNAL_AVE_WEIGHT * rx_status->signal * 16 +
  2077. (16 - IEEE80211_SIGNAL_AVE_WEIGHT) *
  2078. ifmgd->ave_beacon_signal) / 16;
  2079. ifmgd->count_beacon_signal++;
  2080. }
  2081. if (ifmgd->rssi_min_thold != ifmgd->rssi_max_thold &&
  2082. ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT) {
  2083. int sig = ifmgd->ave_beacon_signal;
  2084. int last_sig = ifmgd->last_ave_beacon_signal;
  2085. /*
  2086. * if signal crosses either of the boundaries, invoke callback
  2087. * with appropriate parameters
  2088. */
  2089. if (sig > ifmgd->rssi_max_thold &&
  2090. (last_sig <= ifmgd->rssi_min_thold || last_sig == 0)) {
  2091. ifmgd->last_ave_beacon_signal = sig;
  2092. drv_rssi_callback(local, RSSI_EVENT_HIGH);
  2093. } else if (sig < ifmgd->rssi_min_thold &&
  2094. (last_sig >= ifmgd->rssi_max_thold ||
  2095. last_sig == 0)) {
  2096. ifmgd->last_ave_beacon_signal = sig;
  2097. drv_rssi_callback(local, RSSI_EVENT_LOW);
  2098. }
  2099. }
  2100. if (bss_conf->cqm_rssi_thold &&
  2101. ifmgd->count_beacon_signal >= IEEE80211_SIGNAL_AVE_MIN_COUNT &&
  2102. !(sdata->vif.driver_flags & IEEE80211_VIF_SUPPORTS_CQM_RSSI)) {
  2103. int sig = ifmgd->ave_beacon_signal / 16;
  2104. int last_event = ifmgd->last_cqm_event_signal;
  2105. int thold = bss_conf->cqm_rssi_thold;
  2106. int hyst = bss_conf->cqm_rssi_hyst;
  2107. if (sig < thold &&
  2108. (last_event == 0 || sig < last_event - hyst)) {
  2109. ifmgd->last_cqm_event_signal = sig;
  2110. ieee80211_cqm_rssi_notify(
  2111. &sdata->vif,
  2112. NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW,
  2113. GFP_KERNEL);
  2114. } else if (sig > thold &&
  2115. (last_event == 0 || sig > last_event + hyst)) {
  2116. ifmgd->last_cqm_event_signal = sig;
  2117. ieee80211_cqm_rssi_notify(
  2118. &sdata->vif,
  2119. NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH,
  2120. GFP_KERNEL);
  2121. }
  2122. }
  2123. if (ifmgd->flags & IEEE80211_STA_BEACON_POLL) {
  2124. mlme_dbg_ratelimited(sdata,
  2125. "cancelling probereq poll due to a received beacon\n");
  2126. mutex_lock(&local->mtx);
  2127. ifmgd->flags &= ~IEEE80211_STA_BEACON_POLL;
  2128. ieee80211_run_deferred_scan(local);
  2129. mutex_unlock(&local->mtx);
  2130. mutex_lock(&local->iflist_mtx);
  2131. ieee80211_recalc_ps(local, -1);
  2132. mutex_unlock(&local->iflist_mtx);
  2133. }
  2134. /*
  2135. * Push the beacon loss detection into the future since
  2136. * we are processing a beacon from the AP just now.
  2137. */
  2138. ieee80211_sta_reset_beacon_monitor(sdata);
  2139. ncrc = crc32_be(0, (void *)&mgmt->u.beacon.beacon_int, 4);
  2140. ncrc = ieee802_11_parse_elems_crc(mgmt->u.beacon.variable,
  2141. len - baselen, &elems,
  2142. care_about_ies, ncrc);
  2143. if (local->hw.flags & IEEE80211_HW_PS_NULLFUNC_STACK) {
  2144. bool directed_tim = ieee80211_check_tim(elems.tim,
  2145. elems.tim_len,
  2146. ifmgd->aid);
  2147. if (directed_tim) {
  2148. if (local->hw.conf.dynamic_ps_timeout > 0) {
  2149. if (local->hw.conf.flags & IEEE80211_CONF_PS) {
  2150. local->hw.conf.flags &= ~IEEE80211_CONF_PS;
  2151. ieee80211_hw_config(local,
  2152. IEEE80211_CONF_CHANGE_PS);
  2153. }
  2154. ieee80211_send_nullfunc(local, sdata, 0);
  2155. } else if (!local->pspolling && sdata->u.mgd.powersave) {
  2156. local->pspolling = true;
  2157. /*
  2158. * Here is assumed that the driver will be
  2159. * able to send ps-poll frame and receive a
  2160. * response even though power save mode is
  2161. * enabled, but some drivers might require
  2162. * to disable power save here. This needs
  2163. * to be investigated.
  2164. */
  2165. ieee80211_send_pspoll(local, sdata);
  2166. }
  2167. }
  2168. }
  2169. if (sdata->vif.p2p) {
  2170. u8 noa[2];
  2171. int ret;
  2172. ret = cfg80211_get_p2p_attr(mgmt->u.beacon.variable,
  2173. len - baselen,
  2174. IEEE80211_P2P_ATTR_ABSENCE_NOTICE,
  2175. noa, sizeof(noa));
  2176. if (ret >= 2 && sdata->u.mgd.p2p_noa_index != noa[0]) {
  2177. bss_conf->p2p_oppps = noa[1] & 0x80;
  2178. bss_conf->p2p_ctwindow = noa[1] & 0x7f;
  2179. changed |= BSS_CHANGED_P2P_PS;
  2180. sdata->u.mgd.p2p_noa_index = noa[0];
  2181. /*
  2182. * make sure we update all information, the CRC
  2183. * mechanism doesn't look at P2P attributes.
  2184. */
  2185. ifmgd->beacon_crc_valid = false;
  2186. }
  2187. }
  2188. if (ncrc == ifmgd->beacon_crc && ifmgd->beacon_crc_valid)
  2189. return;
  2190. ifmgd->beacon_crc = ncrc;
  2191. ifmgd->beacon_crc_valid = true;
  2192. ieee80211_rx_bss_info(sdata, mgmt, len, rx_status, &elems,
  2193. true);
  2194. if (ieee80211_sta_wmm_params(local, sdata, elems.wmm_param,
  2195. elems.wmm_param_len))
  2196. changed |= BSS_CHANGED_QOS;
  2197. if (elems.erp_info && elems.erp_info_len >= 1) {
  2198. erp_valid = true;
  2199. erp_value = elems.erp_info[0];
  2200. } else {
  2201. erp_valid = false;
  2202. }
  2203. changed |= ieee80211_handle_bss_capability(sdata,
  2204. le16_to_cpu(mgmt->u.beacon.capab_info),
  2205. erp_valid, erp_value);
  2206. if (elems.ht_cap_elem && elems.ht_operation && elems.wmm_param &&
  2207. !(ifmgd->flags & IEEE80211_STA_DISABLE_11N))
  2208. changed |= ieee80211_config_ht_tx(sdata, elems.ht_operation,
  2209. bssid, true);
  2210. if (elems.country_elem && elems.pwr_constr_elem &&
  2211. mgmt->u.probe_resp.capab_info &
  2212. cpu_to_le16(WLAN_CAPABILITY_SPECTRUM_MGMT))
  2213. changed |= ieee80211_handle_pwr_constr(sdata, chan,
  2214. elems.country_elem,
  2215. elems.country_elem_len,
  2216. elems.pwr_constr_elem);
  2217. ieee80211_bss_info_change_notify(sdata, changed);
  2218. }
  2219. void ieee80211_sta_rx_queued_mgmt(struct ieee80211_sub_if_data *sdata,
  2220. struct sk_buff *skb)
  2221. {
  2222. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2223. struct ieee80211_rx_status *rx_status;
  2224. struct ieee80211_mgmt *mgmt;
  2225. struct cfg80211_bss *bss = NULL;
  2226. enum rx_mgmt_action rma = RX_MGMT_NONE;
  2227. u16 fc;
  2228. rx_status = (struct ieee80211_rx_status *) skb->cb;
  2229. mgmt = (struct ieee80211_mgmt *) skb->data;
  2230. fc = le16_to_cpu(mgmt->frame_control);
  2231. mutex_lock(&ifmgd->mtx);
  2232. switch (fc & IEEE80211_FCTL_STYPE) {
  2233. case IEEE80211_STYPE_BEACON:
  2234. ieee80211_rx_mgmt_beacon(sdata, mgmt, skb->len, rx_status);
  2235. break;
  2236. case IEEE80211_STYPE_PROBE_RESP:
  2237. ieee80211_rx_mgmt_probe_resp(sdata, skb);
  2238. break;
  2239. case IEEE80211_STYPE_AUTH:
  2240. rma = ieee80211_rx_mgmt_auth(sdata, mgmt, skb->len);
  2241. break;
  2242. case IEEE80211_STYPE_DEAUTH:
  2243. rma = ieee80211_rx_mgmt_deauth(sdata, mgmt, skb->len);
  2244. break;
  2245. case IEEE80211_STYPE_DISASSOC:
  2246. rma = ieee80211_rx_mgmt_disassoc(sdata, mgmt, skb->len);
  2247. break;
  2248. case IEEE80211_STYPE_ASSOC_RESP:
  2249. case IEEE80211_STYPE_REASSOC_RESP:
  2250. rma = ieee80211_rx_mgmt_assoc_resp(sdata, mgmt, skb->len, &bss);
  2251. break;
  2252. case IEEE80211_STYPE_ACTION:
  2253. switch (mgmt->u.action.category) {
  2254. case WLAN_CATEGORY_SPECTRUM_MGMT:
  2255. ieee80211_sta_process_chanswitch(sdata,
  2256. &mgmt->u.action.u.chan_switch.sw_elem,
  2257. (void *)ifmgd->associated->priv,
  2258. rx_status->mactime);
  2259. break;
  2260. }
  2261. }
  2262. mutex_unlock(&ifmgd->mtx);
  2263. switch (rma) {
  2264. case RX_MGMT_NONE:
  2265. /* no action */
  2266. break;
  2267. case RX_MGMT_CFG80211_DEAUTH:
  2268. cfg80211_send_deauth(sdata->dev, (u8 *)mgmt, skb->len);
  2269. break;
  2270. case RX_MGMT_CFG80211_DISASSOC:
  2271. cfg80211_send_disassoc(sdata->dev, (u8 *)mgmt, skb->len);
  2272. break;
  2273. case RX_MGMT_CFG80211_RX_AUTH:
  2274. cfg80211_send_rx_auth(sdata->dev, (u8 *)mgmt, skb->len);
  2275. break;
  2276. case RX_MGMT_CFG80211_RX_ASSOC:
  2277. cfg80211_send_rx_assoc(sdata->dev, bss, (u8 *)mgmt, skb->len);
  2278. break;
  2279. case RX_MGMT_CFG80211_ASSOC_TIMEOUT:
  2280. cfg80211_send_assoc_timeout(sdata->dev, mgmt->bssid);
  2281. break;
  2282. default:
  2283. WARN(1, "unexpected: %d", rma);
  2284. }
  2285. }
  2286. static void ieee80211_sta_timer(unsigned long data)
  2287. {
  2288. struct ieee80211_sub_if_data *sdata =
  2289. (struct ieee80211_sub_if_data *) data;
  2290. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2291. struct ieee80211_local *local = sdata->local;
  2292. if (local->quiescing) {
  2293. set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
  2294. return;
  2295. }
  2296. ieee80211_queue_work(&local->hw, &sdata->work);
  2297. }
  2298. static void ieee80211_sta_connection_lost(struct ieee80211_sub_if_data *sdata,
  2299. u8 *bssid, u8 reason)
  2300. {
  2301. struct ieee80211_local *local = sdata->local;
  2302. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2303. u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
  2304. ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH, reason,
  2305. false, frame_buf);
  2306. mutex_unlock(&ifmgd->mtx);
  2307. /*
  2308. * must be outside lock due to cfg80211,
  2309. * but that's not a problem.
  2310. */
  2311. cfg80211_send_deauth(sdata->dev, frame_buf, IEEE80211_DEAUTH_FRAME_LEN);
  2312. mutex_lock(&local->mtx);
  2313. ieee80211_recalc_idle(local);
  2314. mutex_unlock(&local->mtx);
  2315. mutex_lock(&ifmgd->mtx);
  2316. }
  2317. static int ieee80211_probe_auth(struct ieee80211_sub_if_data *sdata)
  2318. {
  2319. struct ieee80211_local *local = sdata->local;
  2320. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2321. struct ieee80211_mgd_auth_data *auth_data = ifmgd->auth_data;
  2322. lockdep_assert_held(&ifmgd->mtx);
  2323. if (WARN_ON_ONCE(!auth_data))
  2324. return -EINVAL;
  2325. auth_data->tries++;
  2326. if (auth_data->tries > IEEE80211_AUTH_MAX_TRIES) {
  2327. sdata_info(sdata, "authentication with %pM timed out\n",
  2328. auth_data->bss->bssid);
  2329. /*
  2330. * Most likely AP is not in the range so remove the
  2331. * bss struct for that AP.
  2332. */
  2333. cfg80211_unlink_bss(local->hw.wiphy, auth_data->bss);
  2334. return -ETIMEDOUT;
  2335. }
  2336. drv_mgd_prepare_tx(local, sdata);
  2337. if (auth_data->bss->proberesp_ies) {
  2338. u16 trans = 1;
  2339. u16 status = 0;
  2340. sdata_info(sdata, "send auth to %pM (try %d/%d)\n",
  2341. auth_data->bss->bssid, auth_data->tries,
  2342. IEEE80211_AUTH_MAX_TRIES);
  2343. auth_data->expected_transaction = 2;
  2344. if (auth_data->algorithm == WLAN_AUTH_SAE) {
  2345. trans = auth_data->sae_trans;
  2346. status = auth_data->sae_status;
  2347. auth_data->expected_transaction = trans;
  2348. }
  2349. ieee80211_send_auth(sdata, trans, auth_data->algorithm, status,
  2350. auth_data->data, auth_data->data_len,
  2351. auth_data->bss->bssid,
  2352. auth_data->bss->bssid, NULL, 0, 0);
  2353. } else {
  2354. const u8 *ssidie;
  2355. sdata_info(sdata, "direct probe to %pM (try %d/%i)\n",
  2356. auth_data->bss->bssid, auth_data->tries,
  2357. IEEE80211_AUTH_MAX_TRIES);
  2358. ssidie = ieee80211_bss_get_ie(auth_data->bss, WLAN_EID_SSID);
  2359. if (!ssidie)
  2360. return -EINVAL;
  2361. /*
  2362. * Direct probe is sent to broadcast address as some APs
  2363. * will not answer to direct packet in unassociated state.
  2364. */
  2365. ieee80211_send_probe_req(sdata, NULL, ssidie + 2, ssidie[1],
  2366. NULL, 0, (u32) -1, true, false,
  2367. auth_data->bss->channel, false);
  2368. }
  2369. auth_data->timeout = jiffies + IEEE80211_AUTH_TIMEOUT;
  2370. run_again(ifmgd, auth_data->timeout);
  2371. return 0;
  2372. }
  2373. static int ieee80211_do_assoc(struct ieee80211_sub_if_data *sdata)
  2374. {
  2375. struct ieee80211_mgd_assoc_data *assoc_data = sdata->u.mgd.assoc_data;
  2376. struct ieee80211_local *local = sdata->local;
  2377. lockdep_assert_held(&sdata->u.mgd.mtx);
  2378. assoc_data->tries++;
  2379. if (assoc_data->tries > IEEE80211_ASSOC_MAX_TRIES) {
  2380. sdata_info(sdata, "association with %pM timed out\n",
  2381. assoc_data->bss->bssid);
  2382. /*
  2383. * Most likely AP is not in the range so remove the
  2384. * bss struct for that AP.
  2385. */
  2386. cfg80211_unlink_bss(local->hw.wiphy, assoc_data->bss);
  2387. return -ETIMEDOUT;
  2388. }
  2389. sdata_info(sdata, "associate with %pM (try %d/%d)\n",
  2390. assoc_data->bss->bssid, assoc_data->tries,
  2391. IEEE80211_ASSOC_MAX_TRIES);
  2392. ieee80211_send_assoc(sdata);
  2393. assoc_data->timeout = jiffies + IEEE80211_ASSOC_TIMEOUT;
  2394. run_again(&sdata->u.mgd, assoc_data->timeout);
  2395. return 0;
  2396. }
  2397. void ieee80211_sta_work(struct ieee80211_sub_if_data *sdata)
  2398. {
  2399. struct ieee80211_local *local = sdata->local;
  2400. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2401. mutex_lock(&ifmgd->mtx);
  2402. if (ifmgd->auth_data &&
  2403. time_after(jiffies, ifmgd->auth_data->timeout)) {
  2404. if (ifmgd->auth_data->done) {
  2405. /*
  2406. * ok ... we waited for assoc but userspace didn't,
  2407. * so let's just kill the auth data
  2408. */
  2409. ieee80211_destroy_auth_data(sdata, false);
  2410. } else if (ieee80211_probe_auth(sdata)) {
  2411. u8 bssid[ETH_ALEN];
  2412. memcpy(bssid, ifmgd->auth_data->bss->bssid, ETH_ALEN);
  2413. ieee80211_destroy_auth_data(sdata, false);
  2414. mutex_unlock(&ifmgd->mtx);
  2415. cfg80211_send_auth_timeout(sdata->dev, bssid);
  2416. mutex_lock(&ifmgd->mtx);
  2417. }
  2418. } else if (ifmgd->auth_data)
  2419. run_again(ifmgd, ifmgd->auth_data->timeout);
  2420. if (ifmgd->assoc_data &&
  2421. time_after(jiffies, ifmgd->assoc_data->timeout)) {
  2422. if (!ifmgd->assoc_data->have_beacon ||
  2423. ieee80211_do_assoc(sdata)) {
  2424. u8 bssid[ETH_ALEN];
  2425. memcpy(bssid, ifmgd->assoc_data->bss->bssid, ETH_ALEN);
  2426. ieee80211_destroy_assoc_data(sdata, false);
  2427. mutex_unlock(&ifmgd->mtx);
  2428. cfg80211_send_assoc_timeout(sdata->dev, bssid);
  2429. mutex_lock(&ifmgd->mtx);
  2430. }
  2431. } else if (ifmgd->assoc_data)
  2432. run_again(ifmgd, ifmgd->assoc_data->timeout);
  2433. if (ifmgd->flags & (IEEE80211_STA_BEACON_POLL |
  2434. IEEE80211_STA_CONNECTION_POLL) &&
  2435. ifmgd->associated) {
  2436. u8 bssid[ETH_ALEN];
  2437. int max_tries;
  2438. memcpy(bssid, ifmgd->associated->bssid, ETH_ALEN);
  2439. if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS)
  2440. max_tries = max_nullfunc_tries;
  2441. else
  2442. max_tries = max_probe_tries;
  2443. /* ACK received for nullfunc probing frame */
  2444. if (!ifmgd->probe_send_count)
  2445. ieee80211_reset_ap_probe(sdata);
  2446. else if (ifmgd->nullfunc_failed) {
  2447. if (ifmgd->probe_send_count < max_tries) {
  2448. mlme_dbg(sdata,
  2449. "No ack for nullfunc frame to AP %pM, try %d/%i\n",
  2450. bssid, ifmgd->probe_send_count,
  2451. max_tries);
  2452. ieee80211_mgd_probe_ap_send(sdata);
  2453. } else {
  2454. mlme_dbg(sdata,
  2455. "No ack for nullfunc frame to AP %pM, disconnecting.\n",
  2456. bssid);
  2457. ieee80211_sta_connection_lost(sdata, bssid,
  2458. WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
  2459. }
  2460. } else if (time_is_after_jiffies(ifmgd->probe_timeout))
  2461. run_again(ifmgd, ifmgd->probe_timeout);
  2462. else if (local->hw.flags & IEEE80211_HW_REPORTS_TX_ACK_STATUS) {
  2463. mlme_dbg(sdata,
  2464. "Failed to send nullfunc to AP %pM after %dms, disconnecting\n",
  2465. bssid, probe_wait_ms);
  2466. ieee80211_sta_connection_lost(sdata, bssid,
  2467. WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
  2468. } else if (ifmgd->probe_send_count < max_tries) {
  2469. mlme_dbg(sdata,
  2470. "No probe response from AP %pM after %dms, try %d/%i\n",
  2471. bssid, probe_wait_ms,
  2472. ifmgd->probe_send_count, max_tries);
  2473. ieee80211_mgd_probe_ap_send(sdata);
  2474. } else {
  2475. /*
  2476. * We actually lost the connection ... or did we?
  2477. * Let's make sure!
  2478. */
  2479. wiphy_debug(local->hw.wiphy,
  2480. "%s: No probe response from AP %pM"
  2481. " after %dms, disconnecting.\n",
  2482. sdata->name,
  2483. bssid, probe_wait_ms);
  2484. ieee80211_sta_connection_lost(sdata, bssid,
  2485. WLAN_REASON_DISASSOC_DUE_TO_INACTIVITY);
  2486. }
  2487. }
  2488. mutex_unlock(&ifmgd->mtx);
  2489. mutex_lock(&local->mtx);
  2490. ieee80211_recalc_idle(local);
  2491. mutex_unlock(&local->mtx);
  2492. }
  2493. static void ieee80211_sta_bcn_mon_timer(unsigned long data)
  2494. {
  2495. struct ieee80211_sub_if_data *sdata =
  2496. (struct ieee80211_sub_if_data *) data;
  2497. struct ieee80211_local *local = sdata->local;
  2498. if (local->quiescing)
  2499. return;
  2500. ieee80211_queue_work(&sdata->local->hw,
  2501. &sdata->u.mgd.beacon_connection_loss_work);
  2502. }
  2503. static void ieee80211_sta_conn_mon_timer(unsigned long data)
  2504. {
  2505. struct ieee80211_sub_if_data *sdata =
  2506. (struct ieee80211_sub_if_data *) data;
  2507. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2508. struct ieee80211_local *local = sdata->local;
  2509. if (local->quiescing)
  2510. return;
  2511. ieee80211_queue_work(&local->hw, &ifmgd->monitor_work);
  2512. }
  2513. static void ieee80211_sta_monitor_work(struct work_struct *work)
  2514. {
  2515. struct ieee80211_sub_if_data *sdata =
  2516. container_of(work, struct ieee80211_sub_if_data,
  2517. u.mgd.monitor_work);
  2518. ieee80211_mgd_probe_ap(sdata, false);
  2519. }
  2520. static void ieee80211_restart_sta_timer(struct ieee80211_sub_if_data *sdata)
  2521. {
  2522. u32 flags;
  2523. if (sdata->vif.type == NL80211_IFTYPE_STATION) {
  2524. __ieee80211_stop_poll(sdata);
  2525. /* let's probe the connection once */
  2526. flags = sdata->local->hw.flags;
  2527. if (!(flags & IEEE80211_HW_CONNECTION_MONITOR))
  2528. ieee80211_queue_work(&sdata->local->hw,
  2529. &sdata->u.mgd.monitor_work);
  2530. /* and do all the other regular work too */
  2531. ieee80211_queue_work(&sdata->local->hw, &sdata->work);
  2532. }
  2533. }
  2534. #ifdef CONFIG_PM
  2535. void ieee80211_sta_quiesce(struct ieee80211_sub_if_data *sdata)
  2536. {
  2537. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2538. /*
  2539. * we need to use atomic bitops for the running bits
  2540. * only because both timers might fire at the same
  2541. * time -- the code here is properly synchronised.
  2542. */
  2543. cancel_work_sync(&ifmgd->request_smps_work);
  2544. cancel_work_sync(&ifmgd->monitor_work);
  2545. cancel_work_sync(&ifmgd->beacon_connection_loss_work);
  2546. cancel_work_sync(&ifmgd->csa_connection_drop_work);
  2547. if (del_timer_sync(&ifmgd->timer))
  2548. set_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running);
  2549. cancel_work_sync(&ifmgd->chswitch_work);
  2550. if (del_timer_sync(&ifmgd->chswitch_timer))
  2551. set_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running);
  2552. /* these will just be re-established on connection */
  2553. del_timer_sync(&ifmgd->conn_mon_timer);
  2554. del_timer_sync(&ifmgd->bcn_mon_timer);
  2555. }
  2556. void ieee80211_sta_restart(struct ieee80211_sub_if_data *sdata)
  2557. {
  2558. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2559. if (!ifmgd->associated)
  2560. return;
  2561. if (sdata->flags & IEEE80211_SDATA_DISCONNECT_RESUME) {
  2562. sdata->flags &= ~IEEE80211_SDATA_DISCONNECT_RESUME;
  2563. mutex_lock(&ifmgd->mtx);
  2564. if (ifmgd->associated) {
  2565. mlme_dbg(sdata,
  2566. "driver requested disconnect after resume\n");
  2567. ieee80211_sta_connection_lost(sdata,
  2568. ifmgd->associated->bssid,
  2569. WLAN_REASON_UNSPECIFIED);
  2570. mutex_unlock(&ifmgd->mtx);
  2571. return;
  2572. }
  2573. mutex_unlock(&ifmgd->mtx);
  2574. }
  2575. if (test_and_clear_bit(TMR_RUNNING_TIMER, &ifmgd->timers_running))
  2576. add_timer(&ifmgd->timer);
  2577. if (test_and_clear_bit(TMR_RUNNING_CHANSW, &ifmgd->timers_running))
  2578. add_timer(&ifmgd->chswitch_timer);
  2579. ieee80211_sta_reset_beacon_monitor(sdata);
  2580. mutex_lock(&sdata->local->mtx);
  2581. ieee80211_restart_sta_timer(sdata);
  2582. mutex_unlock(&sdata->local->mtx);
  2583. }
  2584. #endif
  2585. /* interface setup */
  2586. void ieee80211_sta_setup_sdata(struct ieee80211_sub_if_data *sdata)
  2587. {
  2588. struct ieee80211_if_managed *ifmgd;
  2589. ifmgd = &sdata->u.mgd;
  2590. INIT_WORK(&ifmgd->monitor_work, ieee80211_sta_monitor_work);
  2591. INIT_WORK(&ifmgd->chswitch_work, ieee80211_chswitch_work);
  2592. INIT_WORK(&ifmgd->beacon_connection_loss_work,
  2593. ieee80211_beacon_connection_loss_work);
  2594. INIT_WORK(&ifmgd->csa_connection_drop_work,
  2595. ieee80211_csa_connection_drop_work);
  2596. INIT_WORK(&ifmgd->request_smps_work, ieee80211_request_smps_work);
  2597. setup_timer(&ifmgd->timer, ieee80211_sta_timer,
  2598. (unsigned long) sdata);
  2599. setup_timer(&ifmgd->bcn_mon_timer, ieee80211_sta_bcn_mon_timer,
  2600. (unsigned long) sdata);
  2601. setup_timer(&ifmgd->conn_mon_timer, ieee80211_sta_conn_mon_timer,
  2602. (unsigned long) sdata);
  2603. setup_timer(&ifmgd->chswitch_timer, ieee80211_chswitch_timer,
  2604. (unsigned long) sdata);
  2605. ifmgd->flags = 0;
  2606. ifmgd->powersave = sdata->wdev.ps;
  2607. ifmgd->uapsd_queues = IEEE80211_DEFAULT_UAPSD_QUEUES;
  2608. ifmgd->uapsd_max_sp_len = IEEE80211_DEFAULT_MAX_SP_LEN;
  2609. mutex_init(&ifmgd->mtx);
  2610. if (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS)
  2611. ifmgd->req_smps = IEEE80211_SMPS_AUTOMATIC;
  2612. else
  2613. ifmgd->req_smps = IEEE80211_SMPS_OFF;
  2614. }
  2615. /* scan finished notification */
  2616. void ieee80211_mlme_notify_scan_completed(struct ieee80211_local *local)
  2617. {
  2618. struct ieee80211_sub_if_data *sdata;
  2619. /* Restart STA timers */
  2620. rcu_read_lock();
  2621. list_for_each_entry_rcu(sdata, &local->interfaces, list)
  2622. ieee80211_restart_sta_timer(sdata);
  2623. rcu_read_unlock();
  2624. }
  2625. int ieee80211_max_network_latency(struct notifier_block *nb,
  2626. unsigned long data, void *dummy)
  2627. {
  2628. s32 latency_usec = (s32) data;
  2629. struct ieee80211_local *local =
  2630. container_of(nb, struct ieee80211_local,
  2631. network_latency_notifier);
  2632. mutex_lock(&local->iflist_mtx);
  2633. ieee80211_recalc_ps(local, latency_usec);
  2634. mutex_unlock(&local->iflist_mtx);
  2635. return 0;
  2636. }
  2637. static int ieee80211_prep_channel(struct ieee80211_sub_if_data *sdata,
  2638. struct cfg80211_bss *cbss)
  2639. {
  2640. struct ieee80211_local *local = sdata->local;
  2641. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2642. int ht_cfreq;
  2643. enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
  2644. const u8 *ht_oper_ie;
  2645. const struct ieee80211_ht_operation *ht_oper = NULL;
  2646. struct ieee80211_supported_band *sband;
  2647. sband = local->hw.wiphy->bands[cbss->channel->band];
  2648. ifmgd->flags &= ~IEEE80211_STA_DISABLE_40MHZ;
  2649. if (sband->ht_cap.ht_supported) {
  2650. ht_oper_ie = cfg80211_find_ie(WLAN_EID_HT_OPERATION,
  2651. cbss->information_elements,
  2652. cbss->len_information_elements);
  2653. if (ht_oper_ie && ht_oper_ie[1] >= sizeof(*ht_oper))
  2654. ht_oper = (void *)(ht_oper_ie + 2);
  2655. }
  2656. if (ht_oper) {
  2657. ht_cfreq = ieee80211_channel_to_frequency(ht_oper->primary_chan,
  2658. cbss->channel->band);
  2659. /* check that channel matches the right operating channel */
  2660. if (cbss->channel->center_freq != ht_cfreq) {
  2661. /*
  2662. * It's possible that some APs are confused here;
  2663. * Netgear WNDR3700 sometimes reports 4 higher than
  2664. * the actual channel in association responses, but
  2665. * since we look at probe response/beacon data here
  2666. * it should be OK.
  2667. */
  2668. sdata_info(sdata,
  2669. "Wrong control channel: center-freq: %d ht-cfreq: %d ht->primary_chan: %d band: %d - Disabling HT\n",
  2670. cbss->channel->center_freq,
  2671. ht_cfreq, ht_oper->primary_chan,
  2672. cbss->channel->band);
  2673. ht_oper = NULL;
  2674. }
  2675. }
  2676. if (ht_oper) {
  2677. /*
  2678. * cfg80211 already verified that the channel itself can
  2679. * be used, but it didn't check that we can do the right
  2680. * HT type, so do that here as well. If HT40 isn't allowed
  2681. * on this channel, disable 40 MHz operation.
  2682. */
  2683. const u8 *ht_cap_ie;
  2684. const struct ieee80211_ht_cap *ht_cap;
  2685. u8 chains = 1;
  2686. channel_type = NL80211_CHAN_HT20;
  2687. if (sband->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) {
  2688. switch (ht_oper->ht_param &
  2689. IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
  2690. case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
  2691. if (cbss->channel->flags &
  2692. IEEE80211_CHAN_NO_HT40PLUS)
  2693. ifmgd->flags |=
  2694. IEEE80211_STA_DISABLE_40MHZ;
  2695. else
  2696. channel_type = NL80211_CHAN_HT40PLUS;
  2697. break;
  2698. case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
  2699. if (cbss->channel->flags &
  2700. IEEE80211_CHAN_NO_HT40MINUS)
  2701. ifmgd->flags |=
  2702. IEEE80211_STA_DISABLE_40MHZ;
  2703. else
  2704. channel_type = NL80211_CHAN_HT40MINUS;
  2705. break;
  2706. }
  2707. }
  2708. ht_cap_ie = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY,
  2709. cbss->information_elements,
  2710. cbss->len_information_elements);
  2711. if (ht_cap_ie && ht_cap_ie[1] >= sizeof(*ht_cap)) {
  2712. ht_cap = (void *)(ht_cap_ie + 2);
  2713. chains = ieee80211_mcs_to_chains(&ht_cap->mcs);
  2714. }
  2715. sdata->needed_rx_chains = min(chains, local->rx_chains);
  2716. } else {
  2717. sdata->needed_rx_chains = 1;
  2718. }
  2719. /* will change later if needed */
  2720. sdata->smps_mode = IEEE80211_SMPS_OFF;
  2721. ieee80211_vif_release_channel(sdata);
  2722. return ieee80211_vif_use_channel(sdata, cbss->channel, channel_type,
  2723. IEEE80211_CHANCTX_SHARED);
  2724. }
  2725. static int ieee80211_prep_connection(struct ieee80211_sub_if_data *sdata,
  2726. struct cfg80211_bss *cbss, bool assoc)
  2727. {
  2728. struct ieee80211_local *local = sdata->local;
  2729. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2730. struct ieee80211_bss *bss = (void *)cbss->priv;
  2731. struct sta_info *new_sta = NULL;
  2732. bool have_sta = false;
  2733. int err;
  2734. if (WARN_ON(!ifmgd->auth_data && !ifmgd->assoc_data))
  2735. return -EINVAL;
  2736. if (assoc) {
  2737. rcu_read_lock();
  2738. have_sta = sta_info_get(sdata, cbss->bssid);
  2739. rcu_read_unlock();
  2740. }
  2741. if (!have_sta) {
  2742. new_sta = sta_info_alloc(sdata, cbss->bssid, GFP_KERNEL);
  2743. if (!new_sta)
  2744. return -ENOMEM;
  2745. }
  2746. mutex_lock(&local->mtx);
  2747. ieee80211_recalc_idle(sdata->local);
  2748. mutex_unlock(&local->mtx);
  2749. if (new_sta) {
  2750. u32 rates = 0, basic_rates = 0;
  2751. bool have_higher_than_11mbit;
  2752. int min_rate = INT_MAX, min_rate_index = -1;
  2753. struct ieee80211_supported_band *sband;
  2754. sband = local->hw.wiphy->bands[cbss->channel->band];
  2755. err = ieee80211_prep_channel(sdata, cbss);
  2756. if (err) {
  2757. sta_info_free(local, new_sta);
  2758. return err;
  2759. }
  2760. ieee80211_get_rates(sband, bss->supp_rates,
  2761. bss->supp_rates_len,
  2762. &rates, &basic_rates,
  2763. &have_higher_than_11mbit,
  2764. &min_rate, &min_rate_index);
  2765. /*
  2766. * This used to be a workaround for basic rates missing
  2767. * in the association response frame. Now that we no
  2768. * longer use the basic rates from there, it probably
  2769. * doesn't happen any more, but keep the workaround so
  2770. * in case some *other* APs are buggy in different ways
  2771. * we can connect -- with a warning.
  2772. */
  2773. if (!basic_rates && min_rate_index >= 0) {
  2774. sdata_info(sdata,
  2775. "No basic rates, using min rate instead\n");
  2776. basic_rates = BIT(min_rate_index);
  2777. }
  2778. new_sta->sta.supp_rates[cbss->channel->band] = rates;
  2779. sdata->vif.bss_conf.basic_rates = basic_rates;
  2780. /* cf. IEEE 802.11 9.2.12 */
  2781. if (cbss->channel->band == IEEE80211_BAND_2GHZ &&
  2782. have_higher_than_11mbit)
  2783. sdata->flags |= IEEE80211_SDATA_OPERATING_GMODE;
  2784. else
  2785. sdata->flags &= ~IEEE80211_SDATA_OPERATING_GMODE;
  2786. memcpy(ifmgd->bssid, cbss->bssid, ETH_ALEN);
  2787. /* set timing information */
  2788. sdata->vif.bss_conf.beacon_int = cbss->beacon_interval;
  2789. sdata->vif.bss_conf.sync_tsf = cbss->tsf;
  2790. sdata->vif.bss_conf.sync_device_ts = bss->device_ts;
  2791. /* tell driver about BSSID, basic rates and timing */
  2792. ieee80211_bss_info_change_notify(sdata,
  2793. BSS_CHANGED_BSSID | BSS_CHANGED_BASIC_RATES |
  2794. BSS_CHANGED_BEACON_INT);
  2795. if (assoc)
  2796. sta_info_pre_move_state(new_sta, IEEE80211_STA_AUTH);
  2797. err = sta_info_insert(new_sta);
  2798. new_sta = NULL;
  2799. if (err) {
  2800. sdata_info(sdata,
  2801. "failed to insert STA entry for the AP (error %d)\n",
  2802. err);
  2803. return err;
  2804. }
  2805. } else
  2806. WARN_ON_ONCE(!ether_addr_equal(ifmgd->bssid, cbss->bssid));
  2807. return 0;
  2808. }
  2809. /* config hooks */
  2810. int ieee80211_mgd_auth(struct ieee80211_sub_if_data *sdata,
  2811. struct cfg80211_auth_request *req)
  2812. {
  2813. struct ieee80211_local *local = sdata->local;
  2814. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2815. struct ieee80211_mgd_auth_data *auth_data;
  2816. u16 auth_alg;
  2817. int err;
  2818. /* prepare auth data structure */
  2819. switch (req->auth_type) {
  2820. case NL80211_AUTHTYPE_OPEN_SYSTEM:
  2821. auth_alg = WLAN_AUTH_OPEN;
  2822. break;
  2823. case NL80211_AUTHTYPE_SHARED_KEY:
  2824. if (IS_ERR(local->wep_tx_tfm))
  2825. return -EOPNOTSUPP;
  2826. auth_alg = WLAN_AUTH_SHARED_KEY;
  2827. break;
  2828. case NL80211_AUTHTYPE_FT:
  2829. auth_alg = WLAN_AUTH_FT;
  2830. break;
  2831. case NL80211_AUTHTYPE_NETWORK_EAP:
  2832. auth_alg = WLAN_AUTH_LEAP;
  2833. break;
  2834. case NL80211_AUTHTYPE_SAE:
  2835. auth_alg = WLAN_AUTH_SAE;
  2836. break;
  2837. default:
  2838. return -EOPNOTSUPP;
  2839. }
  2840. auth_data = kzalloc(sizeof(*auth_data) + req->sae_data_len +
  2841. req->ie_len, GFP_KERNEL);
  2842. if (!auth_data)
  2843. return -ENOMEM;
  2844. auth_data->bss = req->bss;
  2845. if (req->sae_data_len >= 4) {
  2846. __le16 *pos = (__le16 *) req->sae_data;
  2847. auth_data->sae_trans = le16_to_cpu(pos[0]);
  2848. auth_data->sae_status = le16_to_cpu(pos[1]);
  2849. memcpy(auth_data->data, req->sae_data + 4,
  2850. req->sae_data_len - 4);
  2851. auth_data->data_len += req->sae_data_len - 4;
  2852. }
  2853. if (req->ie && req->ie_len) {
  2854. memcpy(&auth_data->data[auth_data->data_len],
  2855. req->ie, req->ie_len);
  2856. auth_data->data_len += req->ie_len;
  2857. }
  2858. if (req->key && req->key_len) {
  2859. auth_data->key_len = req->key_len;
  2860. auth_data->key_idx = req->key_idx;
  2861. memcpy(auth_data->key, req->key, req->key_len);
  2862. }
  2863. auth_data->algorithm = auth_alg;
  2864. /* try to authenticate/probe */
  2865. mutex_lock(&ifmgd->mtx);
  2866. if ((ifmgd->auth_data && !ifmgd->auth_data->done) ||
  2867. ifmgd->assoc_data) {
  2868. err = -EBUSY;
  2869. goto err_free;
  2870. }
  2871. if (ifmgd->auth_data)
  2872. ieee80211_destroy_auth_data(sdata, false);
  2873. /* prep auth_data so we don't go into idle on disassoc */
  2874. ifmgd->auth_data = auth_data;
  2875. if (ifmgd->associated)
  2876. ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
  2877. sdata_info(sdata, "authenticate with %pM\n", req->bss->bssid);
  2878. err = ieee80211_prep_connection(sdata, req->bss, false);
  2879. if (err)
  2880. goto err_clear;
  2881. err = ieee80211_probe_auth(sdata);
  2882. if (err) {
  2883. sta_info_destroy_addr(sdata, req->bss->bssid);
  2884. goto err_clear;
  2885. }
  2886. /* hold our own reference */
  2887. cfg80211_ref_bss(auth_data->bss);
  2888. err = 0;
  2889. goto out_unlock;
  2890. err_clear:
  2891. memset(ifmgd->bssid, 0, ETH_ALEN);
  2892. ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
  2893. ifmgd->auth_data = NULL;
  2894. err_free:
  2895. kfree(auth_data);
  2896. out_unlock:
  2897. mutex_unlock(&ifmgd->mtx);
  2898. return err;
  2899. }
  2900. int ieee80211_mgd_assoc(struct ieee80211_sub_if_data *sdata,
  2901. struct cfg80211_assoc_request *req)
  2902. {
  2903. struct ieee80211_local *local = sdata->local;
  2904. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  2905. struct ieee80211_bss *bss = (void *)req->bss->priv;
  2906. struct ieee80211_mgd_assoc_data *assoc_data;
  2907. struct ieee80211_supported_band *sband;
  2908. const u8 *ssidie, *ht_ie;
  2909. int i, err;
  2910. ssidie = ieee80211_bss_get_ie(req->bss, WLAN_EID_SSID);
  2911. if (!ssidie)
  2912. return -EINVAL;
  2913. assoc_data = kzalloc(sizeof(*assoc_data) + req->ie_len, GFP_KERNEL);
  2914. if (!assoc_data)
  2915. return -ENOMEM;
  2916. mutex_lock(&ifmgd->mtx);
  2917. if (ifmgd->associated)
  2918. ieee80211_set_disassoc(sdata, 0, 0, false, NULL);
  2919. if (ifmgd->auth_data && !ifmgd->auth_data->done) {
  2920. err = -EBUSY;
  2921. goto err_free;
  2922. }
  2923. if (ifmgd->assoc_data) {
  2924. err = -EBUSY;
  2925. goto err_free;
  2926. }
  2927. if (ifmgd->auth_data) {
  2928. bool match;
  2929. /* keep sta info, bssid if matching */
  2930. match = ether_addr_equal(ifmgd->bssid, req->bss->bssid);
  2931. ieee80211_destroy_auth_data(sdata, match);
  2932. }
  2933. /* prepare assoc data */
  2934. /*
  2935. * keep only the 40 MHz disable bit set as it might have
  2936. * been set during authentication already, all other bits
  2937. * should be reset for a new connection
  2938. */
  2939. ifmgd->flags &= IEEE80211_STA_DISABLE_40MHZ;
  2940. ifmgd->beacon_crc_valid = false;
  2941. /*
  2942. * IEEE802.11n does not allow TKIP/WEP as pairwise ciphers in HT mode.
  2943. * We still associate in non-HT mode (11a/b/g) if any one of these
  2944. * ciphers is configured as pairwise.
  2945. * We can set this to true for non-11n hardware, that'll be checked
  2946. * separately along with the peer capabilities.
  2947. */
  2948. for (i = 0; i < req->crypto.n_ciphers_pairwise; i++) {
  2949. if (req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP40 ||
  2950. req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_TKIP ||
  2951. req->crypto.ciphers_pairwise[i] == WLAN_CIPHER_SUITE_WEP104) {
  2952. ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
  2953. ifmgd->flags |= IEEE80211_STA_DISABLE_VHT;
  2954. netdev_info(sdata->dev,
  2955. "disabling HT/VHT due to WEP/TKIP use\n");
  2956. }
  2957. }
  2958. if (req->flags & ASSOC_REQ_DISABLE_HT) {
  2959. ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
  2960. ifmgd->flags |= IEEE80211_STA_DISABLE_VHT;
  2961. }
  2962. /* Also disable HT if we don't support it or the AP doesn't use WMM */
  2963. sband = local->hw.wiphy->bands[req->bss->channel->band];
  2964. if (!sband->ht_cap.ht_supported ||
  2965. local->hw.queues < IEEE80211_NUM_ACS || !bss->wmm_used) {
  2966. ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
  2967. if (!bss->wmm_used)
  2968. netdev_info(sdata->dev,
  2969. "disabling HT as WMM/QoS is not supported by the AP\n");
  2970. }
  2971. /* disable VHT if we don't support it or the AP doesn't use WMM */
  2972. if (!sband->vht_cap.vht_supported ||
  2973. local->hw.queues < IEEE80211_NUM_ACS || !bss->wmm_used) {
  2974. ifmgd->flags |= IEEE80211_STA_DISABLE_VHT;
  2975. if (!bss->wmm_used)
  2976. netdev_info(sdata->dev,
  2977. "disabling VHT as WMM/QoS is not supported by the AP\n");
  2978. }
  2979. memcpy(&ifmgd->ht_capa, &req->ht_capa, sizeof(ifmgd->ht_capa));
  2980. memcpy(&ifmgd->ht_capa_mask, &req->ht_capa_mask,
  2981. sizeof(ifmgd->ht_capa_mask));
  2982. if (req->ie && req->ie_len) {
  2983. memcpy(assoc_data->ie, req->ie, req->ie_len);
  2984. assoc_data->ie_len = req->ie_len;
  2985. }
  2986. assoc_data->bss = req->bss;
  2987. if (ifmgd->req_smps == IEEE80211_SMPS_AUTOMATIC) {
  2988. if (ifmgd->powersave)
  2989. sdata->smps_mode = IEEE80211_SMPS_DYNAMIC;
  2990. else
  2991. sdata->smps_mode = IEEE80211_SMPS_OFF;
  2992. } else
  2993. sdata->smps_mode = ifmgd->req_smps;
  2994. assoc_data->capability = req->bss->capability;
  2995. assoc_data->wmm = bss->wmm_used &&
  2996. (local->hw.queues >= IEEE80211_NUM_ACS);
  2997. assoc_data->supp_rates = bss->supp_rates;
  2998. assoc_data->supp_rates_len = bss->supp_rates_len;
  2999. ht_ie = ieee80211_bss_get_ie(req->bss, WLAN_EID_HT_OPERATION);
  3000. if (ht_ie && ht_ie[1] >= sizeof(struct ieee80211_ht_operation))
  3001. assoc_data->ap_ht_param =
  3002. ((struct ieee80211_ht_operation *)(ht_ie + 2))->ht_param;
  3003. else
  3004. ifmgd->flags |= IEEE80211_STA_DISABLE_11N;
  3005. if (bss->wmm_used && bss->uapsd_supported &&
  3006. (sdata->local->hw.flags & IEEE80211_HW_SUPPORTS_UAPSD)) {
  3007. assoc_data->uapsd = true;
  3008. ifmgd->flags |= IEEE80211_STA_UAPSD_ENABLED;
  3009. } else {
  3010. assoc_data->uapsd = false;
  3011. ifmgd->flags &= ~IEEE80211_STA_UAPSD_ENABLED;
  3012. }
  3013. memcpy(assoc_data->ssid, ssidie + 2, ssidie[1]);
  3014. assoc_data->ssid_len = ssidie[1];
  3015. if (req->prev_bssid)
  3016. memcpy(assoc_data->prev_bssid, req->prev_bssid, ETH_ALEN);
  3017. if (req->use_mfp) {
  3018. ifmgd->mfp = IEEE80211_MFP_REQUIRED;
  3019. ifmgd->flags |= IEEE80211_STA_MFP_ENABLED;
  3020. } else {
  3021. ifmgd->mfp = IEEE80211_MFP_DISABLED;
  3022. ifmgd->flags &= ~IEEE80211_STA_MFP_ENABLED;
  3023. }
  3024. if (req->crypto.control_port)
  3025. ifmgd->flags |= IEEE80211_STA_CONTROL_PORT;
  3026. else
  3027. ifmgd->flags &= ~IEEE80211_STA_CONTROL_PORT;
  3028. sdata->control_port_protocol = req->crypto.control_port_ethertype;
  3029. sdata->control_port_no_encrypt = req->crypto.control_port_no_encrypt;
  3030. /* kick off associate process */
  3031. ifmgd->assoc_data = assoc_data;
  3032. err = ieee80211_prep_connection(sdata, req->bss, true);
  3033. if (err)
  3034. goto err_clear;
  3035. if (!bss->dtim_period &&
  3036. sdata->local->hw.flags & IEEE80211_HW_NEED_DTIM_PERIOD) {
  3037. /*
  3038. * Wait up to one beacon interval ...
  3039. * should this be more if we miss one?
  3040. */
  3041. sdata_info(sdata, "waiting for beacon from %pM\n",
  3042. ifmgd->bssid);
  3043. assoc_data->timeout = TU_TO_EXP_TIME(req->bss->beacon_interval);
  3044. } else {
  3045. assoc_data->have_beacon = true;
  3046. assoc_data->sent_assoc = false;
  3047. assoc_data->timeout = jiffies;
  3048. }
  3049. run_again(ifmgd, assoc_data->timeout);
  3050. if (bss->corrupt_data) {
  3051. char *corrupt_type = "data";
  3052. if (bss->corrupt_data & IEEE80211_BSS_CORRUPT_BEACON) {
  3053. if (bss->corrupt_data &
  3054. IEEE80211_BSS_CORRUPT_PROBE_RESP)
  3055. corrupt_type = "beacon and probe response";
  3056. else
  3057. corrupt_type = "beacon";
  3058. } else if (bss->corrupt_data & IEEE80211_BSS_CORRUPT_PROBE_RESP)
  3059. corrupt_type = "probe response";
  3060. sdata_info(sdata, "associating with AP with corrupt %s\n",
  3061. corrupt_type);
  3062. }
  3063. err = 0;
  3064. goto out;
  3065. err_clear:
  3066. memset(ifmgd->bssid, 0, ETH_ALEN);
  3067. ieee80211_bss_info_change_notify(sdata, BSS_CHANGED_BSSID);
  3068. ifmgd->assoc_data = NULL;
  3069. err_free:
  3070. kfree(assoc_data);
  3071. out:
  3072. mutex_unlock(&ifmgd->mtx);
  3073. return err;
  3074. }
  3075. int ieee80211_mgd_deauth(struct ieee80211_sub_if_data *sdata,
  3076. struct cfg80211_deauth_request *req)
  3077. {
  3078. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  3079. u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
  3080. bool tx = !req->local_state_change;
  3081. bool sent_frame = false;
  3082. mutex_lock(&ifmgd->mtx);
  3083. sdata_info(sdata,
  3084. "deauthenticating from %pM by local choice (reason=%d)\n",
  3085. req->bssid, req->reason_code);
  3086. if (ifmgd->auth_data) {
  3087. drv_mgd_prepare_tx(sdata->local, sdata);
  3088. ieee80211_send_deauth_disassoc(sdata, req->bssid,
  3089. IEEE80211_STYPE_DEAUTH,
  3090. req->reason_code, tx,
  3091. frame_buf);
  3092. ieee80211_destroy_auth_data(sdata, false);
  3093. mutex_unlock(&ifmgd->mtx);
  3094. sent_frame = tx;
  3095. goto out;
  3096. }
  3097. if (ifmgd->associated &&
  3098. ether_addr_equal(ifmgd->associated->bssid, req->bssid)) {
  3099. ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DEAUTH,
  3100. req->reason_code, tx, frame_buf);
  3101. sent_frame = tx;
  3102. }
  3103. mutex_unlock(&ifmgd->mtx);
  3104. out:
  3105. mutex_lock(&sdata->local->mtx);
  3106. ieee80211_recalc_idle(sdata->local);
  3107. mutex_unlock(&sdata->local->mtx);
  3108. if (sent_frame)
  3109. __cfg80211_send_deauth(sdata->dev, frame_buf,
  3110. IEEE80211_DEAUTH_FRAME_LEN);
  3111. return 0;
  3112. }
  3113. int ieee80211_mgd_disassoc(struct ieee80211_sub_if_data *sdata,
  3114. struct cfg80211_disassoc_request *req)
  3115. {
  3116. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  3117. u8 bssid[ETH_ALEN];
  3118. u8 frame_buf[IEEE80211_DEAUTH_FRAME_LEN];
  3119. mutex_lock(&ifmgd->mtx);
  3120. /*
  3121. * cfg80211 should catch this ... but it's racy since
  3122. * we can receive a disassoc frame, process it, hand it
  3123. * to cfg80211 while that's in a locked section already
  3124. * trying to tell us that the user wants to disconnect.
  3125. */
  3126. if (ifmgd->associated != req->bss) {
  3127. mutex_unlock(&ifmgd->mtx);
  3128. return -ENOLINK;
  3129. }
  3130. sdata_info(sdata,
  3131. "disassociating from %pM by local choice (reason=%d)\n",
  3132. req->bss->bssid, req->reason_code);
  3133. memcpy(bssid, req->bss->bssid, ETH_ALEN);
  3134. ieee80211_set_disassoc(sdata, IEEE80211_STYPE_DISASSOC,
  3135. req->reason_code, !req->local_state_change,
  3136. frame_buf);
  3137. mutex_unlock(&ifmgd->mtx);
  3138. __cfg80211_send_disassoc(sdata->dev, frame_buf,
  3139. IEEE80211_DEAUTH_FRAME_LEN);
  3140. mutex_lock(&sdata->local->mtx);
  3141. ieee80211_recalc_idle(sdata->local);
  3142. mutex_unlock(&sdata->local->mtx);
  3143. return 0;
  3144. }
  3145. void ieee80211_mgd_stop(struct ieee80211_sub_if_data *sdata)
  3146. {
  3147. struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
  3148. mutex_lock(&ifmgd->mtx);
  3149. if (ifmgd->assoc_data)
  3150. ieee80211_destroy_assoc_data(sdata, false);
  3151. if (ifmgd->auth_data)
  3152. ieee80211_destroy_auth_data(sdata, false);
  3153. del_timer_sync(&ifmgd->timer);
  3154. mutex_unlock(&ifmgd->mtx);
  3155. }
  3156. void ieee80211_cqm_rssi_notify(struct ieee80211_vif *vif,
  3157. enum nl80211_cqm_rssi_threshold_event rssi_event,
  3158. gfp_t gfp)
  3159. {
  3160. struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
  3161. trace_api_cqm_rssi_notify(sdata, rssi_event);
  3162. cfg80211_cqm_rssi_notify(sdata->dev, rssi_event, gfp);
  3163. }
  3164. EXPORT_SYMBOL(ieee80211_cqm_rssi_notify);