main.c 61 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183
  1. /******************************************************************************
  2. *
  3. * Copyright(c) 2003 - 2014 Intel Corporation. All rights reserved.
  4. * Copyright(c) 2015 Intel Deutschland GmbH
  5. *
  6. * Portions of this file are derived from the ipw3945 project, as well
  7. * as portions of the ieee80211 subsystem header files.
  8. *
  9. * This program is free software; you can redistribute it and/or modify it
  10. * under the terms of version 2 of the GNU General Public License as
  11. * published by the Free Software Foundation.
  12. *
  13. * This program is distributed in the hope that it will be useful, but WITHOUT
  14. * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15. * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  16. * more details.
  17. *
  18. * You should have received a copy of the GNU General Public License along with
  19. * this program; if not, write to the Free Software Foundation, Inc.,
  20. * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
  21. *
  22. * The full GNU General Public License is included in this distribution in the
  23. * file called LICENSE.
  24. *
  25. * Contact Information:
  26. * Intel Linux Wireless <linuxwifi@intel.com>
  27. * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  28. *
  29. *****************************************************************************/
  30. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  31. #include <linux/kernel.h>
  32. #include <linux/module.h>
  33. #include <linux/init.h>
  34. #include <linux/slab.h>
  35. #include <linux/delay.h>
  36. #include <linux/sched.h>
  37. #include <linux/skbuff.h>
  38. #include <linux/netdevice.h>
  39. #include <linux/etherdevice.h>
  40. #include <linux/if_arp.h>
  41. #include <net/mac80211.h>
  42. #include <asm/div64.h>
  43. #include "iwl-eeprom-read.h"
  44. #include "iwl-eeprom-parse.h"
  45. #include "iwl-io.h"
  46. #include "iwl-trans.h"
  47. #include "iwl-op-mode.h"
  48. #include "iwl-drv.h"
  49. #include "iwl-modparams.h"
  50. #include "iwl-prph.h"
  51. #include "dev.h"
  52. #include "calib.h"
  53. #include "agn.h"
  54. /******************************************************************************
  55. *
  56. * module boiler plate
  57. *
  58. ******************************************************************************/
  59. #define DRV_DESCRIPTION "Intel(R) Wireless WiFi Link AGN driver for Linux"
  60. MODULE_DESCRIPTION(DRV_DESCRIPTION);
  61. MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
  62. MODULE_LICENSE("GPL");
  63. /* Please keep this array *SORTED* by hex value.
  64. * Access is done through binary search.
  65. * A warning will be triggered on violation.
  66. */
  67. static const struct iwl_hcmd_names iwl_dvm_cmd_names[] = {
  68. HCMD_NAME(REPLY_ALIVE),
  69. HCMD_NAME(REPLY_ERROR),
  70. HCMD_NAME(REPLY_ECHO),
  71. HCMD_NAME(REPLY_RXON),
  72. HCMD_NAME(REPLY_RXON_ASSOC),
  73. HCMD_NAME(REPLY_QOS_PARAM),
  74. HCMD_NAME(REPLY_RXON_TIMING),
  75. HCMD_NAME(REPLY_ADD_STA),
  76. HCMD_NAME(REPLY_REMOVE_STA),
  77. HCMD_NAME(REPLY_REMOVE_ALL_STA),
  78. HCMD_NAME(REPLY_TX),
  79. HCMD_NAME(REPLY_TXFIFO_FLUSH),
  80. HCMD_NAME(REPLY_WEPKEY),
  81. HCMD_NAME(REPLY_LEDS_CMD),
  82. HCMD_NAME(REPLY_TX_LINK_QUALITY_CMD),
  83. HCMD_NAME(COEX_PRIORITY_TABLE_CMD),
  84. HCMD_NAME(COEX_MEDIUM_NOTIFICATION),
  85. HCMD_NAME(COEX_EVENT_CMD),
  86. HCMD_NAME(TEMPERATURE_NOTIFICATION),
  87. HCMD_NAME(CALIBRATION_CFG_CMD),
  88. HCMD_NAME(CALIBRATION_RES_NOTIFICATION),
  89. HCMD_NAME(CALIBRATION_COMPLETE_NOTIFICATION),
  90. HCMD_NAME(REPLY_QUIET_CMD),
  91. HCMD_NAME(REPLY_CHANNEL_SWITCH),
  92. HCMD_NAME(CHANNEL_SWITCH_NOTIFICATION),
  93. HCMD_NAME(REPLY_SPECTRUM_MEASUREMENT_CMD),
  94. HCMD_NAME(SPECTRUM_MEASURE_NOTIFICATION),
  95. HCMD_NAME(POWER_TABLE_CMD),
  96. HCMD_NAME(PM_SLEEP_NOTIFICATION),
  97. HCMD_NAME(PM_DEBUG_STATISTIC_NOTIFIC),
  98. HCMD_NAME(REPLY_SCAN_CMD),
  99. HCMD_NAME(REPLY_SCAN_ABORT_CMD),
  100. HCMD_NAME(SCAN_START_NOTIFICATION),
  101. HCMD_NAME(SCAN_RESULTS_NOTIFICATION),
  102. HCMD_NAME(SCAN_COMPLETE_NOTIFICATION),
  103. HCMD_NAME(BEACON_NOTIFICATION),
  104. HCMD_NAME(REPLY_TX_BEACON),
  105. HCMD_NAME(WHO_IS_AWAKE_NOTIFICATION),
  106. HCMD_NAME(REPLY_TX_POWER_DBM_CMD),
  107. HCMD_NAME(QUIET_NOTIFICATION),
  108. HCMD_NAME(REPLY_TX_PWR_TABLE_CMD),
  109. HCMD_NAME(REPLY_TX_POWER_DBM_CMD_V1),
  110. HCMD_NAME(TX_ANT_CONFIGURATION_CMD),
  111. HCMD_NAME(MEASURE_ABORT_NOTIFICATION),
  112. HCMD_NAME(REPLY_BT_CONFIG),
  113. HCMD_NAME(REPLY_STATISTICS_CMD),
  114. HCMD_NAME(STATISTICS_NOTIFICATION),
  115. HCMD_NAME(REPLY_CARD_STATE_CMD),
  116. HCMD_NAME(CARD_STATE_NOTIFICATION),
  117. HCMD_NAME(MISSED_BEACONS_NOTIFICATION),
  118. HCMD_NAME(REPLY_CT_KILL_CONFIG_CMD),
  119. HCMD_NAME(SENSITIVITY_CMD),
  120. HCMD_NAME(REPLY_PHY_CALIBRATION_CMD),
  121. HCMD_NAME(REPLY_WIPAN_PARAMS),
  122. HCMD_NAME(REPLY_WIPAN_RXON),
  123. HCMD_NAME(REPLY_WIPAN_RXON_TIMING),
  124. HCMD_NAME(REPLY_WIPAN_RXON_ASSOC),
  125. HCMD_NAME(REPLY_WIPAN_QOS_PARAM),
  126. HCMD_NAME(REPLY_WIPAN_WEPKEY),
  127. HCMD_NAME(REPLY_WIPAN_P2P_CHANNEL_SWITCH),
  128. HCMD_NAME(REPLY_WIPAN_NOA_NOTIFICATION),
  129. HCMD_NAME(REPLY_WIPAN_DEACTIVATION_COMPLETE),
  130. HCMD_NAME(REPLY_RX_PHY_CMD),
  131. HCMD_NAME(REPLY_RX_MPDU_CMD),
  132. HCMD_NAME(REPLY_RX),
  133. HCMD_NAME(REPLY_COMPRESSED_BA),
  134. HCMD_NAME(REPLY_BT_COEX_PRIO_TABLE),
  135. HCMD_NAME(REPLY_BT_COEX_PROT_ENV),
  136. HCMD_NAME(REPLY_BT_COEX_PROFILE_NOTIF),
  137. HCMD_NAME(REPLY_D3_CONFIG),
  138. HCMD_NAME(REPLY_WOWLAN_PATTERNS),
  139. HCMD_NAME(REPLY_WOWLAN_WAKEUP_FILTER),
  140. HCMD_NAME(REPLY_WOWLAN_TSC_RSC_PARAMS),
  141. HCMD_NAME(REPLY_WOWLAN_TKIP_PARAMS),
  142. HCMD_NAME(REPLY_WOWLAN_KEK_KCK_MATERIAL),
  143. HCMD_NAME(REPLY_WOWLAN_GET_STATUS),
  144. };
  145. static const struct iwl_hcmd_arr iwl_dvm_groups[] = {
  146. [0x0] = HCMD_ARR(iwl_dvm_cmd_names),
  147. };
  148. static const struct iwl_op_mode_ops iwl_dvm_ops;
  149. void iwl_update_chain_flags(struct iwl_priv *priv)
  150. {
  151. struct iwl_rxon_context *ctx;
  152. for_each_context(priv, ctx) {
  153. iwlagn_set_rxon_chain(priv, ctx);
  154. if (ctx->active.rx_chain != ctx->staging.rx_chain)
  155. iwlagn_commit_rxon(priv, ctx);
  156. }
  157. }
  158. /* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */
  159. static void iwl_set_beacon_tim(struct iwl_priv *priv,
  160. struct iwl_tx_beacon_cmd *tx_beacon_cmd,
  161. u8 *beacon, u32 frame_size)
  162. {
  163. u16 tim_idx;
  164. struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;
  165. /*
  166. * The index is relative to frame start but we start looking at the
  167. * variable-length part of the beacon.
  168. */
  169. tim_idx = mgmt->u.beacon.variable - beacon;
  170. /* Parse variable-length elements of beacon to find WLAN_EID_TIM */
  171. while ((tim_idx < (frame_size - 2)) &&
  172. (beacon[tim_idx] != WLAN_EID_TIM))
  173. tim_idx += beacon[tim_idx+1] + 2;
  174. /* If TIM field was found, set variables */
  175. if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
  176. tx_beacon_cmd->tim_idx = cpu_to_le16(tim_idx);
  177. tx_beacon_cmd->tim_size = beacon[tim_idx+1];
  178. } else
  179. IWL_WARN(priv, "Unable to find TIM Element in beacon\n");
  180. }
  181. int iwlagn_send_beacon_cmd(struct iwl_priv *priv)
  182. {
  183. struct iwl_tx_beacon_cmd *tx_beacon_cmd;
  184. struct iwl_host_cmd cmd = {
  185. .id = REPLY_TX_BEACON,
  186. };
  187. struct ieee80211_tx_info *info;
  188. u32 frame_size;
  189. u32 rate_flags;
  190. u32 rate;
  191. /*
  192. * We have to set up the TX command, the TX Beacon command, and the
  193. * beacon contents.
  194. */
  195. lockdep_assert_held(&priv->mutex);
  196. if (!priv->beacon_ctx) {
  197. IWL_ERR(priv, "trying to build beacon w/o beacon context!\n");
  198. return 0;
  199. }
  200. if (WARN_ON(!priv->beacon_skb))
  201. return -EINVAL;
  202. /* Allocate beacon command */
  203. if (!priv->beacon_cmd)
  204. priv->beacon_cmd = kzalloc(sizeof(*tx_beacon_cmd), GFP_KERNEL);
  205. tx_beacon_cmd = priv->beacon_cmd;
  206. if (!tx_beacon_cmd)
  207. return -ENOMEM;
  208. frame_size = priv->beacon_skb->len;
  209. /* Set up TX command fields */
  210. tx_beacon_cmd->tx.len = cpu_to_le16((u16)frame_size);
  211. tx_beacon_cmd->tx.sta_id = priv->beacon_ctx->bcast_sta_id;
  212. tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
  213. tx_beacon_cmd->tx.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK |
  214. TX_CMD_FLG_TSF_MSK | TX_CMD_FLG_STA_RATE_MSK;
  215. /* Set up TX beacon command fields */
  216. iwl_set_beacon_tim(priv, tx_beacon_cmd, priv->beacon_skb->data,
  217. frame_size);
  218. /* Set up packet rate and flags */
  219. info = IEEE80211_SKB_CB(priv->beacon_skb);
  220. /*
  221. * Let's set up the rate at least somewhat correctly;
  222. * it will currently not actually be used by the uCode,
  223. * it uses the broadcast station's rate instead.
  224. */
  225. if (info->control.rates[0].idx < 0 ||
  226. info->control.rates[0].flags & IEEE80211_TX_RC_MCS)
  227. rate = 0;
  228. else
  229. rate = info->control.rates[0].idx;
  230. priv->mgmt_tx_ant = iwl_toggle_tx_ant(priv, priv->mgmt_tx_ant,
  231. priv->nvm_data->valid_tx_ant);
  232. rate_flags = iwl_ant_idx_to_flags(priv->mgmt_tx_ant);
  233. /* In mac80211, rates for 5 GHz start at 0 */
  234. if (info->band == IEEE80211_BAND_5GHZ)
  235. rate += IWL_FIRST_OFDM_RATE;
  236. else if (rate >= IWL_FIRST_CCK_RATE && rate <= IWL_LAST_CCK_RATE)
  237. rate_flags |= RATE_MCS_CCK_MSK;
  238. tx_beacon_cmd->tx.rate_n_flags =
  239. iwl_hw_set_rate_n_flags(rate, rate_flags);
  240. /* Submit command */
  241. cmd.len[0] = sizeof(*tx_beacon_cmd);
  242. cmd.data[0] = tx_beacon_cmd;
  243. cmd.dataflags[0] = IWL_HCMD_DFL_NOCOPY;
  244. cmd.len[1] = frame_size;
  245. cmd.data[1] = priv->beacon_skb->data;
  246. cmd.dataflags[1] = IWL_HCMD_DFL_NOCOPY;
  247. return iwl_dvm_send_cmd(priv, &cmd);
  248. }
  249. static void iwl_bg_beacon_update(struct work_struct *work)
  250. {
  251. struct iwl_priv *priv =
  252. container_of(work, struct iwl_priv, beacon_update);
  253. struct sk_buff *beacon;
  254. mutex_lock(&priv->mutex);
  255. if (!priv->beacon_ctx) {
  256. IWL_ERR(priv, "updating beacon w/o beacon context!\n");
  257. goto out;
  258. }
  259. if (priv->beacon_ctx->vif->type != NL80211_IFTYPE_AP) {
  260. /*
  261. * The ucode will send beacon notifications even in
  262. * IBSS mode, but we don't want to process them. But
  263. * we need to defer the type check to here due to
  264. * requiring locking around the beacon_ctx access.
  265. */
  266. goto out;
  267. }
  268. /* Pull updated AP beacon from mac80211. will fail if not in AP mode */
  269. beacon = ieee80211_beacon_get(priv->hw, priv->beacon_ctx->vif);
  270. if (!beacon) {
  271. IWL_ERR(priv, "update beacon failed -- keeping old\n");
  272. goto out;
  273. }
  274. /* new beacon skb is allocated every time; dispose previous.*/
  275. dev_kfree_skb(priv->beacon_skb);
  276. priv->beacon_skb = beacon;
  277. iwlagn_send_beacon_cmd(priv);
  278. out:
  279. mutex_unlock(&priv->mutex);
  280. }
  281. static void iwl_bg_bt_runtime_config(struct work_struct *work)
  282. {
  283. struct iwl_priv *priv =
  284. container_of(work, struct iwl_priv, bt_runtime_config);
  285. mutex_lock(&priv->mutex);
  286. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  287. goto out;
  288. /* dont send host command if rf-kill is on */
  289. if (!iwl_is_ready_rf(priv))
  290. goto out;
  291. iwlagn_send_advance_bt_config(priv);
  292. out:
  293. mutex_unlock(&priv->mutex);
  294. }
  295. static void iwl_bg_bt_full_concurrency(struct work_struct *work)
  296. {
  297. struct iwl_priv *priv =
  298. container_of(work, struct iwl_priv, bt_full_concurrency);
  299. struct iwl_rxon_context *ctx;
  300. mutex_lock(&priv->mutex);
  301. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  302. goto out;
  303. /* dont send host command if rf-kill is on */
  304. if (!iwl_is_ready_rf(priv))
  305. goto out;
  306. IWL_DEBUG_INFO(priv, "BT coex in %s mode\n",
  307. priv->bt_full_concurrent ?
  308. "full concurrency" : "3-wire");
  309. /*
  310. * LQ & RXON updated cmds must be sent before BT Config cmd
  311. * to avoid 3-wire collisions
  312. */
  313. for_each_context(priv, ctx) {
  314. iwlagn_set_rxon_chain(priv, ctx);
  315. iwlagn_commit_rxon(priv, ctx);
  316. }
  317. iwlagn_send_advance_bt_config(priv);
  318. out:
  319. mutex_unlock(&priv->mutex);
  320. }
  321. int iwl_send_statistics_request(struct iwl_priv *priv, u8 flags, bool clear)
  322. {
  323. struct iwl_statistics_cmd statistics_cmd = {
  324. .configuration_flags =
  325. clear ? IWL_STATS_CONF_CLEAR_STATS : 0,
  326. };
  327. if (flags & CMD_ASYNC)
  328. return iwl_dvm_send_cmd_pdu(priv, REPLY_STATISTICS_CMD,
  329. CMD_ASYNC,
  330. sizeof(struct iwl_statistics_cmd),
  331. &statistics_cmd);
  332. else
  333. return iwl_dvm_send_cmd_pdu(priv, REPLY_STATISTICS_CMD, 0,
  334. sizeof(struct iwl_statistics_cmd),
  335. &statistics_cmd);
  336. }
  337. /**
  338. * iwl_bg_statistics_periodic - Timer callback to queue statistics
  339. *
  340. * This callback is provided in order to send a statistics request.
  341. *
  342. * This timer function is continually reset to execute within
  343. * REG_RECALIB_PERIOD seconds since the last STATISTICS_NOTIFICATION
  344. * was received. We need to ensure we receive the statistics in order
  345. * to update the temperature used for calibrating the TXPOWER.
  346. */
  347. static void iwl_bg_statistics_periodic(unsigned long data)
  348. {
  349. struct iwl_priv *priv = (struct iwl_priv *)data;
  350. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  351. return;
  352. /* dont send host command if rf-kill is on */
  353. if (!iwl_is_ready_rf(priv))
  354. return;
  355. iwl_send_statistics_request(priv, CMD_ASYNC, false);
  356. }
  357. static void iwl_print_cont_event_trace(struct iwl_priv *priv, u32 base,
  358. u32 start_idx, u32 num_events,
  359. u32 capacity, u32 mode)
  360. {
  361. u32 i;
  362. u32 ptr; /* SRAM byte address of log data */
  363. u32 ev, time, data; /* event log data */
  364. unsigned long reg_flags;
  365. if (mode == 0)
  366. ptr = base + (4 * sizeof(u32)) + (start_idx * 2 * sizeof(u32));
  367. else
  368. ptr = base + (4 * sizeof(u32)) + (start_idx * 3 * sizeof(u32));
  369. /* Make sure device is powered up for SRAM reads */
  370. if (!iwl_trans_grab_nic_access(priv->trans, &reg_flags))
  371. return;
  372. /* Set starting address; reads will auto-increment */
  373. iwl_write32(priv->trans, HBUS_TARG_MEM_RADDR, ptr);
  374. /*
  375. * Refuse to read more than would have fit into the log from
  376. * the current start_idx. This used to happen due to the race
  377. * described below, but now WARN because the code below should
  378. * prevent it from happening here.
  379. */
  380. if (WARN_ON(num_events > capacity - start_idx))
  381. num_events = capacity - start_idx;
  382. /*
  383. * "time" is actually "data" for mode 0 (no timestamp).
  384. * place event id # at far right for easier visual parsing.
  385. */
  386. for (i = 0; i < num_events; i++) {
  387. ev = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT);
  388. time = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT);
  389. if (mode == 0) {
  390. trace_iwlwifi_dev_ucode_cont_event(
  391. priv->trans->dev, 0, time, ev);
  392. } else {
  393. data = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT);
  394. trace_iwlwifi_dev_ucode_cont_event(
  395. priv->trans->dev, time, data, ev);
  396. }
  397. }
  398. /* Allow device to power down */
  399. iwl_trans_release_nic_access(priv->trans, &reg_flags);
  400. }
  401. static void iwl_continuous_event_trace(struct iwl_priv *priv)
  402. {
  403. u32 capacity; /* event log capacity in # entries */
  404. struct {
  405. u32 capacity;
  406. u32 mode;
  407. u32 wrap_counter;
  408. u32 write_counter;
  409. } __packed read;
  410. u32 base; /* SRAM byte address of event log header */
  411. u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
  412. u32 num_wraps; /* # times uCode wrapped to top of log */
  413. u32 next_entry; /* index of next entry to be written by uCode */
  414. base = priv->device_pointers.log_event_table;
  415. if (iwlagn_hw_valid_rtc_data_addr(base)) {
  416. iwl_trans_read_mem_bytes(priv->trans, base,
  417. &read, sizeof(read));
  418. capacity = read.capacity;
  419. mode = read.mode;
  420. num_wraps = read.wrap_counter;
  421. next_entry = read.write_counter;
  422. } else
  423. return;
  424. /*
  425. * Unfortunately, the uCode doesn't use temporary variables.
  426. * Therefore, it can happen that we read next_entry == capacity,
  427. * which really means next_entry == 0.
  428. */
  429. if (unlikely(next_entry == capacity))
  430. next_entry = 0;
  431. /*
  432. * Additionally, the uCode increases the write pointer before
  433. * the wraps counter, so if the write pointer is smaller than
  434. * the old write pointer (wrap occurred) but we read that no
  435. * wrap occurred, we actually read between the next_entry and
  436. * num_wraps update (this does happen in practice!!) -- take
  437. * that into account by increasing num_wraps.
  438. */
  439. if (unlikely(next_entry < priv->event_log.next_entry &&
  440. num_wraps == priv->event_log.num_wraps))
  441. num_wraps++;
  442. if (num_wraps == priv->event_log.num_wraps) {
  443. iwl_print_cont_event_trace(
  444. priv, base, priv->event_log.next_entry,
  445. next_entry - priv->event_log.next_entry,
  446. capacity, mode);
  447. priv->event_log.non_wraps_count++;
  448. } else {
  449. if (num_wraps - priv->event_log.num_wraps > 1)
  450. priv->event_log.wraps_more_count++;
  451. else
  452. priv->event_log.wraps_once_count++;
  453. trace_iwlwifi_dev_ucode_wrap_event(priv->trans->dev,
  454. num_wraps - priv->event_log.num_wraps,
  455. next_entry, priv->event_log.next_entry);
  456. if (next_entry < priv->event_log.next_entry) {
  457. iwl_print_cont_event_trace(
  458. priv, base, priv->event_log.next_entry,
  459. capacity - priv->event_log.next_entry,
  460. capacity, mode);
  461. iwl_print_cont_event_trace(
  462. priv, base, 0, next_entry, capacity, mode);
  463. } else {
  464. iwl_print_cont_event_trace(
  465. priv, base, next_entry,
  466. capacity - next_entry,
  467. capacity, mode);
  468. iwl_print_cont_event_trace(
  469. priv, base, 0, next_entry, capacity, mode);
  470. }
  471. }
  472. priv->event_log.num_wraps = num_wraps;
  473. priv->event_log.next_entry = next_entry;
  474. }
  475. /**
  476. * iwl_bg_ucode_trace - Timer callback to log ucode event
  477. *
  478. * The timer is continually set to execute every
  479. * UCODE_TRACE_PERIOD milliseconds after the last timer expired
  480. * this function is to perform continuous uCode event logging operation
  481. * if enabled
  482. */
  483. static void iwl_bg_ucode_trace(unsigned long data)
  484. {
  485. struct iwl_priv *priv = (struct iwl_priv *)data;
  486. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  487. return;
  488. if (priv->event_log.ucode_trace) {
  489. iwl_continuous_event_trace(priv);
  490. /* Reschedule the timer to occur in UCODE_TRACE_PERIOD */
  491. mod_timer(&priv->ucode_trace,
  492. jiffies + msecs_to_jiffies(UCODE_TRACE_PERIOD));
  493. }
  494. }
  495. static void iwl_bg_tx_flush(struct work_struct *work)
  496. {
  497. struct iwl_priv *priv =
  498. container_of(work, struct iwl_priv, tx_flush);
  499. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  500. return;
  501. /* do nothing if rf-kill is on */
  502. if (!iwl_is_ready_rf(priv))
  503. return;
  504. IWL_DEBUG_INFO(priv, "device request: flush all tx frames\n");
  505. iwlagn_dev_txfifo_flush(priv);
  506. }
  507. /*
  508. * queue/FIFO/AC mapping definitions
  509. */
  510. static const u8 iwlagn_bss_ac_to_fifo[] = {
  511. IWL_TX_FIFO_VO,
  512. IWL_TX_FIFO_VI,
  513. IWL_TX_FIFO_BE,
  514. IWL_TX_FIFO_BK,
  515. };
  516. static const u8 iwlagn_bss_ac_to_queue[] = {
  517. 0, 1, 2, 3,
  518. };
  519. static const u8 iwlagn_pan_ac_to_fifo[] = {
  520. IWL_TX_FIFO_VO_IPAN,
  521. IWL_TX_FIFO_VI_IPAN,
  522. IWL_TX_FIFO_BE_IPAN,
  523. IWL_TX_FIFO_BK_IPAN,
  524. };
  525. static const u8 iwlagn_pan_ac_to_queue[] = {
  526. 7, 6, 5, 4,
  527. };
  528. static void iwl_init_context(struct iwl_priv *priv, u32 ucode_flags)
  529. {
  530. int i;
  531. /*
  532. * The default context is always valid,
  533. * the PAN context depends on uCode.
  534. */
  535. priv->valid_contexts = BIT(IWL_RXON_CTX_BSS);
  536. if (ucode_flags & IWL_UCODE_TLV_FLAGS_PAN)
  537. priv->valid_contexts |= BIT(IWL_RXON_CTX_PAN);
  538. for (i = 0; i < NUM_IWL_RXON_CTX; i++)
  539. priv->contexts[i].ctxid = i;
  540. priv->contexts[IWL_RXON_CTX_BSS].always_active = true;
  541. priv->contexts[IWL_RXON_CTX_BSS].is_active = true;
  542. priv->contexts[IWL_RXON_CTX_BSS].rxon_cmd = REPLY_RXON;
  543. priv->contexts[IWL_RXON_CTX_BSS].rxon_timing_cmd = REPLY_RXON_TIMING;
  544. priv->contexts[IWL_RXON_CTX_BSS].rxon_assoc_cmd = REPLY_RXON_ASSOC;
  545. priv->contexts[IWL_RXON_CTX_BSS].qos_cmd = REPLY_QOS_PARAM;
  546. priv->contexts[IWL_RXON_CTX_BSS].ap_sta_id = IWL_AP_ID;
  547. priv->contexts[IWL_RXON_CTX_BSS].wep_key_cmd = REPLY_WEPKEY;
  548. priv->contexts[IWL_RXON_CTX_BSS].bcast_sta_id = IWLAGN_BROADCAST_ID;
  549. priv->contexts[IWL_RXON_CTX_BSS].exclusive_interface_modes =
  550. BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_MONITOR);
  551. priv->contexts[IWL_RXON_CTX_BSS].interface_modes =
  552. BIT(NL80211_IFTYPE_STATION);
  553. priv->contexts[IWL_RXON_CTX_BSS].ap_devtype = RXON_DEV_TYPE_AP;
  554. priv->contexts[IWL_RXON_CTX_BSS].ibss_devtype = RXON_DEV_TYPE_IBSS;
  555. priv->contexts[IWL_RXON_CTX_BSS].station_devtype = RXON_DEV_TYPE_ESS;
  556. priv->contexts[IWL_RXON_CTX_BSS].unused_devtype = RXON_DEV_TYPE_ESS;
  557. memcpy(priv->contexts[IWL_RXON_CTX_BSS].ac_to_queue,
  558. iwlagn_bss_ac_to_queue, sizeof(iwlagn_bss_ac_to_queue));
  559. memcpy(priv->contexts[IWL_RXON_CTX_BSS].ac_to_fifo,
  560. iwlagn_bss_ac_to_fifo, sizeof(iwlagn_bss_ac_to_fifo));
  561. priv->contexts[IWL_RXON_CTX_PAN].rxon_cmd = REPLY_WIPAN_RXON;
  562. priv->contexts[IWL_RXON_CTX_PAN].rxon_timing_cmd =
  563. REPLY_WIPAN_RXON_TIMING;
  564. priv->contexts[IWL_RXON_CTX_PAN].rxon_assoc_cmd =
  565. REPLY_WIPAN_RXON_ASSOC;
  566. priv->contexts[IWL_RXON_CTX_PAN].qos_cmd = REPLY_WIPAN_QOS_PARAM;
  567. priv->contexts[IWL_RXON_CTX_PAN].ap_sta_id = IWL_AP_ID_PAN;
  568. priv->contexts[IWL_RXON_CTX_PAN].wep_key_cmd = REPLY_WIPAN_WEPKEY;
  569. priv->contexts[IWL_RXON_CTX_PAN].bcast_sta_id = IWLAGN_PAN_BCAST_ID;
  570. priv->contexts[IWL_RXON_CTX_PAN].station_flags = STA_FLG_PAN_STATION;
  571. priv->contexts[IWL_RXON_CTX_PAN].interface_modes =
  572. BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_AP);
  573. priv->contexts[IWL_RXON_CTX_PAN].ap_devtype = RXON_DEV_TYPE_CP;
  574. priv->contexts[IWL_RXON_CTX_PAN].station_devtype = RXON_DEV_TYPE_2STA;
  575. priv->contexts[IWL_RXON_CTX_PAN].unused_devtype = RXON_DEV_TYPE_P2P;
  576. memcpy(priv->contexts[IWL_RXON_CTX_PAN].ac_to_queue,
  577. iwlagn_pan_ac_to_queue, sizeof(iwlagn_pan_ac_to_queue));
  578. memcpy(priv->contexts[IWL_RXON_CTX_PAN].ac_to_fifo,
  579. iwlagn_pan_ac_to_fifo, sizeof(iwlagn_pan_ac_to_fifo));
  580. priv->contexts[IWL_RXON_CTX_PAN].mcast_queue = IWL_IPAN_MCAST_QUEUE;
  581. BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
  582. }
  583. static void iwl_rf_kill_ct_config(struct iwl_priv *priv)
  584. {
  585. struct iwl_ct_kill_config cmd;
  586. struct iwl_ct_kill_throttling_config adv_cmd;
  587. int ret = 0;
  588. iwl_write32(priv->trans, CSR_UCODE_DRV_GP1_CLR,
  589. CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
  590. priv->thermal_throttle.ct_kill_toggle = false;
  591. if (priv->lib->support_ct_kill_exit) {
  592. adv_cmd.critical_temperature_enter =
  593. cpu_to_le32(priv->hw_params.ct_kill_threshold);
  594. adv_cmd.critical_temperature_exit =
  595. cpu_to_le32(priv->hw_params.ct_kill_exit_threshold);
  596. ret = iwl_dvm_send_cmd_pdu(priv,
  597. REPLY_CT_KILL_CONFIG_CMD,
  598. 0, sizeof(adv_cmd), &adv_cmd);
  599. if (ret)
  600. IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
  601. else
  602. IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
  603. "succeeded, critical temperature enter is %d,"
  604. "exit is %d\n",
  605. priv->hw_params.ct_kill_threshold,
  606. priv->hw_params.ct_kill_exit_threshold);
  607. } else {
  608. cmd.critical_temperature_R =
  609. cpu_to_le32(priv->hw_params.ct_kill_threshold);
  610. ret = iwl_dvm_send_cmd_pdu(priv,
  611. REPLY_CT_KILL_CONFIG_CMD,
  612. 0, sizeof(cmd), &cmd);
  613. if (ret)
  614. IWL_ERR(priv, "REPLY_CT_KILL_CONFIG_CMD failed\n");
  615. else
  616. IWL_DEBUG_INFO(priv, "REPLY_CT_KILL_CONFIG_CMD "
  617. "succeeded, "
  618. "critical temperature is %d\n",
  619. priv->hw_params.ct_kill_threshold);
  620. }
  621. }
  622. static int iwlagn_send_calib_cfg_rt(struct iwl_priv *priv, u32 cfg)
  623. {
  624. struct iwl_calib_cfg_cmd calib_cfg_cmd;
  625. struct iwl_host_cmd cmd = {
  626. .id = CALIBRATION_CFG_CMD,
  627. .len = { sizeof(struct iwl_calib_cfg_cmd), },
  628. .data = { &calib_cfg_cmd, },
  629. };
  630. memset(&calib_cfg_cmd, 0, sizeof(calib_cfg_cmd));
  631. calib_cfg_cmd.ucd_calib_cfg.once.is_enable = IWL_CALIB_RT_CFG_ALL;
  632. calib_cfg_cmd.ucd_calib_cfg.once.start = cpu_to_le32(cfg);
  633. return iwl_dvm_send_cmd(priv, &cmd);
  634. }
  635. static int iwlagn_send_tx_ant_config(struct iwl_priv *priv, u8 valid_tx_ant)
  636. {
  637. struct iwl_tx_ant_config_cmd tx_ant_cmd = {
  638. .valid = cpu_to_le32(valid_tx_ant),
  639. };
  640. if (IWL_UCODE_API(priv->fw->ucode_ver) > 1) {
  641. IWL_DEBUG_HC(priv, "select valid tx ant: %u\n", valid_tx_ant);
  642. return iwl_dvm_send_cmd_pdu(priv, TX_ANT_CONFIGURATION_CMD, 0,
  643. sizeof(struct iwl_tx_ant_config_cmd),
  644. &tx_ant_cmd);
  645. } else {
  646. IWL_DEBUG_HC(priv, "TX_ANT_CONFIGURATION_CMD not supported\n");
  647. return -EOPNOTSUPP;
  648. }
  649. }
  650. static void iwl_send_bt_config(struct iwl_priv *priv)
  651. {
  652. struct iwl_bt_cmd bt_cmd = {
  653. .lead_time = BT_LEAD_TIME_DEF,
  654. .max_kill = BT_MAX_KILL_DEF,
  655. .kill_ack_mask = 0,
  656. .kill_cts_mask = 0,
  657. };
  658. if (!iwlwifi_mod_params.bt_coex_active)
  659. bt_cmd.flags = BT_COEX_DISABLE;
  660. else
  661. bt_cmd.flags = BT_COEX_ENABLE;
  662. priv->bt_enable_flag = bt_cmd.flags;
  663. IWL_DEBUG_INFO(priv, "BT coex %s\n",
  664. (bt_cmd.flags == BT_COEX_DISABLE) ? "disable" : "active");
  665. if (iwl_dvm_send_cmd_pdu(priv, REPLY_BT_CONFIG,
  666. 0, sizeof(struct iwl_bt_cmd), &bt_cmd))
  667. IWL_ERR(priv, "failed to send BT Coex Config\n");
  668. }
  669. /**
  670. * iwl_alive_start - called after REPLY_ALIVE notification received
  671. * from protocol/runtime uCode (initialization uCode's
  672. * Alive gets handled by iwl_init_alive_start()).
  673. */
  674. int iwl_alive_start(struct iwl_priv *priv)
  675. {
  676. int ret = 0;
  677. struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
  678. IWL_DEBUG_INFO(priv, "Runtime Alive received.\n");
  679. /* After the ALIVE response, we can send host commands to the uCode */
  680. set_bit(STATUS_ALIVE, &priv->status);
  681. if (iwl_is_rfkill(priv))
  682. return -ERFKILL;
  683. if (priv->event_log.ucode_trace) {
  684. /* start collecting data now */
  685. mod_timer(&priv->ucode_trace, jiffies);
  686. }
  687. /* download priority table before any calibration request */
  688. if (priv->lib->bt_params &&
  689. priv->lib->bt_params->advanced_bt_coexist) {
  690. /* Configure Bluetooth device coexistence support */
  691. if (priv->lib->bt_params->bt_sco_disable)
  692. priv->bt_enable_pspoll = false;
  693. else
  694. priv->bt_enable_pspoll = true;
  695. priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
  696. priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
  697. priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
  698. iwlagn_send_advance_bt_config(priv);
  699. priv->bt_valid = IWLAGN_BT_VALID_ENABLE_FLAGS;
  700. priv->cur_rssi_ctx = NULL;
  701. iwl_send_prio_tbl(priv);
  702. /* FIXME: w/a to force change uCode BT state machine */
  703. ret = iwl_send_bt_env(priv, IWL_BT_COEX_ENV_OPEN,
  704. BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
  705. if (ret)
  706. return ret;
  707. ret = iwl_send_bt_env(priv, IWL_BT_COEX_ENV_CLOSE,
  708. BT_COEX_PRIO_TBL_EVT_INIT_CALIB2);
  709. if (ret)
  710. return ret;
  711. } else if (priv->lib->bt_params) {
  712. /*
  713. * default is 2-wire BT coexexistence support
  714. */
  715. iwl_send_bt_config(priv);
  716. }
  717. /*
  718. * Perform runtime calibrations, including DC calibration.
  719. */
  720. iwlagn_send_calib_cfg_rt(priv, IWL_CALIB_CFG_DC_IDX);
  721. ieee80211_wake_queues(priv->hw);
  722. /* Configure Tx antenna selection based on H/W config */
  723. iwlagn_send_tx_ant_config(priv, priv->nvm_data->valid_tx_ant);
  724. if (iwl_is_associated_ctx(ctx) && !priv->wowlan) {
  725. struct iwl_rxon_cmd *active_rxon =
  726. (struct iwl_rxon_cmd *)&ctx->active;
  727. /* apply any changes in staging */
  728. ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
  729. active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
  730. } else {
  731. struct iwl_rxon_context *tmp;
  732. /* Initialize our rx_config data */
  733. for_each_context(priv, tmp)
  734. iwl_connection_init_rx_config(priv, tmp);
  735. iwlagn_set_rxon_chain(priv, ctx);
  736. }
  737. if (!priv->wowlan) {
  738. /* WoWLAN ucode will not reply in the same way, skip it */
  739. iwl_reset_run_time_calib(priv);
  740. }
  741. set_bit(STATUS_READY, &priv->status);
  742. /* Configure the adapter for unassociated operation */
  743. ret = iwlagn_commit_rxon(priv, ctx);
  744. if (ret)
  745. return ret;
  746. /* At this point, the NIC is initialized and operational */
  747. iwl_rf_kill_ct_config(priv);
  748. IWL_DEBUG_INFO(priv, "ALIVE processing complete.\n");
  749. return iwl_power_update_mode(priv, true);
  750. }
  751. /**
  752. * iwl_clear_driver_stations - clear knowledge of all stations from driver
  753. * @priv: iwl priv struct
  754. *
  755. * This is called during iwl_down() to make sure that in the case
  756. * we're coming there from a hardware restart mac80211 will be
  757. * able to reconfigure stations -- if we're getting there in the
  758. * normal down flow then the stations will already be cleared.
  759. */
  760. static void iwl_clear_driver_stations(struct iwl_priv *priv)
  761. {
  762. struct iwl_rxon_context *ctx;
  763. spin_lock_bh(&priv->sta_lock);
  764. memset(priv->stations, 0, sizeof(priv->stations));
  765. priv->num_stations = 0;
  766. priv->ucode_key_table = 0;
  767. for_each_context(priv, ctx) {
  768. /*
  769. * Remove all key information that is not stored as part
  770. * of station information since mac80211 may not have had
  771. * a chance to remove all the keys. When device is
  772. * reconfigured by mac80211 after an error all keys will
  773. * be reconfigured.
  774. */
  775. memset(ctx->wep_keys, 0, sizeof(ctx->wep_keys));
  776. ctx->key_mapping_keys = 0;
  777. }
  778. spin_unlock_bh(&priv->sta_lock);
  779. }
  780. void iwl_down(struct iwl_priv *priv)
  781. {
  782. int exit_pending;
  783. IWL_DEBUG_INFO(priv, DRV_NAME " is going down\n");
  784. lockdep_assert_held(&priv->mutex);
  785. iwl_scan_cancel_timeout(priv, 200);
  786. exit_pending =
  787. test_and_set_bit(STATUS_EXIT_PENDING, &priv->status);
  788. iwl_clear_ucode_stations(priv, NULL);
  789. iwl_dealloc_bcast_stations(priv);
  790. iwl_clear_driver_stations(priv);
  791. /* reset BT coex data */
  792. priv->bt_status = 0;
  793. priv->cur_rssi_ctx = NULL;
  794. priv->bt_is_sco = 0;
  795. if (priv->lib->bt_params)
  796. priv->bt_traffic_load =
  797. priv->lib->bt_params->bt_init_traffic_load;
  798. else
  799. priv->bt_traffic_load = 0;
  800. priv->bt_full_concurrent = false;
  801. priv->bt_ci_compliance = 0;
  802. /* Wipe out the EXIT_PENDING status bit if we are not actually
  803. * exiting the module */
  804. if (!exit_pending)
  805. clear_bit(STATUS_EXIT_PENDING, &priv->status);
  806. if (priv->mac80211_registered)
  807. ieee80211_stop_queues(priv->hw);
  808. priv->ucode_loaded = false;
  809. iwl_trans_stop_device(priv->trans);
  810. /* Set num_aux_in_flight must be done after the transport is stopped */
  811. atomic_set(&priv->num_aux_in_flight, 0);
  812. /* Clear out all status bits but a few that are stable across reset */
  813. priv->status &= test_bit(STATUS_RF_KILL_HW, &priv->status) <<
  814. STATUS_RF_KILL_HW |
  815. test_bit(STATUS_FW_ERROR, &priv->status) <<
  816. STATUS_FW_ERROR |
  817. test_bit(STATUS_EXIT_PENDING, &priv->status) <<
  818. STATUS_EXIT_PENDING;
  819. dev_kfree_skb(priv->beacon_skb);
  820. priv->beacon_skb = NULL;
  821. }
  822. /*****************************************************************************
  823. *
  824. * Workqueue callbacks
  825. *
  826. *****************************************************************************/
  827. static void iwl_bg_run_time_calib_work(struct work_struct *work)
  828. {
  829. struct iwl_priv *priv = container_of(work, struct iwl_priv,
  830. run_time_calib_work);
  831. mutex_lock(&priv->mutex);
  832. if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
  833. test_bit(STATUS_SCANNING, &priv->status)) {
  834. mutex_unlock(&priv->mutex);
  835. return;
  836. }
  837. if (priv->start_calib) {
  838. iwl_chain_noise_calibration(priv);
  839. iwl_sensitivity_calibration(priv);
  840. }
  841. mutex_unlock(&priv->mutex);
  842. }
  843. void iwlagn_prepare_restart(struct iwl_priv *priv)
  844. {
  845. bool bt_full_concurrent;
  846. u8 bt_ci_compliance;
  847. u8 bt_load;
  848. u8 bt_status;
  849. bool bt_is_sco;
  850. int i;
  851. lockdep_assert_held(&priv->mutex);
  852. priv->is_open = 0;
  853. /*
  854. * __iwl_down() will clear the BT status variables,
  855. * which is correct, but when we restart we really
  856. * want to keep them so restore them afterwards.
  857. *
  858. * The restart process will later pick them up and
  859. * re-configure the hw when we reconfigure the BT
  860. * command.
  861. */
  862. bt_full_concurrent = priv->bt_full_concurrent;
  863. bt_ci_compliance = priv->bt_ci_compliance;
  864. bt_load = priv->bt_traffic_load;
  865. bt_status = priv->bt_status;
  866. bt_is_sco = priv->bt_is_sco;
  867. iwl_down(priv);
  868. priv->bt_full_concurrent = bt_full_concurrent;
  869. priv->bt_ci_compliance = bt_ci_compliance;
  870. priv->bt_traffic_load = bt_load;
  871. priv->bt_status = bt_status;
  872. priv->bt_is_sco = bt_is_sco;
  873. /* reset aggregation queues */
  874. for (i = IWLAGN_FIRST_AMPDU_QUEUE; i < IWL_MAX_HW_QUEUES; i++)
  875. priv->queue_to_mac80211[i] = IWL_INVALID_MAC80211_QUEUE;
  876. /* and stop counts */
  877. for (i = 0; i < IWL_MAX_HW_QUEUES; i++)
  878. atomic_set(&priv->queue_stop_count[i], 0);
  879. memset(priv->agg_q_alloc, 0, sizeof(priv->agg_q_alloc));
  880. }
  881. static void iwl_bg_restart(struct work_struct *data)
  882. {
  883. struct iwl_priv *priv = container_of(data, struct iwl_priv, restart);
  884. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  885. return;
  886. if (test_and_clear_bit(STATUS_FW_ERROR, &priv->status)) {
  887. mutex_lock(&priv->mutex);
  888. iwlagn_prepare_restart(priv);
  889. mutex_unlock(&priv->mutex);
  890. iwl_cancel_deferred_work(priv);
  891. if (priv->mac80211_registered)
  892. ieee80211_restart_hw(priv->hw);
  893. else
  894. IWL_ERR(priv,
  895. "Cannot request restart before registrating with mac80211\n");
  896. } else {
  897. WARN_ON(1);
  898. }
  899. }
  900. /*****************************************************************************
  901. *
  902. * driver setup and teardown
  903. *
  904. *****************************************************************************/
  905. static void iwl_setup_deferred_work(struct iwl_priv *priv)
  906. {
  907. priv->workqueue = create_singlethread_workqueue(DRV_NAME);
  908. INIT_WORK(&priv->restart, iwl_bg_restart);
  909. INIT_WORK(&priv->beacon_update, iwl_bg_beacon_update);
  910. INIT_WORK(&priv->run_time_calib_work, iwl_bg_run_time_calib_work);
  911. INIT_WORK(&priv->tx_flush, iwl_bg_tx_flush);
  912. INIT_WORK(&priv->bt_full_concurrency, iwl_bg_bt_full_concurrency);
  913. INIT_WORK(&priv->bt_runtime_config, iwl_bg_bt_runtime_config);
  914. iwl_setup_scan_deferred_work(priv);
  915. if (priv->lib->bt_params)
  916. iwlagn_bt_setup_deferred_work(priv);
  917. setup_timer(&priv->statistics_periodic, iwl_bg_statistics_periodic,
  918. (unsigned long)priv);
  919. setup_timer(&priv->ucode_trace, iwl_bg_ucode_trace,
  920. (unsigned long)priv);
  921. }
  922. void iwl_cancel_deferred_work(struct iwl_priv *priv)
  923. {
  924. if (priv->lib->bt_params)
  925. iwlagn_bt_cancel_deferred_work(priv);
  926. cancel_work_sync(&priv->run_time_calib_work);
  927. cancel_work_sync(&priv->beacon_update);
  928. iwl_cancel_scan_deferred_work(priv);
  929. cancel_work_sync(&priv->bt_full_concurrency);
  930. cancel_work_sync(&priv->bt_runtime_config);
  931. del_timer_sync(&priv->statistics_periodic);
  932. del_timer_sync(&priv->ucode_trace);
  933. }
  934. static int iwl_init_drv(struct iwl_priv *priv)
  935. {
  936. spin_lock_init(&priv->sta_lock);
  937. mutex_init(&priv->mutex);
  938. INIT_LIST_HEAD(&priv->calib_results);
  939. priv->band = IEEE80211_BAND_2GHZ;
  940. priv->plcp_delta_threshold = priv->lib->plcp_delta_threshold;
  941. priv->iw_mode = NL80211_IFTYPE_STATION;
  942. priv->current_ht_config.smps = IEEE80211_SMPS_STATIC;
  943. priv->missed_beacon_threshold = IWL_MISSED_BEACON_THRESHOLD_DEF;
  944. priv->agg_tids_count = 0;
  945. priv->rx_statistics_jiffies = jiffies;
  946. /* Choose which receivers/antennas to use */
  947. iwlagn_set_rxon_chain(priv, &priv->contexts[IWL_RXON_CTX_BSS]);
  948. iwl_init_scan_params(priv);
  949. /* init bt coex */
  950. if (priv->lib->bt_params &&
  951. priv->lib->bt_params->advanced_bt_coexist) {
  952. priv->kill_ack_mask = IWLAGN_BT_KILL_ACK_MASK_DEFAULT;
  953. priv->kill_cts_mask = IWLAGN_BT_KILL_CTS_MASK_DEFAULT;
  954. priv->bt_valid = IWLAGN_BT_ALL_VALID_MSK;
  955. priv->bt_on_thresh = BT_ON_THRESHOLD_DEF;
  956. priv->bt_duration = BT_DURATION_LIMIT_DEF;
  957. priv->dynamic_frag_thresh = BT_FRAG_THRESHOLD_DEF;
  958. }
  959. return 0;
  960. }
  961. static void iwl_uninit_drv(struct iwl_priv *priv)
  962. {
  963. kfree(priv->scan_cmd);
  964. kfree(priv->beacon_cmd);
  965. kfree(rcu_dereference_raw(priv->noa_data));
  966. iwl_calib_free_results(priv);
  967. #ifdef CONFIG_IWLWIFI_DEBUGFS
  968. kfree(priv->wowlan_sram);
  969. #endif
  970. }
  971. static void iwl_set_hw_params(struct iwl_priv *priv)
  972. {
  973. if (priv->cfg->ht_params)
  974. priv->hw_params.use_rts_for_aggregation =
  975. priv->cfg->ht_params->use_rts_for_aggregation;
  976. /* Device-specific setup */
  977. priv->lib->set_hw_params(priv);
  978. }
  979. /* show what optional capabilities we have */
  980. static void iwl_option_config(struct iwl_priv *priv)
  981. {
  982. #ifdef CONFIG_IWLWIFI_DEBUG
  983. IWL_INFO(priv, "CONFIG_IWLWIFI_DEBUG enabled\n");
  984. #else
  985. IWL_INFO(priv, "CONFIG_IWLWIFI_DEBUG disabled\n");
  986. #endif
  987. #ifdef CONFIG_IWLWIFI_DEBUGFS
  988. IWL_INFO(priv, "CONFIG_IWLWIFI_DEBUGFS enabled\n");
  989. #else
  990. IWL_INFO(priv, "CONFIG_IWLWIFI_DEBUGFS disabled\n");
  991. #endif
  992. #ifdef CONFIG_IWLWIFI_DEVICE_TRACING
  993. IWL_INFO(priv, "CONFIG_IWLWIFI_DEVICE_TRACING enabled\n");
  994. #else
  995. IWL_INFO(priv, "CONFIG_IWLWIFI_DEVICE_TRACING disabled\n");
  996. #endif
  997. }
  998. static int iwl_eeprom_init_hw_params(struct iwl_priv *priv)
  999. {
  1000. struct iwl_nvm_data *data = priv->nvm_data;
  1001. if (data->sku_cap_11n_enable &&
  1002. !priv->cfg->ht_params) {
  1003. IWL_ERR(priv, "Invalid 11n configuration\n");
  1004. return -EINVAL;
  1005. }
  1006. if (!data->sku_cap_11n_enable && !data->sku_cap_band_24GHz_enable &&
  1007. !data->sku_cap_band_52GHz_enable) {
  1008. IWL_ERR(priv, "Invalid device sku\n");
  1009. return -EINVAL;
  1010. }
  1011. IWL_DEBUG_INFO(priv,
  1012. "Device SKU: 24GHz %s %s, 52GHz %s %s, 11.n %s %s\n",
  1013. data->sku_cap_band_24GHz_enable ? "" : "NOT", "enabled",
  1014. data->sku_cap_band_52GHz_enable ? "" : "NOT", "enabled",
  1015. data->sku_cap_11n_enable ? "" : "NOT", "enabled");
  1016. priv->hw_params.tx_chains_num =
  1017. num_of_ant(data->valid_tx_ant);
  1018. if (priv->cfg->rx_with_siso_diversity)
  1019. priv->hw_params.rx_chains_num = 1;
  1020. else
  1021. priv->hw_params.rx_chains_num =
  1022. num_of_ant(data->valid_rx_ant);
  1023. IWL_DEBUG_INFO(priv, "Valid Tx ant: 0x%X, Valid Rx ant: 0x%X\n",
  1024. data->valid_tx_ant,
  1025. data->valid_rx_ant);
  1026. return 0;
  1027. }
  1028. static struct iwl_op_mode *iwl_op_mode_dvm_start(struct iwl_trans *trans,
  1029. const struct iwl_cfg *cfg,
  1030. const struct iwl_fw *fw,
  1031. struct dentry *dbgfs_dir)
  1032. {
  1033. struct iwl_priv *priv;
  1034. struct ieee80211_hw *hw;
  1035. struct iwl_op_mode *op_mode;
  1036. u16 num_mac;
  1037. u32 ucode_flags;
  1038. struct iwl_trans_config trans_cfg = {};
  1039. static const u8 no_reclaim_cmds[] = {
  1040. REPLY_RX_PHY_CMD,
  1041. REPLY_RX_MPDU_CMD,
  1042. REPLY_COMPRESSED_BA,
  1043. STATISTICS_NOTIFICATION,
  1044. REPLY_TX,
  1045. };
  1046. int i;
  1047. /************************
  1048. * 1. Allocating HW data
  1049. ************************/
  1050. hw = iwl_alloc_all();
  1051. if (!hw) {
  1052. pr_err("%s: Cannot allocate network device\n", cfg->name);
  1053. goto out;
  1054. }
  1055. op_mode = hw->priv;
  1056. op_mode->ops = &iwl_dvm_ops;
  1057. priv = IWL_OP_MODE_GET_DVM(op_mode);
  1058. priv->trans = trans;
  1059. priv->dev = trans->dev;
  1060. priv->cfg = cfg;
  1061. priv->fw = fw;
  1062. switch (priv->cfg->device_family) {
  1063. case IWL_DEVICE_FAMILY_1000:
  1064. case IWL_DEVICE_FAMILY_100:
  1065. priv->lib = &iwl_dvm_1000_cfg;
  1066. break;
  1067. case IWL_DEVICE_FAMILY_2000:
  1068. priv->lib = &iwl_dvm_2000_cfg;
  1069. break;
  1070. case IWL_DEVICE_FAMILY_105:
  1071. priv->lib = &iwl_dvm_105_cfg;
  1072. break;
  1073. case IWL_DEVICE_FAMILY_2030:
  1074. case IWL_DEVICE_FAMILY_135:
  1075. priv->lib = &iwl_dvm_2030_cfg;
  1076. break;
  1077. case IWL_DEVICE_FAMILY_5000:
  1078. priv->lib = &iwl_dvm_5000_cfg;
  1079. break;
  1080. case IWL_DEVICE_FAMILY_5150:
  1081. priv->lib = &iwl_dvm_5150_cfg;
  1082. break;
  1083. case IWL_DEVICE_FAMILY_6000:
  1084. case IWL_DEVICE_FAMILY_6000i:
  1085. priv->lib = &iwl_dvm_6000_cfg;
  1086. break;
  1087. case IWL_DEVICE_FAMILY_6005:
  1088. priv->lib = &iwl_dvm_6005_cfg;
  1089. break;
  1090. case IWL_DEVICE_FAMILY_6050:
  1091. case IWL_DEVICE_FAMILY_6150:
  1092. priv->lib = &iwl_dvm_6050_cfg;
  1093. break;
  1094. case IWL_DEVICE_FAMILY_6030:
  1095. priv->lib = &iwl_dvm_6030_cfg;
  1096. break;
  1097. default:
  1098. break;
  1099. }
  1100. if (WARN_ON(!priv->lib))
  1101. goto out_free_hw;
  1102. /*
  1103. * Populate the state variables that the transport layer needs
  1104. * to know about.
  1105. */
  1106. trans_cfg.op_mode = op_mode;
  1107. trans_cfg.no_reclaim_cmds = no_reclaim_cmds;
  1108. trans_cfg.n_no_reclaim_cmds = ARRAY_SIZE(no_reclaim_cmds);
  1109. switch (iwlwifi_mod_params.amsdu_size) {
  1110. case IWL_AMSDU_4K:
  1111. trans_cfg.rx_buf_size = IWL_AMSDU_4K;
  1112. break;
  1113. case IWL_AMSDU_8K:
  1114. trans_cfg.rx_buf_size = IWL_AMSDU_8K;
  1115. break;
  1116. case IWL_AMSDU_12K:
  1117. default:
  1118. trans_cfg.rx_buf_size = IWL_AMSDU_4K;
  1119. pr_err("Unsupported amsdu_size: %d\n",
  1120. iwlwifi_mod_params.amsdu_size);
  1121. }
  1122. trans_cfg.cmd_q_wdg_timeout = IWL_WATCHDOG_DISABLED;
  1123. trans_cfg.command_groups = iwl_dvm_groups;
  1124. trans_cfg.command_groups_size = ARRAY_SIZE(iwl_dvm_groups);
  1125. trans_cfg.cmd_fifo = IWLAGN_CMD_FIFO_NUM;
  1126. WARN_ON(sizeof(priv->transport_queue_stop) * BITS_PER_BYTE <
  1127. priv->cfg->base_params->num_of_queues);
  1128. ucode_flags = fw->ucode_capa.flags;
  1129. if (ucode_flags & IWL_UCODE_TLV_FLAGS_PAN) {
  1130. priv->sta_key_max_num = STA_KEY_MAX_NUM_PAN;
  1131. trans_cfg.cmd_queue = IWL_IPAN_CMD_QUEUE_NUM;
  1132. } else {
  1133. priv->sta_key_max_num = STA_KEY_MAX_NUM;
  1134. trans_cfg.cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
  1135. }
  1136. /* Configure transport layer */
  1137. iwl_trans_configure(priv->trans, &trans_cfg);
  1138. trans->rx_mpdu_cmd = REPLY_RX_MPDU_CMD;
  1139. trans->rx_mpdu_cmd_hdr_size = sizeof(struct iwl_rx_mpdu_res_start);
  1140. trans->command_groups = trans_cfg.command_groups;
  1141. trans->command_groups_size = trans_cfg.command_groups_size;
  1142. /* At this point both hw and priv are allocated. */
  1143. SET_IEEE80211_DEV(priv->hw, priv->trans->dev);
  1144. iwl_option_config(priv);
  1145. IWL_DEBUG_INFO(priv, "*** LOAD DRIVER ***\n");
  1146. /* is antenna coupling more than 35dB ? */
  1147. priv->bt_ant_couple_ok =
  1148. (iwlwifi_mod_params.ant_coupling >
  1149. IWL_BT_ANTENNA_COUPLING_THRESHOLD) ?
  1150. true : false;
  1151. /* bt channel inhibition enabled*/
  1152. priv->bt_ch_announce = true;
  1153. IWL_DEBUG_INFO(priv, "BT channel inhibition is %s\n",
  1154. (priv->bt_ch_announce) ? "On" : "Off");
  1155. /* these spin locks will be used in apm_ops.init and EEPROM access
  1156. * we should init now
  1157. */
  1158. spin_lock_init(&priv->statistics.lock);
  1159. /***********************
  1160. * 2. Read REV register
  1161. ***********************/
  1162. IWL_INFO(priv, "Detected %s, REV=0x%X\n",
  1163. priv->cfg->name, priv->trans->hw_rev);
  1164. if (iwl_trans_start_hw(priv->trans))
  1165. goto out_free_hw;
  1166. /* Read the EEPROM */
  1167. if (iwl_read_eeprom(priv->trans, &priv->eeprom_blob,
  1168. &priv->eeprom_blob_size)) {
  1169. IWL_ERR(priv, "Unable to init EEPROM\n");
  1170. goto out_free_hw;
  1171. }
  1172. /* Reset chip to save power until we load uCode during "up". */
  1173. iwl_trans_stop_device(priv->trans);
  1174. priv->nvm_data = iwl_parse_eeprom_data(priv->trans->dev, priv->cfg,
  1175. priv->eeprom_blob,
  1176. priv->eeprom_blob_size);
  1177. if (!priv->nvm_data)
  1178. goto out_free_eeprom_blob;
  1179. if (iwl_nvm_check_version(priv->nvm_data, priv->trans))
  1180. goto out_free_eeprom;
  1181. if (iwl_eeprom_init_hw_params(priv))
  1182. goto out_free_eeprom;
  1183. /* extract MAC Address */
  1184. memcpy(priv->addresses[0].addr, priv->nvm_data->hw_addr, ETH_ALEN);
  1185. IWL_DEBUG_INFO(priv, "MAC address: %pM\n", priv->addresses[0].addr);
  1186. priv->hw->wiphy->addresses = priv->addresses;
  1187. priv->hw->wiphy->n_addresses = 1;
  1188. num_mac = priv->nvm_data->n_hw_addrs;
  1189. if (num_mac > 1) {
  1190. memcpy(priv->addresses[1].addr, priv->addresses[0].addr,
  1191. ETH_ALEN);
  1192. priv->addresses[1].addr[5]++;
  1193. priv->hw->wiphy->n_addresses++;
  1194. }
  1195. /************************
  1196. * 4. Setup HW constants
  1197. ************************/
  1198. iwl_set_hw_params(priv);
  1199. if (!(priv->nvm_data->sku_cap_ipan_enable)) {
  1200. IWL_DEBUG_INFO(priv, "Your EEPROM disabled PAN\n");
  1201. ucode_flags &= ~IWL_UCODE_TLV_FLAGS_PAN;
  1202. /*
  1203. * if not PAN, then don't support P2P -- might be a uCode
  1204. * packaging bug or due to the eeprom check above
  1205. */
  1206. priv->sta_key_max_num = STA_KEY_MAX_NUM;
  1207. trans_cfg.cmd_queue = IWL_DEFAULT_CMD_QUEUE_NUM;
  1208. /* Configure transport layer again*/
  1209. iwl_trans_configure(priv->trans, &trans_cfg);
  1210. }
  1211. /*******************
  1212. * 5. Setup priv
  1213. *******************/
  1214. for (i = 0; i < IWL_MAX_HW_QUEUES; i++) {
  1215. priv->queue_to_mac80211[i] = IWL_INVALID_MAC80211_QUEUE;
  1216. if (i < IWLAGN_FIRST_AMPDU_QUEUE &&
  1217. i != IWL_DEFAULT_CMD_QUEUE_NUM &&
  1218. i != IWL_IPAN_CMD_QUEUE_NUM)
  1219. priv->queue_to_mac80211[i] = i;
  1220. atomic_set(&priv->queue_stop_count[i], 0);
  1221. }
  1222. if (iwl_init_drv(priv))
  1223. goto out_free_eeprom;
  1224. /* At this point both hw and priv are initialized. */
  1225. /********************
  1226. * 6. Setup services
  1227. ********************/
  1228. iwl_setup_deferred_work(priv);
  1229. iwl_setup_rx_handlers(priv);
  1230. iwl_power_initialize(priv);
  1231. iwl_tt_initialize(priv);
  1232. snprintf(priv->hw->wiphy->fw_version,
  1233. sizeof(priv->hw->wiphy->fw_version),
  1234. "%s", fw->fw_version);
  1235. priv->new_scan_threshold_behaviour =
  1236. !!(ucode_flags & IWL_UCODE_TLV_FLAGS_NEWSCAN);
  1237. priv->phy_calib_chain_noise_reset_cmd =
  1238. fw->ucode_capa.standard_phy_calibration_size;
  1239. priv->phy_calib_chain_noise_gain_cmd =
  1240. fw->ucode_capa.standard_phy_calibration_size + 1;
  1241. /* initialize all valid contexts */
  1242. iwl_init_context(priv, ucode_flags);
  1243. /**************************************************
  1244. * This is still part of probe() in a sense...
  1245. *
  1246. * 7. Setup and register with mac80211 and debugfs
  1247. **************************************************/
  1248. if (iwlagn_mac_setup_register(priv, &fw->ucode_capa))
  1249. goto out_destroy_workqueue;
  1250. if (iwl_dbgfs_register(priv, dbgfs_dir))
  1251. goto out_mac80211_unregister;
  1252. return op_mode;
  1253. out_mac80211_unregister:
  1254. iwlagn_mac_unregister(priv);
  1255. out_destroy_workqueue:
  1256. iwl_tt_exit(priv);
  1257. iwl_cancel_deferred_work(priv);
  1258. destroy_workqueue(priv->workqueue);
  1259. priv->workqueue = NULL;
  1260. iwl_uninit_drv(priv);
  1261. out_free_eeprom_blob:
  1262. kfree(priv->eeprom_blob);
  1263. out_free_eeprom:
  1264. iwl_free_nvm_data(priv->nvm_data);
  1265. out_free_hw:
  1266. ieee80211_free_hw(priv->hw);
  1267. out:
  1268. op_mode = NULL;
  1269. return op_mode;
  1270. }
  1271. static void iwl_op_mode_dvm_stop(struct iwl_op_mode *op_mode)
  1272. {
  1273. struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
  1274. IWL_DEBUG_INFO(priv, "*** UNLOAD DRIVER ***\n");
  1275. iwlagn_mac_unregister(priv);
  1276. iwl_tt_exit(priv);
  1277. kfree(priv->eeprom_blob);
  1278. iwl_free_nvm_data(priv->nvm_data);
  1279. /*netif_stop_queue(dev); */
  1280. flush_workqueue(priv->workqueue);
  1281. /* ieee80211_unregister_hw calls iwlagn_mac_stop, which flushes
  1282. * priv->workqueue... so we can't take down the workqueue
  1283. * until now... */
  1284. destroy_workqueue(priv->workqueue);
  1285. priv->workqueue = NULL;
  1286. iwl_uninit_drv(priv);
  1287. dev_kfree_skb(priv->beacon_skb);
  1288. iwl_trans_op_mode_leave(priv->trans);
  1289. ieee80211_free_hw(priv->hw);
  1290. }
  1291. static const char * const desc_lookup_text[] = {
  1292. "OK",
  1293. "FAIL",
  1294. "BAD_PARAM",
  1295. "BAD_CHECKSUM",
  1296. "NMI_INTERRUPT_WDG",
  1297. "SYSASSERT",
  1298. "FATAL_ERROR",
  1299. "BAD_COMMAND",
  1300. "HW_ERROR_TUNE_LOCK",
  1301. "HW_ERROR_TEMPERATURE",
  1302. "ILLEGAL_CHAN_FREQ",
  1303. "VCC_NOT_STABLE",
  1304. "FH_ERROR",
  1305. "NMI_INTERRUPT_HOST",
  1306. "NMI_INTERRUPT_ACTION_PT",
  1307. "NMI_INTERRUPT_UNKNOWN",
  1308. "UCODE_VERSION_MISMATCH",
  1309. "HW_ERROR_ABS_LOCK",
  1310. "HW_ERROR_CAL_LOCK_FAIL",
  1311. "NMI_INTERRUPT_INST_ACTION_PT",
  1312. "NMI_INTERRUPT_DATA_ACTION_PT",
  1313. "NMI_TRM_HW_ER",
  1314. "NMI_INTERRUPT_TRM",
  1315. "NMI_INTERRUPT_BREAK_POINT",
  1316. "DEBUG_0",
  1317. "DEBUG_1",
  1318. "DEBUG_2",
  1319. "DEBUG_3",
  1320. };
  1321. static struct { char *name; u8 num; } advanced_lookup[] = {
  1322. { "NMI_INTERRUPT_WDG", 0x34 },
  1323. { "SYSASSERT", 0x35 },
  1324. { "UCODE_VERSION_MISMATCH", 0x37 },
  1325. { "BAD_COMMAND", 0x38 },
  1326. { "NMI_INTERRUPT_DATA_ACTION_PT", 0x3C },
  1327. { "FATAL_ERROR", 0x3D },
  1328. { "NMI_TRM_HW_ERR", 0x46 },
  1329. { "NMI_INTERRUPT_TRM", 0x4C },
  1330. { "NMI_INTERRUPT_BREAK_POINT", 0x54 },
  1331. { "NMI_INTERRUPT_WDG_RXF_FULL", 0x5C },
  1332. { "NMI_INTERRUPT_WDG_NO_RBD_RXF_FULL", 0x64 },
  1333. { "NMI_INTERRUPT_HOST", 0x66 },
  1334. { "NMI_INTERRUPT_ACTION_PT", 0x7C },
  1335. { "NMI_INTERRUPT_UNKNOWN", 0x84 },
  1336. { "NMI_INTERRUPT_INST_ACTION_PT", 0x86 },
  1337. { "ADVANCED_SYSASSERT", 0 },
  1338. };
  1339. static const char *desc_lookup(u32 num)
  1340. {
  1341. int i;
  1342. int max = ARRAY_SIZE(desc_lookup_text);
  1343. if (num < max)
  1344. return desc_lookup_text[num];
  1345. max = ARRAY_SIZE(advanced_lookup) - 1;
  1346. for (i = 0; i < max; i++) {
  1347. if (advanced_lookup[i].num == num)
  1348. break;
  1349. }
  1350. return advanced_lookup[i].name;
  1351. }
  1352. #define ERROR_START_OFFSET (1 * sizeof(u32))
  1353. #define ERROR_ELEM_SIZE (7 * sizeof(u32))
  1354. static void iwl_dump_nic_error_log(struct iwl_priv *priv)
  1355. {
  1356. struct iwl_trans *trans = priv->trans;
  1357. u32 base;
  1358. struct iwl_error_event_table table;
  1359. base = priv->device_pointers.error_event_table;
  1360. if (priv->cur_ucode == IWL_UCODE_INIT) {
  1361. if (!base)
  1362. base = priv->fw->init_errlog_ptr;
  1363. } else {
  1364. if (!base)
  1365. base = priv->fw->inst_errlog_ptr;
  1366. }
  1367. if (!iwlagn_hw_valid_rtc_data_addr(base)) {
  1368. IWL_ERR(priv,
  1369. "Not valid error log pointer 0x%08X for %s uCode\n",
  1370. base,
  1371. (priv->cur_ucode == IWL_UCODE_INIT)
  1372. ? "Init" : "RT");
  1373. return;
  1374. }
  1375. /*TODO: Update dbgfs with ISR error stats obtained below */
  1376. iwl_trans_read_mem_bytes(trans, base, &table, sizeof(table));
  1377. if (ERROR_START_OFFSET <= table.valid * ERROR_ELEM_SIZE) {
  1378. IWL_ERR(trans, "Start IWL Error Log Dump:\n");
  1379. IWL_ERR(trans, "Status: 0x%08lX, count: %d\n",
  1380. priv->status, table.valid);
  1381. }
  1382. trace_iwlwifi_dev_ucode_error(trans->dev, table.error_id, table.tsf_low,
  1383. table.data1, table.data2, table.line,
  1384. table.blink2, table.ilink1, table.ilink2,
  1385. table.bcon_time, table.gp1, table.gp2,
  1386. table.gp3, table.ucode_ver, table.hw_ver,
  1387. 0, table.brd_ver);
  1388. IWL_ERR(priv, "0x%08X | %-28s\n", table.error_id,
  1389. desc_lookup(table.error_id));
  1390. IWL_ERR(priv, "0x%08X | uPc\n", table.pc);
  1391. IWL_ERR(priv, "0x%08X | branchlink1\n", table.blink1);
  1392. IWL_ERR(priv, "0x%08X | branchlink2\n", table.blink2);
  1393. IWL_ERR(priv, "0x%08X | interruptlink1\n", table.ilink1);
  1394. IWL_ERR(priv, "0x%08X | interruptlink2\n", table.ilink2);
  1395. IWL_ERR(priv, "0x%08X | data1\n", table.data1);
  1396. IWL_ERR(priv, "0x%08X | data2\n", table.data2);
  1397. IWL_ERR(priv, "0x%08X | line\n", table.line);
  1398. IWL_ERR(priv, "0x%08X | beacon time\n", table.bcon_time);
  1399. IWL_ERR(priv, "0x%08X | tsf low\n", table.tsf_low);
  1400. IWL_ERR(priv, "0x%08X | tsf hi\n", table.tsf_hi);
  1401. IWL_ERR(priv, "0x%08X | time gp1\n", table.gp1);
  1402. IWL_ERR(priv, "0x%08X | time gp2\n", table.gp2);
  1403. IWL_ERR(priv, "0x%08X | time gp3\n", table.gp3);
  1404. IWL_ERR(priv, "0x%08X | uCode version\n", table.ucode_ver);
  1405. IWL_ERR(priv, "0x%08X | hw version\n", table.hw_ver);
  1406. IWL_ERR(priv, "0x%08X | board version\n", table.brd_ver);
  1407. IWL_ERR(priv, "0x%08X | hcmd\n", table.hcmd);
  1408. IWL_ERR(priv, "0x%08X | isr0\n", table.isr0);
  1409. IWL_ERR(priv, "0x%08X | isr1\n", table.isr1);
  1410. IWL_ERR(priv, "0x%08X | isr2\n", table.isr2);
  1411. IWL_ERR(priv, "0x%08X | isr3\n", table.isr3);
  1412. IWL_ERR(priv, "0x%08X | isr4\n", table.isr4);
  1413. IWL_ERR(priv, "0x%08X | isr_pref\n", table.isr_pref);
  1414. IWL_ERR(priv, "0x%08X | wait_event\n", table.wait_event);
  1415. IWL_ERR(priv, "0x%08X | l2p_control\n", table.l2p_control);
  1416. IWL_ERR(priv, "0x%08X | l2p_duration\n", table.l2p_duration);
  1417. IWL_ERR(priv, "0x%08X | l2p_mhvalid\n", table.l2p_mhvalid);
  1418. IWL_ERR(priv, "0x%08X | l2p_addr_match\n", table.l2p_addr_match);
  1419. IWL_ERR(priv, "0x%08X | lmpm_pmg_sel\n", table.lmpm_pmg_sel);
  1420. IWL_ERR(priv, "0x%08X | timestamp\n", table.u_timestamp);
  1421. IWL_ERR(priv, "0x%08X | flow_handler\n", table.flow_handler);
  1422. }
  1423. #define EVENT_START_OFFSET (4 * sizeof(u32))
  1424. /**
  1425. * iwl_print_event_log - Dump error event log to syslog
  1426. *
  1427. */
  1428. static int iwl_print_event_log(struct iwl_priv *priv, u32 start_idx,
  1429. u32 num_events, u32 mode,
  1430. int pos, char **buf, size_t bufsz)
  1431. {
  1432. u32 i;
  1433. u32 base; /* SRAM byte address of event log header */
  1434. u32 event_size; /* 2 u32s, or 3 u32s if timestamp recorded */
  1435. u32 ptr; /* SRAM byte address of log data */
  1436. u32 ev, time, data; /* event log data */
  1437. unsigned long reg_flags;
  1438. struct iwl_trans *trans = priv->trans;
  1439. if (num_events == 0)
  1440. return pos;
  1441. base = priv->device_pointers.log_event_table;
  1442. if (priv->cur_ucode == IWL_UCODE_INIT) {
  1443. if (!base)
  1444. base = priv->fw->init_evtlog_ptr;
  1445. } else {
  1446. if (!base)
  1447. base = priv->fw->inst_evtlog_ptr;
  1448. }
  1449. if (mode == 0)
  1450. event_size = 2 * sizeof(u32);
  1451. else
  1452. event_size = 3 * sizeof(u32);
  1453. ptr = base + EVENT_START_OFFSET + (start_idx * event_size);
  1454. /* Make sure device is powered up for SRAM reads */
  1455. if (!iwl_trans_grab_nic_access(trans, &reg_flags))
  1456. return pos;
  1457. /* Set starting address; reads will auto-increment */
  1458. iwl_write32(trans, HBUS_TARG_MEM_RADDR, ptr);
  1459. /* "time" is actually "data" for mode 0 (no timestamp).
  1460. * place event id # at far right for easier visual parsing. */
  1461. for (i = 0; i < num_events; i++) {
  1462. ev = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
  1463. time = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
  1464. if (mode == 0) {
  1465. /* data, ev */
  1466. if (bufsz) {
  1467. pos += scnprintf(*buf + pos, bufsz - pos,
  1468. "EVT_LOG:0x%08x:%04u\n",
  1469. time, ev);
  1470. } else {
  1471. trace_iwlwifi_dev_ucode_event(trans->dev, 0,
  1472. time, ev);
  1473. IWL_ERR(priv, "EVT_LOG:0x%08x:%04u\n",
  1474. time, ev);
  1475. }
  1476. } else {
  1477. data = iwl_read32(trans, HBUS_TARG_MEM_RDAT);
  1478. if (bufsz) {
  1479. pos += scnprintf(*buf + pos, bufsz - pos,
  1480. "EVT_LOGT:%010u:0x%08x:%04u\n",
  1481. time, data, ev);
  1482. } else {
  1483. IWL_ERR(priv, "EVT_LOGT:%010u:0x%08x:%04u\n",
  1484. time, data, ev);
  1485. trace_iwlwifi_dev_ucode_event(trans->dev, time,
  1486. data, ev);
  1487. }
  1488. }
  1489. }
  1490. /* Allow device to power down */
  1491. iwl_trans_release_nic_access(trans, &reg_flags);
  1492. return pos;
  1493. }
  1494. /**
  1495. * iwl_print_last_event_logs - Dump the newest # of event log to syslog
  1496. */
  1497. static int iwl_print_last_event_logs(struct iwl_priv *priv, u32 capacity,
  1498. u32 num_wraps, u32 next_entry,
  1499. u32 size, u32 mode,
  1500. int pos, char **buf, size_t bufsz)
  1501. {
  1502. /*
  1503. * display the newest DEFAULT_LOG_ENTRIES entries
  1504. * i.e the entries just before the next ont that uCode would fill.
  1505. */
  1506. if (num_wraps) {
  1507. if (next_entry < size) {
  1508. pos = iwl_print_event_log(priv,
  1509. capacity - (size - next_entry),
  1510. size - next_entry, mode,
  1511. pos, buf, bufsz);
  1512. pos = iwl_print_event_log(priv, 0,
  1513. next_entry, mode,
  1514. pos, buf, bufsz);
  1515. } else
  1516. pos = iwl_print_event_log(priv, next_entry - size,
  1517. size, mode, pos, buf, bufsz);
  1518. } else {
  1519. if (next_entry < size) {
  1520. pos = iwl_print_event_log(priv, 0, next_entry,
  1521. mode, pos, buf, bufsz);
  1522. } else {
  1523. pos = iwl_print_event_log(priv, next_entry - size,
  1524. size, mode, pos, buf, bufsz);
  1525. }
  1526. }
  1527. return pos;
  1528. }
  1529. #define DEFAULT_DUMP_EVENT_LOG_ENTRIES (20)
  1530. int iwl_dump_nic_event_log(struct iwl_priv *priv, bool full_log,
  1531. char **buf)
  1532. {
  1533. u32 base; /* SRAM byte address of event log header */
  1534. u32 capacity; /* event log capacity in # entries */
  1535. u32 mode; /* 0 - no timestamp, 1 - timestamp recorded */
  1536. u32 num_wraps; /* # times uCode wrapped to top of log */
  1537. u32 next_entry; /* index of next entry to be written by uCode */
  1538. u32 size; /* # entries that we'll print */
  1539. u32 logsize;
  1540. int pos = 0;
  1541. size_t bufsz = 0;
  1542. struct iwl_trans *trans = priv->trans;
  1543. base = priv->device_pointers.log_event_table;
  1544. if (priv->cur_ucode == IWL_UCODE_INIT) {
  1545. logsize = priv->fw->init_evtlog_size;
  1546. if (!base)
  1547. base = priv->fw->init_evtlog_ptr;
  1548. } else {
  1549. logsize = priv->fw->inst_evtlog_size;
  1550. if (!base)
  1551. base = priv->fw->inst_evtlog_ptr;
  1552. }
  1553. if (!iwlagn_hw_valid_rtc_data_addr(base)) {
  1554. IWL_ERR(priv,
  1555. "Invalid event log pointer 0x%08X for %s uCode\n",
  1556. base,
  1557. (priv->cur_ucode == IWL_UCODE_INIT)
  1558. ? "Init" : "RT");
  1559. return -EINVAL;
  1560. }
  1561. /* event log header */
  1562. capacity = iwl_trans_read_mem32(trans, base);
  1563. mode = iwl_trans_read_mem32(trans, base + (1 * sizeof(u32)));
  1564. num_wraps = iwl_trans_read_mem32(trans, base + (2 * sizeof(u32)));
  1565. next_entry = iwl_trans_read_mem32(trans, base + (3 * sizeof(u32)));
  1566. if (capacity > logsize) {
  1567. IWL_ERR(priv, "Log capacity %d is bogus, limit to %d "
  1568. "entries\n", capacity, logsize);
  1569. capacity = logsize;
  1570. }
  1571. if (next_entry > logsize) {
  1572. IWL_ERR(priv, "Log write index %d is bogus, limit to %d\n",
  1573. next_entry, logsize);
  1574. next_entry = logsize;
  1575. }
  1576. size = num_wraps ? capacity : next_entry;
  1577. /* bail out if nothing in log */
  1578. if (size == 0) {
  1579. IWL_ERR(trans, "Start IWL Event Log Dump: nothing in log\n");
  1580. return pos;
  1581. }
  1582. if (!(iwl_have_debug_level(IWL_DL_FW_ERRORS)) && !full_log)
  1583. size = (size > DEFAULT_DUMP_EVENT_LOG_ENTRIES)
  1584. ? DEFAULT_DUMP_EVENT_LOG_ENTRIES : size;
  1585. IWL_ERR(priv, "Start IWL Event Log Dump: display last %u entries\n",
  1586. size);
  1587. #ifdef CONFIG_IWLWIFI_DEBUG
  1588. if (buf) {
  1589. if (full_log)
  1590. bufsz = capacity * 48;
  1591. else
  1592. bufsz = size * 48;
  1593. *buf = kmalloc(bufsz, GFP_KERNEL);
  1594. if (!*buf)
  1595. return -ENOMEM;
  1596. }
  1597. if (iwl_have_debug_level(IWL_DL_FW_ERRORS) || full_log) {
  1598. /*
  1599. * if uCode has wrapped back to top of log,
  1600. * start at the oldest entry,
  1601. * i.e the next one that uCode would fill.
  1602. */
  1603. if (num_wraps)
  1604. pos = iwl_print_event_log(priv, next_entry,
  1605. capacity - next_entry, mode,
  1606. pos, buf, bufsz);
  1607. /* (then/else) start at top of log */
  1608. pos = iwl_print_event_log(priv, 0,
  1609. next_entry, mode, pos, buf, bufsz);
  1610. } else
  1611. pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
  1612. next_entry, size, mode,
  1613. pos, buf, bufsz);
  1614. #else
  1615. pos = iwl_print_last_event_logs(priv, capacity, num_wraps,
  1616. next_entry, size, mode,
  1617. pos, buf, bufsz);
  1618. #endif
  1619. return pos;
  1620. }
  1621. static void iwlagn_fw_error(struct iwl_priv *priv, bool ondemand)
  1622. {
  1623. unsigned int reload_msec;
  1624. unsigned long reload_jiffies;
  1625. if (iwl_have_debug_level(IWL_DL_FW_ERRORS))
  1626. iwl_print_rx_config_cmd(priv, IWL_RXON_CTX_BSS);
  1627. /* uCode is no longer loaded. */
  1628. priv->ucode_loaded = false;
  1629. /* Set the FW error flag -- cleared on iwl_down */
  1630. set_bit(STATUS_FW_ERROR, &priv->status);
  1631. iwl_abort_notification_waits(&priv->notif_wait);
  1632. /* Keep the restart process from trying to send host
  1633. * commands by clearing the ready bit */
  1634. clear_bit(STATUS_READY, &priv->status);
  1635. if (!ondemand) {
  1636. /*
  1637. * If firmware keep reloading, then it indicate something
  1638. * serious wrong and firmware having problem to recover
  1639. * from it. Instead of keep trying which will fill the syslog
  1640. * and hang the system, let's just stop it
  1641. */
  1642. reload_jiffies = jiffies;
  1643. reload_msec = jiffies_to_msecs((long) reload_jiffies -
  1644. (long) priv->reload_jiffies);
  1645. priv->reload_jiffies = reload_jiffies;
  1646. if (reload_msec <= IWL_MIN_RELOAD_DURATION) {
  1647. priv->reload_count++;
  1648. if (priv->reload_count >= IWL_MAX_CONTINUE_RELOAD_CNT) {
  1649. IWL_ERR(priv, "BUG_ON, Stop restarting\n");
  1650. return;
  1651. }
  1652. } else
  1653. priv->reload_count = 0;
  1654. }
  1655. if (!test_bit(STATUS_EXIT_PENDING, &priv->status)) {
  1656. if (iwlwifi_mod_params.restart_fw) {
  1657. IWL_DEBUG_FW_ERRORS(priv,
  1658. "Restarting adapter due to uCode error.\n");
  1659. queue_work(priv->workqueue, &priv->restart);
  1660. } else
  1661. IWL_DEBUG_FW_ERRORS(priv,
  1662. "Detected FW error, but not restarting\n");
  1663. }
  1664. }
  1665. static void iwl_nic_error(struct iwl_op_mode *op_mode)
  1666. {
  1667. struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
  1668. IWL_ERR(priv, "Loaded firmware version: %s\n",
  1669. priv->fw->fw_version);
  1670. iwl_dump_nic_error_log(priv);
  1671. iwl_dump_nic_event_log(priv, false, NULL);
  1672. iwlagn_fw_error(priv, false);
  1673. }
  1674. static void iwl_cmd_queue_full(struct iwl_op_mode *op_mode)
  1675. {
  1676. struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
  1677. if (!iwl_check_for_ct_kill(priv)) {
  1678. IWL_ERR(priv, "Restarting adapter queue is full\n");
  1679. iwlagn_fw_error(priv, false);
  1680. }
  1681. }
  1682. #define EEPROM_RF_CONFIG_TYPE_MAX 0x3
  1683. static void iwl_nic_config(struct iwl_op_mode *op_mode)
  1684. {
  1685. struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
  1686. /* SKU Control */
  1687. iwl_trans_set_bits_mask(priv->trans, CSR_HW_IF_CONFIG_REG,
  1688. CSR_HW_IF_CONFIG_REG_MSK_MAC_DASH |
  1689. CSR_HW_IF_CONFIG_REG_MSK_MAC_STEP,
  1690. (CSR_HW_REV_STEP(priv->trans->hw_rev) <<
  1691. CSR_HW_IF_CONFIG_REG_POS_MAC_STEP) |
  1692. (CSR_HW_REV_DASH(priv->trans->hw_rev) <<
  1693. CSR_HW_IF_CONFIG_REG_POS_MAC_DASH));
  1694. /* write radio config values to register */
  1695. if (priv->nvm_data->radio_cfg_type <= EEPROM_RF_CONFIG_TYPE_MAX) {
  1696. u32 reg_val =
  1697. priv->nvm_data->radio_cfg_type <<
  1698. CSR_HW_IF_CONFIG_REG_POS_PHY_TYPE |
  1699. priv->nvm_data->radio_cfg_step <<
  1700. CSR_HW_IF_CONFIG_REG_POS_PHY_STEP |
  1701. priv->nvm_data->radio_cfg_dash <<
  1702. CSR_HW_IF_CONFIG_REG_POS_PHY_DASH;
  1703. iwl_trans_set_bits_mask(priv->trans, CSR_HW_IF_CONFIG_REG,
  1704. CSR_HW_IF_CONFIG_REG_MSK_PHY_TYPE |
  1705. CSR_HW_IF_CONFIG_REG_MSK_PHY_STEP |
  1706. CSR_HW_IF_CONFIG_REG_MSK_PHY_DASH,
  1707. reg_val);
  1708. IWL_INFO(priv, "Radio type=0x%x-0x%x-0x%x\n",
  1709. priv->nvm_data->radio_cfg_type,
  1710. priv->nvm_data->radio_cfg_step,
  1711. priv->nvm_data->radio_cfg_dash);
  1712. } else {
  1713. WARN_ON(1);
  1714. }
  1715. /* set CSR_HW_CONFIG_REG for uCode use */
  1716. iwl_set_bit(priv->trans, CSR_HW_IF_CONFIG_REG,
  1717. CSR_HW_IF_CONFIG_REG_BIT_RADIO_SI |
  1718. CSR_HW_IF_CONFIG_REG_BIT_MAC_SI);
  1719. /* W/A : NIC is stuck in a reset state after Early PCIe power off
  1720. * (PCIe power is lost before PERST# is asserted),
  1721. * causing ME FW to lose ownership and not being able to obtain it back.
  1722. */
  1723. iwl_set_bits_mask_prph(priv->trans, APMG_PS_CTRL_REG,
  1724. APMG_PS_CTRL_EARLY_PWR_OFF_RESET_DIS,
  1725. ~APMG_PS_CTRL_EARLY_PWR_OFF_RESET_DIS);
  1726. if (priv->lib->nic_config)
  1727. priv->lib->nic_config(priv);
  1728. }
  1729. static void iwl_wimax_active(struct iwl_op_mode *op_mode)
  1730. {
  1731. struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
  1732. clear_bit(STATUS_READY, &priv->status);
  1733. IWL_ERR(priv, "RF is used by WiMAX\n");
  1734. }
  1735. static void iwl_stop_sw_queue(struct iwl_op_mode *op_mode, int queue)
  1736. {
  1737. struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
  1738. int mq = priv->queue_to_mac80211[queue];
  1739. if (WARN_ON_ONCE(mq == IWL_INVALID_MAC80211_QUEUE))
  1740. return;
  1741. if (atomic_inc_return(&priv->queue_stop_count[mq]) > 1) {
  1742. IWL_DEBUG_TX_QUEUES(priv,
  1743. "queue %d (mac80211 %d) already stopped\n",
  1744. queue, mq);
  1745. return;
  1746. }
  1747. set_bit(mq, &priv->transport_queue_stop);
  1748. ieee80211_stop_queue(priv->hw, mq);
  1749. }
  1750. static void iwl_wake_sw_queue(struct iwl_op_mode *op_mode, int queue)
  1751. {
  1752. struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
  1753. int mq = priv->queue_to_mac80211[queue];
  1754. if (WARN_ON_ONCE(mq == IWL_INVALID_MAC80211_QUEUE))
  1755. return;
  1756. if (atomic_dec_return(&priv->queue_stop_count[mq]) > 0) {
  1757. IWL_DEBUG_TX_QUEUES(priv,
  1758. "queue %d (mac80211 %d) already awake\n",
  1759. queue, mq);
  1760. return;
  1761. }
  1762. clear_bit(mq, &priv->transport_queue_stop);
  1763. if (!priv->passive_no_rx)
  1764. ieee80211_wake_queue(priv->hw, mq);
  1765. }
  1766. void iwlagn_lift_passive_no_rx(struct iwl_priv *priv)
  1767. {
  1768. int mq;
  1769. if (!priv->passive_no_rx)
  1770. return;
  1771. for (mq = 0; mq < IWLAGN_FIRST_AMPDU_QUEUE; mq++) {
  1772. if (!test_bit(mq, &priv->transport_queue_stop)) {
  1773. IWL_DEBUG_TX_QUEUES(priv, "Wake queue %d\n", mq);
  1774. ieee80211_wake_queue(priv->hw, mq);
  1775. } else {
  1776. IWL_DEBUG_TX_QUEUES(priv, "Don't wake queue %d\n", mq);
  1777. }
  1778. }
  1779. priv->passive_no_rx = false;
  1780. }
  1781. static void iwl_free_skb(struct iwl_op_mode *op_mode, struct sk_buff *skb)
  1782. {
  1783. struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
  1784. struct ieee80211_tx_info *info;
  1785. info = IEEE80211_SKB_CB(skb);
  1786. iwl_trans_free_tx_cmd(priv->trans, info->driver_data[1]);
  1787. ieee80211_free_txskb(priv->hw, skb);
  1788. }
  1789. static bool iwl_set_hw_rfkill_state(struct iwl_op_mode *op_mode, bool state)
  1790. {
  1791. struct iwl_priv *priv = IWL_OP_MODE_GET_DVM(op_mode);
  1792. if (state)
  1793. set_bit(STATUS_RF_KILL_HW, &priv->status);
  1794. else
  1795. clear_bit(STATUS_RF_KILL_HW, &priv->status);
  1796. wiphy_rfkill_set_hw_state(priv->hw->wiphy, state);
  1797. return false;
  1798. }
  1799. static const struct iwl_op_mode_ops iwl_dvm_ops = {
  1800. .start = iwl_op_mode_dvm_start,
  1801. .stop = iwl_op_mode_dvm_stop,
  1802. .rx = iwl_rx_dispatch,
  1803. .queue_full = iwl_stop_sw_queue,
  1804. .queue_not_full = iwl_wake_sw_queue,
  1805. .hw_rf_kill = iwl_set_hw_rfkill_state,
  1806. .free_skb = iwl_free_skb,
  1807. .nic_error = iwl_nic_error,
  1808. .cmd_queue_full = iwl_cmd_queue_full,
  1809. .nic_config = iwl_nic_config,
  1810. .wimax_active = iwl_wimax_active,
  1811. };
  1812. /*****************************************************************************
  1813. *
  1814. * driver and module entry point
  1815. *
  1816. *****************************************************************************/
  1817. static int __init iwl_init(void)
  1818. {
  1819. int ret;
  1820. ret = iwlagn_rate_control_register();
  1821. if (ret) {
  1822. pr_err("Unable to register rate control algorithm: %d\n", ret);
  1823. return ret;
  1824. }
  1825. ret = iwl_opmode_register("iwldvm", &iwl_dvm_ops);
  1826. if (ret) {
  1827. pr_err("Unable to register op_mode: %d\n", ret);
  1828. iwlagn_rate_control_unregister();
  1829. }
  1830. return ret;
  1831. }
  1832. module_init(iwl_init);
  1833. static void __exit iwl_exit(void)
  1834. {
  1835. iwl_opmode_deregister("iwldvm");
  1836. iwlagn_rate_control_unregister();
  1837. }
  1838. module_exit(iwl_exit);