iwl-core.c 79 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848
  1. /******************************************************************************
  2. *
  3. * GPL LICENSE SUMMARY
  4. *
  5. * Copyright(c) 2008 - 2010 Intel Corporation. All rights reserved.
  6. *
  7. * This program is free software; you can redistribute it and/or modify
  8. * it under the terms of version 2 of the GNU General Public License as
  9. * published by the Free Software Foundation.
  10. *
  11. * This program is distributed in the hope that it will be useful, but
  12. * WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14. * General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  19. * USA
  20. *
  21. * The full GNU General Public License is included in this distribution
  22. * in the file called LICENSE.GPL.
  23. *
  24. * Contact Information:
  25. * Intel Linux Wireless <ilw@linux.intel.com>
  26. * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  27. *****************************************************************************/
  28. #include <linux/kernel.h>
  29. #include <linux/module.h>
  30. #include <linux/etherdevice.h>
  31. #include <linux/sched.h>
  32. #include <linux/slab.h>
  33. #include <net/mac80211.h>
  34. #include "iwl-eeprom.h"
  35. #include "iwl-dev.h" /* FIXME: remove */
  36. #include "iwl-debug.h"
  37. #include "iwl-core.h"
  38. #include "iwl-io.h"
  39. #include "iwl-power.h"
  40. #include "iwl-sta.h"
  41. #include "iwl-helpers.h"
  42. MODULE_DESCRIPTION("iwl core");
  43. MODULE_VERSION(IWLWIFI_VERSION);
  44. MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
  45. MODULE_LICENSE("GPL");
  46. /*
  47. * set bt_coex_active to true, uCode will do kill/defer
  48. * every time the priority line is asserted (BT is sending signals on the
  49. * priority line in the PCIx).
  50. * set bt_coex_active to false, uCode will ignore the BT activity and
  51. * perform the normal operation
  52. *
  53. * User might experience transmit issue on some platform due to WiFi/BT
  54. * co-exist problem. The possible behaviors are:
  55. * Able to scan and finding all the available AP
  56. * Not able to associate with any AP
  57. * On those platforms, WiFi communication can be restored by set
  58. * "bt_coex_active" module parameter to "false"
  59. *
  60. * default: bt_coex_active = true (BT_COEX_ENABLE)
  61. */
  62. static bool bt_coex_active = true;
  63. module_param(bt_coex_active, bool, S_IRUGO);
  64. MODULE_PARM_DESC(bt_coex_active, "enable wifi/bluetooth co-exist");
  65. #define IWL_DECLARE_RATE_INFO(r, s, ip, in, rp, rn, pp, np) \
  66. [IWL_RATE_##r##M_INDEX] = { IWL_RATE_##r##M_PLCP, \
  67. IWL_RATE_SISO_##s##M_PLCP, \
  68. IWL_RATE_MIMO2_##s##M_PLCP,\
  69. IWL_RATE_MIMO3_##s##M_PLCP,\
  70. IWL_RATE_##r##M_IEEE, \
  71. IWL_RATE_##ip##M_INDEX, \
  72. IWL_RATE_##in##M_INDEX, \
  73. IWL_RATE_##rp##M_INDEX, \
  74. IWL_RATE_##rn##M_INDEX, \
  75. IWL_RATE_##pp##M_INDEX, \
  76. IWL_RATE_##np##M_INDEX }
  77. u32 iwl_debug_level;
  78. EXPORT_SYMBOL(iwl_debug_level);
  79. /*
  80. * Parameter order:
  81. * rate, ht rate, prev rate, next rate, prev tgg rate, next tgg rate
  82. *
  83. * If there isn't a valid next or previous rate then INV is used which
  84. * maps to IWL_RATE_INVALID
  85. *
  86. */
  87. const struct iwl_rate_info iwl_rates[IWL_RATE_COUNT] = {
  88. IWL_DECLARE_RATE_INFO(1, INV, INV, 2, INV, 2, INV, 2), /* 1mbps */
  89. IWL_DECLARE_RATE_INFO(2, INV, 1, 5, 1, 5, 1, 5), /* 2mbps */
  90. IWL_DECLARE_RATE_INFO(5, INV, 2, 6, 2, 11, 2, 11), /*5.5mbps */
  91. IWL_DECLARE_RATE_INFO(11, INV, 9, 12, 9, 12, 5, 18), /* 11mbps */
  92. IWL_DECLARE_RATE_INFO(6, 6, 5, 9, 5, 11, 5, 11), /* 6mbps */
  93. IWL_DECLARE_RATE_INFO(9, 6, 6, 11, 6, 11, 5, 11), /* 9mbps */
  94. IWL_DECLARE_RATE_INFO(12, 12, 11, 18, 11, 18, 11, 18), /* 12mbps */
  95. IWL_DECLARE_RATE_INFO(18, 18, 12, 24, 12, 24, 11, 24), /* 18mbps */
  96. IWL_DECLARE_RATE_INFO(24, 24, 18, 36, 18, 36, 18, 36), /* 24mbps */
  97. IWL_DECLARE_RATE_INFO(36, 36, 24, 48, 24, 48, 24, 48), /* 36mbps */
  98. IWL_DECLARE_RATE_INFO(48, 48, 36, 54, 36, 54, 36, 54), /* 48mbps */
  99. IWL_DECLARE_RATE_INFO(54, 54, 48, INV, 48, INV, 48, INV),/* 54mbps */
  100. IWL_DECLARE_RATE_INFO(60, 60, 48, INV, 48, INV, 48, INV),/* 60mbps */
  101. /* FIXME:RS: ^^ should be INV (legacy) */
  102. };
  103. EXPORT_SYMBOL(iwl_rates);
  104. int iwl_hwrate_to_plcp_idx(u32 rate_n_flags)
  105. {
  106. int idx = 0;
  107. /* HT rate format */
  108. if (rate_n_flags & RATE_MCS_HT_MSK) {
  109. idx = (rate_n_flags & 0xff);
  110. if (idx >= IWL_RATE_MIMO3_6M_PLCP)
  111. idx = idx - IWL_RATE_MIMO3_6M_PLCP;
  112. else if (idx >= IWL_RATE_MIMO2_6M_PLCP)
  113. idx = idx - IWL_RATE_MIMO2_6M_PLCP;
  114. idx += IWL_FIRST_OFDM_RATE;
  115. /* skip 9M not supported in ht*/
  116. if (idx >= IWL_RATE_9M_INDEX)
  117. idx += 1;
  118. if ((idx >= IWL_FIRST_OFDM_RATE) && (idx <= IWL_LAST_OFDM_RATE))
  119. return idx;
  120. /* legacy rate format, search for match in table */
  121. } else {
  122. for (idx = 0; idx < ARRAY_SIZE(iwl_rates); idx++)
  123. if (iwl_rates[idx].plcp == (rate_n_flags & 0xFF))
  124. return idx;
  125. }
  126. return -1;
  127. }
  128. EXPORT_SYMBOL(iwl_hwrate_to_plcp_idx);
  129. u8 iwl_toggle_tx_ant(struct iwl_priv *priv, u8 ant, u8 valid)
  130. {
  131. int i;
  132. u8 ind = ant;
  133. for (i = 0; i < RATE_ANT_NUM - 1; i++) {
  134. ind = (ind + 1) < RATE_ANT_NUM ? ind + 1 : 0;
  135. if (valid & BIT(ind))
  136. return ind;
  137. }
  138. return ant;
  139. }
  140. EXPORT_SYMBOL(iwl_toggle_tx_ant);
  141. const u8 iwl_bcast_addr[ETH_ALEN] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
  142. EXPORT_SYMBOL(iwl_bcast_addr);
  143. /* This function both allocates and initializes hw and priv. */
  144. struct ieee80211_hw *iwl_alloc_all(struct iwl_cfg *cfg,
  145. struct ieee80211_ops *hw_ops)
  146. {
  147. struct iwl_priv *priv;
  148. /* mac80211 allocates memory for this device instance, including
  149. * space for this driver's private structure */
  150. struct ieee80211_hw *hw =
  151. ieee80211_alloc_hw(sizeof(struct iwl_priv), hw_ops);
  152. if (hw == NULL) {
  153. pr_err("%s: Can not allocate network device\n",
  154. cfg->name);
  155. goto out;
  156. }
  157. priv = hw->priv;
  158. priv->hw = hw;
  159. out:
  160. return hw;
  161. }
  162. EXPORT_SYMBOL(iwl_alloc_all);
  163. /*
  164. * QoS support
  165. */
  166. static void iwl_update_qos(struct iwl_priv *priv)
  167. {
  168. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  169. return;
  170. priv->qos_data.def_qos_parm.qos_flags = 0;
  171. if (priv->qos_data.qos_active)
  172. priv->qos_data.def_qos_parm.qos_flags |=
  173. QOS_PARAM_FLG_UPDATE_EDCA_MSK;
  174. if (priv->current_ht_config.is_ht)
  175. priv->qos_data.def_qos_parm.qos_flags |= QOS_PARAM_FLG_TGN_MSK;
  176. IWL_DEBUG_QOS(priv, "send QoS cmd with Qos active=%d FLAGS=0x%X\n",
  177. priv->qos_data.qos_active,
  178. priv->qos_data.def_qos_parm.qos_flags);
  179. iwl_send_cmd_pdu_async(priv, REPLY_QOS_PARAM,
  180. sizeof(struct iwl_qosparam_cmd),
  181. &priv->qos_data.def_qos_parm, NULL);
  182. }
  183. #define MAX_BIT_RATE_40_MHZ 150 /* Mbps */
  184. #define MAX_BIT_RATE_20_MHZ 72 /* Mbps */
  185. static void iwlcore_init_ht_hw_capab(const struct iwl_priv *priv,
  186. struct ieee80211_sta_ht_cap *ht_info,
  187. enum ieee80211_band band)
  188. {
  189. u16 max_bit_rate = 0;
  190. u8 rx_chains_num = priv->hw_params.rx_chains_num;
  191. u8 tx_chains_num = priv->hw_params.tx_chains_num;
  192. ht_info->cap = 0;
  193. memset(&ht_info->mcs, 0, sizeof(ht_info->mcs));
  194. ht_info->ht_supported = true;
  195. if (priv->cfg->ht_greenfield_support)
  196. ht_info->cap |= IEEE80211_HT_CAP_GRN_FLD;
  197. ht_info->cap |= IEEE80211_HT_CAP_SGI_20;
  198. max_bit_rate = MAX_BIT_RATE_20_MHZ;
  199. if (priv->hw_params.ht40_channel & BIT(band)) {
  200. ht_info->cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
  201. ht_info->cap |= IEEE80211_HT_CAP_SGI_40;
  202. ht_info->mcs.rx_mask[4] = 0x01;
  203. max_bit_rate = MAX_BIT_RATE_40_MHZ;
  204. }
  205. if (priv->cfg->mod_params->amsdu_size_8K)
  206. ht_info->cap |= IEEE80211_HT_CAP_MAX_AMSDU;
  207. ht_info->ampdu_factor = CFG_HT_RX_AMPDU_FACTOR_DEF;
  208. ht_info->ampdu_density = CFG_HT_MPDU_DENSITY_DEF;
  209. ht_info->mcs.rx_mask[0] = 0xFF;
  210. if (rx_chains_num >= 2)
  211. ht_info->mcs.rx_mask[1] = 0xFF;
  212. if (rx_chains_num >= 3)
  213. ht_info->mcs.rx_mask[2] = 0xFF;
  214. /* Highest supported Rx data rate */
  215. max_bit_rate *= rx_chains_num;
  216. WARN_ON(max_bit_rate & ~IEEE80211_HT_MCS_RX_HIGHEST_MASK);
  217. ht_info->mcs.rx_highest = cpu_to_le16(max_bit_rate);
  218. /* Tx MCS capabilities */
  219. ht_info->mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
  220. if (tx_chains_num != rx_chains_num) {
  221. ht_info->mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
  222. ht_info->mcs.tx_params |= ((tx_chains_num - 1) <<
  223. IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT);
  224. }
  225. }
  226. /**
  227. * iwlcore_init_geos - Initialize mac80211's geo/channel info based from eeprom
  228. */
  229. int iwlcore_init_geos(struct iwl_priv *priv)
  230. {
  231. struct iwl_channel_info *ch;
  232. struct ieee80211_supported_band *sband;
  233. struct ieee80211_channel *channels;
  234. struct ieee80211_channel *geo_ch;
  235. struct ieee80211_rate *rates;
  236. int i = 0;
  237. if (priv->bands[IEEE80211_BAND_2GHZ].n_bitrates ||
  238. priv->bands[IEEE80211_BAND_5GHZ].n_bitrates) {
  239. IWL_DEBUG_INFO(priv, "Geography modes already initialized.\n");
  240. set_bit(STATUS_GEO_CONFIGURED, &priv->status);
  241. return 0;
  242. }
  243. channels = kzalloc(sizeof(struct ieee80211_channel) *
  244. priv->channel_count, GFP_KERNEL);
  245. if (!channels)
  246. return -ENOMEM;
  247. rates = kzalloc((sizeof(struct ieee80211_rate) * IWL_RATE_COUNT_LEGACY),
  248. GFP_KERNEL);
  249. if (!rates) {
  250. kfree(channels);
  251. return -ENOMEM;
  252. }
  253. /* 5.2GHz channels start after the 2.4GHz channels */
  254. sband = &priv->bands[IEEE80211_BAND_5GHZ];
  255. sband->channels = &channels[ARRAY_SIZE(iwl_eeprom_band_1)];
  256. /* just OFDM */
  257. sband->bitrates = &rates[IWL_FIRST_OFDM_RATE];
  258. sband->n_bitrates = IWL_RATE_COUNT_LEGACY - IWL_FIRST_OFDM_RATE;
  259. if (priv->cfg->sku & IWL_SKU_N)
  260. iwlcore_init_ht_hw_capab(priv, &sband->ht_cap,
  261. IEEE80211_BAND_5GHZ);
  262. sband = &priv->bands[IEEE80211_BAND_2GHZ];
  263. sband->channels = channels;
  264. /* OFDM & CCK */
  265. sband->bitrates = rates;
  266. sband->n_bitrates = IWL_RATE_COUNT_LEGACY;
  267. if (priv->cfg->sku & IWL_SKU_N)
  268. iwlcore_init_ht_hw_capab(priv, &sband->ht_cap,
  269. IEEE80211_BAND_2GHZ);
  270. priv->ieee_channels = channels;
  271. priv->ieee_rates = rates;
  272. for (i = 0; i < priv->channel_count; i++) {
  273. ch = &priv->channel_info[i];
  274. /* FIXME: might be removed if scan is OK */
  275. if (!is_channel_valid(ch))
  276. continue;
  277. if (is_channel_a_band(ch))
  278. sband = &priv->bands[IEEE80211_BAND_5GHZ];
  279. else
  280. sband = &priv->bands[IEEE80211_BAND_2GHZ];
  281. geo_ch = &sband->channels[sband->n_channels++];
  282. geo_ch->center_freq =
  283. ieee80211_channel_to_frequency(ch->channel);
  284. geo_ch->max_power = ch->max_power_avg;
  285. geo_ch->max_antenna_gain = 0xff;
  286. geo_ch->hw_value = ch->channel;
  287. if (is_channel_valid(ch)) {
  288. if (!(ch->flags & EEPROM_CHANNEL_IBSS))
  289. geo_ch->flags |= IEEE80211_CHAN_NO_IBSS;
  290. if (!(ch->flags & EEPROM_CHANNEL_ACTIVE))
  291. geo_ch->flags |= IEEE80211_CHAN_PASSIVE_SCAN;
  292. if (ch->flags & EEPROM_CHANNEL_RADAR)
  293. geo_ch->flags |= IEEE80211_CHAN_RADAR;
  294. geo_ch->flags |= ch->ht40_extension_channel;
  295. if (ch->max_power_avg > priv->tx_power_device_lmt)
  296. priv->tx_power_device_lmt = ch->max_power_avg;
  297. } else {
  298. geo_ch->flags |= IEEE80211_CHAN_DISABLED;
  299. }
  300. IWL_DEBUG_INFO(priv, "Channel %d Freq=%d[%sGHz] %s flag=0x%X\n",
  301. ch->channel, geo_ch->center_freq,
  302. is_channel_a_band(ch) ? "5.2" : "2.4",
  303. geo_ch->flags & IEEE80211_CHAN_DISABLED ?
  304. "restricted" : "valid",
  305. geo_ch->flags);
  306. }
  307. if ((priv->bands[IEEE80211_BAND_5GHZ].n_channels == 0) &&
  308. priv->cfg->sku & IWL_SKU_A) {
  309. IWL_INFO(priv, "Incorrectly detected BG card as ABG. "
  310. "Please send your PCI ID 0x%04X:0x%04X to maintainer.\n",
  311. priv->pci_dev->device,
  312. priv->pci_dev->subsystem_device);
  313. priv->cfg->sku &= ~IWL_SKU_A;
  314. }
  315. IWL_INFO(priv, "Tunable channels: %d 802.11bg, %d 802.11a channels\n",
  316. priv->bands[IEEE80211_BAND_2GHZ].n_channels,
  317. priv->bands[IEEE80211_BAND_5GHZ].n_channels);
  318. set_bit(STATUS_GEO_CONFIGURED, &priv->status);
  319. return 0;
  320. }
  321. EXPORT_SYMBOL(iwlcore_init_geos);
  322. /*
  323. * iwlcore_free_geos - undo allocations in iwlcore_init_geos
  324. */
  325. void iwlcore_free_geos(struct iwl_priv *priv)
  326. {
  327. kfree(priv->ieee_channels);
  328. kfree(priv->ieee_rates);
  329. clear_bit(STATUS_GEO_CONFIGURED, &priv->status);
  330. }
  331. EXPORT_SYMBOL(iwlcore_free_geos);
  332. /*
  333. * iwlcore_tx_cmd_protection: Set rts/cts. 3945 and 4965 only share this
  334. * function.
  335. */
  336. void iwlcore_tx_cmd_protection(struct iwl_priv *priv,
  337. struct ieee80211_tx_info *info,
  338. __le16 fc, __le32 *tx_flags)
  339. {
  340. if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_RTS_CTS) {
  341. *tx_flags |= TX_CMD_FLG_RTS_MSK;
  342. *tx_flags &= ~TX_CMD_FLG_CTS_MSK;
  343. *tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;
  344. if (!ieee80211_is_mgmt(fc))
  345. return;
  346. switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
  347. case cpu_to_le16(IEEE80211_STYPE_AUTH):
  348. case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
  349. case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ):
  350. case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ):
  351. *tx_flags &= ~TX_CMD_FLG_RTS_MSK;
  352. *tx_flags |= TX_CMD_FLG_CTS_MSK;
  353. break;
  354. }
  355. } else if (info->control.rates[0].flags & IEEE80211_TX_RC_USE_CTS_PROTECT) {
  356. *tx_flags &= ~TX_CMD_FLG_RTS_MSK;
  357. *tx_flags |= TX_CMD_FLG_CTS_MSK;
  358. *tx_flags |= TX_CMD_FLG_FULL_TXOP_PROT_MSK;
  359. }
  360. }
  361. EXPORT_SYMBOL(iwlcore_tx_cmd_protection);
  362. static bool is_single_rx_stream(struct iwl_priv *priv)
  363. {
  364. return priv->current_ht_config.smps == IEEE80211_SMPS_STATIC ||
  365. priv->current_ht_config.single_chain_sufficient;
  366. }
  367. static u8 iwl_is_channel_extension(struct iwl_priv *priv,
  368. enum ieee80211_band band,
  369. u16 channel, u8 extension_chan_offset)
  370. {
  371. const struct iwl_channel_info *ch_info;
  372. ch_info = iwl_get_channel_info(priv, band, channel);
  373. if (!is_channel_valid(ch_info))
  374. return 0;
  375. if (extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_ABOVE)
  376. return !(ch_info->ht40_extension_channel &
  377. IEEE80211_CHAN_NO_HT40PLUS);
  378. else if (extension_chan_offset == IEEE80211_HT_PARAM_CHA_SEC_BELOW)
  379. return !(ch_info->ht40_extension_channel &
  380. IEEE80211_CHAN_NO_HT40MINUS);
  381. return 0;
  382. }
  383. u8 iwl_is_ht40_tx_allowed(struct iwl_priv *priv,
  384. struct ieee80211_sta_ht_cap *sta_ht_inf)
  385. {
  386. struct iwl_ht_config *ht_conf = &priv->current_ht_config;
  387. if (!ht_conf->is_ht || !ht_conf->is_40mhz)
  388. return 0;
  389. /* We do not check for IEEE80211_HT_CAP_SUP_WIDTH_20_40
  390. * the bit will not set if it is pure 40MHz case
  391. */
  392. if (sta_ht_inf) {
  393. if (!sta_ht_inf->ht_supported)
  394. return 0;
  395. }
  396. #ifdef CONFIG_IWLWIFI_DEBUGFS
  397. if (priv->disable_ht40)
  398. return 0;
  399. #endif
  400. return iwl_is_channel_extension(priv, priv->band,
  401. le16_to_cpu(priv->staging_rxon.channel),
  402. ht_conf->extension_chan_offset);
  403. }
  404. EXPORT_SYMBOL(iwl_is_ht40_tx_allowed);
  405. static u16 iwl_adjust_beacon_interval(u16 beacon_val, u16 max_beacon_val)
  406. {
  407. u16 new_val = 0;
  408. u16 beacon_factor = 0;
  409. beacon_factor = (beacon_val + max_beacon_val) / max_beacon_val;
  410. new_val = beacon_val / beacon_factor;
  411. if (!new_val)
  412. new_val = max_beacon_val;
  413. return new_val;
  414. }
  415. void iwl_setup_rxon_timing(struct iwl_priv *priv, struct ieee80211_vif *vif)
  416. {
  417. u64 tsf;
  418. s32 interval_tm, rem;
  419. unsigned long flags;
  420. struct ieee80211_conf *conf = NULL;
  421. u16 beacon_int;
  422. conf = ieee80211_get_hw_conf(priv->hw);
  423. spin_lock_irqsave(&priv->lock, flags);
  424. priv->rxon_timing.timestamp = cpu_to_le64(priv->timestamp);
  425. priv->rxon_timing.listen_interval = cpu_to_le16(conf->listen_interval);
  426. beacon_int = vif->bss_conf.beacon_int;
  427. if (vif->type == NL80211_IFTYPE_ADHOC) {
  428. /* TODO: we need to get atim_window from upper stack
  429. * for now we set to 0 */
  430. priv->rxon_timing.atim_window = 0;
  431. } else {
  432. priv->rxon_timing.atim_window = 0;
  433. }
  434. beacon_int = iwl_adjust_beacon_interval(beacon_int,
  435. priv->hw_params.max_beacon_itrvl * TIME_UNIT);
  436. priv->rxon_timing.beacon_interval = cpu_to_le16(beacon_int);
  437. tsf = priv->timestamp; /* tsf is modifed by do_div: copy it */
  438. interval_tm = beacon_int * TIME_UNIT;
  439. rem = do_div(tsf, interval_tm);
  440. priv->rxon_timing.beacon_init_val = cpu_to_le32(interval_tm - rem);
  441. spin_unlock_irqrestore(&priv->lock, flags);
  442. IWL_DEBUG_ASSOC(priv,
  443. "beacon interval %d beacon timer %d beacon tim %d\n",
  444. le16_to_cpu(priv->rxon_timing.beacon_interval),
  445. le32_to_cpu(priv->rxon_timing.beacon_init_val),
  446. le16_to_cpu(priv->rxon_timing.atim_window));
  447. }
  448. EXPORT_SYMBOL(iwl_setup_rxon_timing);
  449. void iwl_set_rxon_hwcrypto(struct iwl_priv *priv, int hw_decrypt)
  450. {
  451. struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
  452. if (hw_decrypt)
  453. rxon->filter_flags &= ~RXON_FILTER_DIS_DECRYPT_MSK;
  454. else
  455. rxon->filter_flags |= RXON_FILTER_DIS_DECRYPT_MSK;
  456. }
  457. EXPORT_SYMBOL(iwl_set_rxon_hwcrypto);
  458. /**
  459. * iwl_check_rxon_cmd - validate RXON structure is valid
  460. *
  461. * NOTE: This is really only useful during development and can eventually
  462. * be #ifdef'd out once the driver is stable and folks aren't actively
  463. * making changes
  464. */
  465. int iwl_check_rxon_cmd(struct iwl_priv *priv)
  466. {
  467. int error = 0;
  468. int counter = 1;
  469. struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
  470. if (rxon->flags & RXON_FLG_BAND_24G_MSK) {
  471. error |= le32_to_cpu(rxon->flags &
  472. (RXON_FLG_TGJ_NARROW_BAND_MSK |
  473. RXON_FLG_RADAR_DETECT_MSK));
  474. if (error)
  475. IWL_WARN(priv, "check 24G fields %d | %d\n",
  476. counter++, error);
  477. } else {
  478. error |= (rxon->flags & RXON_FLG_SHORT_SLOT_MSK) ?
  479. 0 : le32_to_cpu(RXON_FLG_SHORT_SLOT_MSK);
  480. if (error)
  481. IWL_WARN(priv, "check 52 fields %d | %d\n",
  482. counter++, error);
  483. error |= le32_to_cpu(rxon->flags & RXON_FLG_CCK_MSK);
  484. if (error)
  485. IWL_WARN(priv, "check 52 CCK %d | %d\n",
  486. counter++, error);
  487. }
  488. error |= (rxon->node_addr[0] | rxon->bssid_addr[0]) & 0x1;
  489. if (error)
  490. IWL_WARN(priv, "check mac addr %d | %d\n", counter++, error);
  491. /* make sure basic rates 6Mbps and 1Mbps are supported */
  492. error |= (((rxon->ofdm_basic_rates & IWL_RATE_6M_MASK) == 0) &&
  493. ((rxon->cck_basic_rates & IWL_RATE_1M_MASK) == 0));
  494. if (error)
  495. IWL_WARN(priv, "check basic rate %d | %d\n", counter++, error);
  496. error |= (le16_to_cpu(rxon->assoc_id) > 2007);
  497. if (error)
  498. IWL_WARN(priv, "check assoc id %d | %d\n", counter++, error);
  499. error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK))
  500. == (RXON_FLG_CCK_MSK | RXON_FLG_SHORT_SLOT_MSK));
  501. if (error)
  502. IWL_WARN(priv, "check CCK and short slot %d | %d\n",
  503. counter++, error);
  504. error |= ((rxon->flags & (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK))
  505. == (RXON_FLG_CCK_MSK | RXON_FLG_AUTO_DETECT_MSK));
  506. if (error)
  507. IWL_WARN(priv, "check CCK & auto detect %d | %d\n",
  508. counter++, error);
  509. error |= ((rxon->flags & (RXON_FLG_AUTO_DETECT_MSK |
  510. RXON_FLG_TGG_PROTECT_MSK)) == RXON_FLG_TGG_PROTECT_MSK);
  511. if (error)
  512. IWL_WARN(priv, "check TGG and auto detect %d | %d\n",
  513. counter++, error);
  514. if (error)
  515. IWL_WARN(priv, "Tuning to channel %d\n",
  516. le16_to_cpu(rxon->channel));
  517. if (error) {
  518. IWL_ERR(priv, "Not a valid iwl_rxon_assoc_cmd field values\n");
  519. return -1;
  520. }
  521. return 0;
  522. }
  523. EXPORT_SYMBOL(iwl_check_rxon_cmd);
  524. /**
  525. * iwl_full_rxon_required - check if full RXON (vs RXON_ASSOC) cmd is needed
  526. * @priv: staging_rxon is compared to active_rxon
  527. *
  528. * If the RXON structure is changing enough to require a new tune,
  529. * or is clearing the RXON_FILTER_ASSOC_MSK, then return 1 to indicate that
  530. * a new tune (full RXON command, rather than RXON_ASSOC cmd) is required.
  531. */
  532. int iwl_full_rxon_required(struct iwl_priv *priv)
  533. {
  534. /* These items are only settable from the full RXON command */
  535. if (!(iwl_is_associated(priv)) ||
  536. compare_ether_addr(priv->staging_rxon.bssid_addr,
  537. priv->active_rxon.bssid_addr) ||
  538. compare_ether_addr(priv->staging_rxon.node_addr,
  539. priv->active_rxon.node_addr) ||
  540. compare_ether_addr(priv->staging_rxon.wlap_bssid_addr,
  541. priv->active_rxon.wlap_bssid_addr) ||
  542. (priv->staging_rxon.dev_type != priv->active_rxon.dev_type) ||
  543. (priv->staging_rxon.channel != priv->active_rxon.channel) ||
  544. (priv->staging_rxon.air_propagation !=
  545. priv->active_rxon.air_propagation) ||
  546. (priv->staging_rxon.ofdm_ht_single_stream_basic_rates !=
  547. priv->active_rxon.ofdm_ht_single_stream_basic_rates) ||
  548. (priv->staging_rxon.ofdm_ht_dual_stream_basic_rates !=
  549. priv->active_rxon.ofdm_ht_dual_stream_basic_rates) ||
  550. (priv->staging_rxon.ofdm_ht_triple_stream_basic_rates !=
  551. priv->active_rxon.ofdm_ht_triple_stream_basic_rates) ||
  552. (priv->staging_rxon.assoc_id != priv->active_rxon.assoc_id))
  553. return 1;
  554. /* flags, filter_flags, ofdm_basic_rates, and cck_basic_rates can
  555. * be updated with the RXON_ASSOC command -- however only some
  556. * flag transitions are allowed using RXON_ASSOC */
  557. /* Check if we are not switching bands */
  558. if ((priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK) !=
  559. (priv->active_rxon.flags & RXON_FLG_BAND_24G_MSK))
  560. return 1;
  561. /* Check if we are switching association toggle */
  562. if ((priv->staging_rxon.filter_flags & RXON_FILTER_ASSOC_MSK) !=
  563. (priv->active_rxon.filter_flags & RXON_FILTER_ASSOC_MSK))
  564. return 1;
  565. return 0;
  566. }
  567. EXPORT_SYMBOL(iwl_full_rxon_required);
  568. u8 iwl_rate_get_lowest_plcp(struct iwl_priv *priv)
  569. {
  570. /*
  571. * Assign the lowest rate -- should really get this from
  572. * the beacon skb from mac80211.
  573. */
  574. if (priv->staging_rxon.flags & RXON_FLG_BAND_24G_MSK)
  575. return IWL_RATE_1M_PLCP;
  576. else
  577. return IWL_RATE_6M_PLCP;
  578. }
  579. EXPORT_SYMBOL(iwl_rate_get_lowest_plcp);
  580. void iwl_set_rxon_ht(struct iwl_priv *priv, struct iwl_ht_config *ht_conf)
  581. {
  582. struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
  583. if (!ht_conf->is_ht) {
  584. rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK |
  585. RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK |
  586. RXON_FLG_HT40_PROT_MSK |
  587. RXON_FLG_HT_PROT_MSK);
  588. return;
  589. }
  590. /* FIXME: if the definition of ht_protection changed, the "translation"
  591. * will be needed for rxon->flags
  592. */
  593. rxon->flags |= cpu_to_le32(ht_conf->ht_protection << RXON_FLG_HT_OPERATING_MODE_POS);
  594. /* Set up channel bandwidth:
  595. * 20 MHz only, 20/40 mixed or pure 40 if ht40 ok */
  596. /* clear the HT channel mode before set the mode */
  597. rxon->flags &= ~(RXON_FLG_CHANNEL_MODE_MSK |
  598. RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
  599. if (iwl_is_ht40_tx_allowed(priv, NULL)) {
  600. /* pure ht40 */
  601. if (ht_conf->ht_protection == IEEE80211_HT_OP_MODE_PROTECTION_20MHZ) {
  602. rxon->flags |= RXON_FLG_CHANNEL_MODE_PURE_40;
  603. /* Note: control channel is opposite of extension channel */
  604. switch (ht_conf->extension_chan_offset) {
  605. case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
  606. rxon->flags &= ~RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
  607. break;
  608. case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
  609. rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
  610. break;
  611. }
  612. } else {
  613. /* Note: control channel is opposite of extension channel */
  614. switch (ht_conf->extension_chan_offset) {
  615. case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
  616. rxon->flags &= ~(RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK);
  617. rxon->flags |= RXON_FLG_CHANNEL_MODE_MIXED;
  618. break;
  619. case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
  620. rxon->flags |= RXON_FLG_CTRL_CHANNEL_LOC_HI_MSK;
  621. rxon->flags |= RXON_FLG_CHANNEL_MODE_MIXED;
  622. break;
  623. case IEEE80211_HT_PARAM_CHA_SEC_NONE:
  624. default:
  625. /* channel location only valid if in Mixed mode */
  626. IWL_ERR(priv, "invalid extension channel offset\n");
  627. break;
  628. }
  629. }
  630. } else {
  631. rxon->flags |= RXON_FLG_CHANNEL_MODE_LEGACY;
  632. }
  633. if (priv->cfg->ops->hcmd->set_rxon_chain)
  634. priv->cfg->ops->hcmd->set_rxon_chain(priv);
  635. IWL_DEBUG_ASSOC(priv, "rxon flags 0x%X operation mode :0x%X "
  636. "extension channel offset 0x%x\n",
  637. le32_to_cpu(rxon->flags), ht_conf->ht_protection,
  638. ht_conf->extension_chan_offset);
  639. }
  640. EXPORT_SYMBOL(iwl_set_rxon_ht);
  641. #define IWL_NUM_RX_CHAINS_MULTIPLE 3
  642. #define IWL_NUM_RX_CHAINS_SINGLE 2
  643. #define IWL_NUM_IDLE_CHAINS_DUAL 2
  644. #define IWL_NUM_IDLE_CHAINS_SINGLE 1
  645. /*
  646. * Determine how many receiver/antenna chains to use.
  647. *
  648. * More provides better reception via diversity. Fewer saves power
  649. * at the expense of throughput, but only when not in powersave to
  650. * start with.
  651. *
  652. * MIMO (dual stream) requires at least 2, but works better with 3.
  653. * This does not determine *which* chains to use, just how many.
  654. */
  655. static int iwl_get_active_rx_chain_count(struct iwl_priv *priv)
  656. {
  657. /* # of Rx chains to use when expecting MIMO. */
  658. if (is_single_rx_stream(priv))
  659. return IWL_NUM_RX_CHAINS_SINGLE;
  660. else
  661. return IWL_NUM_RX_CHAINS_MULTIPLE;
  662. }
  663. /*
  664. * When we are in power saving mode, unless device support spatial
  665. * multiplexing power save, use the active count for rx chain count.
  666. */
  667. static int iwl_get_idle_rx_chain_count(struct iwl_priv *priv, int active_cnt)
  668. {
  669. /* # Rx chains when idling, depending on SMPS mode */
  670. switch (priv->current_ht_config.smps) {
  671. case IEEE80211_SMPS_STATIC:
  672. case IEEE80211_SMPS_DYNAMIC:
  673. return IWL_NUM_IDLE_CHAINS_SINGLE;
  674. case IEEE80211_SMPS_OFF:
  675. return active_cnt;
  676. default:
  677. WARN(1, "invalid SMPS mode %d",
  678. priv->current_ht_config.smps);
  679. return active_cnt;
  680. }
  681. }
  682. /* up to 4 chains */
  683. static u8 iwl_count_chain_bitmap(u32 chain_bitmap)
  684. {
  685. u8 res;
  686. res = (chain_bitmap & BIT(0)) >> 0;
  687. res += (chain_bitmap & BIT(1)) >> 1;
  688. res += (chain_bitmap & BIT(2)) >> 2;
  689. res += (chain_bitmap & BIT(3)) >> 3;
  690. return res;
  691. }
  692. /**
  693. * iwl_set_rxon_chain - Set up Rx chain usage in "staging" RXON image
  694. *
  695. * Selects how many and which Rx receivers/antennas/chains to use.
  696. * This should not be used for scan command ... it puts data in wrong place.
  697. */
  698. void iwl_set_rxon_chain(struct iwl_priv *priv)
  699. {
  700. bool is_single = is_single_rx_stream(priv);
  701. bool is_cam = !test_bit(STATUS_POWER_PMI, &priv->status);
  702. u8 idle_rx_cnt, active_rx_cnt, valid_rx_cnt;
  703. u32 active_chains;
  704. u16 rx_chain;
  705. /* Tell uCode which antennas are actually connected.
  706. * Before first association, we assume all antennas are connected.
  707. * Just after first association, iwl_chain_noise_calibration()
  708. * checks which antennas actually *are* connected. */
  709. if (priv->chain_noise_data.active_chains)
  710. active_chains = priv->chain_noise_data.active_chains;
  711. else
  712. active_chains = priv->hw_params.valid_rx_ant;
  713. rx_chain = active_chains << RXON_RX_CHAIN_VALID_POS;
  714. /* How many receivers should we use? */
  715. active_rx_cnt = iwl_get_active_rx_chain_count(priv);
  716. idle_rx_cnt = iwl_get_idle_rx_chain_count(priv, active_rx_cnt);
  717. /* correct rx chain count according hw settings
  718. * and chain noise calibration
  719. */
  720. valid_rx_cnt = iwl_count_chain_bitmap(active_chains);
  721. if (valid_rx_cnt < active_rx_cnt)
  722. active_rx_cnt = valid_rx_cnt;
  723. if (valid_rx_cnt < idle_rx_cnt)
  724. idle_rx_cnt = valid_rx_cnt;
  725. rx_chain |= active_rx_cnt << RXON_RX_CHAIN_MIMO_CNT_POS;
  726. rx_chain |= idle_rx_cnt << RXON_RX_CHAIN_CNT_POS;
  727. priv->staging_rxon.rx_chain = cpu_to_le16(rx_chain);
  728. if (!is_single && (active_rx_cnt >= IWL_NUM_RX_CHAINS_SINGLE) && is_cam)
  729. priv->staging_rxon.rx_chain |= RXON_RX_CHAIN_MIMO_FORCE_MSK;
  730. else
  731. priv->staging_rxon.rx_chain &= ~RXON_RX_CHAIN_MIMO_FORCE_MSK;
  732. IWL_DEBUG_ASSOC(priv, "rx_chain=0x%X active=%d idle=%d\n",
  733. priv->staging_rxon.rx_chain,
  734. active_rx_cnt, idle_rx_cnt);
  735. WARN_ON(active_rx_cnt == 0 || idle_rx_cnt == 0 ||
  736. active_rx_cnt < idle_rx_cnt);
  737. }
  738. EXPORT_SYMBOL(iwl_set_rxon_chain);
  739. /* Return valid channel */
  740. u8 iwl_get_single_channel_number(struct iwl_priv *priv,
  741. enum ieee80211_band band)
  742. {
  743. const struct iwl_channel_info *ch_info;
  744. int i;
  745. u8 channel = 0;
  746. /* only scan single channel, good enough to reset the RF */
  747. /* pick the first valid not in-use channel */
  748. if (band == IEEE80211_BAND_5GHZ) {
  749. for (i = 14; i < priv->channel_count; i++) {
  750. if (priv->channel_info[i].channel !=
  751. le16_to_cpu(priv->staging_rxon.channel)) {
  752. channel = priv->channel_info[i].channel;
  753. ch_info = iwl_get_channel_info(priv,
  754. band, channel);
  755. if (is_channel_valid(ch_info))
  756. break;
  757. }
  758. }
  759. } else {
  760. for (i = 0; i < 14; i++) {
  761. if (priv->channel_info[i].channel !=
  762. le16_to_cpu(priv->staging_rxon.channel)) {
  763. channel =
  764. priv->channel_info[i].channel;
  765. ch_info = iwl_get_channel_info(priv,
  766. band, channel);
  767. if (is_channel_valid(ch_info))
  768. break;
  769. }
  770. }
  771. }
  772. return channel;
  773. }
  774. EXPORT_SYMBOL(iwl_get_single_channel_number);
  775. /**
  776. * iwl_set_rxon_channel - Set the phymode and channel values in staging RXON
  777. * @phymode: MODE_IEEE80211A sets to 5.2GHz; all else set to 2.4GHz
  778. * @channel: Any channel valid for the requested phymode
  779. * In addition to setting the staging RXON, priv->phymode is also set.
  780. *
  781. * NOTE: Does not commit to the hardware; it sets appropriate bit fields
  782. * in the staging RXON flag structure based on the phymode
  783. */
  784. int iwl_set_rxon_channel(struct iwl_priv *priv, struct ieee80211_channel *ch)
  785. {
  786. enum ieee80211_band band = ch->band;
  787. u16 channel = ch->hw_value;
  788. if (!iwl_get_channel_info(priv, band, channel)) {
  789. IWL_DEBUG_INFO(priv, "Could not set channel to %d [%d]\n",
  790. channel, band);
  791. return -EINVAL;
  792. }
  793. if ((le16_to_cpu(priv->staging_rxon.channel) == channel) &&
  794. (priv->band == band))
  795. return 0;
  796. priv->staging_rxon.channel = cpu_to_le16(channel);
  797. if (band == IEEE80211_BAND_5GHZ)
  798. priv->staging_rxon.flags &= ~RXON_FLG_BAND_24G_MSK;
  799. else
  800. priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;
  801. priv->band = band;
  802. IWL_DEBUG_INFO(priv, "Staging channel set to %d [%d]\n", channel, band);
  803. return 0;
  804. }
  805. EXPORT_SYMBOL(iwl_set_rxon_channel);
  806. void iwl_set_flags_for_band(struct iwl_priv *priv,
  807. enum ieee80211_band band,
  808. struct ieee80211_vif *vif)
  809. {
  810. if (band == IEEE80211_BAND_5GHZ) {
  811. priv->staging_rxon.flags &=
  812. ~(RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK
  813. | RXON_FLG_CCK_MSK);
  814. priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
  815. } else {
  816. /* Copied from iwl_post_associate() */
  817. if (vif && vif->bss_conf.use_short_slot)
  818. priv->staging_rxon.flags |= RXON_FLG_SHORT_SLOT_MSK;
  819. else
  820. priv->staging_rxon.flags &= ~RXON_FLG_SHORT_SLOT_MSK;
  821. priv->staging_rxon.flags |= RXON_FLG_BAND_24G_MSK;
  822. priv->staging_rxon.flags |= RXON_FLG_AUTO_DETECT_MSK;
  823. priv->staging_rxon.flags &= ~RXON_FLG_CCK_MSK;
  824. }
  825. }
  826. EXPORT_SYMBOL(iwl_set_flags_for_band);
  827. /*
  828. * initialize rxon structure with default values from eeprom
  829. */
  830. void iwl_connection_init_rx_config(struct iwl_priv *priv,
  831. struct ieee80211_vif *vif)
  832. {
  833. const struct iwl_channel_info *ch_info;
  834. enum nl80211_iftype type = NL80211_IFTYPE_STATION;
  835. if (vif)
  836. type = vif->type;
  837. memset(&priv->staging_rxon, 0, sizeof(priv->staging_rxon));
  838. switch (type) {
  839. case NL80211_IFTYPE_AP:
  840. priv->staging_rxon.dev_type = RXON_DEV_TYPE_AP;
  841. break;
  842. case NL80211_IFTYPE_STATION:
  843. priv->staging_rxon.dev_type = RXON_DEV_TYPE_ESS;
  844. priv->staging_rxon.filter_flags = RXON_FILTER_ACCEPT_GRP_MSK;
  845. break;
  846. case NL80211_IFTYPE_ADHOC:
  847. priv->staging_rxon.dev_type = RXON_DEV_TYPE_IBSS;
  848. priv->staging_rxon.flags = RXON_FLG_SHORT_PREAMBLE_MSK;
  849. priv->staging_rxon.filter_flags = RXON_FILTER_BCON_AWARE_MSK |
  850. RXON_FILTER_ACCEPT_GRP_MSK;
  851. break;
  852. default:
  853. IWL_ERR(priv, "Unsupported interface type %d\n", type);
  854. break;
  855. }
  856. #if 0
  857. /* TODO: Figure out when short_preamble would be set and cache from
  858. * that */
  859. if (!hw_to_local(priv->hw)->short_preamble)
  860. priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
  861. else
  862. priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
  863. #endif
  864. ch_info = iwl_get_channel_info(priv, priv->band,
  865. le16_to_cpu(priv->active_rxon.channel));
  866. if (!ch_info)
  867. ch_info = &priv->channel_info[0];
  868. priv->staging_rxon.channel = cpu_to_le16(ch_info->channel);
  869. priv->band = ch_info->band;
  870. iwl_set_flags_for_band(priv, priv->band, vif);
  871. priv->staging_rxon.ofdm_basic_rates =
  872. (IWL_OFDM_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
  873. priv->staging_rxon.cck_basic_rates =
  874. (IWL_CCK_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
  875. /* clear both MIX and PURE40 mode flag */
  876. priv->staging_rxon.flags &= ~(RXON_FLG_CHANNEL_MODE_MIXED |
  877. RXON_FLG_CHANNEL_MODE_PURE_40);
  878. if (vif)
  879. memcpy(priv->staging_rxon.node_addr, vif->addr, ETH_ALEN);
  880. priv->staging_rxon.ofdm_ht_single_stream_basic_rates = 0xff;
  881. priv->staging_rxon.ofdm_ht_dual_stream_basic_rates = 0xff;
  882. priv->staging_rxon.ofdm_ht_triple_stream_basic_rates = 0xff;
  883. }
  884. EXPORT_SYMBOL(iwl_connection_init_rx_config);
  885. void iwl_set_rate(struct iwl_priv *priv)
  886. {
  887. const struct ieee80211_supported_band *hw = NULL;
  888. struct ieee80211_rate *rate;
  889. int i;
  890. hw = iwl_get_hw_mode(priv, priv->band);
  891. if (!hw) {
  892. IWL_ERR(priv, "Failed to set rate: unable to get hw mode\n");
  893. return;
  894. }
  895. priv->active_rate = 0;
  896. for (i = 0; i < hw->n_bitrates; i++) {
  897. rate = &(hw->bitrates[i]);
  898. if (rate->hw_value < IWL_RATE_COUNT_LEGACY)
  899. priv->active_rate |= (1 << rate->hw_value);
  900. }
  901. IWL_DEBUG_RATE(priv, "Set active_rate = %0x\n", priv->active_rate);
  902. priv->staging_rxon.cck_basic_rates =
  903. (IWL_CCK_BASIC_RATES_MASK >> IWL_FIRST_CCK_RATE) & 0xF;
  904. priv->staging_rxon.ofdm_basic_rates =
  905. (IWL_OFDM_BASIC_RATES_MASK >> IWL_FIRST_OFDM_RATE) & 0xFF;
  906. }
  907. EXPORT_SYMBOL(iwl_set_rate);
  908. void iwl_chswitch_done(struct iwl_priv *priv, bool is_success)
  909. {
  910. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  911. return;
  912. if (priv->switch_rxon.switch_in_progress) {
  913. ieee80211_chswitch_done(priv->vif, is_success);
  914. mutex_lock(&priv->mutex);
  915. priv->switch_rxon.switch_in_progress = false;
  916. mutex_unlock(&priv->mutex);
  917. }
  918. }
  919. EXPORT_SYMBOL(iwl_chswitch_done);
  920. void iwl_rx_csa(struct iwl_priv *priv, struct iwl_rx_mem_buffer *rxb)
  921. {
  922. struct iwl_rx_packet *pkt = rxb_addr(rxb);
  923. struct iwl_rxon_cmd *rxon = (void *)&priv->active_rxon;
  924. struct iwl_csa_notification *csa = &(pkt->u.csa_notif);
  925. if (priv->switch_rxon.switch_in_progress) {
  926. if (!le32_to_cpu(csa->status) &&
  927. (csa->channel == priv->switch_rxon.channel)) {
  928. rxon->channel = csa->channel;
  929. priv->staging_rxon.channel = csa->channel;
  930. IWL_DEBUG_11H(priv, "CSA notif: channel %d\n",
  931. le16_to_cpu(csa->channel));
  932. iwl_chswitch_done(priv, true);
  933. } else {
  934. IWL_ERR(priv, "CSA notif (fail) : channel %d\n",
  935. le16_to_cpu(csa->channel));
  936. iwl_chswitch_done(priv, false);
  937. }
  938. }
  939. }
  940. EXPORT_SYMBOL(iwl_rx_csa);
  941. #ifdef CONFIG_IWLWIFI_DEBUG
  942. void iwl_print_rx_config_cmd(struct iwl_priv *priv)
  943. {
  944. struct iwl_rxon_cmd *rxon = &priv->staging_rxon;
  945. IWL_DEBUG_RADIO(priv, "RX CONFIG:\n");
  946. iwl_print_hex_dump(priv, IWL_DL_RADIO, (u8 *) rxon, sizeof(*rxon));
  947. IWL_DEBUG_RADIO(priv, "u16 channel: 0x%x\n", le16_to_cpu(rxon->channel));
  948. IWL_DEBUG_RADIO(priv, "u32 flags: 0x%08X\n", le32_to_cpu(rxon->flags));
  949. IWL_DEBUG_RADIO(priv, "u32 filter_flags: 0x%08x\n",
  950. le32_to_cpu(rxon->filter_flags));
  951. IWL_DEBUG_RADIO(priv, "u8 dev_type: 0x%x\n", rxon->dev_type);
  952. IWL_DEBUG_RADIO(priv, "u8 ofdm_basic_rates: 0x%02x\n",
  953. rxon->ofdm_basic_rates);
  954. IWL_DEBUG_RADIO(priv, "u8 cck_basic_rates: 0x%02x\n", rxon->cck_basic_rates);
  955. IWL_DEBUG_RADIO(priv, "u8[6] node_addr: %pM\n", rxon->node_addr);
  956. IWL_DEBUG_RADIO(priv, "u8[6] bssid_addr: %pM\n", rxon->bssid_addr);
  957. IWL_DEBUG_RADIO(priv, "u16 assoc_id: 0x%x\n", le16_to_cpu(rxon->assoc_id));
  958. }
  959. EXPORT_SYMBOL(iwl_print_rx_config_cmd);
  960. #endif
  961. /**
  962. * iwl_irq_handle_error - called for HW or SW error interrupt from card
  963. */
  964. void iwl_irq_handle_error(struct iwl_priv *priv)
  965. {
  966. /* Set the FW error flag -- cleared on iwl_down */
  967. set_bit(STATUS_FW_ERROR, &priv->status);
  968. /* Cancel currently queued command. */
  969. clear_bit(STATUS_HCMD_ACTIVE, &priv->status);
  970. IWL_ERR(priv, "Loaded firmware version: %s\n",
  971. priv->hw->wiphy->fw_version);
  972. priv->cfg->ops->lib->dump_nic_error_log(priv);
  973. if (priv->cfg->ops->lib->dump_csr)
  974. priv->cfg->ops->lib->dump_csr(priv);
  975. if (priv->cfg->ops->lib->dump_fh)
  976. priv->cfg->ops->lib->dump_fh(priv, NULL, false);
  977. priv->cfg->ops->lib->dump_nic_event_log(priv, false, NULL, false);
  978. #ifdef CONFIG_IWLWIFI_DEBUG
  979. if (iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS)
  980. iwl_print_rx_config_cmd(priv);
  981. #endif
  982. wake_up_interruptible(&priv->wait_command_queue);
  983. /* Keep the restart process from trying to send host
  984. * commands by clearing the INIT status bit */
  985. clear_bit(STATUS_READY, &priv->status);
  986. if (!test_bit(STATUS_EXIT_PENDING, &priv->status)) {
  987. IWL_DEBUG(priv, IWL_DL_FW_ERRORS,
  988. "Restarting adapter due to uCode error.\n");
  989. if (priv->cfg->mod_params->restart_fw)
  990. queue_work(priv->workqueue, &priv->restart);
  991. }
  992. }
  993. EXPORT_SYMBOL(iwl_irq_handle_error);
  994. static int iwl_apm_stop_master(struct iwl_priv *priv)
  995. {
  996. int ret = 0;
  997. /* stop device's busmaster DMA activity */
  998. iwl_set_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_STOP_MASTER);
  999. ret = iwl_poll_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_MASTER_DISABLED,
  1000. CSR_RESET_REG_FLAG_MASTER_DISABLED, 100);
  1001. if (ret)
  1002. IWL_WARN(priv, "Master Disable Timed Out, 100 usec\n");
  1003. IWL_DEBUG_INFO(priv, "stop master\n");
  1004. return ret;
  1005. }
  1006. void iwl_apm_stop(struct iwl_priv *priv)
  1007. {
  1008. IWL_DEBUG_INFO(priv, "Stop card, put in low power state\n");
  1009. /* Stop device's DMA activity */
  1010. iwl_apm_stop_master(priv);
  1011. /* Reset the entire device */
  1012. iwl_set_bit(priv, CSR_RESET, CSR_RESET_REG_FLAG_SW_RESET);
  1013. udelay(10);
  1014. /*
  1015. * Clear "initialization complete" bit to move adapter from
  1016. * D0A* (powered-up Active) --> D0U* (Uninitialized) state.
  1017. */
  1018. iwl_clear_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
  1019. }
  1020. EXPORT_SYMBOL(iwl_apm_stop);
  1021. /*
  1022. * Start up NIC's basic functionality after it has been reset
  1023. * (e.g. after platform boot, or shutdown via iwl_apm_stop())
  1024. * NOTE: This does not load uCode nor start the embedded processor
  1025. */
  1026. int iwl_apm_init(struct iwl_priv *priv)
  1027. {
  1028. int ret = 0;
  1029. u16 lctl;
  1030. IWL_DEBUG_INFO(priv, "Init card's basic functions\n");
  1031. /*
  1032. * Use "set_bit" below rather than "write", to preserve any hardware
  1033. * bits already set by default after reset.
  1034. */
  1035. /* Disable L0S exit timer (platform NMI Work/Around) */
  1036. iwl_set_bit(priv, CSR_GIO_CHICKEN_BITS,
  1037. CSR_GIO_CHICKEN_BITS_REG_BIT_DIS_L0S_EXIT_TIMER);
  1038. /*
  1039. * Disable L0s without affecting L1;
  1040. * don't wait for ICH L0s (ICH bug W/A)
  1041. */
  1042. iwl_set_bit(priv, CSR_GIO_CHICKEN_BITS,
  1043. CSR_GIO_CHICKEN_BITS_REG_BIT_L1A_NO_L0S_RX);
  1044. /* Set FH wait threshold to maximum (HW error during stress W/A) */
  1045. iwl_set_bit(priv, CSR_DBG_HPET_MEM_REG, CSR_DBG_HPET_MEM_REG_VAL);
  1046. /*
  1047. * Enable HAP INTA (interrupt from management bus) to
  1048. * wake device's PCI Express link L1a -> L0s
  1049. * NOTE: This is no-op for 3945 (non-existant bit)
  1050. */
  1051. iwl_set_bit(priv, CSR_HW_IF_CONFIG_REG,
  1052. CSR_HW_IF_CONFIG_REG_BIT_HAP_WAKE_L1A);
  1053. /*
  1054. * HW bug W/A for instability in PCIe bus L0->L0S->L1 transition.
  1055. * Check if BIOS (or OS) enabled L1-ASPM on this device.
  1056. * If so (likely), disable L0S, so device moves directly L0->L1;
  1057. * costs negligible amount of power savings.
  1058. * If not (unlikely), enable L0S, so there is at least some
  1059. * power savings, even without L1.
  1060. */
  1061. if (priv->cfg->set_l0s) {
  1062. lctl = iwl_pcie_link_ctl(priv);
  1063. if ((lctl & PCI_CFG_LINK_CTRL_VAL_L1_EN) ==
  1064. PCI_CFG_LINK_CTRL_VAL_L1_EN) {
  1065. /* L1-ASPM enabled; disable(!) L0S */
  1066. iwl_set_bit(priv, CSR_GIO_REG,
  1067. CSR_GIO_REG_VAL_L0S_ENABLED);
  1068. IWL_DEBUG_POWER(priv, "L1 Enabled; Disabling L0S\n");
  1069. } else {
  1070. /* L1-ASPM disabled; enable(!) L0S */
  1071. iwl_clear_bit(priv, CSR_GIO_REG,
  1072. CSR_GIO_REG_VAL_L0S_ENABLED);
  1073. IWL_DEBUG_POWER(priv, "L1 Disabled; Enabling L0S\n");
  1074. }
  1075. }
  1076. /* Configure analog phase-lock-loop before activating to D0A */
  1077. if (priv->cfg->pll_cfg_val)
  1078. iwl_set_bit(priv, CSR_ANA_PLL_CFG, priv->cfg->pll_cfg_val);
  1079. /*
  1080. * Set "initialization complete" bit to move adapter from
  1081. * D0U* --> D0A* (powered-up active) state.
  1082. */
  1083. iwl_set_bit(priv, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_INIT_DONE);
  1084. /*
  1085. * Wait for clock stabilization; once stabilized, access to
  1086. * device-internal resources is supported, e.g. iwl_write_prph()
  1087. * and accesses to uCode SRAM.
  1088. */
  1089. ret = iwl_poll_bit(priv, CSR_GP_CNTRL,
  1090. CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY,
  1091. CSR_GP_CNTRL_REG_FLAG_MAC_CLOCK_READY, 25000);
  1092. if (ret < 0) {
  1093. IWL_DEBUG_INFO(priv, "Failed to init the card\n");
  1094. goto out;
  1095. }
  1096. /*
  1097. * Enable DMA and BSM (if used) clocks, wait for them to stabilize.
  1098. * BSM (Boostrap State Machine) is only in 3945 and 4965;
  1099. * later devices (i.e. 5000 and later) have non-volatile SRAM,
  1100. * and don't need BSM to restore data after power-saving sleep.
  1101. *
  1102. * Write to "CLK_EN_REG"; "1" bits enable clocks, while "0" bits
  1103. * do not disable clocks. This preserves any hardware bits already
  1104. * set by default in "CLK_CTRL_REG" after reset.
  1105. */
  1106. if (priv->cfg->use_bsm)
  1107. iwl_write_prph(priv, APMG_CLK_EN_REG,
  1108. APMG_CLK_VAL_DMA_CLK_RQT | APMG_CLK_VAL_BSM_CLK_RQT);
  1109. else
  1110. iwl_write_prph(priv, APMG_CLK_EN_REG,
  1111. APMG_CLK_VAL_DMA_CLK_RQT);
  1112. udelay(20);
  1113. /* Disable L1-Active */
  1114. iwl_set_bits_prph(priv, APMG_PCIDEV_STT_REG,
  1115. APMG_PCIDEV_STT_VAL_L1_ACT_DIS);
  1116. out:
  1117. return ret;
  1118. }
  1119. EXPORT_SYMBOL(iwl_apm_init);
  1120. void iwl_configure_filter(struct ieee80211_hw *hw,
  1121. unsigned int changed_flags,
  1122. unsigned int *total_flags,
  1123. u64 multicast)
  1124. {
  1125. struct iwl_priv *priv = hw->priv;
  1126. __le32 filter_or = 0, filter_nand = 0;
  1127. #define CHK(test, flag) do { \
  1128. if (*total_flags & (test)) \
  1129. filter_or |= (flag); \
  1130. else \
  1131. filter_nand |= (flag); \
  1132. } while (0)
  1133. IWL_DEBUG_MAC80211(priv, "Enter: changed: 0x%x, total: 0x%x\n",
  1134. changed_flags, *total_flags);
  1135. CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK);
  1136. CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK);
  1137. CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
  1138. #undef CHK
  1139. mutex_lock(&priv->mutex);
  1140. priv->staging_rxon.filter_flags &= ~filter_nand;
  1141. priv->staging_rxon.filter_flags |= filter_or;
  1142. iwlcore_commit_rxon(priv);
  1143. mutex_unlock(&priv->mutex);
  1144. /*
  1145. * Receiving all multicast frames is always enabled by the
  1146. * default flags setup in iwl_connection_init_rx_config()
  1147. * since we currently do not support programming multicast
  1148. * filters into the device.
  1149. */
  1150. *total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
  1151. FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
  1152. }
  1153. EXPORT_SYMBOL(iwl_configure_filter);
  1154. int iwl_set_tx_power(struct iwl_priv *priv, s8 tx_power, bool force)
  1155. {
  1156. int ret = 0;
  1157. s8 prev_tx_power = priv->tx_power_user_lmt;
  1158. if (tx_power < IWLAGN_TX_POWER_TARGET_POWER_MIN) {
  1159. IWL_WARN(priv,
  1160. "Requested user TXPOWER %d below lower limit %d.\n",
  1161. tx_power,
  1162. IWLAGN_TX_POWER_TARGET_POWER_MIN);
  1163. return -EINVAL;
  1164. }
  1165. if (tx_power > priv->tx_power_device_lmt) {
  1166. IWL_WARN(priv,
  1167. "Requested user TXPOWER %d above upper limit %d.\n",
  1168. tx_power, priv->tx_power_device_lmt);
  1169. return -EINVAL;
  1170. }
  1171. if (priv->tx_power_user_lmt != tx_power)
  1172. force = true;
  1173. /* if nic is not up don't send command */
  1174. if (iwl_is_ready_rf(priv)) {
  1175. priv->tx_power_user_lmt = tx_power;
  1176. if (force && priv->cfg->ops->lib->send_tx_power)
  1177. ret = priv->cfg->ops->lib->send_tx_power(priv);
  1178. else if (!priv->cfg->ops->lib->send_tx_power)
  1179. ret = -EOPNOTSUPP;
  1180. /*
  1181. * if fail to set tx_power, restore the orig. tx power
  1182. */
  1183. if (ret)
  1184. priv->tx_power_user_lmt = prev_tx_power;
  1185. }
  1186. /*
  1187. * Even this is an async host command, the command
  1188. * will always report success from uCode
  1189. * So once driver can placing the command into the queue
  1190. * successfully, driver can use priv->tx_power_user_lmt
  1191. * to reflect the current tx power
  1192. */
  1193. return ret;
  1194. }
  1195. EXPORT_SYMBOL(iwl_set_tx_power);
  1196. irqreturn_t iwl_isr_legacy(int irq, void *data)
  1197. {
  1198. struct iwl_priv *priv = data;
  1199. u32 inta, inta_mask;
  1200. u32 inta_fh;
  1201. unsigned long flags;
  1202. if (!priv)
  1203. return IRQ_NONE;
  1204. spin_lock_irqsave(&priv->lock, flags);
  1205. /* Disable (but don't clear!) interrupts here to avoid
  1206. * back-to-back ISRs and sporadic interrupts from our NIC.
  1207. * If we have something to service, the tasklet will re-enable ints.
  1208. * If we *don't* have something, we'll re-enable before leaving here. */
  1209. inta_mask = iwl_read32(priv, CSR_INT_MASK); /* just for debug */
  1210. iwl_write32(priv, CSR_INT_MASK, 0x00000000);
  1211. /* Discover which interrupts are active/pending */
  1212. inta = iwl_read32(priv, CSR_INT);
  1213. inta_fh = iwl_read32(priv, CSR_FH_INT_STATUS);
  1214. /* Ignore interrupt if there's nothing in NIC to service.
  1215. * This may be due to IRQ shared with another device,
  1216. * or due to sporadic interrupts thrown from our NIC. */
  1217. if (!inta && !inta_fh) {
  1218. IWL_DEBUG_ISR(priv, "Ignore interrupt, inta == 0, inta_fh == 0\n");
  1219. goto none;
  1220. }
  1221. if ((inta == 0xFFFFFFFF) || ((inta & 0xFFFFFFF0) == 0xa5a5a5a0)) {
  1222. /* Hardware disappeared. It might have already raised
  1223. * an interrupt */
  1224. IWL_WARN(priv, "HARDWARE GONE?? INTA == 0x%08x\n", inta);
  1225. goto unplugged;
  1226. }
  1227. IWL_DEBUG_ISR(priv, "ISR inta 0x%08x, enabled 0x%08x, fh 0x%08x\n",
  1228. inta, inta_mask, inta_fh);
  1229. inta &= ~CSR_INT_BIT_SCD;
  1230. /* iwl_irq_tasklet() will service interrupts and re-enable them */
  1231. if (likely(inta || inta_fh))
  1232. tasklet_schedule(&priv->irq_tasklet);
  1233. unplugged:
  1234. spin_unlock_irqrestore(&priv->lock, flags);
  1235. return IRQ_HANDLED;
  1236. none:
  1237. /* re-enable interrupts here since we don't have anything to service. */
  1238. /* only Re-enable if diabled by irq */
  1239. if (test_bit(STATUS_INT_ENABLED, &priv->status))
  1240. iwl_enable_interrupts(priv);
  1241. spin_unlock_irqrestore(&priv->lock, flags);
  1242. return IRQ_NONE;
  1243. }
  1244. EXPORT_SYMBOL(iwl_isr_legacy);
  1245. void iwl_send_bt_config(struct iwl_priv *priv)
  1246. {
  1247. struct iwl_bt_cmd bt_cmd = {
  1248. .lead_time = BT_LEAD_TIME_DEF,
  1249. .max_kill = BT_MAX_KILL_DEF,
  1250. .kill_ack_mask = 0,
  1251. .kill_cts_mask = 0,
  1252. };
  1253. if (!bt_coex_active)
  1254. bt_cmd.flags = BT_COEX_DISABLE;
  1255. else
  1256. bt_cmd.flags = BT_COEX_ENABLE;
  1257. IWL_DEBUG_INFO(priv, "BT coex %s\n",
  1258. (bt_cmd.flags == BT_COEX_DISABLE) ? "disable" : "active");
  1259. if (iwl_send_cmd_pdu(priv, REPLY_BT_CONFIG,
  1260. sizeof(struct iwl_bt_cmd), &bt_cmd))
  1261. IWL_ERR(priv, "failed to send BT Coex Config\n");
  1262. }
  1263. EXPORT_SYMBOL(iwl_send_bt_config);
  1264. int iwl_send_statistics_request(struct iwl_priv *priv, u8 flags, bool clear)
  1265. {
  1266. struct iwl_statistics_cmd statistics_cmd = {
  1267. .configuration_flags =
  1268. clear ? IWL_STATS_CONF_CLEAR_STATS : 0,
  1269. };
  1270. if (flags & CMD_ASYNC)
  1271. return iwl_send_cmd_pdu_async(priv, REPLY_STATISTICS_CMD,
  1272. sizeof(struct iwl_statistics_cmd),
  1273. &statistics_cmd, NULL);
  1274. else
  1275. return iwl_send_cmd_pdu(priv, REPLY_STATISTICS_CMD,
  1276. sizeof(struct iwl_statistics_cmd),
  1277. &statistics_cmd);
  1278. }
  1279. EXPORT_SYMBOL(iwl_send_statistics_request);
  1280. /*
  1281. * CARD_STATE_CMD
  1282. *
  1283. * Use: Sets the device's internal card state to enable, disable, or halt
  1284. *
  1285. * When in the 'enable' state the card operates as normal.
  1286. * When in the 'disable' state, the card enters into a low power mode.
  1287. * When in the 'halt' state, the card is shut down and must be fully
  1288. * restarted to come back on.
  1289. */
  1290. int iwl_send_card_state(struct iwl_priv *priv, u32 flags, u8 meta_flag)
  1291. {
  1292. struct iwl_host_cmd cmd = {
  1293. .id = REPLY_CARD_STATE_CMD,
  1294. .len = sizeof(u32),
  1295. .data = &flags,
  1296. .flags = meta_flag,
  1297. };
  1298. return iwl_send_cmd(priv, &cmd);
  1299. }
  1300. void iwl_rx_pm_sleep_notif(struct iwl_priv *priv,
  1301. struct iwl_rx_mem_buffer *rxb)
  1302. {
  1303. #ifdef CONFIG_IWLWIFI_DEBUG
  1304. struct iwl_rx_packet *pkt = rxb_addr(rxb);
  1305. struct iwl_sleep_notification *sleep = &(pkt->u.sleep_notif);
  1306. IWL_DEBUG_RX(priv, "sleep mode: %d, src: %d\n",
  1307. sleep->pm_sleep_mode, sleep->pm_wakeup_src);
  1308. #endif
  1309. }
  1310. EXPORT_SYMBOL(iwl_rx_pm_sleep_notif);
  1311. void iwl_rx_pm_debug_statistics_notif(struct iwl_priv *priv,
  1312. struct iwl_rx_mem_buffer *rxb)
  1313. {
  1314. struct iwl_rx_packet *pkt = rxb_addr(rxb);
  1315. u32 len = le32_to_cpu(pkt->len_n_flags) & FH_RSCSR_FRAME_SIZE_MSK;
  1316. IWL_DEBUG_RADIO(priv, "Dumping %d bytes of unhandled "
  1317. "notification for %s:\n", len,
  1318. get_cmd_string(pkt->hdr.cmd));
  1319. iwl_print_hex_dump(priv, IWL_DL_RADIO, pkt->u.raw, len);
  1320. }
  1321. EXPORT_SYMBOL(iwl_rx_pm_debug_statistics_notif);
  1322. void iwl_rx_reply_error(struct iwl_priv *priv,
  1323. struct iwl_rx_mem_buffer *rxb)
  1324. {
  1325. struct iwl_rx_packet *pkt = rxb_addr(rxb);
  1326. IWL_ERR(priv, "Error Reply type 0x%08X cmd %s (0x%02X) "
  1327. "seq 0x%04X ser 0x%08X\n",
  1328. le32_to_cpu(pkt->u.err_resp.error_type),
  1329. get_cmd_string(pkt->u.err_resp.cmd_id),
  1330. pkt->u.err_resp.cmd_id,
  1331. le16_to_cpu(pkt->u.err_resp.bad_cmd_seq_num),
  1332. le32_to_cpu(pkt->u.err_resp.error_info));
  1333. }
  1334. EXPORT_SYMBOL(iwl_rx_reply_error);
  1335. void iwl_clear_isr_stats(struct iwl_priv *priv)
  1336. {
  1337. memset(&priv->isr_stats, 0, sizeof(priv->isr_stats));
  1338. }
  1339. int iwl_mac_conf_tx(struct ieee80211_hw *hw, u16 queue,
  1340. const struct ieee80211_tx_queue_params *params)
  1341. {
  1342. struct iwl_priv *priv = hw->priv;
  1343. unsigned long flags;
  1344. int q;
  1345. IWL_DEBUG_MAC80211(priv, "enter\n");
  1346. if (!iwl_is_ready_rf(priv)) {
  1347. IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
  1348. return -EIO;
  1349. }
  1350. if (queue >= AC_NUM) {
  1351. IWL_DEBUG_MAC80211(priv, "leave - queue >= AC_NUM %d\n", queue);
  1352. return 0;
  1353. }
  1354. q = AC_NUM - 1 - queue;
  1355. spin_lock_irqsave(&priv->lock, flags);
  1356. priv->qos_data.def_qos_parm.ac[q].cw_min = cpu_to_le16(params->cw_min);
  1357. priv->qos_data.def_qos_parm.ac[q].cw_max = cpu_to_le16(params->cw_max);
  1358. priv->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
  1359. priv->qos_data.def_qos_parm.ac[q].edca_txop =
  1360. cpu_to_le16((params->txop * 32));
  1361. priv->qos_data.def_qos_parm.ac[q].reserved1 = 0;
  1362. spin_unlock_irqrestore(&priv->lock, flags);
  1363. IWL_DEBUG_MAC80211(priv, "leave\n");
  1364. return 0;
  1365. }
  1366. EXPORT_SYMBOL(iwl_mac_conf_tx);
  1367. int iwl_mac_tx_last_beacon(struct ieee80211_hw *hw)
  1368. {
  1369. struct iwl_priv *priv = hw->priv;
  1370. return priv->ibss_manager == IWL_IBSS_MANAGER;
  1371. }
  1372. EXPORT_SYMBOL_GPL(iwl_mac_tx_last_beacon);
  1373. static void iwl_ht_conf(struct iwl_priv *priv,
  1374. struct ieee80211_vif *vif)
  1375. {
  1376. struct iwl_ht_config *ht_conf = &priv->current_ht_config;
  1377. struct ieee80211_sta *sta;
  1378. struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
  1379. IWL_DEBUG_MAC80211(priv, "enter:\n");
  1380. if (!ht_conf->is_ht)
  1381. return;
  1382. ht_conf->ht_protection =
  1383. bss_conf->ht_operation_mode & IEEE80211_HT_OP_MODE_PROTECTION;
  1384. ht_conf->non_GF_STA_present =
  1385. !!(bss_conf->ht_operation_mode & IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
  1386. ht_conf->single_chain_sufficient = false;
  1387. switch (vif->type) {
  1388. case NL80211_IFTYPE_STATION:
  1389. rcu_read_lock();
  1390. sta = ieee80211_find_sta(vif, bss_conf->bssid);
  1391. if (sta) {
  1392. struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
  1393. int maxstreams;
  1394. maxstreams = (ht_cap->mcs.tx_params &
  1395. IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK)
  1396. >> IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
  1397. maxstreams += 1;
  1398. if ((ht_cap->mcs.rx_mask[1] == 0) &&
  1399. (ht_cap->mcs.rx_mask[2] == 0))
  1400. ht_conf->single_chain_sufficient = true;
  1401. if (maxstreams <= 1)
  1402. ht_conf->single_chain_sufficient = true;
  1403. } else {
  1404. /*
  1405. * If at all, this can only happen through a race
  1406. * when the AP disconnects us while we're still
  1407. * setting up the connection, in that case mac80211
  1408. * will soon tell us about that.
  1409. */
  1410. ht_conf->single_chain_sufficient = true;
  1411. }
  1412. rcu_read_unlock();
  1413. break;
  1414. case NL80211_IFTYPE_ADHOC:
  1415. ht_conf->single_chain_sufficient = true;
  1416. break;
  1417. default:
  1418. break;
  1419. }
  1420. IWL_DEBUG_MAC80211(priv, "leave\n");
  1421. }
  1422. static inline void iwl_set_no_assoc(struct iwl_priv *priv)
  1423. {
  1424. iwl_led_disassociate(priv);
  1425. /*
  1426. * inform the ucode that there is no longer an
  1427. * association and that no more packets should be
  1428. * sent
  1429. */
  1430. priv->staging_rxon.filter_flags &=
  1431. ~RXON_FILTER_ASSOC_MSK;
  1432. priv->staging_rxon.assoc_id = 0;
  1433. iwlcore_commit_rxon(priv);
  1434. }
  1435. static int iwl_mac_beacon_update(struct ieee80211_hw *hw, struct sk_buff *skb)
  1436. {
  1437. struct iwl_priv *priv = hw->priv;
  1438. unsigned long flags;
  1439. __le64 timestamp;
  1440. IWL_DEBUG_MAC80211(priv, "enter\n");
  1441. if (!iwl_is_ready_rf(priv)) {
  1442. IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
  1443. return -EIO;
  1444. }
  1445. spin_lock_irqsave(&priv->lock, flags);
  1446. if (priv->ibss_beacon)
  1447. dev_kfree_skb(priv->ibss_beacon);
  1448. priv->ibss_beacon = skb;
  1449. timestamp = ((struct ieee80211_mgmt *)skb->data)->u.beacon.timestamp;
  1450. priv->timestamp = le64_to_cpu(timestamp);
  1451. IWL_DEBUG_MAC80211(priv, "leave\n");
  1452. spin_unlock_irqrestore(&priv->lock, flags);
  1453. priv->cfg->ops->lib->post_associate(priv, priv->vif);
  1454. return 0;
  1455. }
  1456. void iwl_bss_info_changed(struct ieee80211_hw *hw,
  1457. struct ieee80211_vif *vif,
  1458. struct ieee80211_bss_conf *bss_conf,
  1459. u32 changes)
  1460. {
  1461. struct iwl_priv *priv = hw->priv;
  1462. int ret;
  1463. IWL_DEBUG_MAC80211(priv, "changes = 0x%X\n", changes);
  1464. if (!iwl_is_alive(priv))
  1465. return;
  1466. mutex_lock(&priv->mutex);
  1467. if (changes & BSS_CHANGED_QOS) {
  1468. unsigned long flags;
  1469. spin_lock_irqsave(&priv->lock, flags);
  1470. priv->qos_data.qos_active = bss_conf->qos;
  1471. iwl_update_qos(priv);
  1472. spin_unlock_irqrestore(&priv->lock, flags);
  1473. }
  1474. if (changes & BSS_CHANGED_BEACON && vif->type == NL80211_IFTYPE_AP) {
  1475. dev_kfree_skb(priv->ibss_beacon);
  1476. priv->ibss_beacon = ieee80211_beacon_get(hw, vif);
  1477. }
  1478. if (changes & BSS_CHANGED_BEACON_INT) {
  1479. /* TODO: in AP mode, do something to make this take effect */
  1480. }
  1481. if (changes & BSS_CHANGED_BSSID) {
  1482. IWL_DEBUG_MAC80211(priv, "BSSID %pM\n", bss_conf->bssid);
  1483. /*
  1484. * If there is currently a HW scan going on in the
  1485. * background then we need to cancel it else the RXON
  1486. * below/in post_associate will fail.
  1487. */
  1488. if (iwl_scan_cancel_timeout(priv, 100)) {
  1489. IWL_WARN(priv, "Aborted scan still in progress after 100ms\n");
  1490. IWL_DEBUG_MAC80211(priv, "leaving - scan abort failed.\n");
  1491. mutex_unlock(&priv->mutex);
  1492. return;
  1493. }
  1494. /* mac80211 only sets assoc when in STATION mode */
  1495. if (vif->type == NL80211_IFTYPE_ADHOC || bss_conf->assoc) {
  1496. memcpy(priv->staging_rxon.bssid_addr,
  1497. bss_conf->bssid, ETH_ALEN);
  1498. /* currently needed in a few places */
  1499. memcpy(priv->bssid, bss_conf->bssid, ETH_ALEN);
  1500. } else {
  1501. priv->staging_rxon.filter_flags &=
  1502. ~RXON_FILTER_ASSOC_MSK;
  1503. }
  1504. }
  1505. /*
  1506. * This needs to be after setting the BSSID in case
  1507. * mac80211 decides to do both changes at once because
  1508. * it will invoke post_associate.
  1509. */
  1510. if (vif->type == NL80211_IFTYPE_ADHOC &&
  1511. changes & BSS_CHANGED_BEACON) {
  1512. struct sk_buff *beacon = ieee80211_beacon_get(hw, vif);
  1513. if (beacon)
  1514. iwl_mac_beacon_update(hw, beacon);
  1515. }
  1516. if (changes & BSS_CHANGED_ERP_PREAMBLE) {
  1517. IWL_DEBUG_MAC80211(priv, "ERP_PREAMBLE %d\n",
  1518. bss_conf->use_short_preamble);
  1519. if (bss_conf->use_short_preamble)
  1520. priv->staging_rxon.flags |= RXON_FLG_SHORT_PREAMBLE_MSK;
  1521. else
  1522. priv->staging_rxon.flags &= ~RXON_FLG_SHORT_PREAMBLE_MSK;
  1523. }
  1524. if (changes & BSS_CHANGED_ERP_CTS_PROT) {
  1525. IWL_DEBUG_MAC80211(priv, "ERP_CTS %d\n", bss_conf->use_cts_prot);
  1526. if (bss_conf->use_cts_prot && (priv->band != IEEE80211_BAND_5GHZ))
  1527. priv->staging_rxon.flags |= RXON_FLG_TGG_PROTECT_MSK;
  1528. else
  1529. priv->staging_rxon.flags &= ~RXON_FLG_TGG_PROTECT_MSK;
  1530. if (bss_conf->use_cts_prot)
  1531. priv->staging_rxon.flags |= RXON_FLG_SELF_CTS_EN;
  1532. else
  1533. priv->staging_rxon.flags &= ~RXON_FLG_SELF_CTS_EN;
  1534. }
  1535. if (changes & BSS_CHANGED_BASIC_RATES) {
  1536. /* XXX use this information
  1537. *
  1538. * To do that, remove code from iwl_set_rate() and put something
  1539. * like this here:
  1540. *
  1541. if (A-band)
  1542. priv->staging_rxon.ofdm_basic_rates =
  1543. bss_conf->basic_rates;
  1544. else
  1545. priv->staging_rxon.ofdm_basic_rates =
  1546. bss_conf->basic_rates >> 4;
  1547. priv->staging_rxon.cck_basic_rates =
  1548. bss_conf->basic_rates & 0xF;
  1549. */
  1550. }
  1551. if (changes & BSS_CHANGED_HT) {
  1552. iwl_ht_conf(priv, vif);
  1553. if (priv->cfg->ops->hcmd->set_rxon_chain)
  1554. priv->cfg->ops->hcmd->set_rxon_chain(priv);
  1555. }
  1556. if (changes & BSS_CHANGED_ASSOC) {
  1557. IWL_DEBUG_MAC80211(priv, "ASSOC %d\n", bss_conf->assoc);
  1558. if (bss_conf->assoc) {
  1559. priv->timestamp = bss_conf->timestamp;
  1560. iwl_led_associate(priv);
  1561. if (!iwl_is_rfkill(priv))
  1562. priv->cfg->ops->lib->post_associate(priv, vif);
  1563. } else
  1564. iwl_set_no_assoc(priv);
  1565. }
  1566. if (changes && iwl_is_associated(priv) && bss_conf->aid) {
  1567. IWL_DEBUG_MAC80211(priv, "Changes (%#x) while associated\n",
  1568. changes);
  1569. ret = iwl_send_rxon_assoc(priv);
  1570. if (!ret) {
  1571. /* Sync active_rxon with latest change. */
  1572. memcpy((void *)&priv->active_rxon,
  1573. &priv->staging_rxon,
  1574. sizeof(struct iwl_rxon_cmd));
  1575. }
  1576. }
  1577. if (changes & BSS_CHANGED_BEACON_ENABLED) {
  1578. if (vif->bss_conf.enable_beacon) {
  1579. memcpy(priv->staging_rxon.bssid_addr,
  1580. bss_conf->bssid, ETH_ALEN);
  1581. memcpy(priv->bssid, bss_conf->bssid, ETH_ALEN);
  1582. iwlcore_config_ap(priv, vif);
  1583. } else
  1584. iwl_set_no_assoc(priv);
  1585. }
  1586. if (changes & BSS_CHANGED_IBSS) {
  1587. ret = priv->cfg->ops->lib->manage_ibss_station(priv, vif,
  1588. bss_conf->ibss_joined);
  1589. if (ret)
  1590. IWL_ERR(priv, "failed to %s IBSS station %pM\n",
  1591. bss_conf->ibss_joined ? "add" : "remove",
  1592. bss_conf->bssid);
  1593. }
  1594. mutex_unlock(&priv->mutex);
  1595. IWL_DEBUG_MAC80211(priv, "leave\n");
  1596. }
  1597. EXPORT_SYMBOL(iwl_bss_info_changed);
  1598. static int iwl_set_mode(struct iwl_priv *priv, struct ieee80211_vif *vif)
  1599. {
  1600. iwl_connection_init_rx_config(priv, vif);
  1601. if (priv->cfg->ops->hcmd->set_rxon_chain)
  1602. priv->cfg->ops->hcmd->set_rxon_chain(priv);
  1603. return iwlcore_commit_rxon(priv);
  1604. }
  1605. int iwl_mac_add_interface(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
  1606. {
  1607. struct iwl_priv *priv = hw->priv;
  1608. int err = 0;
  1609. IWL_DEBUG_MAC80211(priv, "enter: type %d, addr %pM\n",
  1610. vif->type, vif->addr);
  1611. mutex_lock(&priv->mutex);
  1612. if (WARN_ON(!iwl_is_ready_rf(priv))) {
  1613. err = -EINVAL;
  1614. goto out;
  1615. }
  1616. if (priv->vif) {
  1617. IWL_DEBUG_MAC80211(priv, "leave - vif != NULL\n");
  1618. err = -EOPNOTSUPP;
  1619. goto out;
  1620. }
  1621. priv->vif = vif;
  1622. priv->iw_mode = vif->type;
  1623. err = iwl_set_mode(priv, vif);
  1624. if (err)
  1625. goto out_err;
  1626. goto out;
  1627. out_err:
  1628. priv->vif = NULL;
  1629. priv->iw_mode = NL80211_IFTYPE_STATION;
  1630. out:
  1631. mutex_unlock(&priv->mutex);
  1632. IWL_DEBUG_MAC80211(priv, "leave\n");
  1633. return err;
  1634. }
  1635. EXPORT_SYMBOL(iwl_mac_add_interface);
  1636. void iwl_mac_remove_interface(struct ieee80211_hw *hw,
  1637. struct ieee80211_vif *vif)
  1638. {
  1639. struct iwl_priv *priv = hw->priv;
  1640. bool scan_completed = false;
  1641. IWL_DEBUG_MAC80211(priv, "enter\n");
  1642. mutex_lock(&priv->mutex);
  1643. if (iwl_is_ready_rf(priv)) {
  1644. iwl_scan_cancel_timeout(priv, 100);
  1645. priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
  1646. iwlcore_commit_rxon(priv);
  1647. }
  1648. if (priv->vif == vif) {
  1649. priv->vif = NULL;
  1650. if (priv->scan_vif == vif) {
  1651. scan_completed = true;
  1652. priv->scan_vif = NULL;
  1653. priv->scan_request = NULL;
  1654. }
  1655. memset(priv->bssid, 0, ETH_ALEN);
  1656. }
  1657. mutex_unlock(&priv->mutex);
  1658. if (scan_completed)
  1659. ieee80211_scan_completed(priv->hw, true);
  1660. IWL_DEBUG_MAC80211(priv, "leave\n");
  1661. }
  1662. EXPORT_SYMBOL(iwl_mac_remove_interface);
  1663. /**
  1664. * iwl_mac_config - mac80211 config callback
  1665. */
  1666. int iwl_mac_config(struct ieee80211_hw *hw, u32 changed)
  1667. {
  1668. struct iwl_priv *priv = hw->priv;
  1669. const struct iwl_channel_info *ch_info;
  1670. struct ieee80211_conf *conf = &hw->conf;
  1671. struct ieee80211_channel *channel = conf->channel;
  1672. struct iwl_ht_config *ht_conf = &priv->current_ht_config;
  1673. unsigned long flags = 0;
  1674. int ret = 0;
  1675. u16 ch;
  1676. int scan_active = 0;
  1677. mutex_lock(&priv->mutex);
  1678. IWL_DEBUG_MAC80211(priv, "enter to channel %d changed 0x%X\n",
  1679. channel->hw_value, changed);
  1680. if (unlikely(!priv->cfg->mod_params->disable_hw_scan &&
  1681. test_bit(STATUS_SCANNING, &priv->status))) {
  1682. scan_active = 1;
  1683. IWL_DEBUG_MAC80211(priv, "leave - scanning\n");
  1684. }
  1685. if (changed & (IEEE80211_CONF_CHANGE_SMPS |
  1686. IEEE80211_CONF_CHANGE_CHANNEL)) {
  1687. /* mac80211 uses static for non-HT which is what we want */
  1688. priv->current_ht_config.smps = conf->smps_mode;
  1689. /*
  1690. * Recalculate chain counts.
  1691. *
  1692. * If monitor mode is enabled then mac80211 will
  1693. * set up the SM PS mode to OFF if an HT channel is
  1694. * configured.
  1695. */
  1696. if (priv->cfg->ops->hcmd->set_rxon_chain)
  1697. priv->cfg->ops->hcmd->set_rxon_chain(priv);
  1698. }
  1699. /* during scanning mac80211 will delay channel setting until
  1700. * scan finish with changed = 0
  1701. */
  1702. if (!changed || (changed & IEEE80211_CONF_CHANGE_CHANNEL)) {
  1703. if (scan_active)
  1704. goto set_ch_out;
  1705. ch = channel->hw_value;
  1706. ch_info = iwl_get_channel_info(priv, channel->band, ch);
  1707. if (!is_channel_valid(ch_info)) {
  1708. IWL_DEBUG_MAC80211(priv, "leave - invalid channel\n");
  1709. ret = -EINVAL;
  1710. goto set_ch_out;
  1711. }
  1712. spin_lock_irqsave(&priv->lock, flags);
  1713. /* Configure HT40 channels */
  1714. ht_conf->is_ht = conf_is_ht(conf);
  1715. if (ht_conf->is_ht) {
  1716. if (conf_is_ht40_minus(conf)) {
  1717. ht_conf->extension_chan_offset =
  1718. IEEE80211_HT_PARAM_CHA_SEC_BELOW;
  1719. ht_conf->is_40mhz = true;
  1720. } else if (conf_is_ht40_plus(conf)) {
  1721. ht_conf->extension_chan_offset =
  1722. IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
  1723. ht_conf->is_40mhz = true;
  1724. } else {
  1725. ht_conf->extension_chan_offset =
  1726. IEEE80211_HT_PARAM_CHA_SEC_NONE;
  1727. ht_conf->is_40mhz = false;
  1728. }
  1729. } else
  1730. ht_conf->is_40mhz = false;
  1731. /* Default to no protection. Protection mode will later be set
  1732. * from BSS config in iwl_ht_conf */
  1733. ht_conf->ht_protection = IEEE80211_HT_OP_MODE_PROTECTION_NONE;
  1734. if ((le16_to_cpu(priv->staging_rxon.channel) != ch))
  1735. priv->staging_rxon.flags = 0;
  1736. iwl_set_rxon_channel(priv, channel);
  1737. iwl_set_rxon_ht(priv, ht_conf);
  1738. iwl_set_flags_for_band(priv, channel->band, priv->vif);
  1739. spin_unlock_irqrestore(&priv->lock, flags);
  1740. if (priv->cfg->ops->lib->update_bcast_station)
  1741. ret = priv->cfg->ops->lib->update_bcast_station(priv);
  1742. set_ch_out:
  1743. /* The list of supported rates and rate mask can be different
  1744. * for each band; since the band may have changed, reset
  1745. * the rate mask to what mac80211 lists */
  1746. iwl_set_rate(priv);
  1747. }
  1748. if (changed & (IEEE80211_CONF_CHANGE_PS |
  1749. IEEE80211_CONF_CHANGE_IDLE)) {
  1750. ret = iwl_power_update_mode(priv, false);
  1751. if (ret)
  1752. IWL_DEBUG_MAC80211(priv, "Error setting sleep level\n");
  1753. }
  1754. if (changed & IEEE80211_CONF_CHANGE_POWER) {
  1755. IWL_DEBUG_MAC80211(priv, "TX Power old=%d new=%d\n",
  1756. priv->tx_power_user_lmt, conf->power_level);
  1757. iwl_set_tx_power(priv, conf->power_level, false);
  1758. }
  1759. if (!iwl_is_ready(priv)) {
  1760. IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
  1761. goto out;
  1762. }
  1763. if (scan_active)
  1764. goto out;
  1765. if (memcmp(&priv->active_rxon,
  1766. &priv->staging_rxon, sizeof(priv->staging_rxon)))
  1767. iwlcore_commit_rxon(priv);
  1768. else
  1769. IWL_DEBUG_INFO(priv, "Not re-sending same RXON configuration.\n");
  1770. out:
  1771. IWL_DEBUG_MAC80211(priv, "leave\n");
  1772. mutex_unlock(&priv->mutex);
  1773. return ret;
  1774. }
  1775. EXPORT_SYMBOL(iwl_mac_config);
  1776. void iwl_mac_reset_tsf(struct ieee80211_hw *hw)
  1777. {
  1778. struct iwl_priv *priv = hw->priv;
  1779. unsigned long flags;
  1780. mutex_lock(&priv->mutex);
  1781. IWL_DEBUG_MAC80211(priv, "enter\n");
  1782. spin_lock_irqsave(&priv->lock, flags);
  1783. memset(&priv->current_ht_config, 0, sizeof(struct iwl_ht_config));
  1784. spin_unlock_irqrestore(&priv->lock, flags);
  1785. spin_lock_irqsave(&priv->lock, flags);
  1786. /* new association get rid of ibss beacon skb */
  1787. if (priv->ibss_beacon)
  1788. dev_kfree_skb(priv->ibss_beacon);
  1789. priv->ibss_beacon = NULL;
  1790. priv->timestamp = 0;
  1791. spin_unlock_irqrestore(&priv->lock, flags);
  1792. if (!iwl_is_ready_rf(priv)) {
  1793. IWL_DEBUG_MAC80211(priv, "leave - not ready\n");
  1794. mutex_unlock(&priv->mutex);
  1795. return;
  1796. }
  1797. /* we are restarting association process
  1798. * clear RXON_FILTER_ASSOC_MSK bit
  1799. */
  1800. iwl_scan_cancel_timeout(priv, 100);
  1801. priv->staging_rxon.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
  1802. iwlcore_commit_rxon(priv);
  1803. iwl_set_rate(priv);
  1804. mutex_unlock(&priv->mutex);
  1805. IWL_DEBUG_MAC80211(priv, "leave\n");
  1806. }
  1807. EXPORT_SYMBOL(iwl_mac_reset_tsf);
  1808. int iwl_alloc_txq_mem(struct iwl_priv *priv)
  1809. {
  1810. if (!priv->txq)
  1811. priv->txq = kzalloc(
  1812. sizeof(struct iwl_tx_queue) * priv->cfg->num_of_queues,
  1813. GFP_KERNEL);
  1814. if (!priv->txq) {
  1815. IWL_ERR(priv, "Not enough memory for txq\n");
  1816. return -ENOMEM;
  1817. }
  1818. return 0;
  1819. }
  1820. EXPORT_SYMBOL(iwl_alloc_txq_mem);
  1821. void iwl_free_txq_mem(struct iwl_priv *priv)
  1822. {
  1823. kfree(priv->txq);
  1824. priv->txq = NULL;
  1825. }
  1826. EXPORT_SYMBOL(iwl_free_txq_mem);
  1827. #ifdef CONFIG_IWLWIFI_DEBUGFS
  1828. #define IWL_TRAFFIC_DUMP_SIZE (IWL_TRAFFIC_ENTRY_SIZE * IWL_TRAFFIC_ENTRIES)
  1829. void iwl_reset_traffic_log(struct iwl_priv *priv)
  1830. {
  1831. priv->tx_traffic_idx = 0;
  1832. priv->rx_traffic_idx = 0;
  1833. if (priv->tx_traffic)
  1834. memset(priv->tx_traffic, 0, IWL_TRAFFIC_DUMP_SIZE);
  1835. if (priv->rx_traffic)
  1836. memset(priv->rx_traffic, 0, IWL_TRAFFIC_DUMP_SIZE);
  1837. }
  1838. int iwl_alloc_traffic_mem(struct iwl_priv *priv)
  1839. {
  1840. u32 traffic_size = IWL_TRAFFIC_DUMP_SIZE;
  1841. if (iwl_debug_level & IWL_DL_TX) {
  1842. if (!priv->tx_traffic) {
  1843. priv->tx_traffic =
  1844. kzalloc(traffic_size, GFP_KERNEL);
  1845. if (!priv->tx_traffic)
  1846. return -ENOMEM;
  1847. }
  1848. }
  1849. if (iwl_debug_level & IWL_DL_RX) {
  1850. if (!priv->rx_traffic) {
  1851. priv->rx_traffic =
  1852. kzalloc(traffic_size, GFP_KERNEL);
  1853. if (!priv->rx_traffic)
  1854. return -ENOMEM;
  1855. }
  1856. }
  1857. iwl_reset_traffic_log(priv);
  1858. return 0;
  1859. }
  1860. EXPORT_SYMBOL(iwl_alloc_traffic_mem);
  1861. void iwl_free_traffic_mem(struct iwl_priv *priv)
  1862. {
  1863. kfree(priv->tx_traffic);
  1864. priv->tx_traffic = NULL;
  1865. kfree(priv->rx_traffic);
  1866. priv->rx_traffic = NULL;
  1867. }
  1868. EXPORT_SYMBOL(iwl_free_traffic_mem);
  1869. void iwl_dbg_log_tx_data_frame(struct iwl_priv *priv,
  1870. u16 length, struct ieee80211_hdr *header)
  1871. {
  1872. __le16 fc;
  1873. u16 len;
  1874. if (likely(!(iwl_debug_level & IWL_DL_TX)))
  1875. return;
  1876. if (!priv->tx_traffic)
  1877. return;
  1878. fc = header->frame_control;
  1879. if (ieee80211_is_data(fc)) {
  1880. len = (length > IWL_TRAFFIC_ENTRY_SIZE)
  1881. ? IWL_TRAFFIC_ENTRY_SIZE : length;
  1882. memcpy((priv->tx_traffic +
  1883. (priv->tx_traffic_idx * IWL_TRAFFIC_ENTRY_SIZE)),
  1884. header, len);
  1885. priv->tx_traffic_idx =
  1886. (priv->tx_traffic_idx + 1) % IWL_TRAFFIC_ENTRIES;
  1887. }
  1888. }
  1889. EXPORT_SYMBOL(iwl_dbg_log_tx_data_frame);
  1890. void iwl_dbg_log_rx_data_frame(struct iwl_priv *priv,
  1891. u16 length, struct ieee80211_hdr *header)
  1892. {
  1893. __le16 fc;
  1894. u16 len;
  1895. if (likely(!(iwl_debug_level & IWL_DL_RX)))
  1896. return;
  1897. if (!priv->rx_traffic)
  1898. return;
  1899. fc = header->frame_control;
  1900. if (ieee80211_is_data(fc)) {
  1901. len = (length > IWL_TRAFFIC_ENTRY_SIZE)
  1902. ? IWL_TRAFFIC_ENTRY_SIZE : length;
  1903. memcpy((priv->rx_traffic +
  1904. (priv->rx_traffic_idx * IWL_TRAFFIC_ENTRY_SIZE)),
  1905. header, len);
  1906. priv->rx_traffic_idx =
  1907. (priv->rx_traffic_idx + 1) % IWL_TRAFFIC_ENTRIES;
  1908. }
  1909. }
  1910. EXPORT_SYMBOL(iwl_dbg_log_rx_data_frame);
  1911. const char *get_mgmt_string(int cmd)
  1912. {
  1913. switch (cmd) {
  1914. IWL_CMD(MANAGEMENT_ASSOC_REQ);
  1915. IWL_CMD(MANAGEMENT_ASSOC_RESP);
  1916. IWL_CMD(MANAGEMENT_REASSOC_REQ);
  1917. IWL_CMD(MANAGEMENT_REASSOC_RESP);
  1918. IWL_CMD(MANAGEMENT_PROBE_REQ);
  1919. IWL_CMD(MANAGEMENT_PROBE_RESP);
  1920. IWL_CMD(MANAGEMENT_BEACON);
  1921. IWL_CMD(MANAGEMENT_ATIM);
  1922. IWL_CMD(MANAGEMENT_DISASSOC);
  1923. IWL_CMD(MANAGEMENT_AUTH);
  1924. IWL_CMD(MANAGEMENT_DEAUTH);
  1925. IWL_CMD(MANAGEMENT_ACTION);
  1926. default:
  1927. return "UNKNOWN";
  1928. }
  1929. }
  1930. const char *get_ctrl_string(int cmd)
  1931. {
  1932. switch (cmd) {
  1933. IWL_CMD(CONTROL_BACK_REQ);
  1934. IWL_CMD(CONTROL_BACK);
  1935. IWL_CMD(CONTROL_PSPOLL);
  1936. IWL_CMD(CONTROL_RTS);
  1937. IWL_CMD(CONTROL_CTS);
  1938. IWL_CMD(CONTROL_ACK);
  1939. IWL_CMD(CONTROL_CFEND);
  1940. IWL_CMD(CONTROL_CFENDACK);
  1941. default:
  1942. return "UNKNOWN";
  1943. }
  1944. }
  1945. void iwl_clear_traffic_stats(struct iwl_priv *priv)
  1946. {
  1947. memset(&priv->tx_stats, 0, sizeof(struct traffic_stats));
  1948. memset(&priv->rx_stats, 0, sizeof(struct traffic_stats));
  1949. priv->led_tpt = 0;
  1950. }
  1951. /*
  1952. * if CONFIG_IWLWIFI_DEBUGFS defined, iwl_update_stats function will
  1953. * record all the MGMT, CTRL and DATA pkt for both TX and Rx pass.
  1954. * Use debugFs to display the rx/rx_statistics
  1955. * if CONFIG_IWLWIFI_DEBUGFS not being defined, then no MGMT and CTRL
  1956. * information will be recorded, but DATA pkt still will be recorded
  1957. * for the reason of iwl_led.c need to control the led blinking based on
  1958. * number of tx and rx data.
  1959. *
  1960. */
  1961. void iwl_update_stats(struct iwl_priv *priv, bool is_tx, __le16 fc, u16 len)
  1962. {
  1963. struct traffic_stats *stats;
  1964. if (is_tx)
  1965. stats = &priv->tx_stats;
  1966. else
  1967. stats = &priv->rx_stats;
  1968. if (ieee80211_is_mgmt(fc)) {
  1969. switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
  1970. case cpu_to_le16(IEEE80211_STYPE_ASSOC_REQ):
  1971. stats->mgmt[MANAGEMENT_ASSOC_REQ]++;
  1972. break;
  1973. case cpu_to_le16(IEEE80211_STYPE_ASSOC_RESP):
  1974. stats->mgmt[MANAGEMENT_ASSOC_RESP]++;
  1975. break;
  1976. case cpu_to_le16(IEEE80211_STYPE_REASSOC_REQ):
  1977. stats->mgmt[MANAGEMENT_REASSOC_REQ]++;
  1978. break;
  1979. case cpu_to_le16(IEEE80211_STYPE_REASSOC_RESP):
  1980. stats->mgmt[MANAGEMENT_REASSOC_RESP]++;
  1981. break;
  1982. case cpu_to_le16(IEEE80211_STYPE_PROBE_REQ):
  1983. stats->mgmt[MANAGEMENT_PROBE_REQ]++;
  1984. break;
  1985. case cpu_to_le16(IEEE80211_STYPE_PROBE_RESP):
  1986. stats->mgmt[MANAGEMENT_PROBE_RESP]++;
  1987. break;
  1988. case cpu_to_le16(IEEE80211_STYPE_BEACON):
  1989. stats->mgmt[MANAGEMENT_BEACON]++;
  1990. break;
  1991. case cpu_to_le16(IEEE80211_STYPE_ATIM):
  1992. stats->mgmt[MANAGEMENT_ATIM]++;
  1993. break;
  1994. case cpu_to_le16(IEEE80211_STYPE_DISASSOC):
  1995. stats->mgmt[MANAGEMENT_DISASSOC]++;
  1996. break;
  1997. case cpu_to_le16(IEEE80211_STYPE_AUTH):
  1998. stats->mgmt[MANAGEMENT_AUTH]++;
  1999. break;
  2000. case cpu_to_le16(IEEE80211_STYPE_DEAUTH):
  2001. stats->mgmt[MANAGEMENT_DEAUTH]++;
  2002. break;
  2003. case cpu_to_le16(IEEE80211_STYPE_ACTION):
  2004. stats->mgmt[MANAGEMENT_ACTION]++;
  2005. break;
  2006. }
  2007. } else if (ieee80211_is_ctl(fc)) {
  2008. switch (fc & cpu_to_le16(IEEE80211_FCTL_STYPE)) {
  2009. case cpu_to_le16(IEEE80211_STYPE_BACK_REQ):
  2010. stats->ctrl[CONTROL_BACK_REQ]++;
  2011. break;
  2012. case cpu_to_le16(IEEE80211_STYPE_BACK):
  2013. stats->ctrl[CONTROL_BACK]++;
  2014. break;
  2015. case cpu_to_le16(IEEE80211_STYPE_PSPOLL):
  2016. stats->ctrl[CONTROL_PSPOLL]++;
  2017. break;
  2018. case cpu_to_le16(IEEE80211_STYPE_RTS):
  2019. stats->ctrl[CONTROL_RTS]++;
  2020. break;
  2021. case cpu_to_le16(IEEE80211_STYPE_CTS):
  2022. stats->ctrl[CONTROL_CTS]++;
  2023. break;
  2024. case cpu_to_le16(IEEE80211_STYPE_ACK):
  2025. stats->ctrl[CONTROL_ACK]++;
  2026. break;
  2027. case cpu_to_le16(IEEE80211_STYPE_CFEND):
  2028. stats->ctrl[CONTROL_CFEND]++;
  2029. break;
  2030. case cpu_to_le16(IEEE80211_STYPE_CFENDACK):
  2031. stats->ctrl[CONTROL_CFENDACK]++;
  2032. break;
  2033. }
  2034. } else {
  2035. /* data */
  2036. stats->data_cnt++;
  2037. stats->data_bytes += len;
  2038. }
  2039. iwl_leds_background(priv);
  2040. }
  2041. EXPORT_SYMBOL(iwl_update_stats);
  2042. #endif
  2043. static const char *get_csr_string(int cmd)
  2044. {
  2045. switch (cmd) {
  2046. IWL_CMD(CSR_HW_IF_CONFIG_REG);
  2047. IWL_CMD(CSR_INT_COALESCING);
  2048. IWL_CMD(CSR_INT);
  2049. IWL_CMD(CSR_INT_MASK);
  2050. IWL_CMD(CSR_FH_INT_STATUS);
  2051. IWL_CMD(CSR_GPIO_IN);
  2052. IWL_CMD(CSR_RESET);
  2053. IWL_CMD(CSR_GP_CNTRL);
  2054. IWL_CMD(CSR_HW_REV);
  2055. IWL_CMD(CSR_EEPROM_REG);
  2056. IWL_CMD(CSR_EEPROM_GP);
  2057. IWL_CMD(CSR_OTP_GP_REG);
  2058. IWL_CMD(CSR_GIO_REG);
  2059. IWL_CMD(CSR_GP_UCODE_REG);
  2060. IWL_CMD(CSR_GP_DRIVER_REG);
  2061. IWL_CMD(CSR_UCODE_DRV_GP1);
  2062. IWL_CMD(CSR_UCODE_DRV_GP2);
  2063. IWL_CMD(CSR_LED_REG);
  2064. IWL_CMD(CSR_DRAM_INT_TBL_REG);
  2065. IWL_CMD(CSR_GIO_CHICKEN_BITS);
  2066. IWL_CMD(CSR_ANA_PLL_CFG);
  2067. IWL_CMD(CSR_HW_REV_WA_REG);
  2068. IWL_CMD(CSR_DBG_HPET_MEM_REG);
  2069. default:
  2070. return "UNKNOWN";
  2071. }
  2072. }
  2073. void iwl_dump_csr(struct iwl_priv *priv)
  2074. {
  2075. int i;
  2076. u32 csr_tbl[] = {
  2077. CSR_HW_IF_CONFIG_REG,
  2078. CSR_INT_COALESCING,
  2079. CSR_INT,
  2080. CSR_INT_MASK,
  2081. CSR_FH_INT_STATUS,
  2082. CSR_GPIO_IN,
  2083. CSR_RESET,
  2084. CSR_GP_CNTRL,
  2085. CSR_HW_REV,
  2086. CSR_EEPROM_REG,
  2087. CSR_EEPROM_GP,
  2088. CSR_OTP_GP_REG,
  2089. CSR_GIO_REG,
  2090. CSR_GP_UCODE_REG,
  2091. CSR_GP_DRIVER_REG,
  2092. CSR_UCODE_DRV_GP1,
  2093. CSR_UCODE_DRV_GP2,
  2094. CSR_LED_REG,
  2095. CSR_DRAM_INT_TBL_REG,
  2096. CSR_GIO_CHICKEN_BITS,
  2097. CSR_ANA_PLL_CFG,
  2098. CSR_HW_REV_WA_REG,
  2099. CSR_DBG_HPET_MEM_REG
  2100. };
  2101. IWL_ERR(priv, "CSR values:\n");
  2102. IWL_ERR(priv, "(2nd byte of CSR_INT_COALESCING is "
  2103. "CSR_INT_PERIODIC_REG)\n");
  2104. for (i = 0; i < ARRAY_SIZE(csr_tbl); i++) {
  2105. IWL_ERR(priv, " %25s: 0X%08x\n",
  2106. get_csr_string(csr_tbl[i]),
  2107. iwl_read32(priv, csr_tbl[i]));
  2108. }
  2109. }
  2110. EXPORT_SYMBOL(iwl_dump_csr);
  2111. static const char *get_fh_string(int cmd)
  2112. {
  2113. switch (cmd) {
  2114. IWL_CMD(FH_RSCSR_CHNL0_STTS_WPTR_REG);
  2115. IWL_CMD(FH_RSCSR_CHNL0_RBDCB_BASE_REG);
  2116. IWL_CMD(FH_RSCSR_CHNL0_WPTR);
  2117. IWL_CMD(FH_MEM_RCSR_CHNL0_CONFIG_REG);
  2118. IWL_CMD(FH_MEM_RSSR_SHARED_CTRL_REG);
  2119. IWL_CMD(FH_MEM_RSSR_RX_STATUS_REG);
  2120. IWL_CMD(FH_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV);
  2121. IWL_CMD(FH_TSSR_TX_STATUS_REG);
  2122. IWL_CMD(FH_TSSR_TX_ERROR_REG);
  2123. default:
  2124. return "UNKNOWN";
  2125. }
  2126. }
  2127. int iwl_dump_fh(struct iwl_priv *priv, char **buf, bool display)
  2128. {
  2129. int i;
  2130. #ifdef CONFIG_IWLWIFI_DEBUG
  2131. int pos = 0;
  2132. size_t bufsz = 0;
  2133. #endif
  2134. u32 fh_tbl[] = {
  2135. FH_RSCSR_CHNL0_STTS_WPTR_REG,
  2136. FH_RSCSR_CHNL0_RBDCB_BASE_REG,
  2137. FH_RSCSR_CHNL0_WPTR,
  2138. FH_MEM_RCSR_CHNL0_CONFIG_REG,
  2139. FH_MEM_RSSR_SHARED_CTRL_REG,
  2140. FH_MEM_RSSR_RX_STATUS_REG,
  2141. FH_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV,
  2142. FH_TSSR_TX_STATUS_REG,
  2143. FH_TSSR_TX_ERROR_REG
  2144. };
  2145. #ifdef CONFIG_IWLWIFI_DEBUG
  2146. if (display) {
  2147. bufsz = ARRAY_SIZE(fh_tbl) * 48 + 40;
  2148. *buf = kmalloc(bufsz, GFP_KERNEL);
  2149. if (!*buf)
  2150. return -ENOMEM;
  2151. pos += scnprintf(*buf + pos, bufsz - pos,
  2152. "FH register values:\n");
  2153. for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
  2154. pos += scnprintf(*buf + pos, bufsz - pos,
  2155. " %34s: 0X%08x\n",
  2156. get_fh_string(fh_tbl[i]),
  2157. iwl_read_direct32(priv, fh_tbl[i]));
  2158. }
  2159. return pos;
  2160. }
  2161. #endif
  2162. IWL_ERR(priv, "FH register values:\n");
  2163. for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
  2164. IWL_ERR(priv, " %34s: 0X%08x\n",
  2165. get_fh_string(fh_tbl[i]),
  2166. iwl_read_direct32(priv, fh_tbl[i]));
  2167. }
  2168. return 0;
  2169. }
  2170. EXPORT_SYMBOL(iwl_dump_fh);
  2171. static void iwl_force_rf_reset(struct iwl_priv *priv)
  2172. {
  2173. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  2174. return;
  2175. if (!iwl_is_associated(priv)) {
  2176. IWL_DEBUG_SCAN(priv, "force reset rejected: not associated\n");
  2177. return;
  2178. }
  2179. /*
  2180. * There is no easy and better way to force reset the radio,
  2181. * the only known method is switching channel which will force to
  2182. * reset and tune the radio.
  2183. * Use internal short scan (single channel) operation to should
  2184. * achieve this objective.
  2185. * Driver should reset the radio when number of consecutive missed
  2186. * beacon, or any other uCode error condition detected.
  2187. */
  2188. IWL_DEBUG_INFO(priv, "perform radio reset.\n");
  2189. iwl_internal_short_hw_scan(priv);
  2190. }
  2191. int iwl_force_reset(struct iwl_priv *priv, int mode, bool external)
  2192. {
  2193. struct iwl_force_reset *force_reset;
  2194. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  2195. return -EINVAL;
  2196. if (mode >= IWL_MAX_FORCE_RESET) {
  2197. IWL_DEBUG_INFO(priv, "invalid reset request.\n");
  2198. return -EINVAL;
  2199. }
  2200. force_reset = &priv->force_reset[mode];
  2201. force_reset->reset_request_count++;
  2202. if (!external) {
  2203. if (force_reset->last_force_reset_jiffies &&
  2204. time_after(force_reset->last_force_reset_jiffies +
  2205. force_reset->reset_duration, jiffies)) {
  2206. IWL_DEBUG_INFO(priv, "force reset rejected\n");
  2207. force_reset->reset_reject_count++;
  2208. return -EAGAIN;
  2209. }
  2210. }
  2211. force_reset->reset_success_count++;
  2212. force_reset->last_force_reset_jiffies = jiffies;
  2213. IWL_DEBUG_INFO(priv, "perform force reset (%d)\n", mode);
  2214. switch (mode) {
  2215. case IWL_RF_RESET:
  2216. iwl_force_rf_reset(priv);
  2217. break;
  2218. case IWL_FW_RESET:
  2219. /*
  2220. * if the request is from external(ex: debugfs),
  2221. * then always perform the request in regardless the module
  2222. * parameter setting
  2223. * if the request is from internal (uCode error or driver
  2224. * detect failure), then fw_restart module parameter
  2225. * need to be check before performing firmware reload
  2226. */
  2227. if (!external && !priv->cfg->mod_params->restart_fw) {
  2228. IWL_DEBUG_INFO(priv, "Cancel firmware reload based on "
  2229. "module parameter setting\n");
  2230. break;
  2231. }
  2232. IWL_ERR(priv, "On demand firmware reload\n");
  2233. /* Set the FW error flag -- cleared on iwl_down */
  2234. set_bit(STATUS_FW_ERROR, &priv->status);
  2235. wake_up_interruptible(&priv->wait_command_queue);
  2236. /*
  2237. * Keep the restart process from trying to send host
  2238. * commands by clearing the INIT status bit
  2239. */
  2240. clear_bit(STATUS_READY, &priv->status);
  2241. queue_work(priv->workqueue, &priv->restart);
  2242. break;
  2243. }
  2244. return 0;
  2245. }
  2246. EXPORT_SYMBOL(iwl_force_reset);
  2247. /**
  2248. * iwl_bg_monitor_recover - Timer callback to check for stuck queue and recover
  2249. *
  2250. * During normal condition (no queue is stuck), the timer is continually set to
  2251. * execute every monitor_recover_period milliseconds after the last timer
  2252. * expired. When the queue read_ptr is at the same place, the timer is
  2253. * shorten to 100mSecs. This is
  2254. * 1) to reduce the chance that the read_ptr may wrap around (not stuck)
  2255. * 2) to detect the stuck queues quicker before the station and AP can
  2256. * disassociate each other.
  2257. *
  2258. * This function monitors all the tx queues and recover from it if any
  2259. * of the queues are stuck.
  2260. * 1. It first check the cmd queue for stuck conditions. If it is stuck,
  2261. * it will recover by resetting the firmware and return.
  2262. * 2. Then, it checks for station association. If it associates it will check
  2263. * other queues. If any queue is stuck, it will recover by resetting
  2264. * the firmware.
  2265. * Note: It the number of times the queue read_ptr to be at the same place to
  2266. * be MAX_REPEAT+1 in order to consider to be stuck.
  2267. */
  2268. /*
  2269. * The maximum number of times the read pointer of the tx queue at the
  2270. * same place without considering to be stuck.
  2271. */
  2272. #define MAX_REPEAT (2)
  2273. static int iwl_check_stuck_queue(struct iwl_priv *priv, int cnt)
  2274. {
  2275. struct iwl_tx_queue *txq;
  2276. struct iwl_queue *q;
  2277. txq = &priv->txq[cnt];
  2278. q = &txq->q;
  2279. /* queue is empty, skip */
  2280. if (q->read_ptr != q->write_ptr) {
  2281. if (q->read_ptr == q->last_read_ptr) {
  2282. /* a queue has not been read from last time */
  2283. if (q->repeat_same_read_ptr > MAX_REPEAT) {
  2284. IWL_ERR(priv,
  2285. "queue %d stuck %d time. Fw reload.\n",
  2286. q->id, q->repeat_same_read_ptr);
  2287. q->repeat_same_read_ptr = 0;
  2288. iwl_force_reset(priv, IWL_FW_RESET, false);
  2289. } else {
  2290. q->repeat_same_read_ptr++;
  2291. IWL_DEBUG_RADIO(priv,
  2292. "queue %d, not read %d time\n",
  2293. q->id,
  2294. q->repeat_same_read_ptr);
  2295. mod_timer(&priv->monitor_recover, jiffies +
  2296. msecs_to_jiffies(IWL_ONE_HUNDRED_MSECS));
  2297. }
  2298. return 1;
  2299. } else {
  2300. q->last_read_ptr = q->read_ptr;
  2301. q->repeat_same_read_ptr = 0;
  2302. }
  2303. }
  2304. return 0;
  2305. }
  2306. void iwl_bg_monitor_recover(unsigned long data)
  2307. {
  2308. struct iwl_priv *priv = (struct iwl_priv *)data;
  2309. int cnt;
  2310. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  2311. return;
  2312. /* monitor and check for stuck cmd queue */
  2313. if (iwl_check_stuck_queue(priv, IWL_CMD_QUEUE_NUM))
  2314. return;
  2315. /* monitor and check for other stuck queues */
  2316. if (iwl_is_associated(priv)) {
  2317. for (cnt = 0; cnt < priv->hw_params.max_txq_num; cnt++) {
  2318. /* skip as we already checked the command queue */
  2319. if (cnt == IWL_CMD_QUEUE_NUM)
  2320. continue;
  2321. if (iwl_check_stuck_queue(priv, cnt))
  2322. return;
  2323. }
  2324. }
  2325. /*
  2326. * Reschedule the timer to occur in
  2327. * priv->cfg->monitor_recover_period
  2328. */
  2329. mod_timer(&priv->monitor_recover,
  2330. jiffies + msecs_to_jiffies(priv->cfg->monitor_recover_period));
  2331. }
  2332. EXPORT_SYMBOL(iwl_bg_monitor_recover);
  2333. /*
  2334. * extended beacon time format
  2335. * time in usec will be changed into a 32-bit value in extended:internal format
  2336. * the extended part is the beacon counts
  2337. * the internal part is the time in usec within one beacon interval
  2338. */
  2339. u32 iwl_usecs_to_beacons(struct iwl_priv *priv, u32 usec, u32 beacon_interval)
  2340. {
  2341. u32 quot;
  2342. u32 rem;
  2343. u32 interval = beacon_interval * TIME_UNIT;
  2344. if (!interval || !usec)
  2345. return 0;
  2346. quot = (usec / interval) &
  2347. (iwl_beacon_time_mask_high(priv,
  2348. priv->hw_params.beacon_time_tsf_bits) >>
  2349. priv->hw_params.beacon_time_tsf_bits);
  2350. rem = (usec % interval) & iwl_beacon_time_mask_low(priv,
  2351. priv->hw_params.beacon_time_tsf_bits);
  2352. return (quot << priv->hw_params.beacon_time_tsf_bits) + rem;
  2353. }
  2354. EXPORT_SYMBOL(iwl_usecs_to_beacons);
  2355. /* base is usually what we get from ucode with each received frame,
  2356. * the same as HW timer counter counting down
  2357. */
  2358. __le32 iwl_add_beacon_time(struct iwl_priv *priv, u32 base,
  2359. u32 addon, u32 beacon_interval)
  2360. {
  2361. u32 base_low = base & iwl_beacon_time_mask_low(priv,
  2362. priv->hw_params.beacon_time_tsf_bits);
  2363. u32 addon_low = addon & iwl_beacon_time_mask_low(priv,
  2364. priv->hw_params.beacon_time_tsf_bits);
  2365. u32 interval = beacon_interval * TIME_UNIT;
  2366. u32 res = (base & iwl_beacon_time_mask_high(priv,
  2367. priv->hw_params.beacon_time_tsf_bits)) +
  2368. (addon & iwl_beacon_time_mask_high(priv,
  2369. priv->hw_params.beacon_time_tsf_bits));
  2370. if (base_low > addon_low)
  2371. res += base_low - addon_low;
  2372. else if (base_low < addon_low) {
  2373. res += interval + base_low - addon_low;
  2374. res += (1 << priv->hw_params.beacon_time_tsf_bits);
  2375. } else
  2376. res += (1 << priv->hw_params.beacon_time_tsf_bits);
  2377. return cpu_to_le32(res);
  2378. }
  2379. EXPORT_SYMBOL(iwl_add_beacon_time);
  2380. #ifdef CONFIG_PM
  2381. int iwl_pci_suspend(struct pci_dev *pdev, pm_message_t state)
  2382. {
  2383. struct iwl_priv *priv = pci_get_drvdata(pdev);
  2384. /*
  2385. * This function is called when system goes into suspend state
  2386. * mac80211 will call iwl_mac_stop() from the mac80211 suspend function
  2387. * first but since iwl_mac_stop() has no knowledge of who the caller is,
  2388. * it will not call apm_ops.stop() to stop the DMA operation.
  2389. * Calling apm_ops.stop here to make sure we stop the DMA.
  2390. */
  2391. priv->cfg->ops->lib->apm_ops.stop(priv);
  2392. pci_save_state(pdev);
  2393. pci_disable_device(pdev);
  2394. pci_set_power_state(pdev, PCI_D3hot);
  2395. return 0;
  2396. }
  2397. EXPORT_SYMBOL(iwl_pci_suspend);
  2398. int iwl_pci_resume(struct pci_dev *pdev)
  2399. {
  2400. struct iwl_priv *priv = pci_get_drvdata(pdev);
  2401. int ret;
  2402. bool hw_rfkill = false;
  2403. /*
  2404. * We disable the RETRY_TIMEOUT register (0x41) to keep
  2405. * PCI Tx retries from interfering with C3 CPU state.
  2406. */
  2407. pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);
  2408. pci_set_power_state(pdev, PCI_D0);
  2409. ret = pci_enable_device(pdev);
  2410. if (ret)
  2411. return ret;
  2412. pci_restore_state(pdev);
  2413. iwl_enable_interrupts(priv);
  2414. if (!(iwl_read32(priv, CSR_GP_CNTRL) &
  2415. CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
  2416. hw_rfkill = true;
  2417. if (hw_rfkill)
  2418. set_bit(STATUS_RF_KILL_HW, &priv->status);
  2419. else
  2420. clear_bit(STATUS_RF_KILL_HW, &priv->status);
  2421. wiphy_rfkill_set_hw_state(priv->hw->wiphy, hw_rfkill);
  2422. return 0;
  2423. }
  2424. EXPORT_SYMBOL(iwl_pci_resume);
  2425. #endif /* CONFIG_PM */