mac80211.c 41 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633
  1. /******************************************************************************
  2. *
  3. * Copyright(c) 2003 - 2012 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. #include <linux/kernel.h>
  30. #include <linux/module.h>
  31. #include <linux/init.h>
  32. #include <linux/slab.h>
  33. #include <linux/dma-mapping.h>
  34. #include <linux/delay.h>
  35. #include <linux/sched.h>
  36. #include <linux/skbuff.h>
  37. #include <linux/netdevice.h>
  38. #include <linux/etherdevice.h>
  39. #include <linux/if_arp.h>
  40. #include <net/ieee80211_radiotap.h>
  41. #include <net/mac80211.h>
  42. #include <asm/div64.h>
  43. #include "iwl-io.h"
  44. #include "iwl-trans.h"
  45. #include "iwl-op-mode.h"
  46. #include "iwl-modparams.h"
  47. #include "dev.h"
  48. #include "calib.h"
  49. #include "agn.h"
  50. /*****************************************************************************
  51. *
  52. * mac80211 entry point functions
  53. *
  54. *****************************************************************************/
  55. static const struct ieee80211_iface_limit iwlagn_sta_ap_limits[] = {
  56. {
  57. .max = 1,
  58. .types = BIT(NL80211_IFTYPE_STATION),
  59. },
  60. {
  61. .max = 1,
  62. .types = BIT(NL80211_IFTYPE_AP),
  63. },
  64. };
  65. static const struct ieee80211_iface_limit iwlagn_2sta_limits[] = {
  66. {
  67. .max = 2,
  68. .types = BIT(NL80211_IFTYPE_STATION),
  69. },
  70. };
  71. static const struct ieee80211_iface_limit iwlagn_p2p_sta_go_limits[] = {
  72. {
  73. .max = 1,
  74. .types = BIT(NL80211_IFTYPE_STATION),
  75. },
  76. {
  77. .max = 1,
  78. .types = BIT(NL80211_IFTYPE_P2P_GO) |
  79. BIT(NL80211_IFTYPE_AP),
  80. },
  81. };
  82. static const struct ieee80211_iface_limit iwlagn_p2p_2sta_limits[] = {
  83. {
  84. .max = 2,
  85. .types = BIT(NL80211_IFTYPE_STATION),
  86. },
  87. {
  88. .max = 1,
  89. .types = BIT(NL80211_IFTYPE_P2P_CLIENT),
  90. },
  91. };
  92. static const struct ieee80211_iface_combination
  93. iwlagn_iface_combinations_dualmode[] = {
  94. { .num_different_channels = 1,
  95. .max_interfaces = 2,
  96. .beacon_int_infra_match = true,
  97. .limits = iwlagn_sta_ap_limits,
  98. .n_limits = ARRAY_SIZE(iwlagn_sta_ap_limits),
  99. },
  100. { .num_different_channels = 1,
  101. .max_interfaces = 2,
  102. .limits = iwlagn_2sta_limits,
  103. .n_limits = ARRAY_SIZE(iwlagn_2sta_limits),
  104. },
  105. };
  106. static const struct ieee80211_iface_combination
  107. iwlagn_iface_combinations_p2p[] = {
  108. { .num_different_channels = 1,
  109. .max_interfaces = 2,
  110. .beacon_int_infra_match = true,
  111. .limits = iwlagn_p2p_sta_go_limits,
  112. .n_limits = ARRAY_SIZE(iwlagn_p2p_sta_go_limits),
  113. },
  114. { .num_different_channels = 1,
  115. .max_interfaces = 2,
  116. .limits = iwlagn_p2p_2sta_limits,
  117. .n_limits = ARRAY_SIZE(iwlagn_p2p_2sta_limits),
  118. },
  119. };
  120. /*
  121. * Not a mac80211 entry point function, but it fits in with all the
  122. * other mac80211 functions grouped here.
  123. */
  124. int iwlagn_mac_setup_register(struct iwl_priv *priv,
  125. const struct iwl_ucode_capabilities *capa)
  126. {
  127. int ret;
  128. struct ieee80211_hw *hw = priv->hw;
  129. struct iwl_rxon_context *ctx;
  130. hw->rate_control_algorithm = "iwl-agn-rs";
  131. /* Tell mac80211 our characteristics */
  132. hw->flags = IEEE80211_HW_SIGNAL_DBM |
  133. IEEE80211_HW_AMPDU_AGGREGATION |
  134. IEEE80211_HW_NEED_DTIM_PERIOD |
  135. IEEE80211_HW_SPECTRUM_MGMT |
  136. IEEE80211_HW_REPORTS_TX_ACK_STATUS |
  137. IEEE80211_HW_QUEUE_CONTROL |
  138. IEEE80211_HW_SUPPORTS_PS |
  139. IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
  140. IEEE80211_HW_WANT_MONITOR_VIF |
  141. IEEE80211_HW_SCAN_WHILE_IDLE;
  142. hw->offchannel_tx_hw_queue = IWL_AUX_QUEUE;
  143. hw->radiotap_mcs_details |= IEEE80211_RADIOTAP_MCS_HAVE_FMT;
  144. /*
  145. * Including the following line will crash some AP's. This
  146. * workaround removes the stimulus which causes the crash until
  147. * the AP software can be fixed.
  148. hw->max_tx_aggregation_subframes = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
  149. */
  150. if (priv->hw_params.sku & EEPROM_SKU_CAP_11N_ENABLE)
  151. hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
  152. IEEE80211_HW_SUPPORTS_STATIC_SMPS;
  153. #ifndef CONFIG_IWLWIFI_EXPERIMENTAL_MFP
  154. /* enable 11w if the uCode advertise */
  155. if (capa->flags & IWL_UCODE_TLV_FLAGS_MFP)
  156. #endif /* !CONFIG_IWLWIFI_EXPERIMENTAL_MFP */
  157. hw->flags |= IEEE80211_HW_MFP_CAPABLE;
  158. hw->sta_data_size = sizeof(struct iwl_station_priv);
  159. hw->vif_data_size = sizeof(struct iwl_vif_priv);
  160. for_each_context(priv, ctx) {
  161. hw->wiphy->interface_modes |= ctx->interface_modes;
  162. hw->wiphy->interface_modes |= ctx->exclusive_interface_modes;
  163. }
  164. BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
  165. if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)) {
  166. hw->wiphy->iface_combinations = iwlagn_iface_combinations_p2p;
  167. hw->wiphy->n_iface_combinations =
  168. ARRAY_SIZE(iwlagn_iface_combinations_p2p);
  169. } else if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
  170. hw->wiphy->iface_combinations =
  171. iwlagn_iface_combinations_dualmode;
  172. hw->wiphy->n_iface_combinations =
  173. ARRAY_SIZE(iwlagn_iface_combinations_dualmode);
  174. }
  175. hw->wiphy->max_remain_on_channel_duration = 1000;
  176. hw->wiphy->flags |= WIPHY_FLAG_CUSTOM_REGULATORY |
  177. WIPHY_FLAG_DISABLE_BEACON_HINTS |
  178. WIPHY_FLAG_IBSS_RSN;
  179. #ifdef CONFIG_PM_SLEEP
  180. if (priv->fw->img[IWL_UCODE_WOWLAN].sec[0].len &&
  181. priv->trans->ops->wowlan_suspend &&
  182. device_can_wakeup(priv->trans->dev)) {
  183. hw->wiphy->wowlan.flags = WIPHY_WOWLAN_MAGIC_PKT |
  184. WIPHY_WOWLAN_DISCONNECT |
  185. WIPHY_WOWLAN_EAP_IDENTITY_REQ |
  186. WIPHY_WOWLAN_RFKILL_RELEASE;
  187. if (!iwlwifi_mod_params.sw_crypto)
  188. hw->wiphy->wowlan.flags |=
  189. WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
  190. WIPHY_WOWLAN_GTK_REKEY_FAILURE;
  191. hw->wiphy->wowlan.n_patterns = IWLAGN_WOWLAN_MAX_PATTERNS;
  192. hw->wiphy->wowlan.pattern_min_len =
  193. IWLAGN_WOWLAN_MIN_PATTERN_LEN;
  194. hw->wiphy->wowlan.pattern_max_len =
  195. IWLAGN_WOWLAN_MAX_PATTERN_LEN;
  196. }
  197. #endif
  198. if (iwlwifi_mod_params.power_save)
  199. hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
  200. else
  201. hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
  202. hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
  203. /* we create the 802.11 header and a max-length SSID element */
  204. hw->wiphy->max_scan_ie_len = capa->max_probe_length - 24 - 34;
  205. /*
  206. * We don't use all queues: 4 and 9 are unused and any
  207. * aggregation queue gets mapped down to the AC queue.
  208. */
  209. hw->queues = IWLAGN_FIRST_AMPDU_QUEUE;
  210. hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
  211. if (priv->eeprom_data->bands[IEEE80211_BAND_2GHZ].n_channels)
  212. priv->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
  213. &priv->eeprom_data->bands[IEEE80211_BAND_2GHZ];
  214. if (priv->eeprom_data->bands[IEEE80211_BAND_5GHZ].n_channels)
  215. priv->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
  216. &priv->eeprom_data->bands[IEEE80211_BAND_5GHZ];
  217. hw->wiphy->hw_version = priv->trans->hw_id;
  218. iwl_leds_init(priv);
  219. ret = ieee80211_register_hw(priv->hw);
  220. if (ret) {
  221. IWL_ERR(priv, "Failed to register hw (error %d)\n", ret);
  222. iwl_leds_exit(priv);
  223. return ret;
  224. }
  225. priv->mac80211_registered = 1;
  226. return 0;
  227. }
  228. void iwlagn_mac_unregister(struct iwl_priv *priv)
  229. {
  230. if (!priv->mac80211_registered)
  231. return;
  232. iwl_leds_exit(priv);
  233. ieee80211_unregister_hw(priv->hw);
  234. priv->mac80211_registered = 0;
  235. }
  236. static int __iwl_up(struct iwl_priv *priv)
  237. {
  238. struct iwl_rxon_context *ctx;
  239. int ret;
  240. lockdep_assert_held(&priv->mutex);
  241. if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
  242. IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
  243. return -EIO;
  244. }
  245. for_each_context(priv, ctx) {
  246. ret = iwlagn_alloc_bcast_station(priv, ctx);
  247. if (ret) {
  248. iwl_dealloc_bcast_stations(priv);
  249. return ret;
  250. }
  251. }
  252. ret = iwl_run_init_ucode(priv);
  253. if (ret) {
  254. IWL_ERR(priv, "Failed to run INIT ucode: %d\n", ret);
  255. goto error;
  256. }
  257. ret = iwl_load_ucode_wait_alive(priv, IWL_UCODE_REGULAR);
  258. if (ret) {
  259. IWL_ERR(priv, "Failed to start RT ucode: %d\n", ret);
  260. goto error;
  261. }
  262. ret = iwl_alive_start(priv);
  263. if (ret)
  264. goto error;
  265. return 0;
  266. error:
  267. set_bit(STATUS_EXIT_PENDING, &priv->status);
  268. iwl_down(priv);
  269. clear_bit(STATUS_EXIT_PENDING, &priv->status);
  270. IWL_ERR(priv, "Unable to initialize device.\n");
  271. return ret;
  272. }
  273. static int iwlagn_mac_start(struct ieee80211_hw *hw)
  274. {
  275. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  276. int ret;
  277. IWL_DEBUG_MAC80211(priv, "enter\n");
  278. /* we should be verifying the device is ready to be opened */
  279. mutex_lock(&priv->mutex);
  280. ret = __iwl_up(priv);
  281. mutex_unlock(&priv->mutex);
  282. if (ret)
  283. return ret;
  284. IWL_DEBUG_INFO(priv, "Start UP work done.\n");
  285. /* Now we should be done, and the READY bit should be set. */
  286. if (WARN_ON(!test_bit(STATUS_READY, &priv->status)))
  287. ret = -EIO;
  288. iwlagn_led_enable(priv);
  289. priv->is_open = 1;
  290. IWL_DEBUG_MAC80211(priv, "leave\n");
  291. return 0;
  292. }
  293. static void iwlagn_mac_stop(struct ieee80211_hw *hw)
  294. {
  295. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  296. IWL_DEBUG_MAC80211(priv, "enter\n");
  297. if (!priv->is_open)
  298. return;
  299. priv->is_open = 0;
  300. mutex_lock(&priv->mutex);
  301. iwl_down(priv);
  302. mutex_unlock(&priv->mutex);
  303. iwl_cancel_deferred_work(priv);
  304. flush_workqueue(priv->workqueue);
  305. /* User space software may expect getting rfkill changes
  306. * even if interface is down, trans->down will leave the RF
  307. * kill interrupt enabled
  308. */
  309. iwl_trans_stop_hw(priv->trans, false);
  310. IWL_DEBUG_MAC80211(priv, "leave\n");
  311. }
  312. static void iwlagn_mac_set_rekey_data(struct ieee80211_hw *hw,
  313. struct ieee80211_vif *vif,
  314. struct cfg80211_gtk_rekey_data *data)
  315. {
  316. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  317. if (iwlwifi_mod_params.sw_crypto)
  318. return;
  319. IWL_DEBUG_MAC80211(priv, "enter\n");
  320. mutex_lock(&priv->mutex);
  321. if (priv->contexts[IWL_RXON_CTX_BSS].vif != vif)
  322. goto out;
  323. memcpy(priv->kek, data->kek, NL80211_KEK_LEN);
  324. memcpy(priv->kck, data->kck, NL80211_KCK_LEN);
  325. priv->replay_ctr =
  326. cpu_to_le64(be64_to_cpup((__be64 *)&data->replay_ctr));
  327. priv->have_rekey_data = true;
  328. out:
  329. mutex_unlock(&priv->mutex);
  330. IWL_DEBUG_MAC80211(priv, "leave\n");
  331. }
  332. #ifdef CONFIG_PM_SLEEP
  333. static int iwlagn_mac_suspend(struct ieee80211_hw *hw,
  334. struct cfg80211_wowlan *wowlan)
  335. {
  336. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  337. struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
  338. int ret;
  339. if (WARN_ON(!wowlan))
  340. return -EINVAL;
  341. IWL_DEBUG_MAC80211(priv, "enter\n");
  342. mutex_lock(&priv->mutex);
  343. /* Don't attempt WoWLAN when not associated, tear down instead. */
  344. if (!ctx->vif || ctx->vif->type != NL80211_IFTYPE_STATION ||
  345. !iwl_is_associated_ctx(ctx)) {
  346. ret = 1;
  347. goto out;
  348. }
  349. ret = iwlagn_suspend(priv, wowlan);
  350. if (ret)
  351. goto error;
  352. iwl_trans_wowlan_suspend(priv->trans);
  353. goto out;
  354. error:
  355. priv->wowlan = false;
  356. iwlagn_prepare_restart(priv);
  357. ieee80211_restart_hw(priv->hw);
  358. out:
  359. mutex_unlock(&priv->mutex);
  360. IWL_DEBUG_MAC80211(priv, "leave\n");
  361. return ret;
  362. }
  363. static int iwlagn_mac_resume(struct ieee80211_hw *hw)
  364. {
  365. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  366. struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
  367. struct ieee80211_vif *vif;
  368. unsigned long flags;
  369. u32 base, status = 0xffffffff;
  370. int ret = -EIO;
  371. IWL_DEBUG_MAC80211(priv, "enter\n");
  372. mutex_lock(&priv->mutex);
  373. iwl_write32(priv->trans, CSR_UCODE_DRV_GP1_CLR,
  374. CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
  375. base = priv->device_pointers.error_event_table;
  376. if (iwlagn_hw_valid_rtc_data_addr(base)) {
  377. spin_lock_irqsave(&priv->trans->reg_lock, flags);
  378. ret = iwl_grab_nic_access_silent(priv->trans);
  379. if (likely(ret == 0)) {
  380. iwl_write32(priv->trans, HBUS_TARG_MEM_RADDR, base);
  381. status = iwl_read32(priv->trans, HBUS_TARG_MEM_RDAT);
  382. iwl_release_nic_access(priv->trans);
  383. }
  384. spin_unlock_irqrestore(&priv->trans->reg_lock, flags);
  385. #ifdef CONFIG_IWLWIFI_DEBUGFS
  386. if (ret == 0) {
  387. const struct fw_img *img;
  388. img = &(priv->fw->img[IWL_UCODE_WOWLAN]);
  389. if (!priv->wowlan_sram) {
  390. priv->wowlan_sram =
  391. kzalloc(img->sec[IWL_UCODE_SECTION_DATA].len,
  392. GFP_KERNEL);
  393. }
  394. if (priv->wowlan_sram)
  395. _iwl_read_targ_mem_words(
  396. priv->trans, 0x800000,
  397. priv->wowlan_sram,
  398. img->sec[IWL_UCODE_SECTION_DATA].len / 4);
  399. }
  400. #endif
  401. }
  402. /* we'll clear ctx->vif during iwlagn_prepare_restart() */
  403. vif = ctx->vif;
  404. priv->wowlan = false;
  405. iwlagn_prepare_restart(priv);
  406. memset((void *)&ctx->active, 0, sizeof(ctx->active));
  407. iwl_connection_init_rx_config(priv, ctx);
  408. iwlagn_set_rxon_chain(priv, ctx);
  409. mutex_unlock(&priv->mutex);
  410. IWL_DEBUG_MAC80211(priv, "leave\n");
  411. ieee80211_resume_disconnect(vif);
  412. return 1;
  413. }
  414. static void iwlagn_mac_set_wakeup(struct ieee80211_hw *hw, bool enabled)
  415. {
  416. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  417. device_set_wakeup_enable(priv->trans->dev, enabled);
  418. }
  419. #endif
  420. static void iwlagn_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
  421. {
  422. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  423. IWL_DEBUG_TX(priv, "dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
  424. ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
  425. if (iwlagn_tx_skb(priv, skb))
  426. dev_kfree_skb_any(skb);
  427. }
  428. static void iwlagn_mac_update_tkip_key(struct ieee80211_hw *hw,
  429. struct ieee80211_vif *vif,
  430. struct ieee80211_key_conf *keyconf,
  431. struct ieee80211_sta *sta,
  432. u32 iv32, u16 *phase1key)
  433. {
  434. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  435. iwl_update_tkip_key(priv, vif, keyconf, sta, iv32, phase1key);
  436. }
  437. static int iwlagn_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
  438. struct ieee80211_vif *vif,
  439. struct ieee80211_sta *sta,
  440. struct ieee80211_key_conf *key)
  441. {
  442. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  443. struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
  444. struct iwl_rxon_context *ctx = vif_priv->ctx;
  445. int ret;
  446. bool is_default_wep_key = false;
  447. IWL_DEBUG_MAC80211(priv, "enter\n");
  448. if (iwlwifi_mod_params.sw_crypto) {
  449. IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
  450. return -EOPNOTSUPP;
  451. }
  452. switch (key->cipher) {
  453. case WLAN_CIPHER_SUITE_TKIP:
  454. key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
  455. /* fall through */
  456. case WLAN_CIPHER_SUITE_CCMP:
  457. key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
  458. break;
  459. default:
  460. break;
  461. }
  462. /*
  463. * We could program these keys into the hardware as well, but we
  464. * don't expect much multicast traffic in IBSS and having keys
  465. * for more stations is probably more useful.
  466. *
  467. * Mark key TX-only and return 0.
  468. */
  469. if (vif->type == NL80211_IFTYPE_ADHOC &&
  470. !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
  471. key->hw_key_idx = WEP_INVALID_OFFSET;
  472. return 0;
  473. }
  474. /* If they key was TX-only, accept deletion */
  475. if (cmd == DISABLE_KEY && key->hw_key_idx == WEP_INVALID_OFFSET)
  476. return 0;
  477. mutex_lock(&priv->mutex);
  478. iwl_scan_cancel_timeout(priv, 100);
  479. BUILD_BUG_ON(WEP_INVALID_OFFSET == IWLAGN_HW_KEY_DEFAULT);
  480. /*
  481. * If we are getting WEP group key and we didn't receive any key mapping
  482. * so far, we are in legacy wep mode (group key only), otherwise we are
  483. * in 1X mode.
  484. * In legacy wep mode, we use another host command to the uCode.
  485. */
  486. if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
  487. key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
  488. if (cmd == SET_KEY)
  489. is_default_wep_key = !ctx->key_mapping_keys;
  490. else
  491. is_default_wep_key =
  492. key->hw_key_idx == IWLAGN_HW_KEY_DEFAULT;
  493. }
  494. switch (cmd) {
  495. case SET_KEY:
  496. if (is_default_wep_key) {
  497. ret = iwl_set_default_wep_key(priv, vif_priv->ctx, key);
  498. break;
  499. }
  500. ret = iwl_set_dynamic_key(priv, vif_priv->ctx, key, sta);
  501. if (ret) {
  502. /*
  503. * can't add key for RX, but we don't need it
  504. * in the device for TX so still return 0
  505. */
  506. ret = 0;
  507. key->hw_key_idx = WEP_INVALID_OFFSET;
  508. }
  509. IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
  510. break;
  511. case DISABLE_KEY:
  512. if (is_default_wep_key)
  513. ret = iwl_remove_default_wep_key(priv, ctx, key);
  514. else
  515. ret = iwl_remove_dynamic_key(priv, ctx, key, sta);
  516. IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
  517. break;
  518. default:
  519. ret = -EINVAL;
  520. }
  521. mutex_unlock(&priv->mutex);
  522. IWL_DEBUG_MAC80211(priv, "leave\n");
  523. return ret;
  524. }
  525. static int iwlagn_mac_ampdu_action(struct ieee80211_hw *hw,
  526. struct ieee80211_vif *vif,
  527. enum ieee80211_ampdu_mlme_action action,
  528. struct ieee80211_sta *sta, u16 tid, u16 *ssn,
  529. u8 buf_size)
  530. {
  531. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  532. int ret = -EINVAL;
  533. struct iwl_station_priv *sta_priv = (void *) sta->drv_priv;
  534. IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n",
  535. sta->addr, tid);
  536. if (!(priv->hw_params.sku & EEPROM_SKU_CAP_11N_ENABLE))
  537. return -EACCES;
  538. IWL_DEBUG_MAC80211(priv, "enter\n");
  539. mutex_lock(&priv->mutex);
  540. switch (action) {
  541. case IEEE80211_AMPDU_RX_START:
  542. if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_RXAGG)
  543. break;
  544. IWL_DEBUG_HT(priv, "start Rx\n");
  545. ret = iwl_sta_rx_agg_start(priv, sta, tid, *ssn);
  546. break;
  547. case IEEE80211_AMPDU_RX_STOP:
  548. IWL_DEBUG_HT(priv, "stop Rx\n");
  549. ret = iwl_sta_rx_agg_stop(priv, sta, tid);
  550. break;
  551. case IEEE80211_AMPDU_TX_START:
  552. if (!priv->trans->ops->txq_enable)
  553. break;
  554. if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_TXAGG)
  555. break;
  556. IWL_DEBUG_HT(priv, "start Tx\n");
  557. ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn);
  558. break;
  559. case IEEE80211_AMPDU_TX_STOP:
  560. IWL_DEBUG_HT(priv, "stop Tx\n");
  561. ret = iwlagn_tx_agg_stop(priv, vif, sta, tid);
  562. if ((ret == 0) && (priv->agg_tids_count > 0)) {
  563. priv->agg_tids_count--;
  564. IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
  565. priv->agg_tids_count);
  566. }
  567. if (!priv->agg_tids_count &&
  568. priv->hw_params.use_rts_for_aggregation) {
  569. /*
  570. * switch off RTS/CTS if it was previously enabled
  571. */
  572. sta_priv->lq_sta.lq.general_params.flags &=
  573. ~LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
  574. iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
  575. &sta_priv->lq_sta.lq, CMD_ASYNC, false);
  576. }
  577. break;
  578. case IEEE80211_AMPDU_TX_OPERATIONAL:
  579. ret = iwlagn_tx_agg_oper(priv, vif, sta, tid, buf_size);
  580. break;
  581. }
  582. mutex_unlock(&priv->mutex);
  583. IWL_DEBUG_MAC80211(priv, "leave\n");
  584. return ret;
  585. }
  586. static int iwlagn_mac_sta_add(struct ieee80211_hw *hw,
  587. struct ieee80211_vif *vif,
  588. struct ieee80211_sta *sta)
  589. {
  590. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  591. struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
  592. struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
  593. bool is_ap = vif->type == NL80211_IFTYPE_STATION;
  594. int ret;
  595. u8 sta_id;
  596. IWL_DEBUG_INFO(priv, "proceeding to add station %pM\n",
  597. sta->addr);
  598. sta_priv->sta_id = IWL_INVALID_STATION;
  599. atomic_set(&sta_priv->pending_frames, 0);
  600. if (vif->type == NL80211_IFTYPE_AP)
  601. sta_priv->client = true;
  602. ret = iwl_add_station_common(priv, vif_priv->ctx, sta->addr,
  603. is_ap, sta, &sta_id);
  604. if (ret) {
  605. IWL_ERR(priv, "Unable to add station %pM (%d)\n",
  606. sta->addr, ret);
  607. /* Should we return success if return code is EEXIST ? */
  608. return ret;
  609. }
  610. sta_priv->sta_id = sta_id;
  611. return 0;
  612. }
  613. static int iwlagn_mac_sta_remove(struct ieee80211_hw *hw,
  614. struct ieee80211_vif *vif,
  615. struct ieee80211_sta *sta)
  616. {
  617. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  618. struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
  619. int ret;
  620. IWL_DEBUG_INFO(priv, "proceeding to remove station %pM\n", sta->addr);
  621. if (vif->type == NL80211_IFTYPE_STATION) {
  622. /*
  623. * Station will be removed from device when the RXON
  624. * is set to unassociated -- just deactivate it here
  625. * to avoid re-programming it.
  626. */
  627. ret = 0;
  628. iwl_deactivate_station(priv, sta_priv->sta_id, sta->addr);
  629. } else {
  630. ret = iwl_remove_station(priv, sta_priv->sta_id, sta->addr);
  631. if (ret)
  632. IWL_DEBUG_QUIET_RFKILL(priv,
  633. "Error removing station %pM\n", sta->addr);
  634. }
  635. return ret;
  636. }
  637. static int iwlagn_mac_sta_state(struct ieee80211_hw *hw,
  638. struct ieee80211_vif *vif,
  639. struct ieee80211_sta *sta,
  640. enum ieee80211_sta_state old_state,
  641. enum ieee80211_sta_state new_state)
  642. {
  643. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  644. struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
  645. enum {
  646. NONE, ADD, REMOVE, HT_RATE_INIT, ADD_RATE_INIT,
  647. } op = NONE;
  648. int ret;
  649. IWL_DEBUG_MAC80211(priv, "station %pM state change %d->%d\n",
  650. sta->addr, old_state, new_state);
  651. mutex_lock(&priv->mutex);
  652. if (vif->type == NL80211_IFTYPE_STATION) {
  653. if (old_state == IEEE80211_STA_NOTEXIST &&
  654. new_state == IEEE80211_STA_NONE)
  655. op = ADD;
  656. else if (old_state == IEEE80211_STA_NONE &&
  657. new_state == IEEE80211_STA_NOTEXIST)
  658. op = REMOVE;
  659. else if (old_state == IEEE80211_STA_AUTH &&
  660. new_state == IEEE80211_STA_ASSOC)
  661. op = HT_RATE_INIT;
  662. } else {
  663. if (old_state == IEEE80211_STA_AUTH &&
  664. new_state == IEEE80211_STA_ASSOC)
  665. op = ADD_RATE_INIT;
  666. else if (old_state == IEEE80211_STA_ASSOC &&
  667. new_state == IEEE80211_STA_AUTH)
  668. op = REMOVE;
  669. }
  670. switch (op) {
  671. case ADD:
  672. ret = iwlagn_mac_sta_add(hw, vif, sta);
  673. break;
  674. case REMOVE:
  675. ret = iwlagn_mac_sta_remove(hw, vif, sta);
  676. break;
  677. case ADD_RATE_INIT:
  678. ret = iwlagn_mac_sta_add(hw, vif, sta);
  679. if (ret)
  680. break;
  681. /* Initialize rate scaling */
  682. IWL_DEBUG_INFO(priv,
  683. "Initializing rate scaling for station %pM\n",
  684. sta->addr);
  685. iwl_rs_rate_init(priv, sta, iwl_sta_id(sta));
  686. ret = 0;
  687. break;
  688. case HT_RATE_INIT:
  689. /* Initialize rate scaling */
  690. ret = iwl_sta_update_ht(priv, vif_priv->ctx, sta);
  691. if (ret)
  692. break;
  693. IWL_DEBUG_INFO(priv,
  694. "Initializing rate scaling for station %pM\n",
  695. sta->addr);
  696. iwl_rs_rate_init(priv, sta, iwl_sta_id(sta));
  697. ret = 0;
  698. break;
  699. default:
  700. ret = 0;
  701. break;
  702. }
  703. /*
  704. * mac80211 might WARN if we fail, but due the way we
  705. * (badly) handle hard rfkill, we might fail here
  706. */
  707. if (iwl_is_rfkill(priv))
  708. ret = 0;
  709. mutex_unlock(&priv->mutex);
  710. IWL_DEBUG_MAC80211(priv, "leave\n");
  711. return ret;
  712. }
  713. static void iwlagn_mac_channel_switch(struct ieee80211_hw *hw,
  714. struct ieee80211_channel_switch *ch_switch)
  715. {
  716. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  717. struct ieee80211_conf *conf = &hw->conf;
  718. struct ieee80211_channel *channel = ch_switch->channel;
  719. struct iwl_ht_config *ht_conf = &priv->current_ht_config;
  720. /*
  721. * MULTI-FIXME
  722. * When we add support for multiple interfaces, we need to
  723. * revisit this. The channel switch command in the device
  724. * only affects the BSS context, but what does that really
  725. * mean? And what if we get a CSA on the second interface?
  726. * This needs a lot of work.
  727. */
  728. struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
  729. u16 ch;
  730. IWL_DEBUG_MAC80211(priv, "enter\n");
  731. mutex_lock(&priv->mutex);
  732. if (iwl_is_rfkill(priv))
  733. goto out;
  734. if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
  735. test_bit(STATUS_SCANNING, &priv->status) ||
  736. test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status))
  737. goto out;
  738. if (!iwl_is_associated_ctx(ctx))
  739. goto out;
  740. if (!priv->lib->set_channel_switch)
  741. goto out;
  742. ch = channel->hw_value;
  743. if (le16_to_cpu(ctx->active.channel) == ch)
  744. goto out;
  745. priv->current_ht_config.smps = conf->smps_mode;
  746. /* Configure HT40 channels */
  747. ctx->ht.enabled = conf_is_ht(conf);
  748. if (ctx->ht.enabled)
  749. iwlagn_config_ht40(conf, ctx);
  750. else
  751. ctx->ht.is_40mhz = false;
  752. if ((le16_to_cpu(ctx->staging.channel) != ch))
  753. ctx->staging.flags = 0;
  754. iwl_set_rxon_channel(priv, channel, ctx);
  755. iwl_set_rxon_ht(priv, ht_conf);
  756. iwl_set_flags_for_band(priv, ctx, channel->band, ctx->vif);
  757. /*
  758. * at this point, staging_rxon has the
  759. * configuration for channel switch
  760. */
  761. set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
  762. priv->switch_channel = cpu_to_le16(ch);
  763. if (priv->lib->set_channel_switch(priv, ch_switch)) {
  764. clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
  765. priv->switch_channel = 0;
  766. ieee80211_chswitch_done(ctx->vif, false);
  767. }
  768. out:
  769. mutex_unlock(&priv->mutex);
  770. IWL_DEBUG_MAC80211(priv, "leave\n");
  771. }
  772. void iwl_chswitch_done(struct iwl_priv *priv, bool is_success)
  773. {
  774. /*
  775. * MULTI-FIXME
  776. * See iwlagn_mac_channel_switch.
  777. */
  778. struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
  779. if (test_bit(STATUS_EXIT_PENDING, &priv->status))
  780. return;
  781. if (test_and_clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status))
  782. ieee80211_chswitch_done(ctx->vif, is_success);
  783. }
  784. static void iwlagn_configure_filter(struct ieee80211_hw *hw,
  785. unsigned int changed_flags,
  786. unsigned int *total_flags,
  787. u64 multicast)
  788. {
  789. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  790. __le32 filter_or = 0, filter_nand = 0;
  791. struct iwl_rxon_context *ctx;
  792. #define CHK(test, flag) do { \
  793. if (*total_flags & (test)) \
  794. filter_or |= (flag); \
  795. else \
  796. filter_nand |= (flag); \
  797. } while (0)
  798. IWL_DEBUG_MAC80211(priv, "Enter: changed: 0x%x, total: 0x%x\n",
  799. changed_flags, *total_flags);
  800. CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK);
  801. /* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
  802. CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
  803. CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
  804. #undef CHK
  805. mutex_lock(&priv->mutex);
  806. for_each_context(priv, ctx) {
  807. ctx->staging.filter_flags &= ~filter_nand;
  808. ctx->staging.filter_flags |= filter_or;
  809. /*
  810. * Not committing directly because hardware can perform a scan,
  811. * but we'll eventually commit the filter flags change anyway.
  812. */
  813. }
  814. mutex_unlock(&priv->mutex);
  815. /*
  816. * Receiving all multicast frames is always enabled by the
  817. * default flags setup in iwl_connection_init_rx_config()
  818. * since we currently do not support programming multicast
  819. * filters into the device.
  820. */
  821. *total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
  822. FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
  823. }
  824. static void iwlagn_mac_flush(struct ieee80211_hw *hw, bool drop)
  825. {
  826. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  827. mutex_lock(&priv->mutex);
  828. IWL_DEBUG_MAC80211(priv, "enter\n");
  829. if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
  830. IWL_DEBUG_TX(priv, "Aborting flush due to device shutdown\n");
  831. goto done;
  832. }
  833. if (iwl_is_rfkill(priv)) {
  834. IWL_DEBUG_TX(priv, "Aborting flush due to RF Kill\n");
  835. goto done;
  836. }
  837. /*
  838. * mac80211 will not push any more frames for transmit
  839. * until the flush is completed
  840. */
  841. if (drop) {
  842. IWL_DEBUG_MAC80211(priv, "send flush command\n");
  843. if (iwlagn_txfifo_flush(priv, IWL_DROP_ALL)) {
  844. IWL_ERR(priv, "flush request fail\n");
  845. goto done;
  846. }
  847. }
  848. IWL_DEBUG_MAC80211(priv, "wait transmit/flush all frames\n");
  849. iwl_trans_wait_tx_queue_empty(priv->trans);
  850. done:
  851. mutex_unlock(&priv->mutex);
  852. IWL_DEBUG_MAC80211(priv, "leave\n");
  853. }
  854. static int iwlagn_mac_remain_on_channel(struct ieee80211_hw *hw,
  855. struct ieee80211_channel *channel,
  856. enum nl80211_channel_type channel_type,
  857. int duration)
  858. {
  859. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  860. struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_PAN];
  861. int err = 0;
  862. if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
  863. return -EOPNOTSUPP;
  864. if (!(ctx->interface_modes & BIT(NL80211_IFTYPE_P2P_CLIENT)))
  865. return -EOPNOTSUPP;
  866. IWL_DEBUG_MAC80211(priv, "enter\n");
  867. mutex_lock(&priv->mutex);
  868. if (test_bit(STATUS_SCAN_HW, &priv->status)) {
  869. err = -EBUSY;
  870. goto out;
  871. }
  872. priv->hw_roc_channel = channel;
  873. priv->hw_roc_chantype = channel_type;
  874. /* convert from ms to TU */
  875. priv->hw_roc_duration = DIV_ROUND_UP(1000 * duration, 1024);
  876. priv->hw_roc_start_notified = false;
  877. cancel_delayed_work(&priv->hw_roc_disable_work);
  878. if (!ctx->is_active) {
  879. static const struct iwl_qos_info default_qos_data = {
  880. .def_qos_parm = {
  881. .ac[0] = {
  882. .cw_min = cpu_to_le16(3),
  883. .cw_max = cpu_to_le16(7),
  884. .aifsn = 2,
  885. .edca_txop = cpu_to_le16(1504),
  886. },
  887. .ac[1] = {
  888. .cw_min = cpu_to_le16(7),
  889. .cw_max = cpu_to_le16(15),
  890. .aifsn = 2,
  891. .edca_txop = cpu_to_le16(3008),
  892. },
  893. .ac[2] = {
  894. .cw_min = cpu_to_le16(15),
  895. .cw_max = cpu_to_le16(1023),
  896. .aifsn = 3,
  897. },
  898. .ac[3] = {
  899. .cw_min = cpu_to_le16(15),
  900. .cw_max = cpu_to_le16(1023),
  901. .aifsn = 7,
  902. },
  903. },
  904. };
  905. ctx->is_active = true;
  906. ctx->qos_data = default_qos_data;
  907. ctx->staging.dev_type = RXON_DEV_TYPE_P2P;
  908. memcpy(ctx->staging.node_addr,
  909. priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr,
  910. ETH_ALEN);
  911. memcpy(ctx->staging.bssid_addr,
  912. priv->contexts[IWL_RXON_CTX_BSS].staging.node_addr,
  913. ETH_ALEN);
  914. err = iwlagn_commit_rxon(priv, ctx);
  915. if (err)
  916. goto out;
  917. ctx->staging.filter_flags |= RXON_FILTER_ASSOC_MSK |
  918. RXON_FILTER_PROMISC_MSK |
  919. RXON_FILTER_CTL2HOST_MSK;
  920. err = iwlagn_commit_rxon(priv, ctx);
  921. if (err) {
  922. iwlagn_disable_roc(priv);
  923. goto out;
  924. }
  925. priv->hw_roc_setup = true;
  926. }
  927. err = iwl_scan_initiate(priv, ctx->vif, IWL_SCAN_ROC, channel->band);
  928. if (err)
  929. iwlagn_disable_roc(priv);
  930. out:
  931. mutex_unlock(&priv->mutex);
  932. IWL_DEBUG_MAC80211(priv, "leave\n");
  933. return err;
  934. }
  935. static int iwlagn_mac_cancel_remain_on_channel(struct ieee80211_hw *hw)
  936. {
  937. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  938. if (!(priv->valid_contexts & BIT(IWL_RXON_CTX_PAN)))
  939. return -EOPNOTSUPP;
  940. IWL_DEBUG_MAC80211(priv, "enter\n");
  941. mutex_lock(&priv->mutex);
  942. iwl_scan_cancel_timeout(priv, priv->hw_roc_duration);
  943. iwlagn_disable_roc(priv);
  944. mutex_unlock(&priv->mutex);
  945. IWL_DEBUG_MAC80211(priv, "leave\n");
  946. return 0;
  947. }
  948. static void iwlagn_mac_rssi_callback(struct ieee80211_hw *hw,
  949. enum ieee80211_rssi_event rssi_event)
  950. {
  951. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  952. IWL_DEBUG_MAC80211(priv, "enter\n");
  953. mutex_lock(&priv->mutex);
  954. if (priv->cfg->bt_params &&
  955. priv->cfg->bt_params->advanced_bt_coexist) {
  956. if (rssi_event == RSSI_EVENT_LOW)
  957. priv->bt_enable_pspoll = true;
  958. else if (rssi_event == RSSI_EVENT_HIGH)
  959. priv->bt_enable_pspoll = false;
  960. iwlagn_send_advance_bt_config(priv);
  961. } else {
  962. IWL_DEBUG_MAC80211(priv, "Advanced BT coex disabled,"
  963. "ignoring RSSI callback\n");
  964. }
  965. mutex_unlock(&priv->mutex);
  966. IWL_DEBUG_MAC80211(priv, "leave\n");
  967. }
  968. static int iwlagn_mac_set_tim(struct ieee80211_hw *hw,
  969. struct ieee80211_sta *sta, bool set)
  970. {
  971. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  972. queue_work(priv->workqueue, &priv->beacon_update);
  973. return 0;
  974. }
  975. static int iwlagn_mac_conf_tx(struct ieee80211_hw *hw,
  976. struct ieee80211_vif *vif, u16 queue,
  977. const struct ieee80211_tx_queue_params *params)
  978. {
  979. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  980. struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
  981. struct iwl_rxon_context *ctx = vif_priv->ctx;
  982. int q;
  983. if (WARN_ON(!ctx))
  984. return -EINVAL;
  985. IWL_DEBUG_MAC80211(priv, "enter\n");
  986. if (!iwl_is_ready_rf(priv)) {
  987. IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
  988. return -EIO;
  989. }
  990. if (queue >= AC_NUM) {
  991. IWL_DEBUG_MAC80211(priv, "leave - queue >= AC_NUM %d\n", queue);
  992. return 0;
  993. }
  994. q = AC_NUM - 1 - queue;
  995. mutex_lock(&priv->mutex);
  996. ctx->qos_data.def_qos_parm.ac[q].cw_min =
  997. cpu_to_le16(params->cw_min);
  998. ctx->qos_data.def_qos_parm.ac[q].cw_max =
  999. cpu_to_le16(params->cw_max);
  1000. ctx->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
  1001. ctx->qos_data.def_qos_parm.ac[q].edca_txop =
  1002. cpu_to_le16((params->txop * 32));
  1003. ctx->qos_data.def_qos_parm.ac[q].reserved1 = 0;
  1004. mutex_unlock(&priv->mutex);
  1005. IWL_DEBUG_MAC80211(priv, "leave\n");
  1006. return 0;
  1007. }
  1008. static int iwlagn_mac_tx_last_beacon(struct ieee80211_hw *hw)
  1009. {
  1010. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  1011. return priv->ibss_manager == IWL_IBSS_MANAGER;
  1012. }
  1013. static int iwl_set_mode(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
  1014. {
  1015. iwl_connection_init_rx_config(priv, ctx);
  1016. iwlagn_set_rxon_chain(priv, ctx);
  1017. return iwlagn_commit_rxon(priv, ctx);
  1018. }
  1019. static int iwl_setup_interface(struct iwl_priv *priv,
  1020. struct iwl_rxon_context *ctx)
  1021. {
  1022. struct ieee80211_vif *vif = ctx->vif;
  1023. int err, ac;
  1024. lockdep_assert_held(&priv->mutex);
  1025. /*
  1026. * This variable will be correct only when there's just
  1027. * a single context, but all code using it is for hardware
  1028. * that supports only one context.
  1029. */
  1030. priv->iw_mode = vif->type;
  1031. ctx->is_active = true;
  1032. err = iwl_set_mode(priv, ctx);
  1033. if (err) {
  1034. if (!ctx->always_active)
  1035. ctx->is_active = false;
  1036. return err;
  1037. }
  1038. if (priv->cfg->bt_params && priv->cfg->bt_params->advanced_bt_coexist &&
  1039. vif->type == NL80211_IFTYPE_ADHOC) {
  1040. /*
  1041. * pretend to have high BT traffic as long as we
  1042. * are operating in IBSS mode, as this will cause
  1043. * the rate scaling etc. to behave as intended.
  1044. */
  1045. priv->bt_traffic_load = IWL_BT_COEX_TRAFFIC_LOAD_HIGH;
  1046. }
  1047. /* set up queue mappings */
  1048. for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
  1049. vif->hw_queue[ac] = ctx->ac_to_queue[ac];
  1050. if (vif->type == NL80211_IFTYPE_AP)
  1051. vif->cab_queue = ctx->mcast_queue;
  1052. else
  1053. vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
  1054. return 0;
  1055. }
  1056. static int iwlagn_mac_add_interface(struct ieee80211_hw *hw,
  1057. struct ieee80211_vif *vif)
  1058. {
  1059. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  1060. struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
  1061. struct iwl_rxon_context *tmp, *ctx = NULL;
  1062. int err;
  1063. enum nl80211_iftype viftype = ieee80211_vif_type_p2p(vif);
  1064. bool reset = false;
  1065. IWL_DEBUG_MAC80211(priv, "enter: type %d, addr %pM\n",
  1066. viftype, vif->addr);
  1067. cancel_delayed_work_sync(&priv->hw_roc_disable_work);
  1068. mutex_lock(&priv->mutex);
  1069. iwlagn_disable_roc(priv);
  1070. if (!iwl_is_ready_rf(priv)) {
  1071. IWL_WARN(priv, "Try to add interface when device not ready\n");
  1072. err = -EINVAL;
  1073. goto out;
  1074. }
  1075. for_each_context(priv, tmp) {
  1076. u32 possible_modes =
  1077. tmp->interface_modes | tmp->exclusive_interface_modes;
  1078. if (tmp->vif) {
  1079. /* On reset we need to add the same interface again */
  1080. if (tmp->vif == vif) {
  1081. reset = true;
  1082. ctx = tmp;
  1083. break;
  1084. }
  1085. /* check if this busy context is exclusive */
  1086. if (tmp->exclusive_interface_modes &
  1087. BIT(tmp->vif->type)) {
  1088. err = -EINVAL;
  1089. goto out;
  1090. }
  1091. continue;
  1092. }
  1093. if (!(possible_modes & BIT(viftype)))
  1094. continue;
  1095. /* have maybe usable context w/o interface */
  1096. ctx = tmp;
  1097. break;
  1098. }
  1099. if (!ctx) {
  1100. err = -EOPNOTSUPP;
  1101. goto out;
  1102. }
  1103. vif_priv->ctx = ctx;
  1104. ctx->vif = vif;
  1105. err = iwl_setup_interface(priv, ctx);
  1106. if (!err || reset)
  1107. goto out;
  1108. ctx->vif = NULL;
  1109. priv->iw_mode = NL80211_IFTYPE_STATION;
  1110. out:
  1111. mutex_unlock(&priv->mutex);
  1112. IWL_DEBUG_MAC80211(priv, "leave\n");
  1113. return err;
  1114. }
  1115. static void iwl_teardown_interface(struct iwl_priv *priv,
  1116. struct ieee80211_vif *vif,
  1117. bool mode_change)
  1118. {
  1119. struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
  1120. lockdep_assert_held(&priv->mutex);
  1121. if (priv->scan_vif == vif) {
  1122. iwl_scan_cancel_timeout(priv, 200);
  1123. iwl_force_scan_end(priv);
  1124. }
  1125. if (!mode_change) {
  1126. iwl_set_mode(priv, ctx);
  1127. if (!ctx->always_active)
  1128. ctx->is_active = false;
  1129. }
  1130. /*
  1131. * When removing the IBSS interface, overwrite the
  1132. * BT traffic load with the stored one from the last
  1133. * notification, if any. If this is a device that
  1134. * doesn't implement this, this has no effect since
  1135. * both values are the same and zero.
  1136. */
  1137. if (vif->type == NL80211_IFTYPE_ADHOC)
  1138. priv->bt_traffic_load = priv->last_bt_traffic_load;
  1139. }
  1140. static void iwlagn_mac_remove_interface(struct ieee80211_hw *hw,
  1141. struct ieee80211_vif *vif)
  1142. {
  1143. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  1144. struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
  1145. IWL_DEBUG_MAC80211(priv, "enter\n");
  1146. mutex_lock(&priv->mutex);
  1147. if (WARN_ON(ctx->vif != vif)) {
  1148. struct iwl_rxon_context *tmp;
  1149. IWL_ERR(priv, "ctx->vif = %p, vif = %p\n", ctx->vif, vif);
  1150. for_each_context(priv, tmp)
  1151. IWL_ERR(priv, "\tID = %d:\tctx = %p\tctx->vif = %p\n",
  1152. tmp->ctxid, tmp, tmp->vif);
  1153. }
  1154. ctx->vif = NULL;
  1155. iwl_teardown_interface(priv, vif, false);
  1156. mutex_unlock(&priv->mutex);
  1157. IWL_DEBUG_MAC80211(priv, "leave\n");
  1158. }
  1159. static int iwlagn_mac_change_interface(struct ieee80211_hw *hw,
  1160. struct ieee80211_vif *vif,
  1161. enum nl80211_iftype newtype, bool newp2p)
  1162. {
  1163. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  1164. struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
  1165. struct iwl_rxon_context *bss_ctx = &priv->contexts[IWL_RXON_CTX_BSS];
  1166. struct iwl_rxon_context *tmp;
  1167. enum nl80211_iftype newviftype = newtype;
  1168. u32 interface_modes;
  1169. int err;
  1170. IWL_DEBUG_MAC80211(priv, "enter\n");
  1171. newtype = ieee80211_iftype_p2p(newtype, newp2p);
  1172. mutex_lock(&priv->mutex);
  1173. if (!ctx->vif || !iwl_is_ready_rf(priv)) {
  1174. /*
  1175. * Huh? But wait ... this can maybe happen when
  1176. * we're in the middle of a firmware restart!
  1177. */
  1178. err = -EBUSY;
  1179. goto out;
  1180. }
  1181. interface_modes = ctx->interface_modes | ctx->exclusive_interface_modes;
  1182. if (!(interface_modes & BIT(newtype))) {
  1183. err = -EBUSY;
  1184. goto out;
  1185. }
  1186. /*
  1187. * Refuse a change that should be done by moving from the PAN
  1188. * context to the BSS context instead, if the BSS context is
  1189. * available and can support the new interface type.
  1190. */
  1191. if (ctx->ctxid == IWL_RXON_CTX_PAN && !bss_ctx->vif &&
  1192. (bss_ctx->interface_modes & BIT(newtype) ||
  1193. bss_ctx->exclusive_interface_modes & BIT(newtype))) {
  1194. BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
  1195. err = -EBUSY;
  1196. goto out;
  1197. }
  1198. if (ctx->exclusive_interface_modes & BIT(newtype)) {
  1199. for_each_context(priv, tmp) {
  1200. if (ctx == tmp)
  1201. continue;
  1202. if (!tmp->vif)
  1203. continue;
  1204. /*
  1205. * The current mode switch would be exclusive, but
  1206. * another context is active ... refuse the switch.
  1207. */
  1208. err = -EBUSY;
  1209. goto out;
  1210. }
  1211. }
  1212. /* success */
  1213. iwl_teardown_interface(priv, vif, true);
  1214. vif->type = newviftype;
  1215. vif->p2p = newp2p;
  1216. err = iwl_setup_interface(priv, ctx);
  1217. WARN_ON(err);
  1218. /*
  1219. * We've switched internally, but submitting to the
  1220. * device may have failed for some reason. Mask this
  1221. * error, because otherwise mac80211 will not switch
  1222. * (and set the interface type back) and we'll be
  1223. * out of sync with it.
  1224. */
  1225. err = 0;
  1226. out:
  1227. mutex_unlock(&priv->mutex);
  1228. IWL_DEBUG_MAC80211(priv, "leave\n");
  1229. return err;
  1230. }
  1231. static int iwlagn_mac_hw_scan(struct ieee80211_hw *hw,
  1232. struct ieee80211_vif *vif,
  1233. struct cfg80211_scan_request *req)
  1234. {
  1235. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  1236. int ret;
  1237. IWL_DEBUG_MAC80211(priv, "enter\n");
  1238. if (req->n_channels == 0)
  1239. return -EINVAL;
  1240. mutex_lock(&priv->mutex);
  1241. /*
  1242. * If an internal scan is in progress, just set
  1243. * up the scan_request as per above.
  1244. */
  1245. if (priv->scan_type != IWL_SCAN_NORMAL) {
  1246. IWL_DEBUG_SCAN(priv,
  1247. "SCAN request during internal scan - defer\n");
  1248. priv->scan_request = req;
  1249. priv->scan_vif = vif;
  1250. ret = 0;
  1251. } else {
  1252. priv->scan_request = req;
  1253. priv->scan_vif = vif;
  1254. /*
  1255. * mac80211 will only ask for one band at a time
  1256. * so using channels[0] here is ok
  1257. */
  1258. ret = iwl_scan_initiate(priv, vif, IWL_SCAN_NORMAL,
  1259. req->channels[0]->band);
  1260. if (ret) {
  1261. priv->scan_request = NULL;
  1262. priv->scan_vif = NULL;
  1263. }
  1264. }
  1265. IWL_DEBUG_MAC80211(priv, "leave\n");
  1266. mutex_unlock(&priv->mutex);
  1267. return ret;
  1268. }
  1269. static void iwl_sta_modify_ps_wake(struct iwl_priv *priv, int sta_id)
  1270. {
  1271. struct iwl_addsta_cmd cmd = {
  1272. .mode = STA_CONTROL_MODIFY_MSK,
  1273. .station_flags_msk = STA_FLG_PWR_SAVE_MSK,
  1274. .sta.sta_id = sta_id,
  1275. };
  1276. iwl_send_add_sta(priv, &cmd, CMD_ASYNC);
  1277. }
  1278. static void iwlagn_mac_sta_notify(struct ieee80211_hw *hw,
  1279. struct ieee80211_vif *vif,
  1280. enum sta_notify_cmd cmd,
  1281. struct ieee80211_sta *sta)
  1282. {
  1283. struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
  1284. struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
  1285. int sta_id;
  1286. IWL_DEBUG_MAC80211(priv, "enter\n");
  1287. switch (cmd) {
  1288. case STA_NOTIFY_SLEEP:
  1289. WARN_ON(!sta_priv->client);
  1290. sta_priv->asleep = true;
  1291. if (atomic_read(&sta_priv->pending_frames) > 0)
  1292. ieee80211_sta_block_awake(hw, sta, true);
  1293. break;
  1294. case STA_NOTIFY_AWAKE:
  1295. WARN_ON(!sta_priv->client);
  1296. if (!sta_priv->asleep)
  1297. break;
  1298. sta_priv->asleep = false;
  1299. sta_id = iwl_sta_id(sta);
  1300. if (sta_id != IWL_INVALID_STATION)
  1301. iwl_sta_modify_ps_wake(priv, sta_id);
  1302. break;
  1303. default:
  1304. break;
  1305. }
  1306. IWL_DEBUG_MAC80211(priv, "leave\n");
  1307. }
  1308. struct ieee80211_ops iwlagn_hw_ops = {
  1309. .tx = iwlagn_mac_tx,
  1310. .start = iwlagn_mac_start,
  1311. .stop = iwlagn_mac_stop,
  1312. #ifdef CONFIG_PM_SLEEP
  1313. .suspend = iwlagn_mac_suspend,
  1314. .resume = iwlagn_mac_resume,
  1315. .set_wakeup = iwlagn_mac_set_wakeup,
  1316. #endif
  1317. .add_interface = iwlagn_mac_add_interface,
  1318. .remove_interface = iwlagn_mac_remove_interface,
  1319. .change_interface = iwlagn_mac_change_interface,
  1320. .config = iwlagn_mac_config,
  1321. .configure_filter = iwlagn_configure_filter,
  1322. .set_key = iwlagn_mac_set_key,
  1323. .update_tkip_key = iwlagn_mac_update_tkip_key,
  1324. .set_rekey_data = iwlagn_mac_set_rekey_data,
  1325. .conf_tx = iwlagn_mac_conf_tx,
  1326. .bss_info_changed = iwlagn_bss_info_changed,
  1327. .ampdu_action = iwlagn_mac_ampdu_action,
  1328. .hw_scan = iwlagn_mac_hw_scan,
  1329. .sta_notify = iwlagn_mac_sta_notify,
  1330. .sta_state = iwlagn_mac_sta_state,
  1331. .channel_switch = iwlagn_mac_channel_switch,
  1332. .flush = iwlagn_mac_flush,
  1333. .tx_last_beacon = iwlagn_mac_tx_last_beacon,
  1334. .remain_on_channel = iwlagn_mac_remain_on_channel,
  1335. .cancel_remain_on_channel = iwlagn_mac_cancel_remain_on_channel,
  1336. .rssi_callback = iwlagn_mac_rssi_callback,
  1337. CFG80211_TESTMODE_CMD(iwlagn_mac_testmode_cmd)
  1338. CFG80211_TESTMODE_DUMP(iwlagn_mac_testmode_dump)
  1339. .set_tim = iwlagn_mac_set_tim,
  1340. };
  1341. /* This function both allocates and initializes hw and priv. */
  1342. struct ieee80211_hw *iwl_alloc_all(void)
  1343. {
  1344. struct iwl_priv *priv;
  1345. struct iwl_op_mode *op_mode;
  1346. /* mac80211 allocates memory for this device instance, including
  1347. * space for this driver's private structure */
  1348. struct ieee80211_hw *hw;
  1349. hw = ieee80211_alloc_hw(sizeof(struct iwl_priv) +
  1350. sizeof(struct iwl_op_mode), &iwlagn_hw_ops);
  1351. if (!hw)
  1352. goto out;
  1353. op_mode = hw->priv;
  1354. priv = IWL_OP_MODE_GET_DVM(op_mode);
  1355. priv->hw = hw;
  1356. out:
  1357. return hw;
  1358. }