iwl-agn.c 94 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029203020312032203320342035203620372038203920402041204220432044204520462047204820492050205120522053205420552056205720582059206020612062206320642065206620672068206920702071207220732074207520762077207820792080208120822083208420852086208720882089209020912092209320942095209620972098209921002101210221032104210521062107210821092110211121122113211421152116211721182119212021212122212321242125212621272128212921302131213221332134213521362137213821392140214121422143214421452146214721482149215021512152215321542155215621572158215921602161216221632164216521662167216821692170217121722173217421752176217721782179218021812182218321842185218621872188218921902191219221932194219521962197219821992200220122022203220422052206220722082209221022112212221322142215221622172218221922202221222222232224222522262227222822292230223122322233223422352236223722382239224022412242224322442245224622472248224922502251225222532254225522562257225822592260226122622263226422652266226722682269227022712272227322742275227622772278227922802281228222832284228522862287228822892290229122922293229422952296229722982299230023012302230323042305230623072308230923102311231223132314231523162317231823192320232123222323232423252326232723282329233023312332233323342335233623372338233923402341234223432344234523462347234823492350235123522353235423552356235723582359236023612362236323642365236623672368236923702371237223732374237523762377237823792380238123822383238423852386238723882389239023912392239323942395239623972398239924002401240224032404240524062407240824092410241124122413241424152416241724182419242024212422242324242425242624272428242924302431243224332434243524362437243824392440244124422443244424452446244724482449245024512452245324542455245624572458245924602461246224632464246524662467246824692470247124722473247424752476247724782479248024812482248324842485248624872488248924902491249224932494249524962497249824992500250125022503250425052506250725082509251025112512251325142515251625172518251925202521252225232524252525262527252825292530253125322533253425352536253725382539254025412542254325442545254625472548254925502551255225532554255525562557255825592560256125622563256425652566256725682569257025712572257325742575257625772578257925802581258225832584258525862587258825892590259125922593259425952596259725982599260026012602260326042605260626072608260926102611261226132614261526162617261826192620262126222623262426252626262726282629263026312632263326342635263626372638263926402641264226432644264526462647264826492650265126522653265426552656265726582659266026612662266326642665266626672668266926702671267226732674267526762677267826792680268126822683268426852686268726882689269026912692269326942695269626972698269927002701270227032704270527062707270827092710271127122713271427152716271727182719272027212722272327242725272627272728272927302731273227332734273527362737273827392740274127422743274427452746274727482749275027512752275327542755275627572758275927602761276227632764276527662767276827692770277127722773277427752776277727782779278027812782278327842785278627872788278927902791279227932794279527962797279827992800280128022803280428052806280728082809281028112812281328142815281628172818281928202821282228232824282528262827282828292830283128322833283428352836283728382839284028412842284328442845284628472848284928502851285228532854285528562857285828592860286128622863286428652866286728682869287028712872287328742875287628772878287928802881288228832884288528862887288828892890289128922893289428952896289728982899290029012902290329042905290629072908290929102911291229132914291529162917291829192920292129222923292429252926292729282929293029312932293329342935293629372938293929402941294229432944294529462947294829492950295129522953295429552956295729582959296029612962296329642965296629672968296929702971297229732974297529762977297829792980298129822983298429852986298729882989299029912992299329942995299629972998299930003001300230033004300530063007300830093010301130123013301430153016301730183019302030213022302330243025302630273028302930303031303230333034303530363037303830393040304130423043304430453046304730483049305030513052305330543055305630573058305930603061306230633064306530663067306830693070307130723073307430753076307730783079308030813082308330843085308630873088308930903091309230933094309530963097309830993100310131023103310431053106310731083109311031113112311331143115311631173118311931203121312231233124312531263127312831293130313131323133313431353136313731383139314031413142314331443145314631473148314931503151315231533154315531563157315831593160316131623163316431653166316731683169317031713172317331743175317631773178317931803181318231833184318531863187318831893190319131923193319431953196319731983199320032013202320332043205320632073208320932103211321232133214321532163217321832193220322132223223322432253226322732283229323032313232323332343235323632373238323932403241324232433244324532463247324832493250325132523253325432553256325732583259326032613262326332643265326632673268326932703271327232733274327532763277327832793280328132823283328432853286328732883289329032913292329332943295329632973298329933003301330233033304330533063307330833093310331133123313331433153316331733183319332033213322332333243325332633273328332933303331333233333334333533363337333833393340334133423343334433453346334733483349335033513352335333543355335633573358335933603361336233633364336533663367336833693370337133723373337433753376337733783379338033813382338333843385338633873388338933903391339233933394339533963397339833993400340134023403340434053406340734083409341034113412341334143415341634173418341934203421342234233424342534263427342834293430343134323433343434353436343734383439344034413442344334443445344634473448344934503451345234533454345534563457345834593460346134623463346434653466346734683469347034713472
  1. /******************************************************************************
  2. *
  3. * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
  4. *
  5. * Portions of this file are derived from the ipw3945 project, as well
  6. * as portions of the ieee80211 subsystem header files.
  7. *
  8. * This program is free software; you can redistribute it and/or modify it
  9. * under the terms of version 2 of the GNU General Public License as
  10. * published by the Free Software Foundation.
  11. *
  12. * This program is distributed in the hope that it will be useful, but WITHOUT
  13. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  15. * more details.
  16. *
  17. * You should have received a copy of the GNU General Public License along with
  18. * this program; if not, write to the Free Software Foundation, Inc.,
  19. * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  20. *
  21. * The full GNU General Public License is included in this distribution in the
  22. * file called LICENSE.
  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. *****************************************************************************/
  29. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  30. #include <linux/kernel.h>
  31. #include <linux/module.h>
  32. #include <linux/init.h>
  33. #include <linux/slab.h>
  34. #include <linux/dma-mapping.h>
  35. #include <linux/delay.h>
  36. #include <linux/sched.h>
  37. #include <linux/skbuff.h>
  38. #include <linux/netdevice.h>
  39. #include <linux/wireless.h>
  40. #include <linux/firmware.h>
  41. #include <linux/etherdevice.h>
  42. #include <linux/if_arp.h>
  43. #include <net/mac80211.h>
  44. #include <asm/div64.h>
  45. #include "iwl-eeprom.h"
  46. #include "iwl-dev.h"
  47. #include "iwl-core.h"
  48. #include "iwl-io.h"
  49. #include "iwl-helpers.h"
  50. #include "iwl-sta.h"
  51. #include "iwl-agn-calib.h"
  52. #include "iwl-agn.h"
  53. #include "iwl-pci.h"
  54. #include "iwl-trans.h"
  55. /******************************************************************************
  56. *
  57. * module boiler plate
  58. *
  59. ******************************************************************************/
  60. /*
  61. * module name, copyright, version, etc.
  62. */
  63. #define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux"
  64. #ifdef CONFIG_IWLWIFI_DEBUG
  65. #define VD "d"
  66. #else
  67. #define VD
  68. #endif
  69. #define DRV_VERSION IWLWIFI_VERSION VD
  70. MODULE_DESCRIPTION(DRV_DESCRIPTION);
  71. MODULE_VERSION(DRV_VERSION);
  72. MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
  73. MODULE_LICENSE("GPL");
  74. static int iwlagn_ant_coupling;
  75. static bool iwlagn_bt_ch_announce = 1;
  76. void iwl_update_chain_flags(struct iwl_priv *priv)
  77. {
  78. struct iwl_rxon_context *ctx;
  79. for_each_context(priv, ctx) {
  80. iwlagn_set_rxon_chain(priv, ctx);
  81. if (ctx->active.rx_chain != ctx->staging.rx_chain)
  82. iwlagn_commit_rxon(priv, ctx);
  83. }
  84. }
  85. /* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */
  86. static void iwl_set_beacon_tim(struct iwl_priv *priv,
  87. struct iwl_tx_beacon_cmd *tx_beacon_cmd,
  88. u8 *beacon, u32 frame_size)
  89. {
  90. u16 tim_idx;
  91. struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;
  92. /*
  93. * The index is relative to frame start but we start looking at the
  94. * variable-length part of the beacon.
  95. */
  96. tim_idx = mgmt->u.beacon.variable - beacon;
  97. /* Parse variable-length elements of beacon to find WLAN_EID_TIM */
  98. while ((tim_idx < (frame_size - 2)) &&
  99. (beacon[tim_idx] != WLAN_EID_TIM))
  100. tim_idx += beacon[tim_idx+1] + 2;
  101. /* If TIM field was found, set variables */
  102. if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
  103. tx_beacon_cmd->tim_idx = cpu_to_le16(tim_idx);
  104. tx_beacon_cmd->tim_size = beacon[tim_idx+1];
  105. } else
  106. IWL_WARN(priv, "Unable to find TIM Element in beacon\n");
  107. }
  108. int iwlagn_send_beacon_cmd(struct iwl_priv *priv)
  109. {
  110. struct iwl_tx_beacon_cmd *tx_beacon_cmd;
  111. struct iwl_host_cmd cmd = {
  112. .id = REPLY_TX_BEACON,
  113. .flags = CMD_SYNC,
  114. };
  115. struct ieee80211_tx_info *info;
  116. u32 frame_size;
  117. u32 rate_flags;
  118. u32 rate;
  119. /*
  120. * We have to set up the TX command, the TX Beacon command, and the
  121. * beacon contents.
  122. */
  123. lockdep_assert_held(&priv->mutex);
  124. if (!priv->beacon_ctx) {
  125. IWL_ERR(priv, "trying to build beacon w/o beacon context!\n");
  126. return 0;
  127. }
  128. if (WARN_ON(!priv->beacon_skb))
  129. return -EINVAL;
  130. /* Allocate beacon command */
  131. if (!priv->beacon_cmd)
  132. priv->beacon_cmd = kzalloc(sizeof(*tx_beacon_cmd), GFP_KERNEL);
  133. tx_beacon_cmd = priv->beacon_cmd;
  134. if (!tx_beacon_cmd)
  135. return -ENOMEM;
  136. frame_size = priv->beacon_skb->len;
  137. /* Set up TX command fields */
  138. tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
  139. tx_beacon_cmd->tx.sta_id = priv->beacon_ctx->bcast_sta_id;
  140. tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
  141. tx_beacon_cmd->tx.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK |
  142. TX_CMD_FLG_TSF_MSK | TX_CMD_FLG_STA_RATE_MSK;
  143. /* Set up TX beacon command fields */
  144. iwl_set_beacon_tim(priv, tx_beacon_cmd, priv->beacon_skb->data,
  145. frame_size);
  146. /* Set up packet rate and flags */
  147. info = IEEE80211_SKB_CB(priv->beacon_skb);
  148. /*
  149. * Let's set up the rate at least somewhat correctly;
  150. * it will currently not actually be used by the uCode,
  151. * it uses the broadcast station's rate instead.
  152. */
  153. if (info->control.rates[0].idx < 0 ||
  154. info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
  155. rate = 0;
  156. else
  157. rate = info->control.rates[0].idx;
  158. priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant,
  159. priv->hw_params.valid_tx_ant);
  160. rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
  161. /* In mac80211, rates for 5 GHz start at 0 */
  162. if (info->band == IEEE80211_BAND_5GHZ)
  163. rate += IWL_FIRST_OFDM_RATE;
  164. else if (rate >= IWL_FIRST_CCK_RATE && rate <= IWL_LAST_CCK_RATE)
  165. rate_flags |= RATE_MCS_CCK_MSK;
  166. tx_beacon_cmd->tx.rate_n_flags =
  167. iwl_hw_set_rate_n_flags(rate, rate_flags);
  168. /* Submit command */
  169. cmd.len[0] = sizeof(*tx_beacon_cmd);
  170. cmd.data[0] = tx_beacon_cmd;
  171. cmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY;
  172. cmd.len[1] = frame_size;
  173. cmd.data[1] = priv->beacon_skb->data;
  174. cmd.dataflags[1] = IWL_HCMD_DFL_NOCOPY;
  175. return trans_send_cmd(&priv->trans, &cmd);
  176. }
  177. static void iwl_bg_beacon_update(struct work_struct *work)
  178. {
  179. struct iwl_priv *priv =
  180. container_of(work, struct iwl_priv, beacon_update);
  181. struct sk_buff *beacon;
  182. mutex_lock(&priv->mutex);
  183. if (!priv->beacon_ctx) {
  184. IWL_ERR(priv, "updating beacon w/o beacon context!\n");
  185. goto out;
  186. }
  187. if (priv->beacon_ctx->vif->type != NL80211_IFTYPE_AP) {
  188. /*
  189. * The ucode will send beacon notifications even in
  190. * IBSS mode, but we don't want to process them. But
  191. * we need to defer the type check to here due to
  192. * requiring locking around the beacon_ctx access.
  193. */
  194. goto out;
  195. }
  196. /* Pull updated AP beacon from mac80211. will fail if not in AP mode */
  197. beacon = ieee80211_beacon_get(priv->hw, priv->beacon_ctx->vif);
  198. if (!beacon) {
  199. IWL_ERR(priv, "update beacon failed -- keeping old\n");
  200. goto out;
  201. }
  202. /* new beacon skb is allocated every time; dispose previous.*/
  203. dev_kfree_skb(priv->beacon_skb);
  204. priv->beacon_skb = beacon;
  205. iwlagn_send_beacon_cmd(priv);
  206. out:
  207. mutex_unlock(&priv->mutex);
  208. }
  209. static void iwl_bg_bt_runtime_config(struct work_struct *work)
  210. {
  211. struct iwl_priv *priv =
  212. container_of(work, struct iwl_priv, bt_runtime_config);
  213. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  214. return;
  215. /* dont send host command if rf-kill is on */
  216. if (!iwl_is_ready_rf(priv))
  217. return;
  218. iwlagn_send_advance_bt_config(priv);
  219. }
  220. static void iwl_bg_bt_full_concurrency(struct work_struct *work)
  221. {
  222. struct iwl_priv *priv =
  223. container_of(work, struct iwl_priv, bt_full_concurrency);
  224. struct iwl_rxon_context *ctx;
  225. mutex_lock(&priv->mutex);
  226. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  227. goto out;
  228. /* dont send host command if rf-kill is on */
  229. if (!iwl_is_ready_rf(priv))
  230. goto out;
  231. IWL_DEBUG_INFO(priv, "BT coex in %s mode\n",
  232. priv->bt_full_concurrent ?
  233. "full concurrency" : "3-wire");
  234. /*
  235. * LQ & RXON updated cmds must be sent before BT Config cmd
  236. * to avoid 3-wire collisions
  237. */
  238. for_each_context(priv, ctx) {
  239. iwlagn_set_rxon_chain(priv, ctx);
  240. iwlagn_commit_rxon(priv, ctx);
  241. }
  242. iwlagn_send_advance_bt_config(priv);
  243. out:
  244. mutex_unlock(&priv->mutex);
  245. }
  246. /**
  247. * iwl_bg_statistics_periodic - Timer callback to queue statistics
  248. *
  249. * This callback is provided in order to send a statistics request.
  250. *
  251. * This timer function is continually reset to execute within
  252. * REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION
  253. * was received. We need to ensure we receive the statistics in order
  254. * to update the temperature used for calibrating the TXPOWER.
  255. */
  256. static void iwl_bg_statistics_periodic(unsigned long data)
  257. {
  258. struct iwl_priv *priv = (struct iwl_priv *)data;
  259. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  260. return;
  261. /* dont send host command if rf-kill is on */
  262. if (!iwl_is_ready_rf(priv))
  263. return;
  264. iwl_send_statistics_request(priv, CMD_ASYNC, false);
  265. }
  266. static void iwl_print_cont_event_trace(struct iwl_priv *priv, u32 base,
  267. u32 start_idx, u32 num_events,
  268. u32 mode)
  269. {
  270. u32 i;
  271. u32 ptr; /* SRAM byte address of log data */
  272. u32 ev, time, data; /* event log data */
  273. unsigned long reg_flags;
  274. if (mode == 0)
  275. ptr = base + (4 * sizeof(u32)) + (start_idx * 2 * sizeof(u32));
  276. else
  277. ptr = base + (4 * sizeof(u32)) + (start_idx * 3 * sizeof(u32));
  278. /* Make sure device is powered up for SRAM reads */
  279. spin_lock_irqsave(&priv->reg_lock, reg_flags);
  280. if (iwl_grab_nic_access(priv)) {
  281. spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
  282. return;
  283. }
  284. /* Set starting address; reads will auto-increment */
  285. iwl_write32(priv, HBUS_TARG_MEM_RADDR, ptr);
  286. rmb();
  287. /*
  288. * "time" is actually "data" for mode 0 (no timestamp).
  289. * place event id # at far right for easier visual parsing.
  290. */
  291. for (i = 0; i < num_events; i++) {
  292. ev = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
  293. time = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
  294. if (mode == 0) {
  295. trace_iwlwifi_dev_ucode_cont_event(priv,
  296. 0, time, ev);
  297. } else {
  298. data = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
  299. trace_iwlwifi_dev_ucode_cont_event(priv,
  300. time, data, ev);
  301. }
  302. }
  303. /* Allow device to power down */
  304. iwl_release_nic_access(priv);
  305. spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
  306. }
  307. static void iwl_continuous_event_trace(struct iwl_priv *priv)
  308. {
  309. u32 capacity; /* event log capacity in # entries */
  310. u32 base; /* SRAM byte address of event log header */
  311. u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
  312. u32 num_wraps; /* # times uCode wrapped to top of log */
  313. u32 next_entry; /* index of next entry to be written by uCode */
  314. base = priv->device_pointers.error_event_table;
  315. if (iwlagn_hw_valid_rtc_data_addr(base)) {
  316. capacity = iwl_read_targ_mem(priv, base);
  317. num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32)));
  318. mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32)));
  319. next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32)));
  320. } else
  321. return;
  322. if (num_wraps == priv->event_log.num_wraps) {
  323. iwl_print_cont_event_trace(priv,
  324. base, priv->event_log.next_entry,
  325. next_entry - priv->event_log.next_entry,
  326. mode);
  327. priv->event_log.non_wraps_count++;
  328. } else {
  329. if ((num_wraps - priv->event_log.num_wraps) > 1)
  330. priv->event_log.wraps_more_count++;
  331. else
  332. priv->event_log.wraps_once_count++;
  333. trace_iwlwifi_dev_ucode_wrap_event(priv,
  334. num_wraps - priv->event_log.num_wraps,
  335. next_entry, priv->event_log.next_entry);
  336. if (next_entry < priv->event_log.next_entry) {
  337. iwl_print_cont_event_trace(priv, base,
  338. priv->event_log.next_entry,
  339. capacity - priv->event_log.next_entry,
  340. mode);
  341. iwl_print_cont_event_trace(priv, base, 0,
  342. next_entry, mode);
  343. } else {
  344. iwl_print_cont_event_trace(priv, base,
  345. next_entry, capacity - next_entry,
  346. mode);
  347. iwl_print_cont_event_trace(priv, base, 0,
  348. next_entry, mode);
  349. }
  350. }
  351. priv->event_log.num_wraps = num_wraps;
  352. priv->event_log.next_entry = next_entry;
  353. }
  354. /**
  355. * iwl_bg_ucode_trace - Timer callback to log ucode event
  356. *
  357. * The timer is continually set to execute every
  358. * UCODE_TRACE_PERIOD milliseconds after the last timer expired
  359. * this function is to perform continuous uCode event logging operation
  360. * if enabled
  361. */
  362. static void iwl_bg_ucode_trace(unsigned long data)
  363. {
  364. struct iwl_priv *priv = (struct iwl_priv *)data;
  365. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  366. return;
  367. if (priv->event_log.ucode_trace) {
  368. iwl_continuous_event_trace(priv);
  369. /* Reschedule the timer to occur in UCODE_TRACE_PERIOD */
  370. mod_timer(&priv->ucode_trace,
  371. jiffies + msecs_to_jiffies(UCODE_TRACE_PERIOD));
  372. }
  373. }
  374. static void iwl_bg_tx_flush(struct work_struct *work)
  375. {
  376. struct iwl_priv *priv =
  377. container_of(work, struct iwl_priv, tx_flush);
  378. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  379. return;
  380. /* do nothing if rf-kill is on */
  381. if (!iwl_is_ready_rf(priv))
  382. return;
  383. IWL_DEBUG_INFO(priv, "device request: flush all tx frames\n");
  384. iwlagn_dev_txfifo_flush(priv, IWL_DROP_ALL);
  385. }
  386. /*****************************************************************************
  387. *
  388. * sysfs attributes
  389. *
  390. *****************************************************************************/
  391. #ifdef CONFIG_IWLWIFI_DEBUG
  392. /*
  393. * The following adds a new attribute to the sysfs representation
  394. * of this device driver (i.e. a new file in /sys/class/net/wlan0/device/)
  395. * used for controlling the debug level.
  396. *
  397. * See the level definitions in iwl for details.
  398. *
  399. * The debug_level being managed using sysfs below is a per device debug
  400. * level that is used instead of the global debug level if it (the per
  401. * device debug level) is set.
  402. */
  403. static ssize_t show_debug_level(struct device *d,
  404. struct device_attribute *attr, char *buf)
  405. {
  406. struct iwl_priv *priv = dev_get_drvdata(d);
  407. return sprintf(buf, "0x%08X\n", iwl_get_debug_level(priv));
  408. }
  409. static ssize_t store_debug_level(struct device *d,
  410. struct device_attribute *attr,
  411. const char *buf, size_t count)
  412. {
  413. struct iwl_priv *priv = dev_get_drvdata(d);
  414. unsigned long val;
  415. int ret;
  416. ret = strict_strtoul(buf, 0, &val);
  417. if (ret)
  418. IWL_ERR(priv, "%s is not in hex or decimal form.\n", buf);
  419. else {
  420. priv->debug_level = val;
  421. if (iwl_alloc_traffic_mem(priv))
  422. IWL_ERR(priv,
  423. "Not enough memory to generate traffic log\n");
  424. }
  425. return strnlen(buf, count);
  426. }
  427. static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO,
  428. show_debug_level, store_debug_level);
  429. #endif /* CONFIG_IWLWIFI_DEBUG */
  430. static ssize_t show_temperature(struct device *d,
  431. struct device_attribute *attr, char *buf)
  432. {
  433. struct iwl_priv *priv = dev_get_drvdata(d);
  434. if (!iwl_is_alive(priv))
  435. return -EAGAIN;
  436. return sprintf(buf, "%d\n", priv->temperature);
  437. }
  438. static DEVICE_ATTR(temperature, S_IRUGO, show_temperature, NULL);
  439. static ssize_t show_tx_power(struct device *d,
  440. struct device_attribute *attr, char *buf)
  441. {
  442. struct iwl_priv *priv = dev_get_drvdata(d);
  443. if (!iwl_is_ready_rf(priv))
  444. return sprintf(buf, "off\n");
  445. else
  446. return sprintf(buf, "%d\n", priv->tx_power_user_lmt);
  447. }
  448. static ssize_t store_tx_power(struct device *d,
  449. struct device_attribute *attr,
  450. const char *buf, size_t count)
  451. {
  452. struct iwl_priv *priv = dev_get_drvdata(d);
  453. unsigned long val;
  454. int ret;
  455. ret = strict_strtoul(buf, 10, &val);
  456. if (ret)
  457. IWL_INFO(priv, "%s is not in decimal form.\n", buf);
  458. else {
  459. ret = iwl_set_tx_power(priv, val, false);
  460. if (ret)
  461. IWL_ERR(priv, "failed setting tx power (0x%d).\n",
  462. ret);
  463. else
  464. ret = count;
  465. }
  466. return ret;
  467. }
  468. static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, show_tx_power, store_tx_power);
  469. static struct attribute *iwl_sysfs_entries[] = {
  470. &dev_attr_temperature.attr,
  471. &dev_attr_tx_power.attr,
  472. #ifdef CONFIG_IWLWIFI_DEBUG
  473. &dev_attr_debug_level.attr,
  474. #endif
  475. NULL
  476. };
  477. static struct attribute_group iwl_attribute_group = {
  478. .name = NULL, /* put in device directory */
  479. .attrs = iwl_sysfs_entries,
  480. };
  481. /******************************************************************************
  482. *
  483. * uCode download functions
  484. *
  485. ******************************************************************************/
  486. static void iwl_free_fw_desc(struct iwl_priv *priv, struct fw_desc *desc)
  487. {
  488. if (desc->v_addr)
  489. dma_free_coherent(priv->bus.dev, desc->len,
  490. desc->v_addr, desc->p_addr);
  491. desc->v_addr = NULL;
  492. desc->len = 0;
  493. }
  494. static void iwl_free_fw_img(struct iwl_priv *priv, struct fw_img *img)
  495. {
  496. iwl_free_fw_desc(priv, &img->code);
  497. iwl_free_fw_desc(priv, &img->data);
  498. }
  499. static void iwl_dealloc_ucode(struct iwl_priv *priv)
  500. {
  501. iwl_free_fw_img(priv, &priv->ucode_rt);
  502. iwl_free_fw_img(priv, &priv->ucode_init);
  503. }
  504. static int iwl_alloc_fw_desc(struct iwl_priv *priv, struct fw_desc *desc,
  505. const void *data, size_t len)
  506. {
  507. if (!len) {
  508. desc->v_addr = NULL;
  509. return -EINVAL;
  510. }
  511. desc->v_addr = dma_alloc_coherent(priv->bus.dev, len,
  512. &desc->p_addr, GFP_KERNEL);
  513. if (!desc->v_addr)
  514. return -ENOMEM;
  515. desc->len = len;
  516. memcpy(desc->v_addr, data, len);
  517. return 0;
  518. }
  519. struct iwlagn_ucode_capabilities {
  520. u32 max_probe_length;
  521. u32 standard_phy_calibration_size;
  522. u32 flags;
  523. };
  524. static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context);
  525. static int iwl_mac_setup_register(struct iwl_priv *priv,
  526. struct iwlagn_ucode_capabilities *capa);
  527. #define UCODE_EXPERIMENTAL_INDEX 100
  528. #define UCODE_EXPERIMENTAL_TAG "exp"
  529. static int __must_check iwl_request_firmware(struct iwl_priv *priv, bool first)
  530. {
  531. const char *name_pre = priv->cfg->fw_name_pre;
  532. char tag[8];
  533. if (first) {
  534. #ifdef CONFIG_IWLWIFI_DEBUG_EXPERIMENTAL_UCODE
  535. priv->fw_index = UCODE_EXPERIMENTAL_INDEX;
  536. strcpy(tag, UCODE_EXPERIMENTAL_TAG);
  537. } else if (priv->fw_index == UCODE_EXPERIMENTAL_INDEX) {
  538. #endif
  539. priv->fw_index = priv->cfg->ucode_api_max;
  540. sprintf(tag, "%d", priv->fw_index);
  541. } else {
  542. priv->fw_index--;
  543. sprintf(tag, "%d", priv->fw_index);
  544. }
  545. if (priv->fw_index < priv->cfg->ucode_api_min) {
  546. IWL_ERR(priv, "no suitable firmware found!\n");
  547. return -ENOENT;
  548. }
  549. sprintf(priv->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
  550. IWL_DEBUG_INFO(priv, "attempting to load firmware %s'%s'\n",
  551. (priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
  552. ? "EXPERIMENTAL " : "",
  553. priv->firmware_name);
  554. return request_firmware_nowait(THIS_MODULE, 1, priv->firmware_name,
  555. priv->bus.dev,
  556. GFP_KERNEL, priv, iwl_ucode_callback);
  557. }
  558. struct iwlagn_firmware_pieces {
  559. const void *inst, *data, *init, *init_data;
  560. size_t inst_size, data_size, init_size, init_data_size;
  561. u32 build;
  562. u32 init_evtlog_ptr, init_evtlog_size, init_errlog_ptr;
  563. u32 inst_evtlog_ptr, inst_evtlog_size, inst_errlog_ptr;
  564. };
  565. static int iwlagn_load_legacy_firmware(struct iwl_priv *priv,
  566. const struct firmware *ucode_raw,
  567. struct iwlagn_firmware_pieces *pieces)
  568. {
  569. struct iwl_ucode_header *ucode = (void *)ucode_raw->data;
  570. u32 api_ver, hdr_size;
  571. const u8 *src;
  572. priv->ucode_ver = le32_to_cpu(ucode->ver);
  573. api_ver = IWL_UCODE_API(priv->ucode_ver);
  574. switch (api_ver) {
  575. default:
  576. hdr_size = 28;
  577. if (ucode_raw->size < hdr_size) {
  578. IWL_ERR(priv, "File size too small!\n");
  579. return -EINVAL;
  580. }
  581. pieces->build = le32_to_cpu(ucode->u.v2.build);
  582. pieces->inst_size = le32_to_cpu(ucode->u.v2.inst_size);
  583. pieces->data_size = le32_to_cpu(ucode->u.v2.data_size);
  584. pieces->init_size = le32_to_cpu(ucode->u.v2.init_size);
  585. pieces->init_data_size = le32_to_cpu(ucode->u.v2.init_data_size);
  586. src = ucode->u.v2.data;
  587. break;
  588. case 0:
  589. case 1:
  590. case 2:
  591. hdr_size = 24;
  592. if (ucode_raw->size < hdr_size) {
  593. IWL_ERR(priv, "File size too small!\n");
  594. return -EINVAL;
  595. }
  596. pieces->build = 0;
  597. pieces->inst_size = le32_to_cpu(ucode->u.v1.inst_size);
  598. pieces->data_size = le32_to_cpu(ucode->u.v1.data_size);
  599. pieces->init_size = le32_to_cpu(ucode->u.v1.init_size);
  600. pieces->init_data_size = le32_to_cpu(ucode->u.v1.init_data_size);
  601. src = ucode->u.v1.data;
  602. break;
  603. }
  604. /* Verify size of file vs. image size info in file's header */
  605. if (ucode_raw->size != hdr_size + pieces->inst_size +
  606. pieces->data_size + pieces->init_size +
  607. pieces->init_data_size) {
  608. IWL_ERR(priv,
  609. "uCode file size %d does not match expected size\n",
  610. (int)ucode_raw->size);
  611. return -EINVAL;
  612. }
  613. pieces->inst = src;
  614. src += pieces->inst_size;
  615. pieces->data = src;
  616. src += pieces->data_size;
  617. pieces->init = src;
  618. src += pieces->init_size;
  619. pieces->init_data = src;
  620. src += pieces->init_data_size;
  621. return 0;
  622. }
  623. static int iwlagn_wanted_ucode_alternative = 1;
  624. static int iwlagn_load_firmware(struct iwl_priv *priv,
  625. const struct firmware *ucode_raw,
  626. struct iwlagn_firmware_pieces *pieces,
  627. struct iwlagn_ucode_capabilities *capa)
  628. {
  629. struct iwl_tlv_ucode_header *ucode = (void *)ucode_raw->data;
  630. struct iwl_ucode_tlv *tlv;
  631. size_t len = ucode_raw->size;
  632. const u8 *data;
  633. int wanted_alternative = iwlagn_wanted_ucode_alternative, tmp;
  634. u64 alternatives;
  635. u32 tlv_len;
  636. enum iwl_ucode_tlv_type tlv_type;
  637. const u8 *tlv_data;
  638. if (len < sizeof(*ucode)) {
  639. IWL_ERR(priv, "uCode has invalid length: %zd\n", len);
  640. return -EINVAL;
  641. }
  642. if (ucode->magic != cpu_to_le32(IWL_TLV_UCODE_MAGIC)) {
  643. IWL_ERR(priv, "invalid uCode magic: 0X%x\n",
  644. le32_to_cpu(ucode->magic));
  645. return -EINVAL;
  646. }
  647. /*
  648. * Check which alternatives are present, and "downgrade"
  649. * when the chosen alternative is not present, warning
  650. * the user when that happens. Some files may not have
  651. * any alternatives, so don't warn in that case.
  652. */
  653. alternatives = le64_to_cpu(ucode->alternatives);
  654. tmp = wanted_alternative;
  655. if (wanted_alternative > 63)
  656. wanted_alternative = 63;
  657. while (wanted_alternative && !(alternatives & BIT(wanted_alternative)))
  658. wanted_alternative--;
  659. if (wanted_alternative && wanted_alternative != tmp)
  660. IWL_WARN(priv,
  661. "uCode alternative %d not available, choosing %d\n",
  662. tmp, wanted_alternative);
  663. priv->ucode_ver = le32_to_cpu(ucode->ver);
  664. pieces->build = le32_to_cpu(ucode->build);
  665. data = ucode->data;
  666. len -= sizeof(*ucode);
  667. while (len >= sizeof(*tlv)) {
  668. u16 tlv_alt;
  669. len -= sizeof(*tlv);
  670. tlv = (void *)data;
  671. tlv_len = le32_to_cpu(tlv->length);
  672. tlv_type = le16_to_cpu(tlv->type);
  673. tlv_alt = le16_to_cpu(tlv->alternative);
  674. tlv_data = tlv->data;
  675. if (len < tlv_len) {
  676. IWL_ERR(priv, "invalid TLV len: %zd/%u\n",
  677. len, tlv_len);
  678. return -EINVAL;
  679. }
  680. len -= ALIGN(tlv_len, 4);
  681. data += sizeof(*tlv) + ALIGN(tlv_len, 4);
  682. /*
  683. * Alternative 0 is always valid.
  684. *
  685. * Skip alternative TLVs that are not selected.
  686. */
  687. if (tlv_alt != 0 && tlv_alt != wanted_alternative)
  688. continue;
  689. switch (tlv_type) {
  690. case IWL_UCODE_TLV_INST:
  691. pieces->inst = tlv_data;
  692. pieces->inst_size = tlv_len;
  693. break;
  694. case IWL_UCODE_TLV_DATA:
  695. pieces->data = tlv_data;
  696. pieces->data_size = tlv_len;
  697. break;
  698. case IWL_UCODE_TLV_INIT:
  699. pieces->init = tlv_data;
  700. pieces->init_size = tlv_len;
  701. break;
  702. case IWL_UCODE_TLV_INIT_DATA:
  703. pieces->init_data = tlv_data;
  704. pieces->init_data_size = tlv_len;
  705. break;
  706. case IWL_UCODE_TLV_BOOT:
  707. IWL_ERR(priv, "Found unexpected BOOT ucode\n");
  708. break;
  709. case IWL_UCODE_TLV_PROBE_MAX_LEN:
  710. if (tlv_len != sizeof(u32))
  711. goto invalid_tlv_len;
  712. capa->max_probe_length =
  713. le32_to_cpup((__le32 *)tlv_data);
  714. break;
  715. case IWL_UCODE_TLV_PAN:
  716. if (tlv_len)
  717. goto invalid_tlv_len;
  718. capa->flags |= IWL_UCODE_TLV_FLAGS_PAN;
  719. break;
  720. case IWL_UCODE_TLV_FLAGS:
  721. /* must be at least one u32 */
  722. if (tlv_len < sizeof(u32))
  723. goto invalid_tlv_len;
  724. /* and a proper number of u32s */
  725. if (tlv_len % sizeof(u32))
  726. goto invalid_tlv_len;
  727. /*
  728. * This driver only reads the first u32 as
  729. * right now no more features are defined,
  730. * if that changes then either the driver
  731. * will not work with the new firmware, or
  732. * it'll not take advantage of new features.
  733. */
  734. capa->flags = le32_to_cpup((__le32 *)tlv_data);
  735. break;
  736. case IWL_UCODE_TLV_INIT_EVTLOG_PTR:
  737. if (tlv_len != sizeof(u32))
  738. goto invalid_tlv_len;
  739. pieces->init_evtlog_ptr =
  740. le32_to_cpup((__le32 *)tlv_data);
  741. break;
  742. case IWL_UCODE_TLV_INIT_EVTLOG_SIZE:
  743. if (tlv_len != sizeof(u32))
  744. goto invalid_tlv_len;
  745. pieces->init_evtlog_size =
  746. le32_to_cpup((__le32 *)tlv_data);
  747. break;
  748. case IWL_UCODE_TLV_INIT_ERRLOG_PTR:
  749. if (tlv_len != sizeof(u32))
  750. goto invalid_tlv_len;
  751. pieces->init_errlog_ptr =
  752. le32_to_cpup((__le32 *)tlv_data);
  753. break;
  754. case IWL_UCODE_TLV_RUNT_EVTLOG_PTR:
  755. if (tlv_len != sizeof(u32))
  756. goto invalid_tlv_len;
  757. pieces->inst_evtlog_ptr =
  758. le32_to_cpup((__le32 *)tlv_data);
  759. break;
  760. case IWL_UCODE_TLV_RUNT_EVTLOG_SIZE:
  761. if (tlv_len != sizeof(u32))
  762. goto invalid_tlv_len;
  763. pieces->inst_evtlog_size =
  764. le32_to_cpup((__le32 *)tlv_data);
  765. break;
  766. case IWL_UCODE_TLV_RUNT_ERRLOG_PTR:
  767. if (tlv_len != sizeof(u32))
  768. goto invalid_tlv_len;
  769. pieces->inst_errlog_ptr =
  770. le32_to_cpup((__le32 *)tlv_data);
  771. break;
  772. case IWL_UCODE_TLV_ENHANCE_SENS_TBL:
  773. if (tlv_len)
  774. goto invalid_tlv_len;
  775. priv->enhance_sensitivity_table = true;
  776. break;
  777. case IWL_UCODE_TLV_PHY_CALIBRATION_SIZE:
  778. if (tlv_len != sizeof(u32))
  779. goto invalid_tlv_len;
  780. capa->standard_phy_calibration_size =
  781. le32_to_cpup((__le32 *)tlv_data);
  782. break;
  783. default:
  784. IWL_DEBUG_INFO(priv, "unknown TLV: %d\n", tlv_type);
  785. break;
  786. }
  787. }
  788. if (len) {
  789. IWL_ERR(priv, "invalid TLV after parsing: %zd\n", len);
  790. iwl_print_hex_dump(priv, IWL_DL_FW, (u8 *)data, len);
  791. return -EINVAL;
  792. }
  793. return 0;
  794. invalid_tlv_len:
  795. IWL_ERR(priv, "TLV %d has invalid size: %u\n", tlv_type, tlv_len);
  796. iwl_print_hex_dump(priv, IWL_DL_FW, tlv_data, tlv_len);
  797. return -EINVAL;
  798. }
  799. /**
  800. * iwl_ucode_callback - callback when firmware was loaded
  801. *
  802. * If loaded successfully, copies the firmware into buffers
  803. * for the card to fetch (via DMA).
  804. */
  805. static void iwl_ucode_callback(const struct firmware *ucode_raw, void *context)
  806. {
  807. struct iwl_priv *priv = context;
  808. struct iwl_ucode_header *ucode;
  809. int err;
  810. struct iwlagn_firmware_pieces pieces;
  811. const unsigned int api_max = priv->cfg->ucode_api_max;
  812. const unsigned int api_min = priv->cfg->ucode_api_min;
  813. u32 api_ver;
  814. char buildstr[25];
  815. u32 build;
  816. struct iwlagn_ucode_capabilities ucode_capa = {
  817. .max_probe_length = 200,
  818. .standard_phy_calibration_size =
  819. IWL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE,
  820. };
  821. memset(&pieces, 0, sizeof(pieces));
  822. if (!ucode_raw) {
  823. if (priv->fw_index <= priv->cfg->ucode_api_max)
  824. IWL_ERR(priv,
  825. "request for firmware file '%s' failed.\n",
  826. priv->firmware_name);
  827. goto try_again;
  828. }
  829. IWL_DEBUG_INFO(priv, "Loaded firmware file '%s' (%zd bytes).\n",
  830. priv->firmware_name, ucode_raw->size);
  831. /* Make sure that we got at least the API version number */
  832. if (ucode_raw->size < 4) {
  833. IWL_ERR(priv, "File size way too small!\n");
  834. goto try_again;
  835. }
  836. /* Data from ucode file: header followed by uCode images */
  837. ucode = (struct iwl_ucode_header *)ucode_raw->data;
  838. if (ucode->ver)
  839. err = iwlagn_load_legacy_firmware(priv, ucode_raw, &pieces);
  840. else
  841. err = iwlagn_load_firmware(priv, ucode_raw, &pieces,
  842. &ucode_capa);
  843. if (err)
  844. goto try_again;
  845. api_ver = IWL_UCODE_API(priv->ucode_ver);
  846. build = pieces.build;
  847. /*
  848. * api_ver should match the api version forming part of the
  849. * firmware filename ... but we don't check for that and only rely
  850. * on the API version read from firmware header from here on forward
  851. */
  852. /* no api version check required for experimental uCode */
  853. if (priv->fw_index != UCODE_EXPERIMENTAL_INDEX) {
  854. if (api_ver < api_min || api_ver > api_max) {
  855. IWL_ERR(priv,
  856. "Driver unable to support your firmware API. "
  857. "Driver supports v%u, firmware is v%u.\n",
  858. api_max, api_ver);
  859. goto try_again;
  860. }
  861. if (api_ver != api_max)
  862. IWL_ERR(priv,
  863. "Firmware has old API version. Expected v%u, "
  864. "got v%u. New firmware can be obtained "
  865. "from http://www.intellinuxwireless.org.\n",
  866. api_max, api_ver);
  867. }
  868. if (build)
  869. sprintf(buildstr, " build %u%s", build,
  870. (priv->fw_index == UCODE_EXPERIMENTAL_INDEX)
  871. ? " (EXP)" : "");
  872. else
  873. buildstr[0] = '\0';
  874. IWL_INFO(priv, "loaded firmware version %u.%u.%u.%u%s\n",
  875. IWL_UCODE_MAJOR(priv->ucode_ver),
  876. IWL_UCODE_MINOR(priv->ucode_ver),
  877. IWL_UCODE_API(priv->ucode_ver),
  878. IWL_UCODE_SERIAL(priv->ucode_ver),
  879. buildstr);
  880. snprintf(priv->hw->wiphy->fw_version,
  881. sizeof(priv->hw->wiphy->fw_version),
  882. "%u.%u.%u.%u%s",
  883. IWL_UCODE_MAJOR(priv->ucode_ver),
  884. IWL_UCODE_MINOR(priv->ucode_ver),
  885. IWL_UCODE_API(priv->ucode_ver),
  886. IWL_UCODE_SERIAL(priv->ucode_ver),
  887. buildstr);
  888. /*
  889. * For any of the failures below (before allocating pci memory)
  890. * we will try to load a version with a smaller API -- maybe the
  891. * user just got a corrupted version of the latest API.
  892. */
  893. IWL_DEBUG_INFO(priv, "f/w package hdr ucode version raw = 0x%x\n",
  894. priv->ucode_ver);
  895. IWL_DEBUG_INFO(priv, "f/w package hdr runtime inst size = %Zd\n",
  896. pieces.inst_size);
  897. IWL_DEBUG_INFO(priv, "f/w package hdr runtime data size = %Zd\n",
  898. pieces.data_size);
  899. IWL_DEBUG_INFO(priv, "f/w package hdr init inst size = %Zd\n",
  900. pieces.init_size);
  901. IWL_DEBUG_INFO(priv, "f/w package hdr init data size = %Zd\n",
  902. pieces.init_data_size);
  903. /* Verify that uCode images will fit in card's SRAM */
  904. if (pieces.inst_size > priv->hw_params.max_inst_size) {
  905. IWL_ERR(priv, "uCode instr len %Zd too large to fit in\n",
  906. pieces.inst_size);
  907. goto try_again;
  908. }
  909. if (pieces.data_size > priv->hw_params.max_data_size) {
  910. IWL_ERR(priv, "uCode data len %Zd too large to fit in\n",
  911. pieces.data_size);
  912. goto try_again;
  913. }
  914. if (pieces.init_size > priv->hw_params.max_inst_size) {
  915. IWL_ERR(priv, "uCode init instr len %Zd too large to fit in\n",
  916. pieces.init_size);
  917. goto try_again;
  918. }
  919. if (pieces.init_data_size > priv->hw_params.max_data_size) {
  920. IWL_ERR(priv, "uCode init data len %Zd too large to fit in\n",
  921. pieces.init_data_size);
  922. goto try_again;
  923. }
  924. /* Allocate ucode buffers for card's bus-master loading ... */
  925. /* Runtime instructions and 2 copies of data:
  926. * 1) unmodified from disk
  927. * 2) backup cache for save/restore during power-downs */
  928. if (iwl_alloc_fw_desc(priv, &priv->ucode_rt.code,
  929. pieces.inst, pieces.inst_size))
  930. goto err_pci_alloc;
  931. if (iwl_alloc_fw_desc(priv, &priv->ucode_rt.data,
  932. pieces.data, pieces.data_size))
  933. goto err_pci_alloc;
  934. /* Initialization instructions and data */
  935. if (pieces.init_size && pieces.init_data_size) {
  936. if (iwl_alloc_fw_desc(priv, &priv->ucode_init.code,
  937. pieces.init, pieces.init_size))
  938. goto err_pci_alloc;
  939. if (iwl_alloc_fw_desc(priv, &priv->ucode_init.data,
  940. pieces.init_data, pieces.init_data_size))
  941. goto err_pci_alloc;
  942. }
  943. /* Now that we can no longer fail, copy information */
  944. /*
  945. * The (size - 16) / 12 formula is based on the information recorded
  946. * for each event, which is of mode 1 (including timestamp) for all
  947. * new microcodes that include this information.
  948. */
  949. priv->_agn.init_evtlog_ptr = pieces.init_evtlog_ptr;
  950. if (pieces.init_evtlog_size)
  951. priv->_agn.init_evtlog_size = (pieces.init_evtlog_size - 16)/12;
  952. else
  953. priv->_agn.init_evtlog_size =
  954. priv->cfg->base_params->max_event_log_size;
  955. priv->_agn.init_errlog_ptr = pieces.init_errlog_ptr;
  956. priv->_agn.inst_evtlog_ptr = pieces.inst_evtlog_ptr;
  957. if (pieces.inst_evtlog_size)
  958. priv->_agn.inst_evtlog_size = (pieces.inst_evtlog_size - 16)/12;
  959. else
  960. priv->_agn.inst_evtlog_size =
  961. priv->cfg->base_params->max_event_log_size;
  962. priv->_agn.inst_errlog_ptr = pieces.inst_errlog_ptr;
  963. priv->new_scan_threshold_behaviour =
  964. !!(ucode_capa.flags & IWL_UCODE_TLV_FLAGS_NEWSCAN);
  965. if ((priv->cfg->sku & EEPROM_SKU_CAP_IPAN_ENABLE) &&
  966. (ucode_capa.flags & IWL_UCODE_TLV_FLAGS_PAN)) {
  967. priv->valid_contexts |= BIT(IWL_RXON_CTX_PAN);
  968. priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN;
  969. } else
  970. priv->sta_key_max_num = STA_KEY_MAX_NUM;
  971. if (priv->valid_contexts != BIT(IWL_RXON_CTX_BSS))
  972. priv->cmd_queue = IWL_IPAN_CMD_QUEUE_NUM;
  973. else
  974. priv->cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
  975. /*
  976. * figure out the offset of chain noise reset and gain commands
  977. * base on the size of standard phy calibration commands table size
  978. */
  979. if (ucode_capa.standard_phy_calibration_size >
  980. IWL_MAX_PHY_CALIBRATE_TBL_SIZE)
  981. ucode_capa.standard_phy_calibration_size =
  982. IWL_MAX_STANDARD_PHY_CALIBRATE_TBL_SIZE;
  983. priv->_agn.phy_calib_chain_noise_reset_cmd =
  984. ucode_capa.standard_phy_calibration_size;
  985. priv->_agn.phy_calib_chain_noise_gain_cmd =
  986. ucode_capa.standard_phy_calibration_size + 1;
  987. /**************************************************
  988. * This is still part of probe() in a sense...
  989. *
  990. * 9. Setup and register with mac80211 and debugfs
  991. **************************************************/
  992. err = iwl_mac_setup_register(priv, &ucode_capa);
  993. if (err)
  994. goto out_unbind;
  995. err = iwl_dbgfs_register(priv, DRV_NAME);
  996. if (err)
  997. IWL_ERR(priv, "failed to create debugfs files. Ignoring error: %d\n", err);
  998. err = sysfs_create_group(&(priv->bus.dev->kobj),
  999. &iwl_attribute_group);
  1000. if (err) {
  1001. IWL_ERR(priv, "failed to create sysfs device attributes\n");
  1002. goto out_unbind;
  1003. }
  1004. /* We have our copies now, allow OS release its copies */
  1005. release_firmware(ucode_raw);
  1006. complete(&priv->_agn.firmware_loading_complete);
  1007. return;
  1008. try_again:
  1009. /* try next, if any */
  1010. if (iwl_request_firmware(priv, false))
  1011. goto out_unbind;
  1012. release_firmware(ucode_raw);
  1013. return;
  1014. err_pci_alloc:
  1015. IWL_ERR(priv, "failed to allocate pci memory\n");
  1016. iwl_dealloc_ucode(priv);
  1017. out_unbind:
  1018. complete(&priv->_agn.firmware_loading_complete);
  1019. device_release_driver(priv->bus.dev);
  1020. release_firmware(ucode_raw);
  1021. }
  1022. static const char * const desc_lookup_text[] = {
  1023. "OK",
  1024. "FAIL",
  1025. "BAD_PARAM",
  1026. "BAD_CHECKSUM",
  1027. "NMI_INTERRUPT_WDG",
  1028. "SYSASSERT",
  1029. "FATAL_ERROR",
  1030. "BAD_COMMAND",
  1031. "HW_ERROR_TUNE_LOCK",
  1032. "HW_ERROR_TEMPERATURE",
  1033. "ILLEGAL_CHAN_FREQ",
  1034. "VCC_NOT_STABLE",
  1035. "FH_ERROR",
  1036. "NMI_INTERRUPT_HOST",
  1037. "NMI_INTERRUPT_ACTION_PT",
  1038. "NMI_INTERRUPT_UNKNOWN",
  1039. "UCODE_VERSION_MISMATCH",
  1040. "HW_ERROR_ABS_LOCK",
  1041. "HW_ERROR_CAL_LOCK_FAIL",
  1042. "NMI_INTERRUPT_INST_ACTION_PT",
  1043. "NMI_INTERRUPT_DATA_ACTION_PT",
  1044. "NMI_TRM_HW_ER",
  1045. "NMI_INTERRUPT_TRM",
  1046. "NMI_INTERRUPT_BREAK_POINT",
  1047. "DEBUG_0",
  1048. "DEBUG_1",
  1049. "DEBUG_2",
  1050. "DEBUG_3",
  1051. };
  1052. static struct { char *name; u8 num; } advanced_lookup[] = {
  1053. { "NMI_INTERRUPT_WDG", 0x34 },
  1054. { "SYSASSERT", 0x35 },
  1055. { "UCODE_VERSION_MISMATCH", 0x37 },
  1056. { "BAD_COMMAND", 0x38 },
  1057. { "NMI_INTERRUPT_DATA_ACTION_PT", 0x3C },
  1058. { "FATAL_ERROR", 0x3D },
  1059. { "NMI_TRM_HW_ERR", 0x46 },
  1060. { "NMI_INTERRUPT_TRM", 0x4C },
  1061. { "NMI_INTERRUPT_BREAK_POINT", 0x54 },
  1062. { "NMI_INTERRUPT_WDG_RXF_FULL", 0x5C },
  1063. { "NMI_INTERRUPT_WDG_NO_RBD_RXF_FULL", 0x64 },
  1064. { "NMI_INTERRUPT_HOST", 0x66 },
  1065. { "NMI_INTERRUPT_ACTION_PT", 0x7C },
  1066. { "NMI_INTERRUPT_UNKNOWN", 0x84 },
  1067. { "NMI_INTERRUPT_INST_ACTION_PT", 0x86 },
  1068. { "ADVANCED_SYSASSERT", 0 },
  1069. };
  1070. static const char *desc_lookup(u32 num)
  1071. {
  1072. int i;
  1073. int max = ARRAY_SIZE(desc_lookup_text);
  1074. if (num < max)
  1075. return desc_lookup_text[num];
  1076. max = ARRAY_SIZE(advanced_lookup) - 1;
  1077. for (i = 0; i < max; i++) {
  1078. if (advanced_lookup[i].num == num)
  1079. break;
  1080. }
  1081. return advanced_lookup[i].name;
  1082. }
  1083. #define ERROR_START_OFFSET (1 * sizeof(u32))
  1084. #define ERROR_ELEM_SIZE (7 * sizeof(u32))
  1085. void iwl_dump_nic_error_log(struct iwl_priv *priv)
  1086. {
  1087. u32 base;
  1088. struct iwl_error_event_table table;
  1089. base = priv->device_pointers.error_event_table;
  1090. if (priv->ucode_type == IWL_UCODE_INIT) {
  1091. if (!base)
  1092. base = priv->_agn.init_errlog_ptr;
  1093. } else {
  1094. if (!base)
  1095. base = priv->_agn.inst_errlog_ptr;
  1096. }
  1097. if (!iwlagn_hw_valid_rtc_data_addr(base)) {
  1098. IWL_ERR(priv,
  1099. "Not valid error log pointer 0x%08X for %s uCode\n",
  1100. base,
  1101. (priv->ucode_type == IWL_UCODE_INIT)
  1102. ? "Init" : "RT");
  1103. return;
  1104. }
  1105. iwl_read_targ_mem_words(priv, base, &table, sizeof(table));
  1106. if (ERROR_START_OFFSET <= table.valid * ERROR_ELEM_SIZE) {
  1107. IWL_ERR(priv, "Start IWL Error Log Dump:\n");
  1108. IWL_ERR(priv, "Status: 0x%08lX, count: %d\n",
  1109. priv->status, table.valid);
  1110. }
  1111. priv->isr_stats.err_code = table.error_id;
  1112. trace_iwlwifi_dev_ucode_error(priv, table.error_id, table.tsf_low,
  1113. table.data1, table.data2, table.line,
  1114. table.blink1, table.blink2, table.ilink1,
  1115. table.ilink2, table.bcon_time, table.gp1,
  1116. table.gp2, table.gp3, table.ucode_ver,
  1117. table.hw_ver, table.brd_ver);
  1118. IWL_ERR(priv, "0x%08X | %-28s\n", table.error_id,
  1119. desc_lookup(table.error_id));
  1120. IWL_ERR(priv, "0x%08X | uPc\n", table.pc);
  1121. IWL_ERR(priv, "0x%08X | branchlink1\n", table.blink1);
  1122. IWL_ERR(priv, "0x%08X | branchlink2\n", table.blink2);
  1123. IWL_ERR(priv, "0x%08X | interruptlink1\n", table.ilink1);
  1124. IWL_ERR(priv, "0x%08X | interruptlink2\n", table.ilink2);
  1125. IWL_ERR(priv, "0x%08X | data1\n", table.data1);
  1126. IWL_ERR(priv, "0x%08X | data2\n", table.data2);
  1127. IWL_ERR(priv, "0x%08X | line\n", table.line);
  1128. IWL_ERR(priv, "0x%08X | beacon time\n", table.bcon_time);
  1129. IWL_ERR(priv, "0x%08X | tsf low\n", table.tsf_low);
  1130. IWL_ERR(priv, "0x%08X | tsf hi\n", table.tsf_hi);
  1131. IWL_ERR(priv, "0x%08X | time gp1\n", table.gp1);
  1132. IWL_ERR(priv, "0x%08X | time gp2\n", table.gp2);
  1133. IWL_ERR(priv, "0x%08X | time gp3\n", table.gp3);
  1134. IWL_ERR(priv, "0x%08X | uCode version\n", table.ucode_ver);
  1135. IWL_ERR(priv, "0x%08X | hw version\n", table.hw_ver);
  1136. IWL_ERR(priv, "0x%08X | board version\n", table.brd_ver);
  1137. IWL_ERR(priv, "0x%08X | hcmd\n", table.hcmd);
  1138. }
  1139. #define EVENT_START_OFFSET (4 * sizeof(u32))
  1140. /**
  1141. * iwl_print_event_log - Dump error event log to syslog
  1142. *
  1143. */
  1144. static int iwl_print_event_log(struct iwl_priv *priv, u32 start_idx,
  1145. u32 num_events, u32 mode,
  1146. int pos, char **buf, size_t bufsz)
  1147. {
  1148. u32 i;
  1149. u32 base; /* SRAM byte address of event log header */
  1150. u32 event_size; /* 2 u32s, or 3 u32s if timestamp recorded */
  1151. u32 ptr; /* SRAM byte address of log data */
  1152. u32 ev, time, data; /* event log data */
  1153. unsigned long reg_flags;
  1154. if (num_events == 0)
  1155. return pos;
  1156. base = priv->device_pointers.log_event_table;
  1157. if (priv->ucode_type == IWL_UCODE_INIT) {
  1158. if (!base)
  1159. base = priv->_agn.init_evtlog_ptr;
  1160. } else {
  1161. if (!base)
  1162. base = priv->_agn.inst_evtlog_ptr;
  1163. }
  1164. if (mode == 0)
  1165. event_size = 2 * sizeof(u32);
  1166. else
  1167. event_size = 3 * sizeof(u32);
  1168. ptr = base + EVENT_START_OFFSET + (start_idx * event_size);
  1169. /* Make sure device is powered up for SRAM reads */
  1170. spin_lock_irqsave(&priv->reg_lock, reg_flags);
  1171. iwl_grab_nic_access(priv);
  1172. /* Set starting address; reads will auto-increment */
  1173. iwl_write32(priv, HBUS_TARG_MEM_RADDR, ptr);
  1174. rmb();
  1175. /* "time" is actually "data" for mode 0 (no timestamp).
  1176. * place event id # at far right for easier visual parsing. */
  1177. for (i = 0; i < num_events; i++) {
  1178. ev = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
  1179. time = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
  1180. if (mode == 0) {
  1181. /* data, ev */
  1182. if (bufsz) {
  1183. pos += scnprintf(*buf + pos, bufsz - pos,
  1184. "EVT_LOG:0x%08x:%04u\n",
  1185. time, ev);
  1186. } else {
  1187. trace_iwlwifi_dev_ucode_event(priv, 0,
  1188. time, ev);
  1189. IWL_ERR(priv, "EVT_LOG:0x%08x:%04u\n",
  1190. time, ev);
  1191. }
  1192. } else {
  1193. data = iwl_read32(priv, HBUS_TARG_MEM_RDAT);
  1194. if (bufsz) {
  1195. pos += scnprintf(*buf + pos, bufsz - pos,
  1196. "EVT_LOGT:%010u:0x%08x:%04u\n",
  1197. time, data, ev);
  1198. } else {
  1199. IWL_ERR(priv, "EVT_LOGT:%010u:0x%08x:%04u\n",
  1200. time, data, ev);
  1201. trace_iwlwifi_dev_ucode_event(priv, time,
  1202. data, ev);
  1203. }
  1204. }
  1205. }
  1206. /* Allow device to power down */
  1207. iwl_release_nic_access(priv);
  1208. spin_unlock_irqrestore(&priv->reg_lock, reg_flags);
  1209. return pos;
  1210. }
  1211. /**
  1212. * iwl_print_last_event_logs - Dump the newest # of event log to syslog
  1213. */
  1214. static int iwl_print_last_event_logs(struct iwl_priv *priv, u32 capacity,
  1215. u32 num_wraps, u32 next_entry,
  1216. u32 size, u32 mode,
  1217. int pos, char **buf, size_t bufsz)
  1218. {
  1219. /*
  1220. * display the newest DEFAULT_LOG_ENTRIES entries
  1221. * i.e the entries just before the next ont that uCode would fill.
  1222. */
  1223. if (num_wraps) {
  1224. if (next_entry < size) {
  1225. pos = iwl_print_event_log(priv,
  1226. capacity - (size - next_entry),
  1227. size - next_entry, mode,
  1228. pos, buf, bufsz);
  1229. pos = iwl_print_event_log(priv, 0,
  1230. next_entry, mode,
  1231. pos, buf, bufsz);
  1232. } else
  1233. pos = iwl_print_event_log(priv, next_entry - size,
  1234. size, mode, pos, buf, bufsz);
  1235. } else {
  1236. if (next_entry < size) {
  1237. pos = iwl_print_event_log(priv, 0, next_entry,
  1238. mode, pos, buf, bufsz);
  1239. } else {
  1240. pos = iwl_print_event_log(priv, next_entry - size,
  1241. size, mode, pos, buf, bufsz);
  1242. }
  1243. }
  1244. return pos;
  1245. }
  1246. #define DEFAULT_DUMP_EVENT_LOG_ENTRIES (20)
  1247. int iwl_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
  1248. char **buf, bool display)
  1249. {
  1250. u32 base; /* SRAM byte address of event log header */
  1251. u32 capacity; /* event log capacity in # entries */
  1252. u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
  1253. u32 num_wraps; /* # times uCode wrapped to top of log */
  1254. u32 next_entry; /* index of next entry to be written by uCode */
  1255. u32 size; /* # entries that we'll print */
  1256. u32 logsize;
  1257. int pos = 0;
  1258. size_t bufsz = 0;
  1259. base = priv->device_pointers.log_event_table;
  1260. if (priv->ucode_type == IWL_UCODE_INIT) {
  1261. logsize = priv->_agn.init_evtlog_size;
  1262. if (!base)
  1263. base = priv->_agn.init_evtlog_ptr;
  1264. } else {
  1265. logsize = priv->_agn.inst_evtlog_size;
  1266. if (!base)
  1267. base = priv->_agn.inst_evtlog_ptr;
  1268. }
  1269. if (!iwlagn_hw_valid_rtc_data_addr(base)) {
  1270. IWL_ERR(priv,
  1271. "Invalid event log pointer 0x%08X for %s uCode\n",
  1272. base,
  1273. (priv->ucode_type == IWL_UCODE_INIT)
  1274. ? "Init" : "RT");
  1275. return -EINVAL;
  1276. }
  1277. /* event log header */
  1278. capacity = iwl_read_targ_mem(priv, base);
  1279. mode = iwl_read_targ_mem(priv, base + (1 * sizeof(u32)));
  1280. num_wraps = iwl_read_targ_mem(priv, base + (2 * sizeof(u32)));
  1281. next_entry = iwl_read_targ_mem(priv, base + (3 * sizeof(u32)));
  1282. if (capacity > logsize) {
  1283. IWL_ERR(priv, "Log capacity %d is bogus, limit to %d entries\n",
  1284. capacity, logsize);
  1285. capacity = logsize;
  1286. }
  1287. if (next_entry > logsize) {
  1288. IWL_ERR(priv, "Log write index %d is bogus, limit to %d\n",
  1289. next_entry, logsize);
  1290. next_entry = logsize;
  1291. }
  1292. size = num_wraps ? capacity : next_entry;
  1293. /* bail out if nothing in log */
  1294. if (size == 0) {
  1295. IWL_ERR(priv, "Start IWL Event Log Dump: nothing in log\n");
  1296. return pos;
  1297. }
  1298. /* enable/disable bt channel inhibition */
  1299. priv->bt_ch_announce = iwlagn_bt_ch_announce;
  1300. #ifdef CONFIG_IWLWIFI_DEBUG
  1301. if (!(iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS) && !full_log)
  1302. size = (size > DEFAULT_DUMP_EVENT_LOG_ENTRIES)
  1303. ? DEFAULT_DUMP_EVENT_LOG_ENTRIES : size;
  1304. #else
  1305. size = (size > DEFAULT_DUMP_EVENT_LOG_ENTRIES)
  1306. ? DEFAULT_DUMP_EVENT_LOG_ENTRIES : size;
  1307. #endif
  1308. IWL_ERR(priv, "Start IWL Event Log Dump: display last %u entries\n",
  1309. size);
  1310. #ifdef CONFIG_IWLWIFI_DEBUG
  1311. if (display) {
  1312. if (full_log)
  1313. bufsz = capacity * 48;
  1314. else
  1315. bufsz = size * 48;
  1316. *buf = kmalloc(bufsz, GFP_KERNEL);
  1317. if (!*buf)
  1318. return -ENOMEM;
  1319. }
  1320. if ((iwl_get_debug_level(priv) & IWL_DL_FW_ERRORS) || full_log) {
  1321. /*
  1322. * if uCode has wrapped back to top of log,
  1323. * start at the oldest entry,
  1324. * i.e the next one that uCode would fill.
  1325. */
  1326. if (num_wraps)
  1327. pos = iwl_print_event_log(priv, next_entry,
  1328. capacity - next_entry, mode,
  1329. pos, buf, bufsz);
  1330. /* (then/else) start at top of log */
  1331. pos = iwl_print_event_log(priv, 0,
  1332. next_entry, mode, pos, buf, bufsz);
  1333. } else
  1334. pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
  1335. next_entry, size, mode,
  1336. pos, buf, bufsz);
  1337. #else
  1338. pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
  1339. next_entry, size, mode,
  1340. pos, buf, bufsz);
  1341. #endif
  1342. return pos;
  1343. }
  1344. static void iwl_rf_kill_ct_config(struct iwl_priv *priv)
  1345. {
  1346. struct iwl_ct_kill_config cmd;
  1347. struct iwl_ct_kill_throttling_config adv_cmd;
  1348. unsigned long flags;
  1349. int ret = 0;
  1350. spin_lock_irqsave(&priv->lock, flags);
  1351. iwl_write32(priv, CSR_UCODE_DRV_GP1_CLR,
  1352. CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
  1353. spin_unlock_irqrestore(&priv->lock, flags);
  1354. priv->thermal_throttle.ct_kill_toggle = false;
  1355. if (priv->cfg->base_params->support_ct_kill_exit) {
  1356. adv_cmd.critical_temperature_enter =
  1357. cpu_to_le32(priv->hw_params.ct_kill_threshold);
  1358. adv_cmd.critical_temperature_exit =
  1359. cpu_to_le32(priv->hw_params.ct_kill_exit_threshold);
  1360. ret = trans_send_cmd_pdu(&priv->trans,
  1361. REPLY_CT_KILL_CONFIG_CMD,
  1362. CMD_SYNC, sizeof(adv_cmd), &adv_cmd);
  1363. if (ret)
  1364. IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
  1365. else
  1366. IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
  1367. "succeeded, "
  1368. "critical temperature enter is %d,"
  1369. "exit is %d\n",
  1370. priv->hw_params.ct_kill_threshold,
  1371. priv->hw_params.ct_kill_exit_threshold);
  1372. } else {
  1373. cmd.critical_temperature_R =
  1374. cpu_to_le32(priv->hw_params.ct_kill_threshold);
  1375. ret = trans_send_cmd_pdu(&priv->trans,
  1376. REPLY_CT_KILL_CONFIG_CMD,
  1377. CMD_SYNC, sizeof(cmd), &cmd);
  1378. if (ret)
  1379. IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
  1380. else
  1381. IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
  1382. "succeeded, "
  1383. "critical temperature is %d\n",
  1384. priv->hw_params.ct_kill_threshold);
  1385. }
  1386. }
  1387. static int iwlagn_send_calib_cfg_rt(struct iwl_priv *priv, u32 cfg)
  1388. {
  1389. struct iwl_calib_cfg_cmd calib_cfg_cmd;
  1390. struct iwl_host_cmd cmd = {
  1391. .id = CALIBRATION_CFG_CMD,
  1392. .len = { sizeof(struct iwl_calib_cfg_cmd), },
  1393. .data = { &calib_cfg_cmd, },
  1394. };
  1395. memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
  1396. calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_INIT_CFG_ALL;
  1397. calib_cfg_cmd.ucd_calib_cfg.once.start = cpu_to_le32(cfg);
  1398. return trans_send_cmd(&priv->trans, &cmd);
  1399. }
  1400. static int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant)
  1401. {
  1402. struct iwl_tx_ant_config_cmd tx_ant_cmd = {
  1403. .valid = cpu_to_le32(valid_tx_ant),
  1404. };
  1405. if (IWL_UCODE_API(priv->ucode_ver) > 1) {
  1406. IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant);
  1407. return trans_send_cmd_pdu(&priv->trans,
  1408. TX_ANT_CONFIGURATION_CMD,
  1409. CMD_SYNC,
  1410. sizeof(struct iwl_tx_ant_config_cmd),
  1411. &tx_ant_cmd);
  1412. } else {
  1413. IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n");
  1414. return -EOPNOTSUPP;
  1415. }
  1416. }
  1417. /**
  1418. * iwl_alive_start - called after REPLY_ALIVE notification received
  1419. * from protocol/runtime uCode (initialization uCode's
  1420. * Alive gets handled by iwl_init_alive_start()).
  1421. */
  1422. int iwl_alive_start(struct iwl_priv *priv)
  1423. {
  1424. int ret = 0;
  1425. struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
  1426. /*TODO: this should go to the transport layer */
  1427. iwl_reset_ict(priv);
  1428. IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
  1429. /* After the ALIVE response, we can send host commands to the uCode */
  1430. set_bit(STATUS_ALIVE, &priv->status);
  1431. /* Enable watchdog to monitor the driver tx queues */
  1432. iwl_setup_watchdog(priv);
  1433. if (iwl_is_rfkill(priv))
  1434. return -ERFKILL;
  1435. /* download priority table before any calibration request */
  1436. if (priv->cfg->bt_params &&
  1437. priv->cfg->bt_params->advanced_bt_coexist) {
  1438. /* Configure Bluetooth device coexistence support */
  1439. if (priv->cfg->bt_params->bt_sco_disable)
  1440. priv->bt_enable_pspoll = false;
  1441. else
  1442. priv->bt_enable_pspoll = true;
  1443. priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
  1444. priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
  1445. priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
  1446. iwlagn_send_advance_bt_config(priv);
  1447. priv->bt_valid = IWLAGN_BT_VALID_ENABLE_FLAGS;
  1448. priv->cur_rssi_ctx = NULL;
  1449. iwlagn_send_prio_tbl(priv);
  1450. /* FIXME: w/a to force change uCode BT state machine */
  1451. ret = iwlagn_send_bt_env(priv, IWL_BT_COEX_ENV_OPEN,
  1452. BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
  1453. if (ret)
  1454. return ret;
  1455. ret = iwlagn_send_bt_env(priv, IWL_BT_COEX_ENV_CLOSE,
  1456. BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
  1457. if (ret)
  1458. return ret;
  1459. } else {
  1460. /*
  1461. * default is 2-wire BT coexexistence support
  1462. */
  1463. iwl_send_bt_config(priv);
  1464. }
  1465. if (priv->hw_params.calib_rt_cfg)
  1466. iwlagn_send_calib_cfg_rt(priv, priv->hw_params.calib_rt_cfg);
  1467. ieee80211_wake_queues(priv->hw);
  1468. priv->active_rate = IWL_RATES_MASK;
  1469. /* Configure Tx antenna selection based on H/W config */
  1470. iwlagn_send_tx_ant_config(priv, priv->cfg->valid_tx_ant);
  1471. if (iwl_is_associated_ctx(ctx)) {
  1472. struct iwl_rxon_cmd *active_rxon =
  1473. (struct iwl_rxon_cmd *)&ctx->active;
  1474. /* apply any changes in staging */
  1475. ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
  1476. active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
  1477. } else {
  1478. struct iwl_rxon_context *tmp;
  1479. /* Initialize our rx_config data */
  1480. for_each_context(priv, tmp)
  1481. iwl_connection_init_rx_config(priv, tmp);
  1482. iwlagn_set_rxon_chain(priv, ctx);
  1483. }
  1484. iwl_reset_run_time_calib(priv);
  1485. set_bit(STATUS_READY, &priv->status);
  1486. /* Configure the adapter for unassociated operation */
  1487. ret = iwlagn_commit_rxon(priv, ctx);
  1488. if (ret)
  1489. return ret;
  1490. /* At this point, the NIC is initialized and operational */
  1491. iwl_rf_kill_ct_config(priv);
  1492. IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
  1493. return iwl_power_update_mode(priv, true);
  1494. }
  1495. static void iwl_cancel_deferred_work(struct iwl_priv *priv);
  1496. static void __iwl_down(struct iwl_priv *priv)
  1497. {
  1498. int exit_pending;
  1499. IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
  1500. iwl_scan_cancel_timeout(priv, 200);
  1501. exit_pending = test_and_set_bit(STATUS_EXIT_PENDING, &priv->status);
  1502. /* Stop TX queues watchdog. We need to have STATUS_EXIT_PENDING bit set
  1503. * to prevent rearm timer */
  1504. del_timer_sync(&priv->watchdog);
  1505. iwl_clear_ucode_stations(priv, NULL);
  1506. iwl_dealloc_bcast_stations(priv);
  1507. iwl_clear_driver_stations(priv);
  1508. /* reset BT coex data */
  1509. priv->bt_status = 0;
  1510. priv->cur_rssi_ctx = NULL;
  1511. priv->bt_is_sco = 0;
  1512. if (priv->cfg->bt_params)
  1513. priv->bt_traffic_load =
  1514. priv->cfg->bt_params->bt_init_traffic_load;
  1515. else
  1516. priv->bt_traffic_load = 0;
  1517. priv->bt_full_concurrent = false;
  1518. priv->bt_ci_compliance = 0;
  1519. /* Wipe out the EXIT_PENDING status bit if we are not actually
  1520. * exiting the module */
  1521. if (!exit_pending)
  1522. clear_bit(STATUS_EXIT_PENDING, &priv->status);
  1523. if (priv->mac80211_registered)
  1524. ieee80211_stop_queues(priv->hw);
  1525. /* Clear out all status bits but a few that are stable across reset */
  1526. priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
  1527. STATUS_RF_KILL_HW |
  1528. test_bit(STATUS_GEO_CONFIGURED, &priv->status) <<
  1529. STATUS_GEO_CONFIGURED |
  1530. test_bit(STATUS_FW_ERROR, &priv->status) <<
  1531. STATUS_FW_ERROR |
  1532. test_bit(STATUS_EXIT_PENDING, &priv->status) <<
  1533. STATUS_EXIT_PENDING;
  1534. trans_stop_device(&priv->trans);
  1535. dev_kfree_skb(priv->beacon_skb);
  1536. priv->beacon_skb = NULL;
  1537. }
  1538. static void iwl_down(struct iwl_priv *priv)
  1539. {
  1540. mutex_lock(&priv->mutex);
  1541. __iwl_down(priv);
  1542. mutex_unlock(&priv->mutex);
  1543. iwl_cancel_deferred_work(priv);
  1544. }
  1545. #define MAX_HW_RESTARTS 5
  1546. static int __iwl_up(struct iwl_priv *priv)
  1547. {
  1548. struct iwl_rxon_context *ctx;
  1549. int ret;
  1550. lockdep_assert_held(&priv->mutex);
  1551. if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
  1552. IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
  1553. return -EIO;
  1554. }
  1555. for_each_context(priv, ctx) {
  1556. ret = iwlagn_alloc_bcast_station(priv, ctx);
  1557. if (ret) {
  1558. iwl_dealloc_bcast_stations(priv);
  1559. return ret;
  1560. }
  1561. }
  1562. ret = iwlagn_run_init_ucode(priv);
  1563. if (ret) {
  1564. IWL_ERR(priv, "Failed to run INIT ucode: %d\n", ret);
  1565. goto error;
  1566. }
  1567. ret = iwlagn_load_ucode_wait_alive(priv,
  1568. &priv->ucode_rt,
  1569. IWL_UCODE_REGULAR);
  1570. if (ret) {
  1571. IWL_ERR(priv, "Failed to start RT ucode: %d\n", ret);
  1572. goto error;
  1573. }
  1574. ret = iwl_alive_start(priv);
  1575. if (ret)
  1576. goto error;
  1577. return 0;
  1578. error:
  1579. set_bit(STATUS_EXIT_PENDING, &priv->status);
  1580. __iwl_down(priv);
  1581. clear_bit(STATUS_EXIT_PENDING, &priv->status);
  1582. IWL_ERR(priv, "Unable to initialize device.\n");
  1583. return ret;
  1584. }
  1585. /*****************************************************************************
  1586. *
  1587. * Workqueue callbacks
  1588. *
  1589. *****************************************************************************/
  1590. static void iwl_bg_run_time_calib_work(struct work_struct *work)
  1591. {
  1592. struct iwl_priv *priv = container_of(work, struct iwl_priv,
  1593. run_time_calib_work);
  1594. mutex_lock(&priv->mutex);
  1595. if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
  1596. test_bit(STATUS_SCANNING, &priv->status)) {
  1597. mutex_unlock(&priv->mutex);
  1598. return;
  1599. }
  1600. if (priv->start_calib) {
  1601. iwl_chain_noise_calibration(priv);
  1602. iwl_sensitivity_calibration(priv);
  1603. }
  1604. mutex_unlock(&priv->mutex);
  1605. }
  1606. static void iwlagn_prepare_restart(struct iwl_priv *priv)
  1607. {
  1608. struct iwl_rxon_context *ctx;
  1609. bool bt_full_concurrent;
  1610. u8 bt_ci_compliance;
  1611. u8 bt_load;
  1612. u8 bt_status;
  1613. bool bt_is_sco;
  1614. lockdep_assert_held(&priv->mutex);
  1615. for_each_context(priv, ctx)
  1616. ctx->vif = NULL;
  1617. priv->is_open = 0;
  1618. /*
  1619. * __iwl_down() will clear the BT status variables,
  1620. * which is correct, but when we restart we really
  1621. * want to keep them so restore them afterwards.
  1622. *
  1623. * The restart process will later pick them up and
  1624. * re-configure the hw when we reconfigure the BT
  1625. * command.
  1626. */
  1627. bt_full_concurrent = priv->bt_full_concurrent;
  1628. bt_ci_compliance = priv->bt_ci_compliance;
  1629. bt_load = priv->bt_traffic_load;
  1630. bt_status = priv->bt_status;
  1631. bt_is_sco = priv->bt_is_sco;
  1632. __iwl_down(priv);
  1633. priv->bt_full_concurrent = bt_full_concurrent;
  1634. priv->bt_ci_compliance = bt_ci_compliance;
  1635. priv->bt_traffic_load = bt_load;
  1636. priv->bt_status = bt_status;
  1637. priv->bt_is_sco = bt_is_sco;
  1638. }
  1639. static void iwl_bg_restart(struct work_struct *data)
  1640. {
  1641. struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
  1642. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  1643. return;
  1644. if (test_and_clear_bit(STATUS_FW_ERROR, &priv->status)) {
  1645. mutex_lock(&priv->mutex);
  1646. iwlagn_prepare_restart(priv);
  1647. mutex_unlock(&priv->mutex);
  1648. iwl_cancel_deferred_work(priv);
  1649. ieee80211_restart_hw(priv->hw);
  1650. } else {
  1651. WARN_ON(1);
  1652. }
  1653. }
  1654. static int iwl_mac_offchannel_tx(struct ieee80211_hw *hw, struct sk_buff *skb,
  1655. struct ieee80211_channel *chan,
  1656. enum nl80211_channel_type channel_type,
  1657. unsigned int wait)
  1658. {
  1659. struct iwl_priv *priv = hw->priv;
  1660. int ret;
  1661. /* Not supported if we don't have PAN */
  1662. if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN))) {
  1663. ret = -EOPNOTSUPP;
  1664. goto free;
  1665. }
  1666. /* Not supported on pre-P2P firmware */
  1667. if (!(priv->contexts[IWL_RXON_CTX_PAN].interface_modes &
  1668. BIT(NL80211_IFTYPE_P2P_CLIENT))) {
  1669. ret = -EOPNOTSUPP;
  1670. goto free;
  1671. }
  1672. mutex_lock(&priv->mutex);
  1673. if (!priv->contexts[IWL_RXON_CTX_PAN].is_active) {
  1674. /*
  1675. * If the PAN context is free, use the normal
  1676. * way of doing remain-on-channel offload + TX.
  1677. */
  1678. ret = 1;
  1679. goto out;
  1680. }
  1681. /* TODO: queue up if scanning? */
  1682. if (test_bit(STATUS_SCANNING, &priv->status) ||
  1683. priv->_agn.offchan_tx_skb) {
  1684. ret = -EBUSY;
  1685. goto out;
  1686. }
  1687. /*
  1688. * max_scan_ie_len doesn't include the blank SSID or the header,
  1689. * so need to add that again here.
  1690. */
  1691. if (skb->len > hw->wiphy->max_scan_ie_len + 24 + 2) {
  1692. ret = -ENOBUFS;
  1693. goto out;
  1694. }
  1695. priv->_agn.offchan_tx_skb = skb;
  1696. priv->_agn.offchan_tx_timeout = wait;
  1697. priv->_agn.offchan_tx_chan = chan;
  1698. ret = iwl_scan_initiate(priv, priv->contexts[IWL_RXON_CTX_PAN].vif,
  1699. IWL_SCAN_OFFCH_TX, chan->band);
  1700. if (ret)
  1701. priv->_agn.offchan_tx_skb = NULL;
  1702. out:
  1703. mutex_unlock(&priv->mutex);
  1704. free:
  1705. if (ret < 0)
  1706. kfree_skb(skb);
  1707. return ret;
  1708. }
  1709. static int iwl_mac_offchannel_tx_cancel_wait(struct ieee80211_hw *hw)
  1710. {
  1711. struct iwl_priv *priv = hw->priv;
  1712. int ret;
  1713. mutex_lock(&priv->mutex);
  1714. if (!priv->_agn.offchan_tx_skb) {
  1715. ret = -EINVAL;
  1716. goto unlock;
  1717. }
  1718. priv->_agn.offchan_tx_skb = NULL;
  1719. ret = iwl_scan_cancel_timeout(priv, 200);
  1720. if (ret)
  1721. ret = -EIO;
  1722. unlock:
  1723. mutex_unlock(&priv->mutex);
  1724. return ret;
  1725. }
  1726. /*****************************************************************************
  1727. *
  1728. * mac80211 entry point functions
  1729. *
  1730. *****************************************************************************/
  1731. static const struct ieee80211_iface_limit iwlagn_sta_ap_limits[] = {
  1732. {
  1733. .max = 1,
  1734. .types = BIT(NL80211_IFTYPE_STATION),
  1735. },
  1736. {
  1737. .max = 1,
  1738. .types = BIT(NL80211_IFTYPE_AP),
  1739. },
  1740. };
  1741. static const struct ieee80211_iface_limit iwlagn_2sta_limits[] = {
  1742. {
  1743. .max = 2,
  1744. .types = BIT(NL80211_IFTYPE_STATION),
  1745. },
  1746. };
  1747. static const struct ieee80211_iface_limit iwlagn_p2p_sta_go_limits[] = {
  1748. {
  1749. .max = 1,
  1750. .types = BIT(NL80211_IFTYPE_STATION),
  1751. },
  1752. {
  1753. .max = 1,
  1754. .types = BIT(NL80211_IFTYPE_P2P_GO) |
  1755. BIT(NL80211_IFTYPE_AP),
  1756. },
  1757. };
  1758. static const struct ieee80211_iface_limit iwlagn_p2p_2sta_limits[] = {
  1759. {
  1760. .max = 2,
  1761. .types = BIT(NL80211_IFTYPE_STATION),
  1762. },
  1763. {
  1764. .max = 1,
  1765. .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
  1766. },
  1767. };
  1768. static const struct ieee80211_iface_combination
  1769. iwlagn_iface_combinations_dualmode[] = {
  1770. { .num_different_channels = 1,
  1771. .max_interfaces = 2,
  1772. .beacon_int_infra_match = true,
  1773. .limits = iwlagn_sta_ap_limits,
  1774. .n_limits = ARRAY_SIZE(iwlagn_sta_ap_limits),
  1775. },
  1776. { .num_different_channels = 1,
  1777. .max_interfaces = 2,
  1778. .limits = iwlagn_2sta_limits,
  1779. .n_limits = ARRAY_SIZE(iwlagn_2sta_limits),
  1780. },
  1781. };
  1782. static const struct ieee80211_iface_combination
  1783. iwlagn_iface_combinations_p2p[] = {
  1784. { .num_different_channels = 1,
  1785. .max_interfaces = 2,
  1786. .beacon_int_infra_match = true,
  1787. .limits = iwlagn_p2p_sta_go_limits,
  1788. .n_limits = ARRAY_SIZE(iwlagn_p2p_sta_go_limits),
  1789. },
  1790. { .num_different_channels = 1,
  1791. .max_interfaces = 2,
  1792. .limits = iwlagn_p2p_2sta_limits,
  1793. .n_limits = ARRAY_SIZE(iwlagn_p2p_2sta_limits),
  1794. },
  1795. };
  1796. /*
  1797. * Not a mac80211 entry point function, but it fits in with all the
  1798. * other mac80211 functions grouped here.
  1799. */
  1800. static int iwl_mac_setup_register(struct iwl_priv *priv,
  1801. struct iwlagn_ucode_capabilities *capa)
  1802. {
  1803. int ret;
  1804. struct ieee80211_hw *hw = priv->hw;
  1805. struct iwl_rxon_context *ctx;
  1806. hw->rate_control_algorithm = "iwl-agn-rs";
  1807. /* Tell mac80211 our characteristics */
  1808. hw->flags = IEEE80211_HW_SIGNAL_DBM |
  1809. IEEE80211_HW_AMPDU_AGGREGATION |
  1810. IEEE80211_HW_NEED_DTIM_PERIOD |
  1811. IEEE80211_HW_SPECTRUM_MGMT |
  1812. IEEE80211_HW_REPORTS_TX_ACK_STATUS;
  1813. hw->max_tx_aggregation_subframes = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
  1814. hw->flags |= IEEE80211_HW_SUPPORTS_PS |
  1815. IEEE80211_HW_SUPPORTS_DYNAMIC_PS;
  1816. if (priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE)
  1817. hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
  1818. IEEE80211_HW_SUPPORTS_STATIC_SMPS;
  1819. if (capa->flags & IWL_UCODE_TLV_FLAGS_MFP)
  1820. hw->flags |= IEEE80211_HW_MFP_CAPABLE;
  1821. hw->sta_data_size = sizeof(struct iwl_station_priv);
  1822. hw->vif_data_size = sizeof(struct iwl_vif_priv);
  1823. for_each_context(priv, ctx) {
  1824. hw->wiphy->interface_modes |= ctx->interface_modes;
  1825. hw->wiphy->interface_modes |= ctx->exclusive_interface_modes;
  1826. }
  1827. BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
  1828. if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)) {
  1829. hw->wiphy->iface_combinations = iwlagn_iface_combinations_p2p;
  1830. hw->wiphy->n_iface_combinations =
  1831. ARRAY_SIZE(iwlagn_iface_combinations_p2p);
  1832. } else if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
  1833. hw->wiphy->iface_combinations = iwlagn_iface_combinations_dualmode;
  1834. hw->wiphy->n_iface_combinations =
  1835. ARRAY_SIZE(iwlagn_iface_combinations_dualmode);
  1836. }
  1837. hw->wiphy->max_remain_on_channel_duration = 1000;
  1838. hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY |
  1839. WIPHY_FLAG_DISABLE_BEACON_HINTS |
  1840. WIPHY_FLAG_IBSS_RSN;
  1841. if (iwlagn_mod_params.power_save)
  1842. hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
  1843. else
  1844. hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
  1845. hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
  1846. /* we create the 802.11 header and a zero-length SSID element */
  1847. hw->wiphy->max_scan_ie_len = capa->max_probe_length - 24 - 2;
  1848. /* Default value; 4 EDCA QOS priorities */
  1849. hw->queues = 4;
  1850. hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
  1851. if (priv->bands[IEEE80211_BAND_2GHZ].n_channels)
  1852. priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
  1853. &priv->bands[IEEE80211_BAND_2GHZ];
  1854. if (priv->bands[IEEE80211_BAND_5GHZ].n_channels)
  1855. priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
  1856. &priv->bands[IEEE80211_BAND_5GHZ];
  1857. iwl_leds_init(priv);
  1858. ret = ieee80211_register_hw(priv->hw);
  1859. if (ret) {
  1860. IWL_ERR(priv, "Failed to register hw (error %d)\n", ret);
  1861. return ret;
  1862. }
  1863. priv->mac80211_registered = 1;
  1864. return 0;
  1865. }
  1866. static int iwlagn_mac_start(struct ieee80211_hw *hw)
  1867. {
  1868. struct iwl_priv *priv = hw->priv;
  1869. int ret;
  1870. IWL_DEBUG_MAC80211(priv, "enter\n");
  1871. /* we should be verifying the device is ready to be opened */
  1872. mutex_lock(&priv->mutex);
  1873. ret = __iwl_up(priv);
  1874. mutex_unlock(&priv->mutex);
  1875. if (ret)
  1876. return ret;
  1877. IWL_DEBUG_INFO(priv, "Start UP work done.\n");
  1878. /* Now we should be done, and the READY bit should be set. */
  1879. if (WARN_ON(!test_bit(STATUS_READY, &priv->status)))
  1880. ret = -EIO;
  1881. iwlagn_led_enable(priv);
  1882. priv->is_open = 1;
  1883. IWL_DEBUG_MAC80211(priv, "leave\n");
  1884. return 0;
  1885. }
  1886. static void iwlagn_mac_stop(struct ieee80211_hw *hw)
  1887. {
  1888. struct iwl_priv *priv = hw->priv;
  1889. IWL_DEBUG_MAC80211(priv, "enter\n");
  1890. if (!priv->is_open)
  1891. return;
  1892. priv->is_open = 0;
  1893. iwl_down(priv);
  1894. flush_workqueue(priv->workqueue);
  1895. /* User space software may expect getting rfkill changes
  1896. * even if interface is down */
  1897. iwl_write32(priv, CSR_INT, 0xFFFFFFFF);
  1898. iwl_enable_rfkill_int(priv);
  1899. IWL_DEBUG_MAC80211(priv, "leave\n");
  1900. }
  1901. static void iwlagn_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
  1902. {
  1903. struct iwl_priv *priv = hw->priv;
  1904. IWL_DEBUG_MACDUMP(priv, "enter\n");
  1905. IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
  1906. ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
  1907. if (iwlagn_tx_skb(priv, skb))
  1908. dev_kfree_skb_any(skb);
  1909. IWL_DEBUG_MACDUMP(priv, "leave\n");
  1910. }
  1911. static void iwlagn_mac_update_tkip_key(struct ieee80211_hw *hw,
  1912. struct ieee80211_vif *vif,
  1913. struct ieee80211_key_conf *keyconf,
  1914. struct ieee80211_sta *sta,
  1915. u32 iv32, u16 *phase1key)
  1916. {
  1917. struct iwl_priv *priv = hw->priv;
  1918. struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
  1919. IWL_DEBUG_MAC80211(priv, "enter\n");
  1920. iwl_update_tkip_key(priv, vif_priv->ctx, keyconf, sta,
  1921. iv32, phase1key);
  1922. IWL_DEBUG_MAC80211(priv, "leave\n");
  1923. }
  1924. static int iwlagn_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
  1925. struct ieee80211_vif *vif,
  1926. struct ieee80211_sta *sta,
  1927. struct ieee80211_key_conf *key)
  1928. {
  1929. struct iwl_priv *priv = hw->priv;
  1930. struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
  1931. struct iwl_rxon_context *ctx = vif_priv->ctx;
  1932. int ret;
  1933. u8 sta_id;
  1934. bool is_default_wep_key = false;
  1935. IWL_DEBUG_MAC80211(priv, "enter\n");
  1936. if (iwlagn_mod_params.sw_crypto) {
  1937. IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
  1938. return -EOPNOTSUPP;
  1939. }
  1940. /*
  1941. * To support IBSS RSN, don't program group keys in IBSS, the
  1942. * hardware will then not attempt to decrypt the frames.
  1943. */
  1944. if (vif->type == NL80211_IFTYPE_ADHOC &&
  1945. !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
  1946. return -EOPNOTSUPP;
  1947. sta_id = iwl_sta_id_or_broadcast(priv, vif_priv->ctx, sta);
  1948. if (sta_id == IWL_INVALID_STATION)
  1949. return -EINVAL;
  1950. mutex_lock(&priv->mutex);
  1951. iwl_scan_cancel_timeout(priv, 100);
  1952. /*
  1953. * If we are getting WEP group key and we didn't receive any key mapping
  1954. * so far, we are in legacy wep mode (group key only), otherwise we are
  1955. * in 1X mode.
  1956. * In legacy wep mode, we use another host command to the uCode.
  1957. */
  1958. if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
  1959. key->cipher == WLAN_CIPHER_SUITE_WEP104) &&
  1960. !sta) {
  1961. if (cmd == SET_KEY)
  1962. is_default_wep_key = !ctx->key_mapping_keys;
  1963. else
  1964. is_default_wep_key =
  1965. (key->hw_key_idx == HW_KEY_DEFAULT);
  1966. }
  1967. switch (cmd) {
  1968. case SET_KEY:
  1969. if (is_default_wep_key)
  1970. ret = iwl_set_default_wep_key(priv, vif_priv->ctx, key);
  1971. else
  1972. ret = iwl_set_dynamic_key(priv, vif_priv->ctx,
  1973. key, sta_id);
  1974. IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
  1975. break;
  1976. case DISABLE_KEY:
  1977. if (is_default_wep_key)
  1978. ret = iwl_remove_default_wep_key(priv, ctx, key);
  1979. else
  1980. ret = iwl_remove_dynamic_key(priv, ctx, key, sta_id);
  1981. IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
  1982. break;
  1983. default:
  1984. ret = -EINVAL;
  1985. }
  1986. mutex_unlock(&priv->mutex);
  1987. IWL_DEBUG_MAC80211(priv, "leave\n");
  1988. return ret;
  1989. }
  1990. static int iwlagn_mac_ampdu_action(struct ieee80211_hw *hw,
  1991. struct ieee80211_vif *vif,
  1992. enum ieee80211_ampdu_mlme_action action,
  1993. struct ieee80211_sta *sta, u16 tid, u16 *ssn,
  1994. u8 buf_size)
  1995. {
  1996. struct iwl_priv *priv = hw->priv;
  1997. int ret = -EINVAL;
  1998. struct iwl_station_priv *sta_priv = (void *) sta->drv_priv;
  1999. IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n",
  2000. sta->addr, tid);
  2001. if (!(priv->cfg->sku & EEPROM_SKU_CAP_11N_ENABLE))
  2002. return -EACCES;
  2003. mutex_lock(&priv->mutex);
  2004. switch (action) {
  2005. case IEEE80211_AMPDU_RX_START:
  2006. IWL_DEBUG_HT(priv, "start Rx\n");
  2007. ret = iwl_sta_rx_agg_start(priv, sta, tid, *ssn);
  2008. break;
  2009. case IEEE80211_AMPDU_RX_STOP:
  2010. IWL_DEBUG_HT(priv, "stop Rx\n");
  2011. ret = iwl_sta_rx_agg_stop(priv, sta, tid);
  2012. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  2013. ret = 0;
  2014. break;
  2015. case IEEE80211_AMPDU_TX_START:
  2016. IWL_DEBUG_HT(priv, "start Tx\n");
  2017. ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn);
  2018. if (ret == 0) {
  2019. priv->_agn.agg_tids_count++;
  2020. IWL_DEBUG_HT(priv, "priv->_agn.agg_tids_count = %u\n",
  2021. priv->_agn.agg_tids_count);
  2022. }
  2023. break;
  2024. case IEEE80211_AMPDU_TX_STOP:
  2025. IWL_DEBUG_HT(priv, "stop Tx\n");
  2026. ret = iwlagn_tx_agg_stop(priv, vif, sta, tid);
  2027. if ((ret == 0) && (priv->_agn.agg_tids_count > 0)) {
  2028. priv->_agn.agg_tids_count--;
  2029. IWL_DEBUG_HT(priv, "priv->_agn.agg_tids_count = %u\n",
  2030. priv->_agn.agg_tids_count);
  2031. }
  2032. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  2033. ret = 0;
  2034. if (priv->cfg->ht_params &&
  2035. priv->cfg->ht_params->use_rts_for_aggregation) {
  2036. /*
  2037. * switch off RTS/CTS if it was previously enabled
  2038. */
  2039. sta_priv->lq_sta.lq.general_params.flags &=
  2040. ~LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
  2041. iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
  2042. &sta_priv->lq_sta.lq, CMD_ASYNC, false);
  2043. }
  2044. break;
  2045. case IEEE80211_AMPDU_TX_OPERATIONAL:
  2046. buf_size = min_t(int, buf_size, LINK_QUAL_AGG_FRAME_LIMIT_DEF);
  2047. trans_txq_agg_setup(&priv->trans, iwl_sta_id(sta), tid,
  2048. buf_size);
  2049. /*
  2050. * If the limit is 0, then it wasn't initialised yet,
  2051. * use the default. We can do that since we take the
  2052. * minimum below, and we don't want to go above our
  2053. * default due to hardware restrictions.
  2054. */
  2055. if (sta_priv->max_agg_bufsize == 0)
  2056. sta_priv->max_agg_bufsize =
  2057. LINK_QUAL_AGG_FRAME_LIMIT_DEF;
  2058. /*
  2059. * Even though in theory the peer could have different
  2060. * aggregation reorder buffer sizes for different sessions,
  2061. * our ucode doesn't allow for that and has a global limit
  2062. * for each station. Therefore, use the minimum of all the
  2063. * aggregation sessions and our default value.
  2064. */
  2065. sta_priv->max_agg_bufsize =
  2066. min(sta_priv->max_agg_bufsize, buf_size);
  2067. if (priv->cfg->ht_params &&
  2068. priv->cfg->ht_params->use_rts_for_aggregation) {
  2069. /*
  2070. * switch to RTS/CTS if it is the prefer protection
  2071. * method for HT traffic
  2072. */
  2073. sta_priv->lq_sta.lq.general_params.flags |=
  2074. LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
  2075. }
  2076. sta_priv->lq_sta.lq.agg_params.agg_frame_cnt_limit =
  2077. sta_priv->max_agg_bufsize;
  2078. iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
  2079. &sta_priv->lq_sta.lq, CMD_ASYNC, false);
  2080. IWL_INFO(priv, "Tx aggregation enabled on ra = %pM tid = %d\n",
  2081. sta->addr, tid);
  2082. ret = 0;
  2083. break;
  2084. }
  2085. mutex_unlock(&priv->mutex);
  2086. return ret;
  2087. }
  2088. static int iwlagn_mac_sta_add(struct ieee80211_hw *hw,
  2089. struct ieee80211_vif *vif,
  2090. struct ieee80211_sta *sta)
  2091. {
  2092. struct iwl_priv *priv = hw->priv;
  2093. struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
  2094. struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
  2095. bool is_ap = vif->type == NL80211_IFTYPE_STATION;
  2096. int ret;
  2097. u8 sta_id;
  2098. IWL_DEBUG_INFO(priv, "received request to add station %pM\n",
  2099. sta->addr);
  2100. mutex_lock(&priv->mutex);
  2101. IWL_DEBUG_INFO(priv, "proceeding to add station %pM\n",
  2102. sta->addr);
  2103. sta_priv->common.sta_id = IWL_INVALID_STATION;
  2104. atomic_set(&sta_priv->pending_frames, 0);
  2105. if (vif->type == NL80211_IFTYPE_AP)
  2106. sta_priv->client = true;
  2107. ret = iwl_add_station_common(priv, vif_priv->ctx, sta->addr,
  2108. is_ap, sta, &sta_id);
  2109. if (ret) {
  2110. IWL_ERR(priv, "Unable to add station %pM (%d)\n",
  2111. sta->addr, ret);
  2112. /* Should we return success if return code is EEXIST ? */
  2113. mutex_unlock(&priv->mutex);
  2114. return ret;
  2115. }
  2116. sta_priv->common.sta_id = sta_id;
  2117. /* Initialize rate scaling */
  2118. IWL_DEBUG_INFO(priv, "Initializing rate scaling for station %pM\n",
  2119. sta->addr);
  2120. iwl_rs_rate_init(priv, sta, sta_id);
  2121. mutex_unlock(&priv->mutex);
  2122. return 0;
  2123. }
  2124. static void iwlagn_mac_channel_switch(struct ieee80211_hw *hw,
  2125. struct ieee80211_channel_switch *ch_switch)
  2126. {
  2127. struct iwl_priv *priv = hw->priv;
  2128. const struct iwl_channel_info *ch_info;
  2129. struct ieee80211_conf *conf = &hw->conf;
  2130. struct ieee80211_channel *channel = ch_switch->channel;
  2131. struct iwl_ht_config *ht_conf = &priv->current_ht_config;
  2132. /*
  2133. * MULTI-FIXME
  2134. * When we add support for multiple interfaces, we need to
  2135. * revisit this. The channel switch command in the device
  2136. * only affects the BSS context, but what does that really
  2137. * mean? And what if we get a CSA on the second interface?
  2138. * This needs a lot of work.
  2139. */
  2140. struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
  2141. u16 ch;
  2142. IWL_DEBUG_MAC80211(priv, "enter\n");
  2143. mutex_lock(&priv->mutex);
  2144. if (iwl_is_rfkill(priv))
  2145. goto out;
  2146. if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
  2147. test_bit(STATUS_SCANNING, &priv->status) ||
  2148. test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status))
  2149. goto out;
  2150. if (!iwl_is_associated_ctx(ctx))
  2151. goto out;
  2152. if (!priv->cfg->lib->set_channel_switch)
  2153. goto out;
  2154. ch = channel->hw_value;
  2155. if (le16_to_cpu(ctx->active.channel) == ch)
  2156. goto out;
  2157. ch_info = iwl_get_channel_info(priv, channel->band, ch);
  2158. if (!is_channel_valid(ch_info)) {
  2159. IWL_DEBUG_MAC80211(priv, "invalid channel\n");
  2160. goto out;
  2161. }
  2162. spin_lock_irq(&priv->lock);
  2163. priv->current_ht_config.smps = conf->smps_mode;
  2164. /* Configure HT40 channels */
  2165. ctx->ht.enabled = conf_is_ht(conf);
  2166. if (ctx->ht.enabled) {
  2167. if (conf_is_ht40_minus(conf)) {
  2168. ctx->ht.extension_chan_offset =
  2169. IEEE80211_HT_PARAM_CHA_SEC_BELOW;
  2170. ctx->ht.is_40mhz = true;
  2171. } else if (conf_is_ht40_plus(conf)) {
  2172. ctx->ht.extension_chan_offset =
  2173. IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
  2174. ctx->ht.is_40mhz = true;
  2175. } else {
  2176. ctx->ht.extension_chan_offset =
  2177. IEEE80211_HT_PARAM_CHA_SEC_NONE;
  2178. ctx->ht.is_40mhz = false;
  2179. }
  2180. } else
  2181. ctx->ht.is_40mhz = false;
  2182. if ((le16_to_cpu(ctx->staging.channel) != ch))
  2183. ctx->staging.flags = 0;
  2184. iwl_set_rxon_channel(priv, channel, ctx);
  2185. iwl_set_rxon_ht(priv, ht_conf);
  2186. iwl_set_flags_for_band(priv, ctx, channel->band, ctx->vif);
  2187. spin_unlock_irq(&priv->lock);
  2188. iwl_set_rate(priv);
  2189. /*
  2190. * at this point, staging_rxon has the
  2191. * configuration for channel switch
  2192. */
  2193. set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
  2194. priv->switch_channel = cpu_to_le16(ch);
  2195. if (priv->cfg->lib->set_channel_switch(priv, ch_switch)) {
  2196. clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
  2197. priv->switch_channel = 0;
  2198. ieee80211_chswitch_done(ctx->vif, false);
  2199. }
  2200. out:
  2201. mutex_unlock(&priv->mutex);
  2202. IWL_DEBUG_MAC80211(priv, "leave\n");
  2203. }
  2204. static void iwlagn_configure_filter(struct ieee80211_hw *hw,
  2205. unsigned int changed_flags,
  2206. unsigned int *total_flags,
  2207. u64 multicast)
  2208. {
  2209. struct iwl_priv *priv = hw->priv;
  2210. __le32 filter_or = 0, filter_nand = 0;
  2211. struct iwl_rxon_context *ctx;
  2212. #define CHK(test, flag) do { \
  2213. if (*total_flags & (test)) \
  2214. filter_or |= (flag); \
  2215. else \
  2216. filter_nand |= (flag); \
  2217. } while (0)
  2218. IWL_DEBUG_MAC80211(priv, "Enter: changed: 0x%x, total: 0x%x\n",
  2219. changed_flags, *total_flags);
  2220. CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK);
  2221. /* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
  2222. CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
  2223. CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
  2224. #undef CHK
  2225. mutex_lock(&priv->mutex);
  2226. for_each_context(priv, ctx) {
  2227. ctx->staging.filter_flags &= ~filter_nand;
  2228. ctx->staging.filter_flags |= filter_or;
  2229. /*
  2230. * Not committing directly because hardware can perform a scan,
  2231. * but we'll eventually commit the filter flags change anyway.
  2232. */
  2233. }
  2234. mutex_unlock(&priv->mutex);
  2235. /*
  2236. * Receiving all multicast frames is always enabled by the
  2237. * default flags setup in iwl_connection_init_rx_config()
  2238. * since we currently do not support programming multicast
  2239. * filters into the device.
  2240. */
  2241. *total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
  2242. FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
  2243. }
  2244. static void iwlagn_mac_flush(struct ieee80211_hw *hw, bool drop)
  2245. {
  2246. struct iwl_priv *priv = hw->priv;
  2247. mutex_lock(&priv->mutex);
  2248. IWL_DEBUG_MAC80211(priv, "enter\n");
  2249. if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
  2250. IWL_DEBUG_TX(priv, "Aborting flush due to device shutdown\n");
  2251. goto done;
  2252. }
  2253. if (iwl_is_rfkill(priv)) {
  2254. IWL_DEBUG_TX(priv, "Aborting flush due to RF Kill\n");
  2255. goto done;
  2256. }
  2257. /*
  2258. * mac80211 will not push any more frames for transmit
  2259. * until the flush is completed
  2260. */
  2261. if (drop) {
  2262. IWL_DEBUG_MAC80211(priv, "send flush command\n");
  2263. if (iwlagn_txfifo_flush(priv, IWL_DROP_ALL)) {
  2264. IWL_ERR(priv, "flush request fail\n");
  2265. goto done;
  2266. }
  2267. }
  2268. IWL_DEBUG_MAC80211(priv, "wait transmit/flush all frames\n");
  2269. iwlagn_wait_tx_queue_empty(priv);
  2270. done:
  2271. mutex_unlock(&priv->mutex);
  2272. IWL_DEBUG_MAC80211(priv, "leave\n");
  2273. }
  2274. static void iwlagn_disable_roc(struct iwl_priv *priv)
  2275. {
  2276. struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];
  2277. struct ieee80211_channel *chan = ACCESS_ONCE(priv->hw->conf.channel);
  2278. lockdep_assert_held(&priv->mutex);
  2279. if (!ctx->is_active)
  2280. return;
  2281. ctx->staging.dev_type = RXON_DEV_TYPE_2STA;
  2282. ctx->staging.filter_flags &= ~RXON_FILTER_ASSOC_MSK;
  2283. iwl_set_rxon_channel(priv, chan, ctx);
  2284. iwl_set_flags_for_band(priv, ctx, chan->band, NULL);
  2285. priv->_agn.hw_roc_channel = NULL;
  2286. iwlagn_commit_rxon(priv, ctx);
  2287. ctx->is_active = false;
  2288. }
  2289. static void iwlagn_bg_roc_done(struct work_struct *work)
  2290. {
  2291. struct iwl_priv *priv = container_of(work, struct iwl_priv,
  2292. _agn.hw_roc_work.work);
  2293. mutex_lock(&priv->mutex);
  2294. ieee80211_remain_on_channel_expired(priv->hw);
  2295. iwlagn_disable_roc(priv);
  2296. mutex_unlock(&priv->mutex);
  2297. }
  2298. static int iwl_mac_remain_on_channel(struct ieee80211_hw *hw,
  2299. struct ieee80211_channel *channel,
  2300. enum nl80211_channel_type channel_type,
  2301. int duration)
  2302. {
  2303. struct iwl_priv *priv = hw->priv;
  2304. int err = 0;
  2305. if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
  2306. return -EOPNOTSUPP;
  2307. if (!(priv->contexts[IWL_RXON_CTX_PAN].interface_modes &
  2308. BIT(NL80211_IFTYPE_P2P_CLIENT)))
  2309. return -EOPNOTSUPP;
  2310. mutex_lock(&priv->mutex);
  2311. if (priv->contexts[IWL_RXON_CTX_PAN].is_active ||
  2312. test_bit(STATUS_SCAN_HW, &priv->status)) {
  2313. err = -EBUSY;
  2314. goto out;
  2315. }
  2316. priv->contexts[IWL_RXON_CTX_PAN].is_active = true;
  2317. priv->_agn.hw_roc_channel = channel;
  2318. priv->_agn.hw_roc_chantype = channel_type;
  2319. priv->_agn.hw_roc_duration = DIV_ROUND_UP(duration * 1000, 1024);
  2320. iwlagn_commit_rxon(priv, &priv->contexts[IWL_RXON_CTX_PAN]);
  2321. queue_delayed_work(priv->workqueue, &priv->_agn.hw_roc_work,
  2322. msecs_to_jiffies(duration + 20));
  2323. msleep(IWL_MIN_SLOT_TIME); /* TU is almost ms */
  2324. ieee80211_ready_on_channel(priv->hw);
  2325. out:
  2326. mutex_unlock(&priv->mutex);
  2327. return err;
  2328. }
  2329. static int iwl_mac_cancel_remain_on_channel(struct ieee80211_hw *hw)
  2330. {
  2331. struct iwl_priv *priv = hw->priv;
  2332. if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
  2333. return -EOPNOTSUPP;
  2334. cancel_delayed_work_sync(&priv->_agn.hw_roc_work);
  2335. mutex_lock(&priv->mutex);
  2336. iwlagn_disable_roc(priv);
  2337. mutex_unlock(&priv->mutex);
  2338. return 0;
  2339. }
  2340. /*****************************************************************************
  2341. *
  2342. * driver setup and teardown
  2343. *
  2344. *****************************************************************************/
  2345. static void iwl_setup_deferred_work(struct iwl_priv *priv)
  2346. {
  2347. priv->workqueue = create_singlethread_workqueue(DRV_NAME);
  2348. init_waitqueue_head(&priv->wait_command_queue);
  2349. INIT_WORK(&priv->restart, iwl_bg_restart);
  2350. INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
  2351. INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
  2352. INIT_WORK(&priv->tx_flush, iwl_bg_tx_flush);
  2353. INIT_WORK(&priv->bt_full_concurrency, iwl_bg_bt_full_concurrency);
  2354. INIT_WORK(&priv->bt_runtime_config, iwl_bg_bt_runtime_config);
  2355. INIT_DELAYED_WORK(&priv->_agn.hw_roc_work, iwlagn_bg_roc_done);
  2356. iwl_setup_scan_deferred_work(priv);
  2357. if (priv->cfg->lib->bt_setup_deferred_work)
  2358. priv->cfg->lib->bt_setup_deferred_work(priv);
  2359. init_timer(&priv->statistics_periodic);
  2360. priv->statistics_periodic.data = (unsigned long)priv;
  2361. priv->statistics_periodic.function = iwl_bg_statistics_periodic;
  2362. init_timer(&priv->ucode_trace);
  2363. priv->ucode_trace.data = (unsigned long)priv;
  2364. priv->ucode_trace.function = iwl_bg_ucode_trace;
  2365. init_timer(&priv->watchdog);
  2366. priv->watchdog.data = (unsigned long)priv;
  2367. priv->watchdog.function = iwl_bg_watchdog;
  2368. }
  2369. static void iwl_cancel_deferred_work(struct iwl_priv *priv)
  2370. {
  2371. if (priv->cfg->lib->cancel_deferred_work)
  2372. priv->cfg->lib->cancel_deferred_work(priv);
  2373. cancel_work_sync(&priv->run_time_calib_work);
  2374. cancel_work_sync(&priv->beacon_update);
  2375. iwl_cancel_scan_deferred_work(priv);
  2376. cancel_work_sync(&priv->bt_full_concurrency);
  2377. cancel_work_sync(&priv->bt_runtime_config);
  2378. del_timer_sync(&priv->statistics_periodic);
  2379. del_timer_sync(&priv->ucode_trace);
  2380. }
  2381. static void iwl_init_hw_rates(struct iwl_priv *priv,
  2382. struct ieee80211_rate *rates)
  2383. {
  2384. int i;
  2385. for (i = 0; i < IWL_RATE_COUNT_LEGACY; i++) {
  2386. rates[i].bitrate = iwl_rates[i].ieee * 5;
  2387. rates[i].hw_value = i; /* Rate scaling will work on indexes */
  2388. rates[i].hw_value_short = i;
  2389. rates[i].flags = 0;
  2390. if ((i >= IWL_FIRST_CCK_RATE) && (i <= IWL_LAST_CCK_RATE)) {
  2391. /*
  2392. * If CCK != 1M then set short preamble rate flag.
  2393. */
  2394. rates[i].flags |=
  2395. (iwl_rates[i].plcp == IWL_RATE_1M_PLCP) ?
  2396. 0 : IEEE80211_RATE_SHORT_PREAMBLE;
  2397. }
  2398. }
  2399. }
  2400. static int iwl_init_drv(struct iwl_priv *priv)
  2401. {
  2402. int ret;
  2403. spin_lock_init(&priv->sta_lock);
  2404. spin_lock_init(&priv->hcmd_lock);
  2405. mutex_init(&priv->mutex);
  2406. priv->ieee_channels = NULL;
  2407. priv->ieee_rates = NULL;
  2408. priv->band = IEEE80211_BAND_2GHZ;
  2409. priv->iw_mode = NL80211_IFTYPE_STATION;
  2410. priv->current_ht_config.smps = IEEE80211_SMPS_STATIC;
  2411. priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
  2412. priv->_agn.agg_tids_count = 0;
  2413. /* initialize force reset */
  2414. priv->force_reset[IWL_RF_RESET].reset_duration =
  2415. IWL_DELAY_NEXT_FORCE_RF_RESET;
  2416. priv->force_reset[IWL_FW_RESET].reset_duration =
  2417. IWL_DELAY_NEXT_FORCE_FW_RELOAD;
  2418. priv->rx_statistics_jiffies = jiffies;
  2419. /* Choose which receivers/antennas to use */
  2420. iwlagn_set_rxon_chain(priv, &priv->contexts[IWL_RXON_CTX_BSS]);
  2421. iwl_init_scan_params(priv);
  2422. /* init bt coex */
  2423. if (priv->cfg->bt_params &&
  2424. priv->cfg->bt_params->advanced_bt_coexist) {
  2425. priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
  2426. priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
  2427. priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
  2428. priv->bt_on_thresh = BT_ON_THRESHOLD_DEF;
  2429. priv->bt_duration = BT_DURATION_LIMIT_DEF;
  2430. priv->dynamic_frag_thresh = BT_FRAG_THRESHOLD_DEF;
  2431. }
  2432. ret = iwl_init_channel_map(priv);
  2433. if (ret) {
  2434. IWL_ERR(priv, "initializing regulatory failed: %d\n", ret);
  2435. goto err;
  2436. }
  2437. ret = iwlcore_init_geos(priv);
  2438. if (ret) {
  2439. IWL_ERR(priv, "initializing geos failed: %d\n", ret);
  2440. goto err_free_channel_map;
  2441. }
  2442. iwl_init_hw_rates(priv, priv->ieee_rates);
  2443. return 0;
  2444. err_free_channel_map:
  2445. iwl_free_channel_map(priv);
  2446. err:
  2447. return ret;
  2448. }
  2449. static void iwl_uninit_drv(struct iwl_priv *priv)
  2450. {
  2451. iwl_calib_free_results(priv);
  2452. iwlcore_free_geos(priv);
  2453. iwl_free_channel_map(priv);
  2454. kfree(priv->scan_cmd);
  2455. kfree(priv->beacon_cmd);
  2456. }
  2457. static void iwl_mac_rssi_callback(struct ieee80211_hw *hw,
  2458. enum ieee80211_rssi_event rssi_event)
  2459. {
  2460. struct iwl_priv *priv = hw->priv;
  2461. mutex_lock(&priv->mutex);
  2462. if (priv->cfg->bt_params &&
  2463. priv->cfg->bt_params->advanced_bt_coexist) {
  2464. if (rssi_event == RSSI_EVENT_LOW)
  2465. priv->bt_enable_pspoll = true;
  2466. else if (rssi_event == RSSI_EVENT_HIGH)
  2467. priv->bt_enable_pspoll = false;
  2468. iwlagn_send_advance_bt_config(priv);
  2469. } else {
  2470. IWL_DEBUG_MAC80211(priv, "Advanced BT coex disabled,"
  2471. "ignoring RSSI callback\n");
  2472. }
  2473. mutex_unlock(&priv->mutex);
  2474. }
  2475. struct ieee80211_ops iwlagn_hw_ops = {
  2476. .tx = iwlagn_mac_tx,
  2477. .start = iwlagn_mac_start,
  2478. .stop = iwlagn_mac_stop,
  2479. .add_interface = iwl_mac_add_interface,
  2480. .remove_interface = iwl_mac_remove_interface,
  2481. .change_interface = iwl_mac_change_interface,
  2482. .config = iwlagn_mac_config,
  2483. .configure_filter = iwlagn_configure_filter,
  2484. .set_key = iwlagn_mac_set_key,
  2485. .update_tkip_key = iwlagn_mac_update_tkip_key,
  2486. .conf_tx = iwl_mac_conf_tx,
  2487. .bss_info_changed = iwlagn_bss_info_changed,
  2488. .ampdu_action = iwlagn_mac_ampdu_action,
  2489. .hw_scan = iwl_mac_hw_scan,
  2490. .sta_notify = iwlagn_mac_sta_notify,
  2491. .sta_add = iwlagn_mac_sta_add,
  2492. .sta_remove = iwl_mac_sta_remove,
  2493. .channel_switch = iwlagn_mac_channel_switch,
  2494. .flush = iwlagn_mac_flush,
  2495. .tx_last_beacon = iwl_mac_tx_last_beacon,
  2496. .remain_on_channel = iwl_mac_remain_on_channel,
  2497. .cancel_remain_on_channel = iwl_mac_cancel_remain_on_channel,
  2498. .offchannel_tx = iwl_mac_offchannel_tx,
  2499. .offchannel_tx_cancel_wait = iwl_mac_offchannel_tx_cancel_wait,
  2500. .rssi_callback = iwl_mac_rssi_callback,
  2501. CFG80211_TESTMODE_CMD(iwl_testmode_cmd)
  2502. CFG80211_TESTMODE_DUMP(iwl_testmode_dump)
  2503. };
  2504. static u32 iwl_hw_detect(struct iwl_priv *priv)
  2505. {
  2506. return iwl_read32(priv, CSR_HW_REV);
  2507. }
  2508. static int iwl_set_hw_params(struct iwl_priv *priv)
  2509. {
  2510. priv->hw_params.max_rxq_size = RX_QUEUE_SIZE;
  2511. priv->hw_params.max_rxq_log = RX_QUEUE_SIZE_LOG;
  2512. if (iwlagn_mod_params.amsdu_size_8K)
  2513. priv->hw_params.rx_page_order = get_order(IWL_RX_BUF_SIZE_8K);
  2514. else
  2515. priv->hw_params.rx_page_order = get_order(IWL_RX_BUF_SIZE_4K);
  2516. priv->hw_params.max_beacon_itrvl = IWL_MAX_UCODE_BEACON_INTERVAL;
  2517. if (iwlagn_mod_params.disable_11n)
  2518. priv->cfg->sku &= ~EEPROM_SKU_CAP_11N_ENABLE;
  2519. /* Device-specific setup */
  2520. return priv->cfg->lib->set_hw_params(priv);
  2521. }
  2522. static const u8 iwlagn_bss_ac_to_fifo[] = {
  2523. IWL_TX_FIFO_VO,
  2524. IWL_TX_FIFO_VI,
  2525. IWL_TX_FIFO_BE,
  2526. IWL_TX_FIFO_BK,
  2527. };
  2528. static const u8 iwlagn_bss_ac_to_queue[] = {
  2529. 0, 1, 2, 3,
  2530. };
  2531. static const u8 iwlagn_pan_ac_to_fifo[] = {
  2532. IWL_TX_FIFO_VO_IPAN,
  2533. IWL_TX_FIFO_VI_IPAN,
  2534. IWL_TX_FIFO_BE_IPAN,
  2535. IWL_TX_FIFO_BK_IPAN,
  2536. };
  2537. static const u8 iwlagn_pan_ac_to_queue[] = {
  2538. 7, 6, 5, 4,
  2539. };
  2540. /* This function both allocates and initializes hw and priv. */
  2541. static struct ieee80211_hw *iwl_alloc_all(struct iwl_cfg *cfg)
  2542. {
  2543. struct iwl_priv *priv;
  2544. /* mac80211 allocates memory for this device instance, including
  2545. * space for this driver's private structure */
  2546. struct ieee80211_hw *hw;
  2547. hw = ieee80211_alloc_hw(sizeof(struct iwl_priv), &iwlagn_hw_ops);
  2548. if (hw == NULL) {
  2549. pr_err("%s: Can not allocate network device\n",
  2550. cfg->name);
  2551. goto out;
  2552. }
  2553. priv = hw->priv;
  2554. priv->hw = hw;
  2555. out:
  2556. return hw;
  2557. }
  2558. static void iwl_init_context(struct iwl_priv *priv)
  2559. {
  2560. int i;
  2561. /*
  2562. * The default context is always valid,
  2563. * more may be discovered when firmware
  2564. * is loaded.
  2565. */
  2566. priv->valid_contexts = BIT(IWL_RXON_CTX_BSS);
  2567. for (i = 0; i < NUM_IWL_RXON_CTX; i++)
  2568. priv->contexts[i].ctxid = i;
  2569. priv->contexts[IWL_RXON_CTX_BSS].always_active = true;
  2570. priv->contexts[IWL_RXON_CTX_BSS].is_active = true;
  2571. priv->contexts[IWL_RXON_CTX_BSS].rxon_cmd = REPLY_RXON;
  2572. priv->contexts[IWL_RXON_CTX_BSS].rxon_timing_cmd = REPLY_RXON_TIMING;
  2573. priv->contexts[IWL_RXON_CTX_BSS].rxon_assoc_cmd = REPLY_RXON_ASSOC;
  2574. priv->contexts[IWL_RXON_CTX_BSS].qos_cmd = REPLY_QOS_PARAM;
  2575. priv->contexts[IWL_RXON_CTX_BSS].ap_sta_id = IWL_AP_ID;
  2576. priv->contexts[IWL_RXON_CTX_BSS].wep_key_cmd = REPLY_WEPKEY;
  2577. priv->contexts[IWL_RXON_CTX_BSS].ac_to_fifo = iwlagn_bss_ac_to_fifo;
  2578. priv->contexts[IWL_RXON_CTX_BSS].ac_to_queue = iwlagn_bss_ac_to_queue;
  2579. priv->contexts[IWL_RXON_CTX_BSS].exclusive_interface_modes =
  2580. BIT(NL80211_IFTYPE_ADHOC);
  2581. priv->contexts[IWL_RXON_CTX_BSS].interface_modes =
  2582. BIT(NL80211_IFTYPE_STATION);
  2583. priv->contexts[IWL_RXON_CTX_BSS].ap_devtype = RXON_DEV_TYPE_AP;
  2584. priv->contexts[IWL_RXON_CTX_BSS].ibss_devtype = RXON_DEV_TYPE_IBSS;
  2585. priv->contexts[IWL_RXON_CTX_BSS].station_devtype = RXON_DEV_TYPE_ESS;
  2586. priv->contexts[IWL_RXON_CTX_BSS].unused_devtype = RXON_DEV_TYPE_ESS;
  2587. priv->contexts[IWL_RXON_CTX_PAN].rxon_cmd = REPLY_WIPAN_RXON;
  2588. priv->contexts[IWL_RXON_CTX_PAN].rxon_timing_cmd =
  2589. REPLY_WIPAN_RXON_TIMING;
  2590. priv->contexts[IWL_RXON_CTX_PAN].rxon_assoc_cmd =
  2591. REPLY_WIPAN_RXON_ASSOC;
  2592. priv->contexts[IWL_RXON_CTX_PAN].qos_cmd = REPLY_WIPAN_QOS_PARAM;
  2593. priv->contexts[IWL_RXON_CTX_PAN].ap_sta_id = IWL_AP_ID_PAN;
  2594. priv->contexts[IWL_RXON_CTX_PAN].wep_key_cmd = REPLY_WIPAN_WEPKEY;
  2595. priv->contexts[IWL_RXON_CTX_PAN].bcast_sta_id = IWLAGN_PAN_BCAST_ID;
  2596. priv->contexts[IWL_RXON_CTX_PAN].station_flags = STA_FLG_PAN_STATION;
  2597. priv->contexts[IWL_RXON_CTX_PAN].ac_to_fifo = iwlagn_pan_ac_to_fifo;
  2598. priv->contexts[IWL_RXON_CTX_PAN].ac_to_queue = iwlagn_pan_ac_to_queue;
  2599. priv->contexts[IWL_RXON_CTX_PAN].mcast_queue = IWL_IPAN_MCAST_QUEUE;
  2600. priv->contexts[IWL_RXON_CTX_PAN].interface_modes =
  2601. BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP);
  2602. #ifdef CONFIG_IWL_P2P
  2603. priv->contexts[IWL_RXON_CTX_PAN].interface_modes |=
  2604. BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
  2605. #endif
  2606. priv->contexts[IWL_RXON_CTX_PAN].ap_devtype = RXON_DEV_TYPE_CP;
  2607. priv->contexts[IWL_RXON_CTX_PAN].station_devtype = RXON_DEV_TYPE_2STA;
  2608. priv->contexts[IWL_RXON_CTX_PAN].unused_devtype = RXON_DEV_TYPE_P2P;
  2609. BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
  2610. }
  2611. int iwl_probe(void *bus_specific, struct iwl_bus_ops *bus_ops,
  2612. struct iwl_cfg *cfg)
  2613. {
  2614. int err = 0;
  2615. struct iwl_priv *priv;
  2616. struct ieee80211_hw *hw;
  2617. u16 num_mac;
  2618. u32 hw_rev;
  2619. /************************
  2620. * 1. Allocating HW data
  2621. ************************/
  2622. hw = iwl_alloc_all(cfg);
  2623. if (!hw) {
  2624. err = -ENOMEM;
  2625. goto out;
  2626. }
  2627. priv = hw->priv;
  2628. priv->bus.priv = priv;
  2629. priv->bus.bus_specific = bus_specific;
  2630. priv->bus.ops = bus_ops;
  2631. priv->bus.irq = priv->bus.ops->get_irq(&priv->bus);
  2632. priv->bus.ops->set_drv_data(&priv->bus, priv);
  2633. priv->bus.dev = priv->bus.ops->get_dev(&priv->bus);
  2634. /* At this point both hw and priv are allocated. */
  2635. SET_IEEE80211_DEV(hw, priv->bus.dev);
  2636. IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
  2637. priv->cfg = cfg;
  2638. priv->inta_mask = CSR_INI_SET_MASK;
  2639. err = iwl_trans_register(&priv->trans, priv);
  2640. if (err)
  2641. goto out_free_priv;
  2642. /* is antenna coupling more than 35dB ? */
  2643. priv->bt_ant_couple_ok =
  2644. (iwlagn_ant_coupling > IWL_BT_ANTENNA_COUPLING_THRESHOLD) ?
  2645. true : false;
  2646. /* enable/disable bt channel inhibition */
  2647. priv->bt_ch_announce = iwlagn_bt_ch_announce;
  2648. IWL_DEBUG_INFO(priv, "BT channel inhibition is %s\n",
  2649. (priv->bt_ch_announce) ? "On" : "Off");
  2650. if (iwl_alloc_traffic_mem(priv))
  2651. IWL_ERR(priv, "Not enough memory to generate traffic log\n");
  2652. /* these spin locks will be used in apm_ops.init and EEPROM access
  2653. * we should init now
  2654. */
  2655. spin_lock_init(&priv->reg_lock);
  2656. spin_lock_init(&priv->lock);
  2657. /*
  2658. * stop and reset the on-board processor just in case it is in a
  2659. * strange state ... like being left stranded by a primary kernel
  2660. * and this is now the kdump kernel trying to start up
  2661. */
  2662. iwl_write32(priv, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
  2663. /***********************
  2664. * 3. Read REV register
  2665. ***********************/
  2666. hw_rev = iwl_hw_detect(priv);
  2667. IWL_INFO(priv, "Detected %s, REV=0x%X\n",
  2668. priv->cfg->name, hw_rev);
  2669. if (trans_prepare_card_hw(&priv->trans)) {
  2670. err = -EIO;
  2671. IWL_WARN(priv, "Failed, HW not ready\n");
  2672. goto out_free_traffic_mem;
  2673. }
  2674. /*****************
  2675. * 4. Read EEPROM
  2676. *****************/
  2677. /* Read the EEPROM */
  2678. err = iwl_eeprom_init(priv, hw_rev);
  2679. if (err) {
  2680. IWL_ERR(priv, "Unable to init EEPROM\n");
  2681. goto out_free_traffic_mem;
  2682. }
  2683. err = iwl_eeprom_check_version(priv);
  2684. if (err)
  2685. goto out_free_eeprom;
  2686. err = iwl_eeprom_check_sku(priv);
  2687. if (err)
  2688. goto out_free_eeprom;
  2689. /* extract MAC Address */
  2690. iwl_eeprom_get_mac(priv, priv->addresses[0].addr);
  2691. IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->addresses[0].addr);
  2692. priv->hw->wiphy->addresses = priv->addresses;
  2693. priv->hw->wiphy->n_addresses = 1;
  2694. num_mac = iwl_eeprom_query16(priv, EEPROM_NUM_MAC_ADDRESS);
  2695. if (num_mac > 1) {
  2696. memcpy(priv->addresses[1].addr, priv->addresses[0].addr,
  2697. ETH_ALEN);
  2698. priv->addresses[1].addr[5]++;
  2699. priv->hw->wiphy->n_addresses++;
  2700. }
  2701. /* initialize all valid contexts */
  2702. iwl_init_context(priv);
  2703. /************************
  2704. * 5. Setup HW constants
  2705. ************************/
  2706. if (iwl_set_hw_params(priv)) {
  2707. err = -ENOENT;
  2708. IWL_ERR(priv, "failed to set hw parameters\n");
  2709. goto out_free_eeprom;
  2710. }
  2711. /*******************
  2712. * 6. Setup priv
  2713. *******************/
  2714. err = iwl_init_drv(priv);
  2715. if (err)
  2716. goto out_free_eeprom;
  2717. /* At this point both hw and priv are initialized. */
  2718. /********************
  2719. * 7. Setup services
  2720. ********************/
  2721. iwl_setup_deferred_work(priv);
  2722. iwl_setup_rx_handlers(priv);
  2723. iwl_testmode_init(priv);
  2724. /*********************************************
  2725. * 8. Enable interrupts
  2726. *********************************************/
  2727. iwl_enable_rfkill_int(priv);
  2728. /* If platform's RF_KILL switch is NOT set to KILL */
  2729. if (iwl_read32(priv, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
  2730. clear_bit(STATUS_RF_KILL_HW, &priv->status);
  2731. else
  2732. set_bit(STATUS_RF_KILL_HW, &priv->status);
  2733. wiphy_rfkill_set_hw_state(priv->hw->wiphy,
  2734. test_bit(STATUS_RF_KILL_HW, &priv->status));
  2735. iwl_power_initialize(priv);
  2736. iwl_tt_initialize(priv);
  2737. init_completion(&priv->_agn.firmware_loading_complete);
  2738. err = iwl_request_firmware(priv, true);
  2739. if (err)
  2740. goto out_destroy_workqueue;
  2741. return 0;
  2742. out_destroy_workqueue:
  2743. destroy_workqueue(priv->workqueue);
  2744. priv->workqueue = NULL;
  2745. iwl_uninit_drv(priv);
  2746. out_free_eeprom:
  2747. iwl_eeprom_free(priv);
  2748. out_free_traffic_mem:
  2749. iwl_free_traffic_mem(priv);
  2750. trans_free(&priv->trans);
  2751. out_free_priv:
  2752. ieee80211_free_hw(priv->hw);
  2753. out:
  2754. return err;
  2755. }
  2756. void __devexit iwl_remove(struct iwl_priv * priv)
  2757. {
  2758. unsigned long flags;
  2759. wait_for_completion(&priv->_agn.firmware_loading_complete);
  2760. IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
  2761. iwl_dbgfs_unregister(priv);
  2762. sysfs_remove_group(&priv->bus.dev->kobj,
  2763. &iwl_attribute_group);
  2764. /* ieee80211_unregister_hw call wil cause iwl_mac_stop to
  2765. * to be called and iwl_down since we are removing the device
  2766. * we need to set STATUS_EXIT_PENDING bit.
  2767. */
  2768. set_bit(STATUS_EXIT_PENDING, &priv->status);
  2769. iwl_testmode_cleanup(priv);
  2770. iwl_leds_exit(priv);
  2771. if (priv->mac80211_registered) {
  2772. ieee80211_unregister_hw(priv->hw);
  2773. priv->mac80211_registered = 0;
  2774. }
  2775. /* Reset to low power before unloading driver. */
  2776. iwl_apm_stop(priv);
  2777. iwl_tt_exit(priv);
  2778. /* make sure we flush any pending irq or
  2779. * tasklet for the driver
  2780. */
  2781. spin_lock_irqsave(&priv->lock, flags);
  2782. iwl_disable_interrupts(priv);
  2783. spin_unlock_irqrestore(&priv->lock, flags);
  2784. trans_sync_irq(&priv->trans);
  2785. iwl_dealloc_ucode(priv);
  2786. trans_rx_free(&priv->trans);
  2787. trans_tx_free(&priv->trans);
  2788. iwl_eeprom_free(priv);
  2789. /*netif_stop_queue(dev); */
  2790. flush_workqueue(priv->workqueue);
  2791. /* ieee80211_unregister_hw calls iwl_mac_stop, which flushes
  2792. * priv->workqueue... so we can't take down the workqueue
  2793. * until now... */
  2794. destroy_workqueue(priv->workqueue);
  2795. priv->workqueue = NULL;
  2796. iwl_free_traffic_mem(priv);
  2797. trans_free(&priv->trans);
  2798. priv->bus.ops->set_drv_data(&priv->bus, NULL);
  2799. iwl_uninit_drv(priv);
  2800. dev_kfree_skb(priv->beacon_skb);
  2801. ieee80211_free_hw(priv->hw);
  2802. }
  2803. /*****************************************************************************
  2804. *
  2805. * driver and module entry point
  2806. *
  2807. *****************************************************************************/
  2808. static int __init iwl_init(void)
  2809. {
  2810. int ret;
  2811. pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
  2812. pr_info(DRV_COPYRIGHT "\n");
  2813. ret = iwlagn_rate_control_register();
  2814. if (ret) {
  2815. pr_err("Unable to register rate control algorithm: %d\n", ret);
  2816. return ret;
  2817. }
  2818. ret = iwl_pci_register_driver();
  2819. if (ret)
  2820. goto error_register;
  2821. return ret;
  2822. error_register:
  2823. iwlagn_rate_control_unregister();
  2824. return ret;
  2825. }
  2826. static void __exit iwl_exit(void)
  2827. {
  2828. iwl_pci_unregister_driver();
  2829. iwlagn_rate_control_unregister();
  2830. }
  2831. module_exit(iwl_exit);
  2832. module_init(iwl_init);
  2833. #ifdef CONFIG_IWLWIFI_DEBUG
  2834. module_param_named(debug, iwl_debug_level, uint, S_IRUGO | S_IWUSR);
  2835. MODULE_PARM_DESC(debug, "debug output mask");
  2836. #endif
  2837. module_param_named(swcrypto, iwlagn_mod_params.sw_crypto, int, S_IRUGO);
  2838. MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])");
  2839. module_param_named(queues_num, iwlagn_mod_params.num_of_queues, int, S_IRUGO);
  2840. MODULE_PARM_DESC(queues_num, "number of hw queues.");
  2841. module_param_named(11n_disable, iwlagn_mod_params.disable_11n, int, S_IRUGO);
  2842. MODULE_PARM_DESC(11n_disable, "disable 11n functionality");
  2843. module_param_named(amsdu_size_8K, iwlagn_mod_params.amsdu_size_8K,
  2844. int, S_IRUGO);
  2845. MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size");
  2846. module_param_named(fw_restart, iwlagn_mod_params.restart_fw, int, S_IRUGO);
  2847. MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");
  2848. module_param_named(ucode_alternative, iwlagn_wanted_ucode_alternative, int,
  2849. S_IRUGO);
  2850. MODULE_PARM_DESC(ucode_alternative,
  2851. "specify ucode alternative to use from ucode file");
  2852. module_param_named(antenna_coupling, iwlagn_ant_coupling, int, S_IRUGO);
  2853. MODULE_PARM_DESC(antenna_coupling,
  2854. "specify antenna coupling in dB (defualt: 0 dB)");
  2855. module_param_named(bt_ch_inhibition, iwlagn_bt_ch_announce, bool, S_IRUGO);
  2856. MODULE_PARM_DESC(bt_ch_inhibition,
  2857. "Disable BT channel inhibition (default: enable)");
  2858. module_param_named(plcp_check, iwlagn_mod_params.plcp_check, bool, S_IRUGO);
  2859. MODULE_PARM_DESC(plcp_check, "Check plcp health (default: 1 [enabled])");
  2860. module_param_named(ack_check, iwlagn_mod_params.ack_check, bool, S_IRUGO);
  2861. MODULE_PARM_DESC(ack_check, "Check ack health (default: 0 [disabled])");
  2862. module_param_named(wd_disable, iwlagn_mod_params.wd_disable, bool, S_IRUGO);
  2863. MODULE_PARM_DESC(wd_disable,
  2864. "Disable stuck queue watchdog timer (default: 0 [enabled])");
  2865. /*
  2866. * set bt_coex_active to true, uCode will do kill/defer
  2867. * every time the priority line is asserted (BT is sending signals on the
  2868. * priority line in the PCIx).
  2869. * set bt_coex_active to false, uCode will ignore the BT activity and
  2870. * perform the normal operation
  2871. *
  2872. * User might experience transmit issue on some platform due to WiFi/BT
  2873. * co-exist problem. The possible behaviors are:
  2874. * Able to scan and finding all the available AP
  2875. * Not able to associate with any AP
  2876. * On those platforms, WiFi communication can be restored by set
  2877. * "bt_coex_active" module parameter to "false"
  2878. *
  2879. * default: bt_coex_active = true (BT_COEX_ENABLE)
  2880. */
  2881. module_param_named(bt_coex_active, iwlagn_mod_params.bt_coex_active,
  2882. bool, S_IRUGO);
  2883. MODULE_PARM_DESC(bt_coex_active, "enable wifi/bt co-exist (default: enable)");
  2884. module_param_named(led_mode, iwlagn_mod_params.led_mode, int, S_IRUGO);
  2885. MODULE_PARM_DESC(led_mode, "0=system default, "
  2886. "1=On(RF On)/Off(RF Off), 2=blinking (default: 0)");
  2887. module_param_named(power_save, iwlagn_mod_params.power_save,
  2888. bool, S_IRUGO);
  2889. MODULE_PARM_DESC(power_save,
  2890. "enable WiFi power management (default: disable)");
  2891. module_param_named(power_level, iwlagn_mod_params.power_level,
  2892. int, S_IRUGO);
  2893. MODULE_PARM_DESC(power_level,
  2894. "default power save level (range from 1 - 5, default: 1)");
  2895. /*
  2896. * For now, keep using power level 1 instead of automatically
  2897. * adjusting ...
  2898. */
  2899. module_param_named(no_sleep_autoadjust, iwlagn_mod_params.no_sleep_autoadjust,
  2900. bool, S_IRUGO);
  2901. MODULE_PARM_DESC(no_sleep_autoadjust,
  2902. "don't automatically adjust sleep level "
  2903. "according to maximum network latency (default: true)");