1 // SPDX-License-Identifier: GPL-2.0-only
2 /******************************************************************************
3  *
4  * Copyright(c) 2003 - 2014 Intel Corporation. All rights reserved.
5  * Copyright (C) 2018 - 2019 Intel Corporation
6  *
7  * Portions of this file are derived from the ipw3945 project, as well
8  * as portions of the ieee80211 subsystem header files.
9  *****************************************************************************/
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/slab.h>
13 #include <linux/dma-mapping.h>
14 #include <linux/delay.h>
15 #include <linux/sched.h>
16 #include <linux/skbuff.h>
17 #include <linux/netdevice.h>
18 #include <linux/etherdevice.h>
19 #include <linux/if_arp.h>
20 
21 #include <net/ieee80211_radiotap.h>
22 #include <net/mac80211.h>
23 
24 #include <asm/div64.h>
25 
26 #include "iwl-io.h"
27 #include "iwl-trans.h"
28 #include "iwl-op-mode.h"
29 #include "iwl-modparams.h"
30 
31 #include "dev.h"
32 #include "calib.h"
33 #include "agn.h"
34 
35 /*****************************************************************************
36  *
37  * mac80211 entry point functions
38  *
39  *****************************************************************************/
40 
41 static const struct ieee80211_iface_limit iwlagn_sta_ap_limits[] = {
42 	{
43 		.max = 1,
44 		.types = BIT(NL80211_IFTYPE_STATION),
45 	},
46 	{
47 		.max = 1,
48 		.types = BIT(NL80211_IFTYPE_AP),
49 	},
50 };
51 
52 static const struct ieee80211_iface_limit iwlagn_2sta_limits[] = {
53 	{
54 		.max = 2,
55 		.types = BIT(NL80211_IFTYPE_STATION),
56 	},
57 };
58 
59 static const struct ieee80211_iface_combination
60 iwlagn_iface_combinations_dualmode[] = {
61 	{ .num_different_channels = 1,
62 	  .max_interfaces = 2,
63 	  .beacon_int_infra_match = true,
64 	  .limits = iwlagn_sta_ap_limits,
65 	  .n_limits = ARRAY_SIZE(iwlagn_sta_ap_limits),
66 	},
67 	{ .num_different_channels = 1,
68 	  .max_interfaces = 2,
69 	  .limits = iwlagn_2sta_limits,
70 	  .n_limits = ARRAY_SIZE(iwlagn_2sta_limits),
71 	},
72 };
73 
74 /*
75  * Not a mac80211 entry point function, but it fits in with all the
76  * other mac80211 functions grouped here.
77  */
78 int iwlagn_mac_setup_register(struct iwl_priv *priv,
79 			      const struct iwl_ucode_capabilities *capa)
80 {
81 	int ret;
82 	struct ieee80211_hw *hw = priv->hw;
83 	struct iwl_rxon_context *ctx;
84 
85 	hw->rate_control_algorithm = "iwl-agn-rs";
86 
87 	/* Tell mac80211 our characteristics */
88 	ieee80211_hw_set(hw, SIGNAL_DBM);
89 	ieee80211_hw_set(hw, AMPDU_AGGREGATION);
90 	ieee80211_hw_set(hw, NEED_DTIM_BEFORE_ASSOC);
91 	ieee80211_hw_set(hw, SPECTRUM_MGMT);
92 	ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
93 	ieee80211_hw_set(hw, QUEUE_CONTROL);
94 	ieee80211_hw_set(hw, SUPPORTS_PS);
95 	ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
96 	ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
97 	ieee80211_hw_set(hw, WANT_MONITOR_VIF);
98 
99 	if (priv->trans->max_skb_frags)
100 		hw->netdev_features = NETIF_F_HIGHDMA | NETIF_F_SG;
101 
102 	hw->offchannel_tx_hw_queue = IWL_AUX_QUEUE;
103 	hw->radiotap_mcs_details |= IEEE80211_RADIOTAP_MCS_HAVE_FMT;
104 
105 	/*
106 	 * Including the following line will crash some AP's.  This
107 	 * workaround removes the stimulus which causes the crash until
108 	 * the AP software can be fixed.
109 	hw->max_tx_aggregation_subframes = LINK_QUAL_AGG_FRAME_LIMIT_DEF;
110 	 */
111 
112 	if (priv->nvm_data->sku_cap_11n_enable)
113 		hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS |
114 				       NL80211_FEATURE_STATIC_SMPS;
115 
116 	/*
117 	 * Enable 11w if advertised by firmware and software crypto
118 	 * is not enabled (as the firmware will interpret some mgmt
119 	 * packets, so enabling it with software crypto isn't safe)
120 	 */
121 	if (priv->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_MFP &&
122 	    !iwlwifi_mod_params.swcrypto)
123 		ieee80211_hw_set(hw, MFP_CAPABLE);
124 
125 	hw->sta_data_size = sizeof(struct iwl_station_priv);
126 	hw->vif_data_size = sizeof(struct iwl_vif_priv);
127 
128 	for_each_context(priv, ctx) {
129 		hw->wiphy->interface_modes |= ctx->interface_modes;
130 		hw->wiphy->interface_modes |= ctx->exclusive_interface_modes;
131 	}
132 
133 	BUILD_BUG_ON(NUM_IWL_RXON_CTX != 2);
134 
135 	if (hw->wiphy->interface_modes & BIT(NL80211_IFTYPE_AP)) {
136 		hw->wiphy->iface_combinations =
137 			iwlagn_iface_combinations_dualmode;
138 		hw->wiphy->n_iface_combinations =
139 			ARRAY_SIZE(iwlagn_iface_combinations_dualmode);
140 	}
141 
142 	hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
143 	hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
144 				       REGULATORY_DISABLE_BEACON_HINTS;
145 
146 #ifdef CONFIG_PM_SLEEP
147 	if (priv->fw->img[IWL_UCODE_WOWLAN].num_sec &&
148 	    priv->trans->ops->d3_suspend &&
149 	    priv->trans->ops->d3_resume &&
150 	    device_can_wakeup(priv->trans->dev)) {
151 		priv->wowlan_support.flags = WIPHY_WOWLAN_MAGIC_PKT |
152 					     WIPHY_WOWLAN_DISCONNECT |
153 					     WIPHY_WOWLAN_EAP_IDENTITY_REQ |
154 					     WIPHY_WOWLAN_RFKILL_RELEASE;
155 		if (!iwlwifi_mod_params.swcrypto)
156 			priv->wowlan_support.flags |=
157 				WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
158 				WIPHY_WOWLAN_GTK_REKEY_FAILURE;
159 
160 		priv->wowlan_support.n_patterns = IWLAGN_WOWLAN_MAX_PATTERNS;
161 		priv->wowlan_support.pattern_min_len =
162 					IWLAGN_WOWLAN_MIN_PATTERN_LEN;
163 		priv->wowlan_support.pattern_max_len =
164 					IWLAGN_WOWLAN_MAX_PATTERN_LEN;
165 		hw->wiphy->wowlan = &priv->wowlan_support;
166 	}
167 #endif
168 
169 	if (iwlwifi_mod_params.power_save)
170 		hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
171 	else
172 		hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
173 
174 	hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
175 	/* we create the 802.11 header and a max-length SSID element */
176 	hw->wiphy->max_scan_ie_len = capa->max_probe_length - 24 - 34;
177 
178 	/*
179 	 * We don't use all queues: 4 and 9 are unused and any
180 	 * aggregation queue gets mapped down to the AC queue.
181 	 */
182 	hw->queues = IWLAGN_FIRST_AMPDU_QUEUE;
183 
184 	hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
185 
186 	if (priv->nvm_data->bands[NL80211_BAND_2GHZ].n_channels)
187 		priv->hw->wiphy->bands[NL80211_BAND_2GHZ] =
188 			&priv->nvm_data->bands[NL80211_BAND_2GHZ];
189 	if (priv->nvm_data->bands[NL80211_BAND_5GHZ].n_channels)
190 		priv->hw->wiphy->bands[NL80211_BAND_5GHZ] =
191 			&priv->nvm_data->bands[NL80211_BAND_5GHZ];
192 
193 	hw->wiphy->hw_version = priv->trans->hw_id;
194 
195 	iwl_leds_init(priv);
196 
197 	wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
198 	wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_EXT_KEY_ID);
199 
200 	ret = ieee80211_register_hw(priv->hw);
201 	if (ret) {
202 		IWL_ERR(priv, "Failed to register hw (error %d)\n", ret);
203 		iwl_leds_exit(priv);
204 		return ret;
205 	}
206 	priv->mac80211_registered = 1;
207 
208 	return 0;
209 }
210 
211 void iwlagn_mac_unregister(struct iwl_priv *priv)
212 {
213 	if (!priv->mac80211_registered)
214 		return;
215 	iwl_leds_exit(priv);
216 	ieee80211_unregister_hw(priv->hw);
217 	priv->mac80211_registered = 0;
218 }
219 
220 static int __iwl_up(struct iwl_priv *priv)
221 {
222 	struct iwl_rxon_context *ctx;
223 	int ret;
224 
225 	lockdep_assert_held(&priv->mutex);
226 
227 	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
228 		IWL_WARN(priv, "Exit pending; will not bring the NIC up\n");
229 		return -EIO;
230 	}
231 
232 	for_each_context(priv, ctx) {
233 		ret = iwlagn_alloc_bcast_station(priv, ctx);
234 		if (ret) {
235 			iwl_dealloc_bcast_stations(priv);
236 			return ret;
237 		}
238 	}
239 
240 	ret = iwl_trans_start_hw(priv->trans);
241 	if (ret) {
242 		IWL_ERR(priv, "Failed to start HW: %d\n", ret);
243 		goto error;
244 	}
245 
246 	ret = iwl_run_init_ucode(priv);
247 	if (ret) {
248 		IWL_ERR(priv, "Failed to run INIT ucode: %d\n", ret);
249 		goto error;
250 	}
251 
252 	ret = iwl_trans_start_hw(priv->trans);
253 	if (ret) {
254 		IWL_ERR(priv, "Failed to start HW: %d\n", ret);
255 		goto error;
256 	}
257 
258 	ret = iwl_load_ucode_wait_alive(priv, IWL_UCODE_REGULAR);
259 	if (ret) {
260 		IWL_ERR(priv, "Failed to start RT ucode: %d\n", ret);
261 		goto error;
262 	}
263 
264 	ret = iwl_alive_start(priv);
265 	if (ret)
266 		goto error;
267 	return 0;
268 
269  error:
270 	set_bit(STATUS_EXIT_PENDING, &priv->status);
271 	iwl_down(priv);
272 	clear_bit(STATUS_EXIT_PENDING, &priv->status);
273 
274 	IWL_ERR(priv, "Unable to initialize device.\n");
275 	return ret;
276 }
277 
278 static int iwlagn_mac_start(struct ieee80211_hw *hw)
279 {
280 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
281 	int ret;
282 
283 	IWL_DEBUG_MAC80211(priv, "enter\n");
284 
285 	/* we should be verifying the device is ready to be opened */
286 	mutex_lock(&priv->mutex);
287 	ret = __iwl_up(priv);
288 	mutex_unlock(&priv->mutex);
289 	if (ret)
290 		return ret;
291 
292 	IWL_DEBUG_INFO(priv, "Start UP work done.\n");
293 
294 	/* Now we should be done, and the READY bit should be set. */
295 	if (WARN_ON(!test_bit(STATUS_READY, &priv->status)))
296 		ret = -EIO;
297 
298 	iwlagn_led_enable(priv);
299 
300 	priv->is_open = 1;
301 	IWL_DEBUG_MAC80211(priv, "leave\n");
302 	return ret;
303 }
304 
305 static void iwlagn_mac_stop(struct ieee80211_hw *hw)
306 {
307 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
308 
309 	IWL_DEBUG_MAC80211(priv, "enter\n");
310 
311 	if (!priv->is_open)
312 		return;
313 
314 	priv->is_open = 0;
315 
316 	mutex_lock(&priv->mutex);
317 	iwl_down(priv);
318 	mutex_unlock(&priv->mutex);
319 
320 	iwl_cancel_deferred_work(priv);
321 
322 	flush_workqueue(priv->workqueue);
323 
324 	IWL_DEBUG_MAC80211(priv, "leave\n");
325 }
326 
327 static void iwlagn_mac_set_rekey_data(struct ieee80211_hw *hw,
328 				      struct ieee80211_vif *vif,
329 				      struct cfg80211_gtk_rekey_data *data)
330 {
331 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
332 
333 	if (iwlwifi_mod_params.swcrypto)
334 		return;
335 
336 	IWL_DEBUG_MAC80211(priv, "enter\n");
337 	mutex_lock(&priv->mutex);
338 
339 	if (priv->contexts[IWL_RXON_CTX_BSS].vif != vif)
340 		goto out;
341 
342 	memcpy(priv->kek, data->kek, NL80211_KEK_LEN);
343 	memcpy(priv->kck, data->kck, NL80211_KCK_LEN);
344 	priv->replay_ctr =
345 		cpu_to_le64(be64_to_cpup((__be64 *)&data->replay_ctr));
346 	priv->have_rekey_data = true;
347 
348  out:
349 	mutex_unlock(&priv->mutex);
350 	IWL_DEBUG_MAC80211(priv, "leave\n");
351 }
352 
353 #ifdef CONFIG_PM_SLEEP
354 
355 static int iwlagn_mac_suspend(struct ieee80211_hw *hw,
356 			      struct cfg80211_wowlan *wowlan)
357 {
358 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
359 	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
360 	int ret;
361 
362 	if (WARN_ON(!wowlan))
363 		return -EINVAL;
364 
365 	IWL_DEBUG_MAC80211(priv, "enter\n");
366 	mutex_lock(&priv->mutex);
367 
368 	/* Don't attempt WoWLAN when not associated, tear down instead. */
369 	if (!ctx->vif || ctx->vif->type != NL80211_IFTYPE_STATION ||
370 	    !iwl_is_associated_ctx(ctx)) {
371 		ret = 1;
372 		goto out;
373 	}
374 
375 	ret = iwlagn_suspend(priv, wowlan);
376 	if (ret)
377 		goto error;
378 
379 	/* let the ucode operate on its own */
380 	iwl_write32(priv->trans, CSR_UCODE_DRV_GP1_SET,
381 		    CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
382 
383 	iwl_trans_d3_suspend(priv->trans, false, true);
384 
385 	goto out;
386 
387  error:
388 	priv->wowlan = false;
389 	iwlagn_prepare_restart(priv);
390 	ieee80211_restart_hw(priv->hw);
391  out:
392 	mutex_unlock(&priv->mutex);
393 	IWL_DEBUG_MAC80211(priv, "leave\n");
394 
395 	return ret;
396 }
397 
398 struct iwl_resume_data {
399 	struct iwl_priv *priv;
400 	struct iwlagn_wowlan_status *cmd;
401 	bool valid;
402 };
403 
404 static bool iwl_resume_status_fn(struct iwl_notif_wait_data *notif_wait,
405 				 struct iwl_rx_packet *pkt, void *data)
406 {
407 	struct iwl_resume_data *resume_data = data;
408 	struct iwl_priv *priv = resume_data->priv;
409 
410 	if (iwl_rx_packet_payload_len(pkt) != sizeof(*resume_data->cmd)) {
411 		IWL_ERR(priv, "rx wrong size data\n");
412 		return true;
413 	}
414 	memcpy(resume_data->cmd, pkt->data, sizeof(*resume_data->cmd));
415 	resume_data->valid = true;
416 
417 	return true;
418 }
419 
420 static int iwlagn_mac_resume(struct ieee80211_hw *hw)
421 {
422 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
423 	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
424 	struct ieee80211_vif *vif;
425 	u32 base;
426 	int ret;
427 	enum iwl_d3_status d3_status;
428 	struct error_table_start {
429 		/* cf. struct iwl_error_event_table */
430 		u32 valid;
431 		u32 error_id;
432 	} err_info;
433 	struct iwl_notification_wait status_wait;
434 	static const u16 status_cmd[] = {
435 		REPLY_WOWLAN_GET_STATUS,
436 	};
437 	struct iwlagn_wowlan_status status_data = {};
438 	struct iwl_resume_data resume_data = {
439 		.priv = priv,
440 		.cmd = &status_data,
441 		.valid = false,
442 	};
443 	struct cfg80211_wowlan_wakeup wakeup = {
444 		.pattern_idx = -1,
445 	};
446 #ifdef CONFIG_IWLWIFI_DEBUGFS
447 	const struct fw_img *img;
448 #endif
449 
450 	IWL_DEBUG_MAC80211(priv, "enter\n");
451 	mutex_lock(&priv->mutex);
452 
453 	/* we'll clear ctx->vif during iwlagn_prepare_restart() */
454 	vif = ctx->vif;
455 
456 	ret = iwl_trans_d3_resume(priv->trans, &d3_status, false, true);
457 	if (ret)
458 		goto out_unlock;
459 
460 	if (d3_status != IWL_D3_STATUS_ALIVE) {
461 		IWL_INFO(priv, "Device was reset during suspend\n");
462 		goto out_unlock;
463 	}
464 
465 	/* uCode is no longer operating by itself */
466 	iwl_write32(priv->trans, CSR_UCODE_DRV_GP1_CLR,
467 		    CSR_UCODE_DRV_GP1_BIT_D3_CFG_COMPLETE);
468 
469 	base = priv->device_pointers.error_event_table;
470 	if (!iwlagn_hw_valid_rtc_data_addr(base)) {
471 		IWL_WARN(priv, "Invalid error table during resume!\n");
472 		goto out_unlock;
473 	}
474 
475 	iwl_trans_read_mem_bytes(priv->trans, base,
476 				 &err_info, sizeof(err_info));
477 
478 	if (err_info.valid) {
479 		IWL_INFO(priv, "error table is valid (%d, 0x%x)\n",
480 			 err_info.valid, err_info.error_id);
481 		if (err_info.error_id == RF_KILL_INDICATOR_FOR_WOWLAN) {
482 			wakeup.rfkill_release = true;
483 			ieee80211_report_wowlan_wakeup(vif, &wakeup,
484 						       GFP_KERNEL);
485 		}
486 		goto out_unlock;
487 	}
488 
489 #ifdef CONFIG_IWLWIFI_DEBUGFS
490 	img = &priv->fw->img[IWL_UCODE_WOWLAN];
491 	if (!priv->wowlan_sram)
492 		priv->wowlan_sram =
493 			kzalloc(img->sec[IWL_UCODE_SECTION_DATA].len,
494 				GFP_KERNEL);
495 
496 	if (priv->wowlan_sram)
497 		iwl_trans_read_mem(priv->trans, 0x800000,
498 				   priv->wowlan_sram,
499 				   img->sec[IWL_UCODE_SECTION_DATA].len / 4);
500 #endif
501 
502 	/*
503 	 * This is very strange. The GET_STATUS command is sent but the device
504 	 * doesn't reply properly, it seems it doesn't close the RBD so one is
505 	 * always left open ... As a result, we need to send another command
506 	 * and have to reset the driver afterwards. As we need to switch to
507 	 * runtime firmware again that'll happen.
508 	 */
509 
510 	iwl_init_notification_wait(&priv->notif_wait, &status_wait, status_cmd,
511 				   ARRAY_SIZE(status_cmd), iwl_resume_status_fn,
512 				   &resume_data);
513 
514 	iwl_dvm_send_cmd_pdu(priv, REPLY_WOWLAN_GET_STATUS, CMD_ASYNC, 0, NULL);
515 	iwl_dvm_send_cmd_pdu(priv, REPLY_ECHO, CMD_ASYNC, 0, NULL);
516 	/* an RBD is left open in the firmware now! */
517 
518 	ret = iwl_wait_notification(&priv->notif_wait, &status_wait, HZ/5);
519 	if (ret)
520 		goto out_unlock;
521 
522 	if (resume_data.valid && priv->contexts[IWL_RXON_CTX_BSS].vif) {
523 		u32 reasons = le32_to_cpu(status_data.wakeup_reason);
524 		struct cfg80211_wowlan_wakeup *wakeup_report;
525 
526 		IWL_INFO(priv, "WoWLAN wakeup reason(s): 0x%.8x\n", reasons);
527 
528 		if (reasons) {
529 			if (reasons & IWLAGN_WOWLAN_WAKEUP_MAGIC_PACKET)
530 				wakeup.magic_pkt = true;
531 			if (reasons & IWLAGN_WOWLAN_WAKEUP_PATTERN_MATCH)
532 				wakeup.pattern_idx = status_data.pattern_number;
533 			if (reasons & (IWLAGN_WOWLAN_WAKEUP_BEACON_MISS |
534 				       IWLAGN_WOWLAN_WAKEUP_LINK_CHANGE))
535 				wakeup.disconnect = true;
536 			if (reasons & IWLAGN_WOWLAN_WAKEUP_GTK_REKEY_FAIL)
537 				wakeup.gtk_rekey_failure = true;
538 			if (reasons & IWLAGN_WOWLAN_WAKEUP_EAP_IDENT_REQ)
539 				wakeup.eap_identity_req = true;
540 			if (reasons & IWLAGN_WOWLAN_WAKEUP_4WAY_HANDSHAKE)
541 				wakeup.four_way_handshake = true;
542 			wakeup_report = &wakeup;
543 		} else {
544 			wakeup_report = NULL;
545 		}
546 
547 		ieee80211_report_wowlan_wakeup(vif, wakeup_report, GFP_KERNEL);
548 	}
549 
550 	priv->wowlan = false;
551 
552 	iwlagn_prepare_restart(priv);
553 
554 	memset((void *)&ctx->active, 0, sizeof(ctx->active));
555 	iwl_connection_init_rx_config(priv, ctx);
556 	iwlagn_set_rxon_chain(priv, ctx);
557 
558  out_unlock:
559 	mutex_unlock(&priv->mutex);
560 	IWL_DEBUG_MAC80211(priv, "leave\n");
561 
562 	ieee80211_resume_disconnect(vif);
563 
564 	return 1;
565 }
566 
567 static void iwlagn_mac_set_wakeup(struct ieee80211_hw *hw, bool enabled)
568 {
569 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
570 
571 	device_set_wakeup_enable(priv->trans->dev, enabled);
572 }
573 #endif
574 
575 static void iwlagn_mac_tx(struct ieee80211_hw *hw,
576 			  struct ieee80211_tx_control *control,
577 			  struct sk_buff *skb)
578 {
579 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
580 
581 	if (iwlagn_tx_skb(priv, control->sta, skb))
582 		ieee80211_free_txskb(hw, skb);
583 }
584 
585 static void iwlagn_mac_update_tkip_key(struct ieee80211_hw *hw,
586 				       struct ieee80211_vif *vif,
587 				       struct ieee80211_key_conf *keyconf,
588 				       struct ieee80211_sta *sta,
589 				       u32 iv32, u16 *phase1key)
590 {
591 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
592 
593 	iwl_update_tkip_key(priv, vif, keyconf, sta, iv32, phase1key);
594 }
595 
596 static int iwlagn_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
597 			      struct ieee80211_vif *vif,
598 			      struct ieee80211_sta *sta,
599 			      struct ieee80211_key_conf *key)
600 {
601 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
602 	struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
603 	struct iwl_rxon_context *ctx = vif_priv->ctx;
604 	int ret;
605 	bool is_default_wep_key = false;
606 
607 	IWL_DEBUG_MAC80211(priv, "enter\n");
608 
609 	if (iwlwifi_mod_params.swcrypto) {
610 		IWL_DEBUG_MAC80211(priv, "leave - hwcrypto disabled\n");
611 		return -EOPNOTSUPP;
612 	}
613 
614 	switch (key->cipher) {
615 	case WLAN_CIPHER_SUITE_TKIP:
616 		key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
617 		fallthrough;
618 	case WLAN_CIPHER_SUITE_CCMP:
619 		key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
620 		break;
621 	default:
622 		break;
623 	}
624 
625 	/*
626 	 * We could program these keys into the hardware as well, but we
627 	 * don't expect much multicast traffic in IBSS and having keys
628 	 * for more stations is probably more useful.
629 	 *
630 	 * Mark key TX-only and return 0.
631 	 */
632 	if (vif->type == NL80211_IFTYPE_ADHOC &&
633 	    !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
634 		key->hw_key_idx = WEP_INVALID_OFFSET;
635 		return 0;
636 	}
637 
638 	/* If they key was TX-only, accept deletion */
639 	if (cmd == DISABLE_KEY && key->hw_key_idx == WEP_INVALID_OFFSET)
640 		return 0;
641 
642 	mutex_lock(&priv->mutex);
643 	iwl_scan_cancel_timeout(priv, 100);
644 
645 	BUILD_BUG_ON(WEP_INVALID_OFFSET == IWLAGN_HW_KEY_DEFAULT);
646 
647 	/*
648 	 * If we are getting WEP group key and we didn't receive any key mapping
649 	 * so far, we are in legacy wep mode (group key only), otherwise we are
650 	 * in 1X mode.
651 	 * In legacy wep mode, we use another host command to the uCode.
652 	 */
653 	if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
654 	     key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
655 		if (cmd == SET_KEY)
656 			is_default_wep_key = !ctx->key_mapping_keys;
657 		else
658 			is_default_wep_key =
659 				key->hw_key_idx == IWLAGN_HW_KEY_DEFAULT;
660 	}
661 
662 
663 	switch (cmd) {
664 	case SET_KEY:
665 		if (is_default_wep_key) {
666 			ret = iwl_set_default_wep_key(priv, vif_priv->ctx, key);
667 			break;
668 		}
669 		ret = iwl_set_dynamic_key(priv, vif_priv->ctx, key, sta);
670 		if (ret) {
671 			/*
672 			 * can't add key for RX, but we don't need it
673 			 * in the device for TX so still return 0
674 			 */
675 			ret = 0;
676 			key->hw_key_idx = WEP_INVALID_OFFSET;
677 		}
678 
679 		IWL_DEBUG_MAC80211(priv, "enable hwcrypto key\n");
680 		break;
681 	case DISABLE_KEY:
682 		if (is_default_wep_key)
683 			ret = iwl_remove_default_wep_key(priv, ctx, key);
684 		else
685 			ret = iwl_remove_dynamic_key(priv, ctx, key, sta);
686 
687 		IWL_DEBUG_MAC80211(priv, "disable hwcrypto key\n");
688 		break;
689 	default:
690 		ret = -EINVAL;
691 	}
692 
693 	mutex_unlock(&priv->mutex);
694 	IWL_DEBUG_MAC80211(priv, "leave\n");
695 
696 	return ret;
697 }
698 
699 static int iwlagn_mac_ampdu_action(struct ieee80211_hw *hw,
700 				   struct ieee80211_vif *vif,
701 				   struct ieee80211_ampdu_params *params)
702 {
703 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
704 	int ret = -EINVAL;
705 	struct ieee80211_sta *sta = params->sta;
706 	enum ieee80211_ampdu_mlme_action action = params->action;
707 	u16 tid = params->tid;
708 	u16 *ssn = &params->ssn;
709 	u8 buf_size = params->buf_size;
710 	struct iwl_station_priv *sta_priv = (void *) sta->drv_priv;
711 
712 	IWL_DEBUG_HT(priv, "A-MPDU action on addr %pM tid %d\n",
713 		     sta->addr, tid);
714 
715 	if (!(priv->nvm_data->sku_cap_11n_enable))
716 		return -EACCES;
717 
718 	IWL_DEBUG_MAC80211(priv, "enter\n");
719 	mutex_lock(&priv->mutex);
720 
721 	switch (action) {
722 	case IEEE80211_AMPDU_RX_START:
723 		if (!iwl_enable_rx_ampdu())
724 			break;
725 		IWL_DEBUG_HT(priv, "start Rx\n");
726 		ret = iwl_sta_rx_agg_start(priv, sta, tid, *ssn);
727 		break;
728 	case IEEE80211_AMPDU_RX_STOP:
729 		IWL_DEBUG_HT(priv, "stop Rx\n");
730 		ret = iwl_sta_rx_agg_stop(priv, sta, tid);
731 		break;
732 	case IEEE80211_AMPDU_TX_START:
733 		if (!priv->trans->ops->txq_enable)
734 			break;
735 		if (!iwl_enable_tx_ampdu())
736 			break;
737 		IWL_DEBUG_HT(priv, "start Tx\n");
738 		ret = iwlagn_tx_agg_start(priv, vif, sta, tid, ssn);
739 		break;
740 	case IEEE80211_AMPDU_TX_STOP_FLUSH:
741 	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
742 		IWL_DEBUG_HT(priv, "Flush Tx\n");
743 		ret = iwlagn_tx_agg_flush(priv, vif, sta, tid);
744 		break;
745 	case IEEE80211_AMPDU_TX_STOP_CONT:
746 		IWL_DEBUG_HT(priv, "stop Tx\n");
747 		ret = iwlagn_tx_agg_stop(priv, vif, sta, tid);
748 		if ((ret == 0) && (priv->agg_tids_count > 0)) {
749 			priv->agg_tids_count--;
750 			IWL_DEBUG_HT(priv, "priv->agg_tids_count = %u\n",
751 				     priv->agg_tids_count);
752 		}
753 		if (!priv->agg_tids_count &&
754 		    priv->hw_params.use_rts_for_aggregation) {
755 			/*
756 			 * switch off RTS/CTS if it was previously enabled
757 			 */
758 			sta_priv->lq_sta.lq.general_params.flags &=
759 				~LINK_QUAL_FLAGS_SET_STA_TLC_RTS_MSK;
760 			iwl_send_lq_cmd(priv, iwl_rxon_ctx_from_vif(vif),
761 					&sta_priv->lq_sta.lq, CMD_ASYNC, false);
762 		}
763 		break;
764 	case IEEE80211_AMPDU_TX_OPERATIONAL:
765 		ret = iwlagn_tx_agg_oper(priv, vif, sta, tid, buf_size);
766 		break;
767 	}
768 	mutex_unlock(&priv->mutex);
769 	IWL_DEBUG_MAC80211(priv, "leave\n");
770 	return ret;
771 }
772 
773 static int iwlagn_mac_sta_add(struct ieee80211_hw *hw,
774 			      struct ieee80211_vif *vif,
775 			      struct ieee80211_sta *sta)
776 {
777 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
778 	struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
779 	struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
780 	bool is_ap = vif->type == NL80211_IFTYPE_STATION;
781 	int ret;
782 	u8 sta_id;
783 
784 	IWL_DEBUG_INFO(priv, "proceeding to add station %pM\n",
785 			sta->addr);
786 	sta_priv->sta_id = IWL_INVALID_STATION;
787 
788 	atomic_set(&sta_priv->pending_frames, 0);
789 	if (vif->type == NL80211_IFTYPE_AP)
790 		sta_priv->client = true;
791 
792 	ret = iwl_add_station_common(priv, vif_priv->ctx, sta->addr,
793 				     is_ap, sta, &sta_id);
794 	if (ret) {
795 		IWL_ERR(priv, "Unable to add station %pM (%d)\n",
796 			sta->addr, ret);
797 		/* Should we return success if return code is EEXIST ? */
798 		return ret;
799 	}
800 
801 	sta_priv->sta_id = sta_id;
802 
803 	return 0;
804 }
805 
806 static int iwlagn_mac_sta_remove(struct ieee80211_hw *hw,
807 				 struct ieee80211_vif *vif,
808 				 struct ieee80211_sta *sta)
809 {
810 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
811 	struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
812 	int ret;
813 
814 	IWL_DEBUG_INFO(priv, "proceeding to remove station %pM\n", sta->addr);
815 
816 	if (vif->type == NL80211_IFTYPE_STATION) {
817 		/*
818 		 * Station will be removed from device when the RXON
819 		 * is set to unassociated -- just deactivate it here
820 		 * to avoid re-programming it.
821 		 */
822 		ret = 0;
823 		iwl_deactivate_station(priv, sta_priv->sta_id, sta->addr);
824 	} else {
825 		ret = iwl_remove_station(priv, sta_priv->sta_id, sta->addr);
826 		if (ret)
827 			IWL_DEBUG_QUIET_RFKILL(priv,
828 				"Error removing station %pM\n", sta->addr);
829 	}
830 	return ret;
831 }
832 
833 static int iwlagn_mac_sta_state(struct ieee80211_hw *hw,
834 				struct ieee80211_vif *vif,
835 				struct ieee80211_sta *sta,
836 				enum ieee80211_sta_state old_state,
837 				enum ieee80211_sta_state new_state)
838 {
839 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
840 	struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
841 	enum {
842 		NONE, ADD, REMOVE, HT_RATE_INIT, ADD_RATE_INIT,
843 	} op = NONE;
844 	int ret;
845 
846 	IWL_DEBUG_MAC80211(priv, "station %pM state change %d->%d\n",
847 			   sta->addr, old_state, new_state);
848 
849 	mutex_lock(&priv->mutex);
850 	if (vif->type == NL80211_IFTYPE_STATION) {
851 		if (old_state == IEEE80211_STA_NOTEXIST &&
852 		    new_state == IEEE80211_STA_NONE)
853 			op = ADD;
854 		else if (old_state == IEEE80211_STA_NONE &&
855 			 new_state == IEEE80211_STA_NOTEXIST)
856 			op = REMOVE;
857 		else if (old_state == IEEE80211_STA_AUTH &&
858 			 new_state == IEEE80211_STA_ASSOC)
859 			op = HT_RATE_INIT;
860 	} else {
861 		if (old_state == IEEE80211_STA_AUTH &&
862 		    new_state == IEEE80211_STA_ASSOC)
863 			op = ADD_RATE_INIT;
864 		else if (old_state == IEEE80211_STA_ASSOC &&
865 			 new_state == IEEE80211_STA_AUTH)
866 			op = REMOVE;
867 	}
868 
869 	switch (op) {
870 	case ADD:
871 		ret = iwlagn_mac_sta_add(hw, vif, sta);
872 		if (ret)
873 			break;
874 		/*
875 		 * Clear the in-progress flag, the AP station entry was added
876 		 * but we'll initialize LQ only when we've associated (which
877 		 * would also clear the in-progress flag). This is necessary
878 		 * in case we never initialize LQ because association fails.
879 		 */
880 		spin_lock_bh(&priv->sta_lock);
881 		priv->stations[iwl_sta_id(sta)].used &=
882 			~IWL_STA_UCODE_INPROGRESS;
883 		spin_unlock_bh(&priv->sta_lock);
884 		break;
885 	case REMOVE:
886 		ret = iwlagn_mac_sta_remove(hw, vif, sta);
887 		break;
888 	case ADD_RATE_INIT:
889 		ret = iwlagn_mac_sta_add(hw, vif, sta);
890 		if (ret)
891 			break;
892 		/* Initialize rate scaling */
893 		IWL_DEBUG_INFO(priv,
894 			       "Initializing rate scaling for station %pM\n",
895 			       sta->addr);
896 		iwl_rs_rate_init(priv, sta, iwl_sta_id(sta));
897 		ret = 0;
898 		break;
899 	case HT_RATE_INIT:
900 		/* Initialize rate scaling */
901 		ret = iwl_sta_update_ht(priv, vif_priv->ctx, sta);
902 		if (ret)
903 			break;
904 		IWL_DEBUG_INFO(priv,
905 			       "Initializing rate scaling for station %pM\n",
906 			       sta->addr);
907 		iwl_rs_rate_init(priv, sta, iwl_sta_id(sta));
908 		ret = 0;
909 		break;
910 	default:
911 		ret = 0;
912 		break;
913 	}
914 
915 	/*
916 	 * mac80211 might WARN if we fail, but due the way we
917 	 * (badly) handle hard rfkill, we might fail here
918 	 */
919 	if (iwl_is_rfkill(priv))
920 		ret = 0;
921 
922 	mutex_unlock(&priv->mutex);
923 	IWL_DEBUG_MAC80211(priv, "leave\n");
924 
925 	return ret;
926 }
927 
928 static void iwlagn_mac_channel_switch(struct ieee80211_hw *hw,
929 				      struct ieee80211_vif *vif,
930 				      struct ieee80211_channel_switch *ch_switch)
931 {
932 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
933 	struct ieee80211_conf *conf = &hw->conf;
934 	struct ieee80211_channel *channel = ch_switch->chandef.chan;
935 	struct iwl_ht_config *ht_conf = &priv->current_ht_config;
936 	/*
937 	 * MULTI-FIXME
938 	 * When we add support for multiple interfaces, we need to
939 	 * revisit this. The channel switch command in the device
940 	 * only affects the BSS context, but what does that really
941 	 * mean? And what if we get a CSA on the second interface?
942 	 * This needs a lot of work.
943 	 */
944 	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
945 	u16 ch;
946 
947 	IWL_DEBUG_MAC80211(priv, "enter\n");
948 
949 	mutex_lock(&priv->mutex);
950 
951 	if (iwl_is_rfkill(priv))
952 		goto out;
953 
954 	if (test_bit(STATUS_EXIT_PENDING, &priv->status) ||
955 	    test_bit(STATUS_SCANNING, &priv->status) ||
956 	    test_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status))
957 		goto out;
958 
959 	if (!iwl_is_associated_ctx(ctx))
960 		goto out;
961 
962 	if (!priv->lib->set_channel_switch)
963 		goto out;
964 
965 	ch = channel->hw_value;
966 	if (le16_to_cpu(ctx->active.channel) == ch)
967 		goto out;
968 
969 	priv->current_ht_config.smps = conf->smps_mode;
970 
971 	/* Configure HT40 channels */
972 	switch (cfg80211_get_chandef_type(&ch_switch->chandef)) {
973 	case NL80211_CHAN_NO_HT:
974 	case NL80211_CHAN_HT20:
975 		ctx->ht.is_40mhz = false;
976 		ctx->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_NONE;
977 		break;
978 	case NL80211_CHAN_HT40MINUS:
979 		ctx->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
980 		ctx->ht.is_40mhz = true;
981 		break;
982 	case NL80211_CHAN_HT40PLUS:
983 		ctx->ht.extension_chan_offset = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
984 		ctx->ht.is_40mhz = true;
985 		break;
986 	}
987 
988 	if ((le16_to_cpu(ctx->staging.channel) != ch))
989 		ctx->staging.flags = 0;
990 
991 	iwl_set_rxon_channel(priv, channel, ctx);
992 	iwl_set_rxon_ht(priv, ht_conf);
993 	iwl_set_flags_for_band(priv, ctx, channel->band, ctx->vif);
994 
995 	/*
996 	 * at this point, staging_rxon has the
997 	 * configuration for channel switch
998 	 */
999 	set_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
1000 	priv->switch_channel = cpu_to_le16(ch);
1001 	if (priv->lib->set_channel_switch(priv, ch_switch)) {
1002 		clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status);
1003 		priv->switch_channel = 0;
1004 		ieee80211_chswitch_done(ctx->vif, false);
1005 	}
1006 
1007 out:
1008 	mutex_unlock(&priv->mutex);
1009 	IWL_DEBUG_MAC80211(priv, "leave\n");
1010 }
1011 
1012 void iwl_chswitch_done(struct iwl_priv *priv, bool is_success)
1013 {
1014 	/*
1015 	 * MULTI-FIXME
1016 	 * See iwlagn_mac_channel_switch.
1017 	 */
1018 	struct iwl_rxon_context *ctx = &priv->contexts[IWL_RXON_CTX_BSS];
1019 
1020 	if (test_bit(STATUS_EXIT_PENDING, &priv->status))
1021 		return;
1022 
1023 	if (!test_and_clear_bit(STATUS_CHANNEL_SWITCH_PENDING, &priv->status))
1024 		return;
1025 
1026 	if (ctx->vif)
1027 		ieee80211_chswitch_done(ctx->vif, is_success);
1028 }
1029 
1030 static void iwlagn_configure_filter(struct ieee80211_hw *hw,
1031 				    unsigned int changed_flags,
1032 				    unsigned int *total_flags,
1033 				    u64 multicast)
1034 {
1035 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1036 	__le32 filter_or = 0, filter_nand = 0;
1037 	struct iwl_rxon_context *ctx;
1038 
1039 #define CHK(test, flag)	do { \
1040 	if (*total_flags & (test))		\
1041 		filter_or |= (flag);		\
1042 	else					\
1043 		filter_nand |= (flag);		\
1044 	} while (0)
1045 
1046 	IWL_DEBUG_MAC80211(priv, "Enter: changed: 0x%x, total: 0x%x\n",
1047 			changed_flags, *total_flags);
1048 
1049 	CHK(FIF_OTHER_BSS, RXON_FILTER_PROMISC_MSK);
1050 	/* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
1051 	CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
1052 	CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);
1053 
1054 #undef CHK
1055 
1056 	mutex_lock(&priv->mutex);
1057 
1058 	for_each_context(priv, ctx) {
1059 		ctx->staging.filter_flags &= ~filter_nand;
1060 		ctx->staging.filter_flags |= filter_or;
1061 
1062 		/*
1063 		 * Not committing directly because hardware can perform a scan,
1064 		 * but we'll eventually commit the filter flags change anyway.
1065 		 */
1066 	}
1067 
1068 	mutex_unlock(&priv->mutex);
1069 
1070 	/*
1071 	 * Receiving all multicast frames is always enabled by the
1072 	 * default flags setup in iwl_connection_init_rx_config()
1073 	 * since we currently do not support programming multicast
1074 	 * filters into the device.
1075 	 */
1076 	*total_flags &= FIF_OTHER_BSS | FIF_ALLMULTI |
1077 			FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
1078 }
1079 
1080 static void iwlagn_mac_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1081 			     u32 queues, bool drop)
1082 {
1083 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1084 	u32 scd_queues;
1085 
1086 	mutex_lock(&priv->mutex);
1087 	IWL_DEBUG_MAC80211(priv, "enter\n");
1088 
1089 	if (test_bit(STATUS_EXIT_PENDING, &priv->status)) {
1090 		IWL_DEBUG_TX(priv, "Aborting flush due to device shutdown\n");
1091 		goto done;
1092 	}
1093 	if (iwl_is_rfkill(priv)) {
1094 		IWL_DEBUG_TX(priv, "Aborting flush due to RF Kill\n");
1095 		goto done;
1096 	}
1097 
1098 	scd_queues = BIT(priv->trans->trans_cfg->base_params->num_of_queues) - 1;
1099 	scd_queues &= ~(BIT(IWL_IPAN_CMD_QUEUE_NUM) |
1100 			BIT(IWL_DEFAULT_CMD_QUEUE_NUM));
1101 
1102 	if (drop) {
1103 		IWL_DEBUG_TX_QUEUES(priv, "Flushing SCD queues: 0x%x\n",
1104 				    scd_queues);
1105 		if (iwlagn_txfifo_flush(priv, scd_queues)) {
1106 			IWL_ERR(priv, "flush request fail\n");
1107 			goto done;
1108 		}
1109 	}
1110 
1111 	IWL_DEBUG_TX_QUEUES(priv, "wait transmit/flush all frames\n");
1112 	iwl_trans_wait_tx_queues_empty(priv->trans, scd_queues);
1113 done:
1114 	mutex_unlock(&priv->mutex);
1115 	IWL_DEBUG_MAC80211(priv, "leave\n");
1116 }
1117 
1118 static void iwlagn_mac_event_callback(struct ieee80211_hw *hw,
1119 				      struct ieee80211_vif *vif,
1120 				      const struct ieee80211_event *event)
1121 {
1122 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1123 
1124 	if (event->type != RSSI_EVENT)
1125 		return;
1126 
1127 	IWL_DEBUG_MAC80211(priv, "enter\n");
1128 
1129 	if (priv->lib->bt_params &&
1130 	    priv->lib->bt_params->advanced_bt_coexist) {
1131 		if (event->u.rssi.data == RSSI_EVENT_LOW)
1132 			priv->bt_enable_pspoll = true;
1133 		else if (event->u.rssi.data == RSSI_EVENT_HIGH)
1134 			priv->bt_enable_pspoll = false;
1135 
1136 		queue_work(priv->workqueue, &priv->bt_runtime_config);
1137 	} else {
1138 		IWL_DEBUG_MAC80211(priv, "Advanced BT coex disabled,"
1139 				"ignoring RSSI callback\n");
1140 	}
1141 
1142 	IWL_DEBUG_MAC80211(priv, "leave\n");
1143 }
1144 
1145 static int iwlagn_mac_set_tim(struct ieee80211_hw *hw,
1146 			      struct ieee80211_sta *sta, bool set)
1147 {
1148 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1149 
1150 	queue_work(priv->workqueue, &priv->beacon_update);
1151 
1152 	return 0;
1153 }
1154 
1155 static int iwlagn_mac_conf_tx(struct ieee80211_hw *hw,
1156 			      struct ieee80211_vif *vif, u16 queue,
1157 			      const struct ieee80211_tx_queue_params *params)
1158 {
1159 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1160 	struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
1161 	struct iwl_rxon_context *ctx = vif_priv->ctx;
1162 	int q;
1163 
1164 	if (WARN_ON(!ctx))
1165 		return -EINVAL;
1166 
1167 	IWL_DEBUG_MAC80211(priv, "enter\n");
1168 
1169 	if (!iwl_is_ready_rf(priv)) {
1170 		IWL_DEBUG_MAC80211(priv, "leave - RF not ready\n");
1171 		return -EIO;
1172 	}
1173 
1174 	if (queue >= AC_NUM) {
1175 		IWL_DEBUG_MAC80211(priv, "leave - queue >= AC_NUM %d\n", queue);
1176 		return 0;
1177 	}
1178 
1179 	q = AC_NUM - 1 - queue;
1180 
1181 	mutex_lock(&priv->mutex);
1182 
1183 	ctx->qos_data.def_qos_parm.ac[q].cw_min =
1184 		cpu_to_le16(params->cw_min);
1185 	ctx->qos_data.def_qos_parm.ac[q].cw_max =
1186 		cpu_to_le16(params->cw_max);
1187 	ctx->qos_data.def_qos_parm.ac[q].aifsn = params->aifs;
1188 	ctx->qos_data.def_qos_parm.ac[q].edca_txop =
1189 			cpu_to_le16((params->txop * 32));
1190 
1191 	ctx->qos_data.def_qos_parm.ac[q].reserved1 = 0;
1192 
1193 	mutex_unlock(&priv->mutex);
1194 
1195 	IWL_DEBUG_MAC80211(priv, "leave\n");
1196 	return 0;
1197 }
1198 
1199 static int iwlagn_mac_tx_last_beacon(struct ieee80211_hw *hw)
1200 {
1201 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1202 
1203 	return priv->ibss_manager == IWL_IBSS_MANAGER;
1204 }
1205 
1206 static int iwl_set_mode(struct iwl_priv *priv, struct iwl_rxon_context *ctx)
1207 {
1208 	iwl_connection_init_rx_config(priv, ctx);
1209 
1210 	iwlagn_set_rxon_chain(priv, ctx);
1211 
1212 	return iwlagn_commit_rxon(priv, ctx);
1213 }
1214 
1215 static int iwl_setup_interface(struct iwl_priv *priv,
1216 			       struct iwl_rxon_context *ctx)
1217 {
1218 	struct ieee80211_vif *vif = ctx->vif;
1219 	int err, ac;
1220 
1221 	lockdep_assert_held(&priv->mutex);
1222 
1223 	/*
1224 	 * This variable will be correct only when there's just
1225 	 * a single context, but all code using it is for hardware
1226 	 * that supports only one context.
1227 	 */
1228 	priv->iw_mode = vif->type;
1229 
1230 	ctx->is_active = true;
1231 
1232 	err = iwl_set_mode(priv, ctx);
1233 	if (err) {
1234 		if (!ctx->always_active)
1235 			ctx->is_active = false;
1236 		return err;
1237 	}
1238 
1239 	if (priv->lib->bt_params && priv->lib->bt_params->advanced_bt_coexist &&
1240 	    vif->type == NL80211_IFTYPE_ADHOC) {
1241 		/*
1242 		 * pretend to have high BT traffic as long as we
1243 		 * are operating in IBSS mode, as this will cause
1244 		 * the rate scaling etc. to behave as intended.
1245 		 */
1246 		priv->bt_traffic_load = IWL_BT_COEX_TRAFFIC_LOAD_HIGH;
1247 	}
1248 
1249 	/* set up queue mappings */
1250 	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
1251 		vif->hw_queue[ac] = ctx->ac_to_queue[ac];
1252 
1253 	if (vif->type == NL80211_IFTYPE_AP)
1254 		vif->cab_queue = ctx->mcast_queue;
1255 	else
1256 		vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
1257 
1258 	return 0;
1259 }
1260 
1261 static int iwlagn_mac_add_interface(struct ieee80211_hw *hw,
1262 				    struct ieee80211_vif *vif)
1263 {
1264 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1265 	struct iwl_vif_priv *vif_priv = (void *)vif->drv_priv;
1266 	struct iwl_rxon_context *tmp, *ctx = NULL;
1267 	int err;
1268 	enum nl80211_iftype viftype = ieee80211_vif_type_p2p(vif);
1269 	bool reset = false;
1270 
1271 	IWL_DEBUG_MAC80211(priv, "enter: type %d, addr %pM\n",
1272 			   viftype, vif->addr);
1273 
1274 	mutex_lock(&priv->mutex);
1275 
1276 	if (!iwl_is_ready_rf(priv)) {
1277 		IWL_WARN(priv, "Try to add interface when device not ready\n");
1278 		err = -EINVAL;
1279 		goto out;
1280 	}
1281 
1282 	for_each_context(priv, tmp) {
1283 		u32 possible_modes =
1284 			tmp->interface_modes | tmp->exclusive_interface_modes;
1285 
1286 		if (tmp->vif) {
1287 			/* On reset we need to add the same interface again */
1288 			if (tmp->vif == vif) {
1289 				reset = true;
1290 				ctx = tmp;
1291 				break;
1292 			}
1293 
1294 			/* check if this busy context is exclusive */
1295 			if (tmp->exclusive_interface_modes &
1296 						BIT(tmp->vif->type)) {
1297 				err = -EINVAL;
1298 				goto out;
1299 			}
1300 			continue;
1301 		}
1302 
1303 		if (!(possible_modes & BIT(viftype)))
1304 			continue;
1305 
1306 		/* have maybe usable context w/o interface */
1307 		ctx = tmp;
1308 		break;
1309 	}
1310 
1311 	if (!ctx) {
1312 		err = -EOPNOTSUPP;
1313 		goto out;
1314 	}
1315 
1316 	vif_priv->ctx = ctx;
1317 	ctx->vif = vif;
1318 
1319 	/*
1320 	 * In SNIFFER device type, the firmware reports the FCS to
1321 	 * the host, rather than snipping it off. Unfortunately,
1322 	 * mac80211 doesn't (yet) provide a per-packet flag for
1323 	 * this, so that we have to set the hardware flag based
1324 	 * on the interfaces added. As the monitor interface can
1325 	 * only be present by itself, and will be removed before
1326 	 * other interfaces are added, this is safe.
1327 	 */
1328 	if (vif->type == NL80211_IFTYPE_MONITOR)
1329 		ieee80211_hw_set(priv->hw, RX_INCLUDES_FCS);
1330 	else
1331 		__clear_bit(IEEE80211_HW_RX_INCLUDES_FCS, priv->hw->flags);
1332 
1333 	err = iwl_setup_interface(priv, ctx);
1334 	if (!err || reset)
1335 		goto out;
1336 
1337 	ctx->vif = NULL;
1338 	priv->iw_mode = NL80211_IFTYPE_STATION;
1339  out:
1340 	mutex_unlock(&priv->mutex);
1341 
1342 	IWL_DEBUG_MAC80211(priv, "leave\n");
1343 	return err;
1344 }
1345 
1346 static void iwl_teardown_interface(struct iwl_priv *priv,
1347 				   struct ieee80211_vif *vif,
1348 				   bool mode_change)
1349 {
1350 	struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
1351 
1352 	lockdep_assert_held(&priv->mutex);
1353 
1354 	if (priv->scan_vif == vif) {
1355 		iwl_scan_cancel_timeout(priv, 200);
1356 		iwl_force_scan_end(priv);
1357 	}
1358 
1359 	if (!mode_change) {
1360 		iwl_set_mode(priv, ctx);
1361 		if (!ctx->always_active)
1362 			ctx->is_active = false;
1363 	}
1364 
1365 	/*
1366 	 * When removing the IBSS interface, overwrite the
1367 	 * BT traffic load with the stored one from the last
1368 	 * notification, if any. If this is a device that
1369 	 * doesn't implement this, this has no effect since
1370 	 * both values are the same and zero.
1371 	 */
1372 	if (vif->type == NL80211_IFTYPE_ADHOC)
1373 		priv->bt_traffic_load = priv->last_bt_traffic_load;
1374 }
1375 
1376 static void iwlagn_mac_remove_interface(struct ieee80211_hw *hw,
1377 			      struct ieee80211_vif *vif)
1378 {
1379 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1380 	struct iwl_rxon_context *ctx = iwl_rxon_ctx_from_vif(vif);
1381 
1382 	IWL_DEBUG_MAC80211(priv, "enter\n");
1383 
1384 	mutex_lock(&priv->mutex);
1385 
1386 	WARN_ON(ctx->vif != vif);
1387 	ctx->vif = NULL;
1388 
1389 	iwl_teardown_interface(priv, vif, false);
1390 
1391 	mutex_unlock(&priv->mutex);
1392 
1393 	IWL_DEBUG_MAC80211(priv, "leave\n");
1394 
1395 }
1396 
1397 static int iwlagn_mac_change_interface(struct ieee80211_hw *hw,
1398 				       struct ieee80211_vif *vif,
1399 				       enum nl80211_iftype newtype, bool newp2p)
1400 {
1401 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1402 	struct iwl_rxon_context *ctx, *tmp;
1403 	enum nl80211_iftype newviftype = newtype;
1404 	u32 interface_modes;
1405 	int err;
1406 
1407 	IWL_DEBUG_MAC80211(priv, "enter\n");
1408 
1409 	newtype = ieee80211_iftype_p2p(newtype, newp2p);
1410 
1411 	mutex_lock(&priv->mutex);
1412 
1413 	ctx = iwl_rxon_ctx_from_vif(vif);
1414 
1415 	/*
1416 	 * To simplify this code, only support changes on the
1417 	 * BSS context. The PAN context is usually reassigned
1418 	 * by creating/removing P2P interfaces anyway.
1419 	 */
1420 	if (ctx->ctxid != IWL_RXON_CTX_BSS) {
1421 		err = -EBUSY;
1422 		goto out;
1423 	}
1424 
1425 	if (!ctx->vif || !iwl_is_ready_rf(priv)) {
1426 		/*
1427 		 * Huh? But wait ... this can maybe happen when
1428 		 * we're in the middle of a firmware restart!
1429 		 */
1430 		err = -EBUSY;
1431 		goto out;
1432 	}
1433 
1434 	/* Check if the switch is supported in the same context */
1435 	interface_modes = ctx->interface_modes | ctx->exclusive_interface_modes;
1436 	if (!(interface_modes & BIT(newtype))) {
1437 		err = -EBUSY;
1438 		goto out;
1439 	}
1440 
1441 	if (ctx->exclusive_interface_modes & BIT(newtype)) {
1442 		for_each_context(priv, tmp) {
1443 			if (ctx == tmp)
1444 				continue;
1445 
1446 			if (!tmp->is_active)
1447 				continue;
1448 
1449 			/*
1450 			 * The current mode switch would be exclusive, but
1451 			 * another context is active ... refuse the switch.
1452 			 */
1453 			err = -EBUSY;
1454 			goto out;
1455 		}
1456 	}
1457 
1458 	/* success */
1459 	iwl_teardown_interface(priv, vif, true);
1460 	vif->type = newviftype;
1461 	vif->p2p = newp2p;
1462 	err = iwl_setup_interface(priv, ctx);
1463 	WARN_ON(err);
1464 	/*
1465 	 * We've switched internally, but submitting to the
1466 	 * device may have failed for some reason. Mask this
1467 	 * error, because otherwise mac80211 will not switch
1468 	 * (and set the interface type back) and we'll be
1469 	 * out of sync with it.
1470 	 */
1471 	err = 0;
1472 
1473  out:
1474 	mutex_unlock(&priv->mutex);
1475 	IWL_DEBUG_MAC80211(priv, "leave\n");
1476 
1477 	return err;
1478 }
1479 
1480 static int iwlagn_mac_hw_scan(struct ieee80211_hw *hw,
1481 			      struct ieee80211_vif *vif,
1482 			      struct ieee80211_scan_request *hw_req)
1483 {
1484 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1485 	struct cfg80211_scan_request *req = &hw_req->req;
1486 	int ret;
1487 
1488 	IWL_DEBUG_MAC80211(priv, "enter\n");
1489 
1490 	if (req->n_channels == 0)
1491 		return -EINVAL;
1492 
1493 	mutex_lock(&priv->mutex);
1494 
1495 	/*
1496 	 * If an internal scan is in progress, just set
1497 	 * up the scan_request as per above.
1498 	 */
1499 	if (priv->scan_type != IWL_SCAN_NORMAL) {
1500 		IWL_DEBUG_SCAN(priv,
1501 			       "SCAN request during internal scan - defer\n");
1502 		priv->scan_request = req;
1503 		priv->scan_vif = vif;
1504 		ret = 0;
1505 	} else {
1506 		priv->scan_request = req;
1507 		priv->scan_vif = vif;
1508 		/*
1509 		 * mac80211 will only ask for one band at a time
1510 		 * so using channels[0] here is ok
1511 		 */
1512 		ret = iwl_scan_initiate(priv, vif, IWL_SCAN_NORMAL,
1513 					req->channels[0]->band);
1514 		if (ret) {
1515 			priv->scan_request = NULL;
1516 			priv->scan_vif = NULL;
1517 		}
1518 	}
1519 
1520 	IWL_DEBUG_MAC80211(priv, "leave\n");
1521 
1522 	mutex_unlock(&priv->mutex);
1523 
1524 	return ret;
1525 }
1526 
1527 static void iwl_sta_modify_ps_wake(struct iwl_priv *priv, int sta_id)
1528 {
1529 	struct iwl_addsta_cmd cmd = {
1530 		.mode = STA_CONTROL_MODIFY_MSK,
1531 		.station_flags_msk = STA_FLG_PWR_SAVE_MSK,
1532 		.sta.sta_id = sta_id,
1533 	};
1534 
1535 	iwl_send_add_sta(priv, &cmd, CMD_ASYNC);
1536 }
1537 
1538 static void iwlagn_mac_sta_notify(struct ieee80211_hw *hw,
1539 				  struct ieee80211_vif *vif,
1540 				  enum sta_notify_cmd cmd,
1541 				  struct ieee80211_sta *sta)
1542 {
1543 	struct iwl_priv *priv = IWL_MAC80211_GET_DVM(hw);
1544 	struct iwl_station_priv *sta_priv = (void *)sta->drv_priv;
1545 	int sta_id;
1546 
1547 	IWL_DEBUG_MAC80211(priv, "enter\n");
1548 
1549 	switch (cmd) {
1550 	case STA_NOTIFY_SLEEP:
1551 		WARN_ON(!sta_priv->client);
1552 		sta_priv->asleep = true;
1553 		if (atomic_read(&sta_priv->pending_frames) > 0)
1554 			ieee80211_sta_block_awake(hw, sta, true);
1555 		break;
1556 	case STA_NOTIFY_AWAKE:
1557 		WARN_ON(!sta_priv->client);
1558 		if (!sta_priv->asleep)
1559 			break;
1560 		sta_priv->asleep = false;
1561 		sta_id = iwl_sta_id(sta);
1562 		if (sta_id != IWL_INVALID_STATION)
1563 			iwl_sta_modify_ps_wake(priv, sta_id);
1564 		break;
1565 	default:
1566 		break;
1567 	}
1568 	IWL_DEBUG_MAC80211(priv, "leave\n");
1569 }
1570 
1571 const struct ieee80211_ops iwlagn_hw_ops = {
1572 	.tx = iwlagn_mac_tx,
1573 	.start = iwlagn_mac_start,
1574 	.stop = iwlagn_mac_stop,
1575 #ifdef CONFIG_PM_SLEEP
1576 	.suspend = iwlagn_mac_suspend,
1577 	.resume = iwlagn_mac_resume,
1578 	.set_wakeup = iwlagn_mac_set_wakeup,
1579 #endif
1580 	.add_interface = iwlagn_mac_add_interface,
1581 	.remove_interface = iwlagn_mac_remove_interface,
1582 	.change_interface = iwlagn_mac_change_interface,
1583 	.config = iwlagn_mac_config,
1584 	.configure_filter = iwlagn_configure_filter,
1585 	.set_key = iwlagn_mac_set_key,
1586 	.update_tkip_key = iwlagn_mac_update_tkip_key,
1587 	.set_rekey_data = iwlagn_mac_set_rekey_data,
1588 	.conf_tx = iwlagn_mac_conf_tx,
1589 	.bss_info_changed = iwlagn_bss_info_changed,
1590 	.ampdu_action = iwlagn_mac_ampdu_action,
1591 	.hw_scan = iwlagn_mac_hw_scan,
1592 	.sta_notify = iwlagn_mac_sta_notify,
1593 	.sta_state = iwlagn_mac_sta_state,
1594 	.channel_switch = iwlagn_mac_channel_switch,
1595 	.flush = iwlagn_mac_flush,
1596 	.tx_last_beacon = iwlagn_mac_tx_last_beacon,
1597 	.event_callback = iwlagn_mac_event_callback,
1598 	.set_tim = iwlagn_mac_set_tim,
1599 };
1600 
1601 /* This function both allocates and initializes hw and priv. */
1602 struct ieee80211_hw *iwl_alloc_all(void)
1603 {
1604 	struct iwl_priv *priv;
1605 	struct iwl_op_mode *op_mode;
1606 	/* mac80211 allocates memory for this device instance, including
1607 	 *   space for this driver's private structure */
1608 	struct ieee80211_hw *hw;
1609 
1610 	hw = ieee80211_alloc_hw(sizeof(struct iwl_priv) +
1611 				sizeof(struct iwl_op_mode), &iwlagn_hw_ops);
1612 	if (!hw)
1613 		goto out;
1614 
1615 	op_mode = hw->priv;
1616 	priv = IWL_OP_MODE_GET_DVM(op_mode);
1617 	priv->hw = hw;
1618 
1619 out:
1620 	return hw;
1621 }
1622