projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
iwlwifi: mvm: remove unnecessary check in iwl_mvm_is_d0i3_supported()
[deliverable/linux.git] / drivers / net / wireless / intel / iwlwifi / mvm / mac80211.c
CommitLineData
8ca151b5
JB		 1/******************************************************************************
2 *
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
5 *
6 * GPL LICENSE SUMMARY
7 *
51368bf7 8 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
8b4139dc 9 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
8ca151b5
JB		 10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of version 2 of the GNU General Public License as
13 * published by the Free Software Foundation.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
23 * USA
24 *
25 * The full GNU General Public License is included in this distribution
410dc5aa 26 * in the file called COPYING.
8ca151b5
JB		 27 *
28 * Contact Information:
29 * Intel Linux Wireless <ilw@linux.intel.com>
30 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
31 *
32 * BSD LICENSE
33 *
51368bf7 34 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
8b4139dc 35 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
8ca151b5
JB		 36 * All rights reserved.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 *
42 * * Redistributions of source code must retain the above copyright
43 * notice, this list of conditions and the following disclaimer.
44 * * Redistributions in binary form must reproduce the above copyright
45 * notice, this list of conditions and the following disclaimer in
46 * the documentation and/or other materials provided with the
47 * distribution.
48 * * Neither the name Intel Corporation nor the names of its
49 * contributors may be used to endorse or promote products derived
50 * from this software without specific prior written permission.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
53 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
54 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
55 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
56 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
57 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
58 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
59 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
60 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
61 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
62 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
63 *
64 *****************************************************************************/
65#include <linux/kernel.h>
66#include <linux/slab.h>
67#include <linux/skbuff.h>
68#include <linux/netdevice.h>
69#include <linux/etherdevice.h>
f0c2646a 70#include <linux/ip.h>
2ee8f021 71#include <linux/if_arp.h>
aadede6e 72#include <linux/devcoredump.h>
8ca151b5 73#include <net/mac80211.h>
7b1dd048 74#include <net/ieee80211_radiotap.h>
f0c2646a 75#include <net/tcp.h>
8ca151b5
JB		 76
77#include "iwl-op-mode.h"
78#include "iwl-io.h"
79#include "mvm.h"
80#include "sta.h"
81#include "time-event.h"
82#include "iwl-eeprom-parse.h"
8ca151b5 83#include "iwl-phy-db.h"
507cadf2 84#include "testmode.h"
655e6d6d
EG		 85#include "iwl-fw-error-dump.h"
86#include "iwl-prph.h"
363039be 87#include "iwl-csr.h"
88931cc9 88#include "iwl-nvm-parse.h"
8ca151b5
JB		 89
90static const struct ieee80211_iface_limit iwl_mvm_limits[] = {
91 {
92 .max = 1,
8eb38710 93 .types = BIT(NL80211_IFTYPE_STATION),
8ca151b5 94 },
3c15a0fb
JB		 95 {
96 .max = 1,
8eb38710
IP		 97 .types = BIT(NL80211_IFTYPE_AP) |
98 BIT(NL80211_IFTYPE_P2P_CLIENT) |
3c15a0fb
JB		 99 BIT(NL80211_IFTYPE_P2P_GO),
100 },
101 {
102 .max = 1,
103 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
104 },
8ca151b5
JB		 105};
106
107static const struct ieee80211_iface_combination iwl_mvm_iface_combinations[] = {
108 {
2624a5ca 109 .num_different_channels = 2,
8ca151b5
JB		 110 .max_interfaces = 3,
111 .limits = iwl_mvm_limits,
112 .n_limits = ARRAY_SIZE(iwl_mvm_limits),
113 },
114};
115
f0c2646a
JB		 116#ifdef CONFIG_PM_SLEEP
117static const struct nl80211_wowlan_tcp_data_token_feature
118iwl_mvm_wowlan_tcp_token_feature = {
119 .min_len = 0,
120 .max_len = 255,
121 .bufsize = IWL_WOWLAN_REMOTE_WAKE_MAX_TOKENS,
122};
123
124static const struct wiphy_wowlan_tcp_support iwl_mvm_wowlan_tcp_support = {
125 .tok = &iwl_mvm_wowlan_tcp_token_feature,
126 .data_payload_max = IWL_WOWLAN_TCP_MAX_PACKET_LEN -
127 sizeof(struct ethhdr) -
128 sizeof(struct iphdr) -
129 sizeof(struct tcphdr),
130 .data_interval_max = 65535, /* __le16 in API */
131 .wake_payload_max = IWL_WOWLAN_REMOTE_WAKE_MAX_PACKET_LEN -
132 sizeof(struct ethhdr) -
133 sizeof(struct iphdr) -
134 sizeof(struct tcphdr),
135 .seq = true,
136};
137#endif
138
77736923 139#ifdef CONFIG_IWLWIFI_BCAST_FILTERING
2ee8f021
EP		 140/*
141 * Use the reserved field to indicate magic values.
142 * these values will only be used internally by the driver,
143 * and won't make it to the fw (reserved will be 0).
144 * BC_FILTER_MAGIC_IP - configure the val of this attribute to
145 * be the vif's ip address. in case there is not a single
146 * ip address (0, or more than 1), this attribute will
147 * be skipped.
148 * BC_FILTER_MAGIC_MAC - set the val of this attribute to
149 * the LSB bytes of the vif's mac address
150 */
151enum {
152 BC_FILTER_MAGIC_NONE = 0,
153 BC_FILTER_MAGIC_IP,
154 BC_FILTER_MAGIC_MAC,
155};
156
77736923
EP		 157static const struct iwl_fw_bcast_filter iwl_mvm_default_bcast_filters[] = {
158 {
159 /* arp */
160 .discard = 0,
161 .frame_type = BCAST_FILTER_FRAME_TYPE_ALL,
162 .attrs = {
163 {
164 /* frame type - arp, hw type - ethernet */
165 .offset_type =
166 BCAST_FILTER_OFFSET_PAYLOAD_START,
167 .offset = sizeof(rfc1042_header),
168 .val = cpu_to_be32(0x08060001),
169 .mask = cpu_to_be32(0xffffffff),
170 },
2ee8f021
EP		 171 {
172 /* arp dest ip */
173 .offset_type =
174 BCAST_FILTER_OFFSET_PAYLOAD_START,
175 .offset = sizeof(rfc1042_header) + 2 +
176 sizeof(struct arphdr) +
177 ETH_ALEN + sizeof(__be32) +
178 ETH_ALEN,
179 .mask = cpu_to_be32(0xffffffff),
180 /* mark it as special field */
181 .reserved1 = cpu_to_le16(BC_FILTER_MAGIC_IP),
182 },
183 },
184 },
185 {
186 /* dhcp offer bcast */
187 .discard = 0,
188 .frame_type = BCAST_FILTER_FRAME_TYPE_IPV4,
189 .attrs = {
190 {
191 /* udp dest port - 68 (bootp client)*/
192 .offset_type = BCAST_FILTER_OFFSET_IP_END,
193 .offset = offsetof(struct udphdr, dest),
194 .val = cpu_to_be32(0x00440000),
195 .mask = cpu_to_be32(0xffff0000),
196 },
197 {
198 /* dhcp - lsb bytes of client hw address */
199 .offset_type = BCAST_FILTER_OFFSET_IP_END,
200 .offset = 38,
201 .mask = cpu_to_be32(0xffffffff),
202 /* mark it as special field */
203 .reserved1 = cpu_to_le16(BC_FILTER_MAGIC_MAC),
204 },
77736923
EP		 205 },
206 },
207 /* last filter must be empty */
208 {},
209};
210#endif
211
7498cf4c
EP		 212void iwl_mvm_ref(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type)
213{
7bb426ea 214 if (!iwl_mvm_is_d0i3_supported(mvm))
7498cf4c
EP		 215 return;
216
217 IWL_DEBUG_RPM(mvm, "Take mvm reference - type %d\n", ref_type);
576eeee9
EP		 218 spin_lock_bh(&mvm->refs_lock);
219 mvm->refs[ref_type]++;
220 spin_unlock_bh(&mvm->refs_lock);
7498cf4c
EP		 221 iwl_trans_ref(mvm->trans);
222}
223
224void iwl_mvm_unref(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type)
225{
7bb426ea 226 if (!iwl_mvm_is_d0i3_supported(mvm))
7498cf4c
EP		 227 return;
228
229 IWL_DEBUG_RPM(mvm, "Leave mvm reference - type %d\n", ref_type);
576eeee9
EP		 230 spin_lock_bh(&mvm->refs_lock);
231 WARN_ON(!mvm->refs[ref_type]--);
232 spin_unlock_bh(&mvm->refs_lock);
7498cf4c
EP		 233 iwl_trans_unref(mvm->trans);
234}
235
576eeee9
EP		 236static void iwl_mvm_unref_all_except(struct iwl_mvm *mvm,
237 enum iwl_mvm_ref_type except_ref)
7498cf4c 238{
576eeee9 239 int i, j;
7498cf4c 240
7bb426ea 241 if (!iwl_mvm_is_d0i3_supported(mvm))
7498cf4c
EP		 242 return;
243
576eeee9
EP		 244 spin_lock_bh(&mvm->refs_lock);
245 for (i = 0; i < IWL_MVM_REF_COUNT; i++) {
246 if (except_ref == i || !mvm->refs[i])
7498cf4c
EP		 247 continue;
248
576eeee9
EP		 249 IWL_DEBUG_RPM(mvm, "Cleanup: remove mvm ref type %d (%d)\n",
250 i, mvm->refs[i]);
251 for (j = 0; j < mvm->refs[i]; j++)
252 iwl_trans_unref(mvm->trans);
253 mvm->refs[i] = 0;
7498cf4c 254 }
576eeee9 255 spin_unlock_bh(&mvm->refs_lock);
7498cf4c
EP		 256}
257
f4cf8680
EP		 258bool iwl_mvm_ref_taken(struct iwl_mvm *mvm)
259{
260 int i;
261 bool taken = false;
262
263 if (!iwl_mvm_is_d0i3_supported(mvm))
264 return true;
265
266 spin_lock_bh(&mvm->refs_lock);
267 for (i = 0; i < IWL_MVM_REF_COUNT; i++) {
268 if (mvm->refs[i]) {
269 taken = true;
270 break;
271 }
272 }
273 spin_unlock_bh(&mvm->refs_lock);
274
275 return taken;
276}
277
576eeee9 278int iwl_mvm_ref_sync(struct iwl_mvm *mvm, enum iwl_mvm_ref_type ref_type)
d40fc489
GG		 279{
280 iwl_mvm_ref(mvm, ref_type);
281
282 if (!wait_event_timeout(mvm->d0i3_exit_waitq,
283 !test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status),
284 HZ)) {
285 WARN_ON_ONCE(1);
286 iwl_mvm_unref(mvm, ref_type);
287 return -EIO;
288 }
289
290 return 0;
291}
292
fe0f2de3
IP		 293static void iwl_mvm_reset_phy_ctxts(struct iwl_mvm *mvm)
294{
295 int i;
296
297 memset(mvm->phy_ctxts, 0, sizeof(mvm->phy_ctxts));
298 for (i = 0; i < NUM_PHY_CTX; i++) {
299 mvm->phy_ctxts[i].id = i;
300 mvm->phy_ctxts[i].ref = 0;
301 }
302}
303
88931cc9 304struct ieee80211_regdomain *iwl_mvm_get_regdomain(struct wiphy *wiphy,
8ba2d7a1 305 const char *alpha2,
47c8b154
JD		 306 enum iwl_mcc_source src_id,
307 bool *changed)
88931cc9
AN		 308{
309 struct ieee80211_regdomain *regd = NULL;
310 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
311 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
312 struct iwl_mcc_update_resp *resp;
313
314 IWL_DEBUG_LAR(mvm, "Getting regdomain data for %s from FW\n", alpha2);
315
8ba2d7a1 316 lockdep_assert_held(&mvm->mutex);
88931cc9 317
8ba2d7a1 318 resp = iwl_mvm_update_mcc(mvm, alpha2, src_id);
88931cc9
AN		 319 if (IS_ERR_OR_NULL(resp)) {
320 IWL_DEBUG_LAR(mvm, "Could not get update from FW %d\n",
b8c474d9 321 PTR_ERR_OR_ZERO(resp));
8ba2d7a1 322 goto out;
88931cc9
AN		 323 }
324
47c8b154
JD		 325 if (changed)
326 *changed = (resp->status == MCC_RESP_NEW_CHAN_PROFILE);
327
162ee3c9 328 regd = iwl_parse_nvm_mcc_info(mvm->trans->dev, mvm->cfg,
88931cc9
AN		 329 __le32_to_cpu(resp->n_channels),
330 resp->channels,
331 __le16_to_cpu(resp->mcc));
8ba2d7a1
EH		 332 /* Store the return source id */
333 src_id = resp->source_id;
88931cc9
AN		 334 kfree(resp);
335 if (IS_ERR_OR_NULL(regd)) {
336 IWL_DEBUG_LAR(mvm, "Could not get parse update from FW %d\n",
b8c474d9 337 PTR_ERR_OR_ZERO(regd));
8ba2d7a1 338 goto out;
88931cc9
AN		 339 }
340
8ba2d7a1
EH		 341 IWL_DEBUG_LAR(mvm, "setting alpha2 from FW to %s (0x%x, 0x%x) src=%d\n",
342 regd->alpha2, regd->alpha2[0], regd->alpha2[1], src_id);
88931cc9 343 mvm->lar_regdom_set = true;
8ba2d7a1 344 mvm->mcc_src = src_id;
88931cc9 345
8ba2d7a1 346out:
88931cc9
AN		 347 return regd;
348}
349
47c8b154
JD		 350void iwl_mvm_update_changed_regdom(struct iwl_mvm *mvm)
351{
352 bool changed;
353 struct ieee80211_regdomain *regd;
354
355 if (!iwl_mvm_is_lar_supported(mvm))
356 return;
357
358 regd = iwl_mvm_get_current_regdomain(mvm, &changed);
359 if (!IS_ERR_OR_NULL(regd)) {
360 /* only update the regulatory core if changed */
361 if (changed)
362 regulatory_set_wiphy_regd(mvm->hw->wiphy, regd);
363
364 kfree(regd);
365 }
366}
367
368struct ieee80211_regdomain *iwl_mvm_get_current_regdomain(struct iwl_mvm *mvm,
369 bool *changed)
8ba2d7a1
EH		 370{
371 return iwl_mvm_get_regdomain(mvm->hw->wiphy, "ZZ",
372 iwl_mvm_is_wifi_mcc_supported(mvm) ?
373 MCC_SOURCE_GET_CURRENT :
47c8b154 374 MCC_SOURCE_OLD_FW, changed);
8ba2d7a1
EH		 375}
376
377int iwl_mvm_init_fw_regd(struct iwl_mvm *mvm)
378{
379 enum iwl_mcc_source used_src;
380 struct ieee80211_regdomain *regd;
b6e160ab
AN		 381 int ret;
382 bool changed;
8ba2d7a1
EH		 383 const struct ieee80211_regdomain *r =
384 rtnl_dereference(mvm->hw->wiphy->regd);
385
386 if (!r)
b6e160ab 387 return -ENOENT;
8ba2d7a1
EH		 388
389 /* save the last source in case we overwrite it below */
390 used_src = mvm->mcc_src;
391 if (iwl_mvm_is_wifi_mcc_supported(mvm)) {
392 /* Notify the firmware we support wifi location updates */
47c8b154 393 regd = iwl_mvm_get_current_regdomain(mvm, NULL);
8ba2d7a1
EH		 394 if (!IS_ERR_OR_NULL(regd))
395 kfree(regd);
396 }
397
398 /* Now set our last stored MCC and source */
b6e160ab
AN		 399 regd = iwl_mvm_get_regdomain(mvm->hw->wiphy, r->alpha2, used_src,
400 &changed);
8ba2d7a1
EH		 401 if (IS_ERR_OR_NULL(regd))
402 return -EIO;
403
b6e160ab
AN		 404 /* update cfg80211 if the regdomain was changed */
405 if (changed)
406 ret = regulatory_set_wiphy_regd_sync_rtnl(mvm->hw->wiphy, regd);
407 else
408 ret = 0;
8ba2d7a1 409
b6e160ab
AN		 410 kfree(regd);
411 return ret;
8ba2d7a1
EH		 412}
413
8ca151b5
JB		 414int iwl_mvm_mac_setup_register(struct iwl_mvm *mvm)
415{
416 struct ieee80211_hw *hw = mvm->hw;
831e85f3 417 int num_mac, ret, i;
5f4c02e2
JB		 418 static const u32 mvm_ciphers[] = {
419 WLAN_CIPHER_SUITE_WEP40,
420 WLAN_CIPHER_SUITE_WEP104,
421 WLAN_CIPHER_SUITE_TKIP,
422 WLAN_CIPHER_SUITE_CCMP,
423 };
8ca151b5
JB		 424
425 /* Tell mac80211 our characteristics */
30686bf7
JB		 426 ieee80211_hw_set(hw, SIGNAL_DBM);
427 ieee80211_hw_set(hw, SPECTRUM_MGMT);
428 ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
429 ieee80211_hw_set(hw, QUEUE_CONTROL);
430 ieee80211_hw_set(hw, WANT_MONITOR_VIF);
431 ieee80211_hw_set(hw, SUPPORTS_PS);
432 ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS);
433 ieee80211_hw_set(hw, AMPDU_AGGREGATION);
434 ieee80211_hw_set(hw, TIMING_BEACON_ONLY);
435 ieee80211_hw_set(hw, CONNECTION_MONITOR);
436 ieee80211_hw_set(hw, CHANCTX_STA_CSA);
437 ieee80211_hw_set(hw, SUPPORT_FAST_XMIT);
438 ieee80211_hw_set(hw, SUPPORTS_CLONED_SKBS);
8ca151b5 439
19e737c9 440 hw->queues = mvm->first_agg_queue;
398e8c6c 441 hw->offchannel_tx_hw_queue = IWL_MVM_OFFCHANNEL_QUEUE;
7b1dd048
EG		 442 hw->radiotap_mcs_details |= IEEE80211_RADIOTAP_MCS_HAVE_FEC |
443 IEEE80211_RADIOTAP_MCS_HAVE_STBC;
339b3086
ES		 444 hw->radiotap_vht_details |= IEEE80211_RADIOTAP_VHT_KNOWN_STBC |
445 IEEE80211_RADIOTAP_VHT_KNOWN_BEAMFORMED;
8ca151b5 446 hw->rate_control_algorithm = "iwl-mvm-rs";
848955cc
JB		 447 hw->uapsd_queues = IWL_MVM_UAPSD_QUEUES;
448 hw->uapsd_max_sp_len = IWL_UAPSD_MAX_SP;
8ca151b5 449
5f4c02e2
JB		 450 BUILD_BUG_ON(ARRAY_SIZE(mvm->ciphers) < ARRAY_SIZE(mvm_ciphers) + 2);
451 memcpy(mvm->ciphers, mvm_ciphers, sizeof(mvm_ciphers));
452 hw->wiphy->n_cipher_suites = ARRAY_SIZE(mvm_ciphers);
453 hw->wiphy->cipher_suites = mvm->ciphers;
454
8ca151b5
JB		 455 /*
456 * Enable 11w if advertised by firmware and software crypto
457 * is not enabled (as the firmware will interpret some mgmt
458 * packets, so enabling it with software crypto isn't safe)
459 */
460 if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_MFP &&
5f4c02e2 461 !iwlwifi_mod_params.sw_crypto) {
30686bf7 462 ieee80211_hw_set(hw, MFP_CAPABLE);
5f4c02e2
JB		 463 mvm->ciphers[hw->wiphy->n_cipher_suites] =
464 WLAN_CIPHER_SUITE_AES_CMAC;
465 hw->wiphy->n_cipher_suites++;
466 }
467
468 /* currently FW API supports only one optional cipher scheme */
469 if (mvm->fw->cs[0].cipher) {
470 mvm->hw->n_cipher_schemes = 1;
471 mvm->hw->cipher_schemes = &mvm->fw->cs[0];
472 mvm->ciphers[hw->wiphy->n_cipher_suites] =
473 mvm->fw->cs[0].cipher;
474 hw->wiphy->n_cipher_suites++;
475 }
8ca151b5 476
30686bf7 477 ieee80211_hw_set(hw, SINGLE_SCAN_ON_ALL_BANDS);
1f940386
LC		 478 hw->wiphy->features |=
479 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR |
3db93420
JB		 480 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR |
481 NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
fb98be5e 482
8ca151b5
JB		 483 hw->sta_data_size = sizeof(struct iwl_mvm_sta);
484 hw->vif_data_size = sizeof(struct iwl_mvm_vif);
fe0f2de3 485 hw->chanctx_data_size = sizeof(u16);
8ca151b5
JB		 486
487 hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
3c15a0fb
JB		 488 BIT(NL80211_IFTYPE_P2P_CLIENT) |
489 BIT(NL80211_IFTYPE_AP) |
490 BIT(NL80211_IFTYPE_P2P_GO) |
c13b1725
EG		 491 BIT(NL80211_IFTYPE_P2P_DEVICE) |
492 BIT(NL80211_IFTYPE_ADHOC);
5023d966 493
a2f73b6c 494 hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
8ba2d7a1
EH		 495 hw->wiphy->regulatory_flags |= REGULATORY_ENABLE_RELAX_NO_IR;
496 if (iwl_mvm_is_lar_supported(mvm))
497 hw->wiphy->regulatory_flags |= REGULATORY_WIPHY_SELF_MANAGED;
498 else
499 hw->wiphy->regulatory_flags |= REGULATORY_CUSTOM_REG |
500 REGULATORY_DISABLE_BEACON_HINTS;
8ca151b5 501
3e56eadf
JB		 502 if (mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_GO_UAPSD)
503 hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
504
94bbed72 505 hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
bd3398e2 506
8ca151b5
JB		 507 hw->wiphy->iface_combinations = iwl_mvm_iface_combinations;
508 hw->wiphy->n_iface_combinations =
509 ARRAY_SIZE(iwl_mvm_iface_combinations);
510
c451e6d4 511 hw->wiphy->max_remain_on_channel_duration = 10000;
8ca151b5 512 hw->max_listen_interval = IWL_CONN_MAX_LISTEN_INTERVAL;
f1a68542
EG		 513 /* we can compensate an offset of up to 3 channels = 15 MHz */
514 hw->wiphy->max_adj_channel_rssi_comp = 3 * 5;
8ca151b5
JB		 515
516 /* Extract MAC address */
517 memcpy(mvm->addresses[0].addr, mvm->nvm_data->hw_addr, ETH_ALEN);
518 hw->wiphy->addresses = mvm->addresses;
519 hw->wiphy->n_addresses = 1;
831e85f3
IP		 520
521 /* Extract additional MAC addresses if available */
522 num_mac = (mvm->nvm_data->n_hw_addrs > 1) ?
523 min(IWL_MVM_MAX_ADDRESSES, mvm->nvm_data->n_hw_addrs) : 1;
524
525 for (i = 1; i < num_mac; i++) {
526 memcpy(mvm->addresses[i].addr, mvm->addresses[i-1].addr,
8ca151b5 527 ETH_ALEN);
831e85f3 528 mvm->addresses[i].addr[5]++;
8ca151b5
JB		 529 hw->wiphy->n_addresses++;
530 }
531
fe0f2de3
IP		 532 iwl_mvm_reset_phy_ctxts(mvm);
533
999d2568 534 hw->wiphy->max_scan_ie_len = iwl_mvm_max_scan_ie_len(mvm);
20f1a5de 535
8ca151b5
JB		 536 hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
537
c7d42480 538 BUILD_BUG_ON(IWL_MVM_SCAN_STOPPING_MASK & IWL_MVM_SCAN_MASK);
507e4cda
LC		 539 BUILD_BUG_ON(IWL_MVM_MAX_UMAC_SCANS > HWEIGHT32(IWL_MVM_SCAN_MASK) ||
540 IWL_MVM_MAX_LMAC_SCANS > HWEIGHT32(IWL_MVM_SCAN_MASK));
541
859d914c 542 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN))
507e4cda
LC		 543 mvm->max_scans = IWL_MVM_MAX_UMAC_SCANS;
544 else
545 mvm->max_scans = IWL_MVM_MAX_LMAC_SCANS;
546
8ca151b5
JB		 547 if (mvm->nvm_data->bands[IEEE80211_BAND_2GHZ].n_channels)
548 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
549 &mvm->nvm_data->bands[IEEE80211_BAND_2GHZ];
3d44eebf 550 if (mvm->nvm_data->bands[IEEE80211_BAND_5GHZ].n_channels) {
8ca151b5
JB		 551 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
552 &mvm->nvm_data->bands[IEEE80211_BAND_5GHZ];
553
859d914c
JB		 554 if (fw_has_capa(&mvm->fw->ucode_capa,
555 IWL_UCODE_TLV_CAPA_BEAMFORMER) &&
556 fw_has_api(&mvm->fw->ucode_capa,
557 IWL_UCODE_TLV_API_LQ_SS_PARAMS))
3d44eebf
ES		 558 hw->wiphy->bands[IEEE80211_BAND_5GHZ]->vht_cap.cap |=
559 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE;
560 }
561
8ca151b5
JB		 562 hw->wiphy->hw_version = mvm->trans->hw_id;
563
ade50652 564 if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM)
8ca151b5
JB		 565 hw->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;
566 else
567 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
568
9954b37c
EG		 569 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_SCHED_SCAN;
570 hw->wiphy->max_sched_scan_ssids = PROBE_OPTION_MAX;
571 hw->wiphy->max_match_sets = IWL_SCAN_MAX_PROFILES;
572 /* we create the 802.11 header and zero length SSID IE. */
573 hw->wiphy->max_sched_scan_ie_len =
574 SCAN_OFFLOAD_PROBE_REQ_SIZE - 24 - 2;
cd55ccea
AS		 575 hw->wiphy->max_sched_scan_plans = IWL_MAX_SCHED_SCAN_PLANS;
576 hw->wiphy->max_sched_scan_plan_interval = U16_MAX;
577
578 /*
579 * the firmware uses u8 for num of iterations, but 0xff is saved for
580 * infinite loop, so the maximum number of iterations is actually 254.
581 */
582 hw->wiphy->max_sched_scan_plan_iterations = 254;
35a000b7 583
8ca151b5 584 hw->wiphy->features |= NL80211_FEATURE_P2P_GO_CTWIN |
ab480030 585 NL80211_FEATURE_LOW_PRIORITY_SCAN |
0d8614b4
EP		 586 NL80211_FEATURE_P2P_GO_OPPPS |
587 NL80211_FEATURE_DYNAMIC_SMPS |
9b5452fd
EG		 588 NL80211_FEATURE_STATIC_SMPS |
589 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION;
8ca151b5 590
859d914c
JB		 591 if (fw_has_capa(&mvm->fw->ucode_capa,
592 IWL_UCODE_TLV_CAPA_TXPOWER_INSERTION_SUPPORT))
f1daa00e 593 hw->wiphy->features |= NL80211_FEATURE_TX_POWER_INSERTION;
859d914c
JB		 594 if (fw_has_capa(&mvm->fw->ucode_capa,
595 IWL_UCODE_TLV_CAPA_QUIET_PERIOD_SUPPORT))
226bcd48 596 hw->wiphy->features |= NL80211_FEATURE_QUIET;
f1daa00e 597
859d914c
JB		 598 if (fw_has_capa(&mvm->fw->ucode_capa,
599 IWL_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT))
73897bd1
AO		 600 hw->wiphy->features |=
601 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES;
602
859d914c
JB		 603 if (fw_has_capa(&mvm->fw->ucode_capa,
604 IWL_UCODE_TLV_CAPA_WFA_TPC_REP_IE_SUPPORT))
73897bd1
AO		 605 hw->wiphy->features |= NL80211_FEATURE_WFA_TPC_IE_IN_PROBES;
606
8ca151b5
JB		 607 mvm->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
608
609#ifdef CONFIG_PM_SLEEP
d15a747f
EP		 610 if (iwl_mvm_is_d0i3_supported(mvm) &&
611 device_can_wakeup(mvm->trans->dev)) {
612 mvm->wowlan.flags = WIPHY_WOWLAN_ANY;
613 hw->wiphy->wowlan = &mvm->wowlan;
91742449
EP		 614 }
615
616 if (mvm->fw->img[IWL_UCODE_WOWLAN].sec[0].len &&
8ca151b5
JB		 617 mvm->trans->ops->d3_suspend &&
618 mvm->trans->ops->d3_resume &&
619 device_can_wakeup(mvm->trans->dev)) {
91742449
EP		 620 mvm->wowlan.flags |= WIPHY_WOWLAN_MAGIC_PKT |
621 WIPHY_WOWLAN_DISCONNECT |
622 WIPHY_WOWLAN_EAP_IDENTITY_REQ |
623 WIPHY_WOWLAN_RFKILL_RELEASE |
624 WIPHY_WOWLAN_NET_DETECT;
8ca151b5 625 if (!iwlwifi_mod_params.sw_crypto)
964dc9e2
JB		 626 mvm->wowlan.flags |= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY |
627 WIPHY_WOWLAN_GTK_REKEY_FAILURE |
628 WIPHY_WOWLAN_4WAY_HANDSHAKE;
629
630 mvm->wowlan.n_patterns = IWL_WOWLAN_MAX_PATTERNS;
631 mvm->wowlan.pattern_min_len = IWL_WOWLAN_MIN_PATTERN_LEN;
632 mvm->wowlan.pattern_max_len = IWL_WOWLAN_MAX_PATTERN_LEN;
c55385f5 633 mvm->wowlan.max_nd_match_sets = IWL_SCAN_MAX_PROFILES;
964dc9e2
JB		 634 mvm->wowlan.tcp = &iwl_mvm_wowlan_tcp_support;
635 hw->wiphy->wowlan = &mvm->wowlan;
8ca151b5
JB		 636 }
637#endif
638
77736923
EP		 639#ifdef CONFIG_IWLWIFI_BCAST_FILTERING
640 /* assign default bcast filtering configuration */
641 mvm->bcast_filters = iwl_mvm_default_bcast_filters;
642#endif
643
8ca151b5
JB		 644 ret = iwl_mvm_leds_init(mvm);
645 if (ret)
646 return ret;
647
859d914c
JB		 648 if (fw_has_capa(&mvm->fw->ucode_capa,
649 IWL_UCODE_TLV_CAPA_TDLS_SUPPORT)) {
d8f1c515
AN		 650 IWL_DEBUG_TDLS(mvm, "TDLS supported\n");
651 hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
7c4f0843 652 ieee80211_hw_set(hw, TDLS_WIDER_BW);
d8f1c515
AN		 653 }
654
859d914c
JB		 655 if (fw_has_capa(&mvm->fw->ucode_capa,
656 IWL_UCODE_TLV_CAPA_TDLS_CHANNEL_SWITCH)) {
1d3c3f63
AN		 657 IWL_DEBUG_TDLS(mvm, "TDLS channel switch supported\n");
658 hw->wiphy->features |= NL80211_FEATURE_TDLS_CHANNEL_SWITCH;
659 }
660
93190fb0
AA		 661 hw->netdev_features |= mvm->cfg->features;
662 if (!iwl_mvm_is_csum_supported(mvm))
663 hw->netdev_features &= ~NETIF_F_RXCSUM;
664
b7327d89
EG		 665 ret = ieee80211_register_hw(mvm->hw);
666 if (ret)
667 iwl_mvm_leds_exit(mvm);
668
669 return ret;
8ca151b5
JB		 670}
671
b2492501
AN		 672static bool iwl_mvm_defer_tx(struct iwl_mvm *mvm,
673 struct ieee80211_sta *sta,
674 struct sk_buff *skb)
675{
676 struct iwl_mvm_sta *mvmsta;
677 bool defer = false;
678
679 /*
680 * double check the IN_D0I3 flag both before and after
681 * taking the spinlock, in order to prevent taking
682 * the spinlock when not needed.
683 */
684 if (likely(!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status)))
685 return false;
686
687 spin_lock(&mvm->d0i3_tx_lock);
688 /*
689 * testing the flag again ensures the skb dequeue
690 * loop (on d0i3 exit) hasn't run yet.
691 */
692 if (!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status))
693 goto out;
694
695 mvmsta = iwl_mvm_sta_from_mac80211(sta);
696 if (mvmsta->sta_id == IWL_MVM_STATION_COUNT ||
697 mvmsta->sta_id != mvm->d0i3_ap_sta_id)
698 goto out;
699
700 __skb_queue_tail(&mvm->d0i3_tx, skb);
701 ieee80211_stop_queues(mvm->hw);
702
703 /* trigger wakeup */
704 iwl_mvm_ref(mvm, IWL_MVM_REF_TX);
705 iwl_mvm_unref(mvm, IWL_MVM_REF_TX);
706
707 defer = true;
708out:
709 spin_unlock(&mvm->d0i3_tx_lock);
710 return defer;
711}
712
8ca151b5
JB		 713static void iwl_mvm_mac_tx(struct ieee80211_hw *hw,
714 struct ieee80211_tx_control *control,
715 struct sk_buff *skb)
716{
717 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3e56eadf
JB		 718 struct ieee80211_sta *sta = control->sta;
719 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
720 struct ieee80211_hdr *hdr = (void *)skb->data;
8ca151b5 721
9ee718aa
EL		 722 if (iwl_mvm_is_radio_killed(mvm)) {
723 IWL_DEBUG_DROP(mvm, "Dropping - RF/CT KILL\n");
8ca151b5
JB		 724 goto drop;
725 }
726
398e8c6c 727 if (IEEE80211_SKB_CB(skb)->hw_queue == IWL_MVM_OFFCHANNEL_QUEUE &&
a6cc5163
MG		 728 !test_bit(IWL_MVM_STATUS_ROC_RUNNING, &mvm->status) &&
729 !test_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING, &mvm->status))
8ca151b5
JB		 730 goto drop;
731
3e56eadf
JB		 732 /* treat non-bufferable MMPDUs as broadcast if sta is sleeping */
733 if (unlikely(info->flags & IEEE80211_TX_CTL_NO_PS_BUFFER &&
734 ieee80211_is_mgmt(hdr->frame_control) &&
735 !ieee80211_is_deauth(hdr->frame_control) &&
736 !ieee80211_is_disassoc(hdr->frame_control) &&
737 !ieee80211_is_action(hdr->frame_control)))
738 sta = NULL;
739
740 if (sta) {
b2492501
AN		 741 if (iwl_mvm_defer_tx(mvm, sta, skb))
742 return;
3e56eadf 743 if (iwl_mvm_tx_skb(mvm, skb, sta))
8ca151b5
JB		 744 goto drop;
745 return;
746 }
747
748 if (iwl_mvm_tx_skb_non_sta(mvm, skb))
749 goto drop;
750 return;
751 drop:
752 ieee80211_free_txskb(hw, skb);
753}
754
205e2210
EG		 755static inline bool iwl_enable_rx_ampdu(const struct iwl_cfg *cfg)
756{
757 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_RXAGG)
758 return false;
759 return true;
760}
761
762static inline bool iwl_enable_tx_ampdu(const struct iwl_cfg *cfg)
763{
764 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_TXAGG)
765 return false;
766 if (iwlwifi_mod_params.disable_11n & IWL_ENABLE_HT_TXAGG)
767 return true;
768
769 /* enabled by default */
770 return true;
771}
772
4203263d
EG		 773#define CHECK_BA_TRIGGER(_mvm, _trig, _tid_bm, _tid, _fmt...) \
774 do { \
775 if (!(le16_to_cpu(_tid_bm) & BIT(_tid))) \
776 break; \
777 iwl_mvm_fw_dbg_collect_trig(_mvm, _trig, _fmt); \
778 } while (0)
779
780static void
781iwl_mvm_ampdu_check_trigger(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
782 struct ieee80211_sta *sta, u16 tid, u16 rx_ba_ssn,
783 enum ieee80211_ampdu_mlme_action action)
784{
785 struct iwl_fw_dbg_trigger_tlv *trig;
786 struct iwl_fw_dbg_trigger_ba *ba_trig;
787
788 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_BA))
789 return;
790
791 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_BA);
792 ba_trig = (void *)trig->data;
793
794 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
795 return;
796
797 switch (action) {
798 case IEEE80211_AMPDU_TX_OPERATIONAL: {
799 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
800 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
801
802 CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_start, tid,
803 "TX AGG START: MAC %pM tid %d ssn %d\n",
804 sta->addr, tid, tid_data->ssn);
805 break;
806 }
807 case IEEE80211_AMPDU_TX_STOP_CONT:
808 CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_stop, tid,
809 "TX AGG STOP: MAC %pM tid %d\n",
810 sta->addr, tid);
811 break;
812 case IEEE80211_AMPDU_RX_START:
813 CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_start, tid,
814 "RX AGG START: MAC %pM tid %d ssn %d\n",
815 sta->addr, tid, rx_ba_ssn);
816 break;
817 case IEEE80211_AMPDU_RX_STOP:
818 CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_stop, tid,
819 "RX AGG STOP: MAC %pM tid %d\n",
820 sta->addr, tid);
821 break;
822 default:
823 break;
824 }
825}
826
8ca151b5
JB		 827static int iwl_mvm_mac_ampdu_action(struct ieee80211_hw *hw,
828 struct ieee80211_vif *vif,
829 enum ieee80211_ampdu_mlme_action action,
830 struct ieee80211_sta *sta, u16 tid,
e3abc8ff 831 u16 *ssn, u8 buf_size, bool amsdu)
8ca151b5
JB		 832{
833 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
834 int ret;
b2492501 835 bool tx_agg_ref = false;
8ca151b5
JB		 836
837 IWL_DEBUG_HT(mvm, "A-MPDU action on addr %pM tid %d: action %d\n",
838 sta->addr, tid, action);
839
840 if (!(mvm->nvm_data->sku_cap_11n_enable))
841 return -EACCES;
842
b2492501 843 /* return from D0i3 before starting a new Tx aggregation */
9256c205
EP		 844 switch (action) {
845 case IEEE80211_AMPDU_TX_START:
846 case IEEE80211_AMPDU_TX_STOP_CONT:
847 case IEEE80211_AMPDU_TX_STOP_FLUSH:
848 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
849 case IEEE80211_AMPDU_TX_OPERATIONAL:
b2492501 850 /*
9256c205
EP		 851 * for tx start, wait synchronously until D0i3 exit to
852 * get the correct sequence number for the tid.
853 * additionally, some other ampdu actions use direct
854 * target access, which is not handled automatically
855 * by the trans layer (unlike commands), so wait for
856 * d0i3 exit in these cases as well.
b2492501 857 */
d40fc489
GG		 858 ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_TX_AGG);
859 if (ret)
860 return ret;
861
862 tx_agg_ref = true;
9256c205
EP		 863 break;
864 default:
865 break;
b2492501
AN		 866 }
867
8ca151b5
JB		 868 mutex_lock(&mvm->mutex);
869
870 switch (action) {
871 case IEEE80211_AMPDU_RX_START:
205e2210 872 if (!iwl_enable_rx_ampdu(mvm->cfg)) {
8ca151b5
JB		 873 ret = -EINVAL;
874 break;
875 }
876 ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, *ssn, true);
877 break;
878 case IEEE80211_AMPDU_RX_STOP:
879 ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, 0, false);
880 break;
881 case IEEE80211_AMPDU_TX_START:
205e2210 882 if (!iwl_enable_tx_ampdu(mvm->cfg)) {
5d158efa
EG		 883 ret = -EINVAL;
884 break;
885 }
8ca151b5
JB		 886 ret = iwl_mvm_sta_tx_agg_start(mvm, vif, sta, tid, ssn);
887 break;
888 case IEEE80211_AMPDU_TX_STOP_CONT:
e3d9e7ce
EG		 889 ret = iwl_mvm_sta_tx_agg_stop(mvm, vif, sta, tid);
890 break;
8ca151b5
JB		 891 case IEEE80211_AMPDU_TX_STOP_FLUSH:
892 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
e3d9e7ce 893 ret = iwl_mvm_sta_tx_agg_flush(mvm, vif, sta, tid);
8ca151b5
JB		 894 break;
895 case IEEE80211_AMPDU_TX_OPERATIONAL:
896 ret = iwl_mvm_sta_tx_agg_oper(mvm, vif, sta, tid, buf_size);
897 break;
898 default:
899 WARN_ON_ONCE(1);
900 ret = -EINVAL;
901 break;
902 }
4203263d
EG		 903
904 if (!ret) {
905 u16 rx_ba_ssn = 0;
906
907 if (action == IEEE80211_AMPDU_RX_START)
908 rx_ba_ssn = *ssn;
909
910 iwl_mvm_ampdu_check_trigger(mvm, vif, sta, tid,
911 rx_ba_ssn, action);
912 }
8ca151b5
JB		 913 mutex_unlock(&mvm->mutex);
914
b2492501
AN		 915 /*
916 * If the tid is marked as started, we won't use it for offloaded
917 * traffic on the next D0i3 entry. It's safe to unref.
918 */
919 if (tx_agg_ref)
920 iwl_mvm_unref(mvm, IWL_MVM_REF_TX_AGG);
921
8ca151b5
JB		 922 return ret;
923}
924
925static void iwl_mvm_cleanup_iterator(void *data, u8 *mac,
926 struct ieee80211_vif *vif)
927{
928 struct iwl_mvm *mvm = data;
929 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
930
931 mvmvif->uploaded = false;
932 mvmvif->ap_sta_id = IWL_MVM_STATION_COUNT;
933
8ca151b5
JB		 934 spin_lock_bh(&mvm->time_event_lock);
935 iwl_mvm_te_clear_data(mvm, &mvmvif->time_event_data);
936 spin_unlock_bh(&mvm->time_event_lock);
937
fe0f2de3 938 mvmvif->phy_ctxt = NULL;
8a275bad 939 memset(&mvmvif->bf_data, 0, sizeof(mvmvif->bf_data));
8ca151b5
JB		 940}
941
aadede6e
JB		 942static ssize_t iwl_mvm_read_coredump(char *buffer, loff_t offset, size_t count,
943 const void *data, size_t datalen)
944{
945 const struct iwl_mvm_dump_ptrs *dump_ptrs = data;
946 ssize_t bytes_read;
947 ssize_t bytes_read_trans;
948
949 if (offset < dump_ptrs->op_mode_len) {
950 bytes_read = min_t(ssize_t, count,
951 dump_ptrs->op_mode_len - offset);
952 memcpy(buffer, (u8 *)dump_ptrs->op_mode_ptr + offset,
953 bytes_read);
954 offset += bytes_read;
955 count -= bytes_read;
956
957 if (count == 0)
958 return bytes_read;
959 } else {
960 bytes_read = 0;
961 }
962
963 if (!dump_ptrs->trans_ptr)
964 return bytes_read;
965
966 offset -= dump_ptrs->op_mode_len;
967 bytes_read_trans = min_t(ssize_t, count,
968 dump_ptrs->trans_ptr->len - offset);
969 memcpy(buffer + bytes_read,
970 (u8 *)dump_ptrs->trans_ptr->data + offset,
971 bytes_read_trans);
972
973 return bytes_read + bytes_read_trans;
974}
975
976static void iwl_mvm_free_coredump(const void *data)
977{
978 const struct iwl_mvm_dump_ptrs *fw_error_dump = data;
979
980 vfree(fw_error_dump->op_mode_ptr);
981 vfree(fw_error_dump->trans_ptr);
982 kfree(fw_error_dump);
983}
984
04fd2c28
LK		 985static void iwl_mvm_dump_fifos(struct iwl_mvm *mvm,
986 struct iwl_fw_error_dump_data **dump_data)
987{
988 struct iwl_fw_error_dump_fifo *fifo_hdr;
989 u32 *fifo_data;
990 u32 fifo_len;
991 unsigned long flags;
992 int i, j;
993
994 if (!iwl_trans_grab_nic_access(mvm->trans, false, &flags))
995 return;
996
997 /* Pull RXF data from all RXFs */
998 for (i = 0; i < ARRAY_SIZE(mvm->shared_mem_cfg.rxfifo_size); i++) {
999 /*
1000 * Keep aside the additional offset that might be needed for
1001 * next RXF
1002 */
1003 u32 offset_diff = RXF_DIFF_FROM_PREV * i;
1004
1005 fifo_hdr = (void *)(*dump_data)->data;
1006 fifo_data = (void *)fifo_hdr->data;
1007 fifo_len = mvm->shared_mem_cfg.rxfifo_size[i];
1008
1009 /* No need to try to read the data if the length is 0 */
1010 if (fifo_len == 0)
1011 continue;
1012
1013 /* Add a TLV for the RXF */
1014 (*dump_data)->type = cpu_to_le32(IWL_FW_ERROR_DUMP_RXF);
1015 (*dump_data)->len = cpu_to_le32(fifo_len + sizeof(*fifo_hdr));
1016
1017 fifo_hdr->fifo_num = cpu_to_le32(i);
1018 fifo_hdr->available_bytes =
1019 cpu_to_le32(iwl_trans_read_prph(mvm->trans,
1020 RXF_RD_D_SPACE +
1021 offset_diff));
1022 fifo_hdr->wr_ptr =
1023 cpu_to_le32(iwl_trans_read_prph(mvm->trans,
1024 RXF_RD_WR_PTR +
1025 offset_diff));
1026 fifo_hdr->rd_ptr =
1027 cpu_to_le32(iwl_trans_read_prph(mvm->trans,
1028 RXF_RD_RD_PTR +
1029 offset_diff));
1030 fifo_hdr->fence_ptr =
1031 cpu_to_le32(iwl_trans_read_prph(mvm->trans,
1032 RXF_RD_FENCE_PTR +
1033 offset_diff));
1034 fifo_hdr->fence_mode =
1035 cpu_to_le32(iwl_trans_read_prph(mvm->trans,
1036 RXF_SET_FENCE_MODE +
1037 offset_diff));
1038
1039 /* Lock fence */
1040 iwl_trans_write_prph(mvm->trans,
1041 RXF_SET_FENCE_MODE + offset_diff, 0x1);
1042 /* Set fence pointer to the same place like WR pointer */
1043 iwl_trans_write_prph(mvm->trans,
1044 RXF_LD_WR2FENCE + offset_diff, 0x1);
1045 /* Set fence offset */
1046 iwl_trans_write_prph(mvm->trans,
1047 RXF_LD_FENCE_OFFSET_ADDR + offset_diff,
1048 0x0);
1049
1050 /* Read FIFO */
1051 fifo_len /= sizeof(u32); /* Size in DWORDS */
1052 for (j = 0; j < fifo_len; j++)
1053 fifo_data[j] = iwl_trans_read_prph(mvm->trans,
1054 RXF_FIFO_RD_FENCE_INC +
1055 offset_diff);
1056 *dump_data = iwl_fw_error_next_data(*dump_data);
1057 }
1058
1059 /* Pull TXF data from all TXFs */
1060 for (i = 0; i < ARRAY_SIZE(mvm->shared_mem_cfg.txfifo_size); i++) {
1061 /* Mark the number of TXF we're pulling now */
1062 iwl_trans_write_prph(mvm->trans, TXF_LARC_NUM, i);
1063
1064 fifo_hdr = (void *)(*dump_data)->data;
1065 fifo_data = (void *)fifo_hdr->data;
1066 fifo_len = mvm->shared_mem_cfg.txfifo_size[i];
1067
1068 /* No need to try to read the data if the length is 0 */
1069 if (fifo_len == 0)
1070 continue;
1071
1072 /* Add a TLV for the FIFO */
1073 (*dump_data)->type = cpu_to_le32(IWL_FW_ERROR_DUMP_TXF);
1074 (*dump_data)->len = cpu_to_le32(fifo_len + sizeof(*fifo_hdr));
1075
1076 fifo_hdr->fifo_num = cpu_to_le32(i);
1077 fifo_hdr->available_bytes =
1078 cpu_to_le32(iwl_trans_read_prph(mvm->trans,
1079 TXF_FIFO_ITEM_CNT));
1080 fifo_hdr->wr_ptr =
1081 cpu_to_le32(iwl_trans_read_prph(mvm->trans,
1082 TXF_WR_PTR));
1083 fifo_hdr->rd_ptr =
1084 cpu_to_le32(iwl_trans_read_prph(mvm->trans,
1085 TXF_RD_PTR));
1086 fifo_hdr->fence_ptr =
1087 cpu_to_le32(iwl_trans_read_prph(mvm->trans,
1088 TXF_FENCE_PTR));
1089 fifo_hdr->fence_mode =
1090 cpu_to_le32(iwl_trans_read_prph(mvm->trans,
1091 TXF_LOCK_FENCE));
1092
1093 /* Set the TXF_READ_MODIFY_ADDR to TXF_WR_PTR */
1094 iwl_trans_write_prph(mvm->trans, TXF_READ_MODIFY_ADDR,
1095 TXF_WR_PTR);
1096
1097 /* Dummy-read to advance the read pointer to the head */
1098 iwl_trans_read_prph(mvm->trans, TXF_READ_MODIFY_DATA);
1099
1100 /* Read FIFO */
1101 fifo_len /= sizeof(u32); /* Size in DWORDS */
1102 for (j = 0; j < fifo_len; j++)
1103 fifo_data[j] = iwl_trans_read_prph(mvm->trans,
1104 TXF_READ_MODIFY_DATA);
1105 *dump_data = iwl_fw_error_next_data(*dump_data);
1106 }
1107
1108 iwl_trans_release_nic_access(mvm->trans, &flags);
1109}
1110
b6eaa45a
EG		 1111void iwl_mvm_free_fw_dump_desc(struct iwl_mvm *mvm)
1112{
1113 if (mvm->fw_dump_desc == &iwl_mvm_dump_desc_assert ||
1114 !mvm->fw_dump_desc)
1115 return;
1116
1117 kfree(mvm->fw_dump_desc);
1118 mvm->fw_dump_desc = NULL;
1119}
1120
e539761d
LK		 1121#define IWL8260_ICCM_OFFSET 0x44000 /* Only for B-step */
1122#define IWL8260_ICCM_LEN 0xC000 /* Only for B-step */
1123
1a616dd2
GBA		 1124static const struct {
1125 u32 start, end;
1126} iwl_prph_dump_addr[] = {
1127 { .start = 0x00a00000, .end = 0x00a00000 },
1128 { .start = 0x00a0000c, .end = 0x00a00024 },
1129 { .start = 0x00a0002c, .end = 0x00a0003c },
1130 { .start = 0x00a00410, .end = 0x00a00418 },
1131 { .start = 0x00a00420, .end = 0x00a00420 },
1132 { .start = 0x00a00428, .end = 0x00a00428 },
1133 { .start = 0x00a00430, .end = 0x00a0043c },
1134 { .start = 0x00a00444, .end = 0x00a00444 },
1135 { .start = 0x00a004c0, .end = 0x00a004cc },
1136 { .start = 0x00a004d8, .end = 0x00a004d8 },
1137 { .start = 0x00a004e0, .end = 0x00a004f0 },
1138 { .start = 0x00a00840, .end = 0x00a00840 },
1139 { .start = 0x00a00850, .end = 0x00a00858 },
1140 { .start = 0x00a01004, .end = 0x00a01008 },
1141 { .start = 0x00a01010, .end = 0x00a01010 },
1142 { .start = 0x00a01018, .end = 0x00a01018 },
1143 { .start = 0x00a01024, .end = 0x00a01024 },
1144 { .start = 0x00a0102c, .end = 0x00a01034 },
1145 { .start = 0x00a0103c, .end = 0x00a01040 },
1146 { .start = 0x00a01048, .end = 0x00a01094 },
1147 { .start = 0x00a01c00, .end = 0x00a01c20 },
1148 { .start = 0x00a01c58, .end = 0x00a01c58 },
1149 { .start = 0x00a01c7c, .end = 0x00a01c7c },
1150 { .start = 0x00a01c28, .end = 0x00a01c54 },
1151 { .start = 0x00a01c5c, .end = 0x00a01c5c },
1152 { .start = 0x00a01c60, .end = 0x00a01cdc },
1153 { .start = 0x00a01ce0, .end = 0x00a01d0c },
1154 { .start = 0x00a01d18, .end = 0x00a01d20 },
1155 { .start = 0x00a01d2c, .end = 0x00a01d30 },
1156 { .start = 0x00a01d40, .end = 0x00a01d5c },
1157 { .start = 0x00a01d80, .end = 0x00a01d80 },
1158 { .start = 0x00a01d98, .end = 0x00a01d9c },
1159 { .start = 0x00a01da8, .end = 0x00a01da8 },
1160 { .start = 0x00a01db8, .end = 0x00a01df4 },
1161 { .start = 0x00a01dc0, .end = 0x00a01dfc },
1162 { .start = 0x00a01e00, .end = 0x00a01e2c },
1163 { .start = 0x00a01e40, .end = 0x00a01e60 },
1164 { .start = 0x00a01e68, .end = 0x00a01e6c },
1165 { .start = 0x00a01e74, .end = 0x00a01e74 },
1166 { .start = 0x00a01e84, .end = 0x00a01e90 },
1167 { .start = 0x00a01e9c, .end = 0x00a01ec4 },
1168 { .start = 0x00a01ed0, .end = 0x00a01ee0 },
1169 { .start = 0x00a01f00, .end = 0x00a01f1c },
1170 { .start = 0x00a01f44, .end = 0x00a01ffc },
1171 { .start = 0x00a02000, .end = 0x00a02048 },
1172 { .start = 0x00a02068, .end = 0x00a020f0 },
1173 { .start = 0x00a02100, .end = 0x00a02118 },
1174 { .start = 0x00a02140, .end = 0x00a0214c },
1175 { .start = 0x00a02168, .end = 0x00a0218c },
1176 { .start = 0x00a021c0, .end = 0x00a021c0 },
1177 { .start = 0x00a02400, .end = 0x00a02410 },
1178 { .start = 0x00a02418, .end = 0x00a02420 },
1179 { .start = 0x00a02428, .end = 0x00a0242c },
1180 { .start = 0x00a02434, .end = 0x00a02434 },
1181 { .start = 0x00a02440, .end = 0x00a02460 },
1182 { .start = 0x00a02468, .end = 0x00a024b0 },
1183 { .start = 0x00a024c8, .end = 0x00a024cc },
1184 { .start = 0x00a02500, .end = 0x00a02504 },
1185 { .start = 0x00a0250c, .end = 0x00a02510 },
1186 { .start = 0x00a02540, .end = 0x00a02554 },
1187 { .start = 0x00a02580, .end = 0x00a025f4 },
1188 { .start = 0x00a02600, .end = 0x00a0260c },
1189 { .start = 0x00a02648, .end = 0x00a02650 },
1190 { .start = 0x00a02680, .end = 0x00a02680 },
1191 { .start = 0x00a026c0, .end = 0x00a026d0 },
1192 { .start = 0x00a02700, .end = 0x00a0270c },
1193 { .start = 0x00a02804, .end = 0x00a02804 },
1194 { .start = 0x00a02818, .end = 0x00a0281c },
1195 { .start = 0x00a02c00, .end = 0x00a02db4 },
1196 { .start = 0x00a02df4, .end = 0x00a02fb0 },
1197 { .start = 0x00a03000, .end = 0x00a03014 },
1198 { .start = 0x00a0301c, .end = 0x00a0302c },
1199 { .start = 0x00a03034, .end = 0x00a03038 },
1200 { .start = 0x00a03040, .end = 0x00a03048 },
1201 { .start = 0x00a03060, .end = 0x00a03068 },
1202 { .start = 0x00a03070, .end = 0x00a03074 },
1203 { .start = 0x00a0307c, .end = 0x00a0307c },
1204 { .start = 0x00a03080, .end = 0x00a03084 },
1205 { .start = 0x00a0308c, .end = 0x00a03090 },
1206 { .start = 0x00a03098, .end = 0x00a03098 },
1207 { .start = 0x00a030a0, .end = 0x00a030a0 },
1208 { .start = 0x00a030a8, .end = 0x00a030b4 },
1209 { .start = 0x00a030bc, .end = 0x00a030bc },
1210 { .start = 0x00a030c0, .end = 0x00a0312c },
1211 { .start = 0x00a03c00, .end = 0x00a03c5c },
1212 { .start = 0x00a04400, .end = 0x00a04454 },
1213 { .start = 0x00a04460, .end = 0x00a04474 },
1214 { .start = 0x00a044c0, .end = 0x00a044ec },
1215 { .start = 0x00a04500, .end = 0x00a04504 },
1216 { .start = 0x00a04510, .end = 0x00a04538 },
1217 { .start = 0x00a04540, .end = 0x00a04548 },
1218 { .start = 0x00a04560, .end = 0x00a0457c },
1219 { .start = 0x00a04590, .end = 0x00a04598 },
1220 { .start = 0x00a045c0, .end = 0x00a045f4 },
1221};
1222
1223static u32 iwl_dump_prph(struct iwl_trans *trans,
1224 struct iwl_fw_error_dump_data **data)
1225{
1226 struct iwl_fw_error_dump_prph *prph;
1227 unsigned long flags;
1228 u32 prph_len = 0, i;
1229
1230 if (!iwl_trans_grab_nic_access(trans, false, &flags))
1231 return 0;
1232
1233 for (i = 0; i < ARRAY_SIZE(iwl_prph_dump_addr); i++) {
1234 /* The range includes both boundaries */
1235 int num_bytes_in_chunk = iwl_prph_dump_addr[i].end -
1236 iwl_prph_dump_addr[i].start + 4;
1237 int reg;
1238 __le32 *val;
1239
1240 prph_len += sizeof(**data) + sizeof(*prph) + num_bytes_in_chunk;
1241
1242 (*data)->type = cpu_to_le32(IWL_FW_ERROR_DUMP_PRPH);
1243 (*data)->len = cpu_to_le32(sizeof(*prph) +
1244 num_bytes_in_chunk);
1245 prph = (void *)(*data)->data;
1246 prph->prph_start = cpu_to_le32(iwl_prph_dump_addr[i].start);
1247 val = (void *)prph->data;
1248
1249 for (reg = iwl_prph_dump_addr[i].start;
1250 reg <= iwl_prph_dump_addr[i].end;
1251 reg += 4)
1252 *val++ = cpu_to_le32(iwl_read_prph_no_grab(trans,
1253 reg));
1254
1255 *data = iwl_fw_error_next_data(*data);
1256 }
1257
1258 iwl_trans_release_nic_access(trans, &flags);
1259
1260 return prph_len;
1261}
1262
4bfa47f3 1263void iwl_mvm_fw_error_dump(struct iwl_mvm *mvm)
655e6d6d
EG		 1264{
1265 struct iwl_fw_error_dump_file *dump_file;
1266 struct iwl_fw_error_dump_data *dump_data;
1267 struct iwl_fw_error_dump_info *dump_info;
a549b296 1268 struct iwl_fw_error_dump_mem *dump_mem;
b6eaa45a 1269 struct iwl_fw_error_dump_trigger_desc *dump_trig;
48eb7b34 1270 struct iwl_mvm_dump_ptrs *fw_error_dump;
655e6d6d 1271 u32 sram_len, sram_ofs;
04fd2c28 1272 u32 file_len, fifo_data_len = 0;
addfaada 1273 u32 smem_len = mvm->cfg->smem_len;
86138324 1274 u32 sram2_len = mvm->cfg->dccm2_len;
36fb9017 1275 bool monitor_dump_only = false;
1a616dd2 1276 int i;
655e6d6d
EG		 1277
1278 lockdep_assert_held(&mvm->mutex);
1279
053225de
EP		 1280 /* there's no point in fw dump if the bus is dead */
1281 if (test_bit(STATUS_TRANS_DEAD, &mvm->trans->status)) {
1282 IWL_ERR(mvm, "Skip fw error dump since bus is dead\n");
1283 return;
1284 }
1285
36fb9017
OG		 1286 if (mvm->fw_dump_trig &&
1287 mvm->fw_dump_trig->mode & IWL_FW_DBG_TRIGGER_MONITOR_ONLY)
1288 monitor_dump_only = true;
1289
aadede6e 1290 fw_error_dump = kzalloc(sizeof(*fw_error_dump), GFP_KERNEL);
48eb7b34
EG		 1291 if (!fw_error_dump)
1292 return;
1293
f53bf4c7
LK		 1294 /* SRAM - include stack CCM if driver knows the values for it */
1295 if (!mvm->cfg->dccm_offset || !mvm->cfg->dccm_len) {
1296 const struct fw_img *img;
1297
1298 img = &mvm->fw->img[mvm->cur_ucode];
1299 sram_ofs = img->sec[IWL_UCODE_SECTION_DATA].offset;
1300 sram_len = img->sec[IWL_UCODE_SECTION_DATA].len;
1301 } else {
1302 sram_ofs = mvm->cfg->dccm_offset;
1303 sram_len = mvm->cfg->dccm_len;
1304 }
655e6d6d 1305
04fd2c28
LK		 1306 /* reading RXF/TXF sizes */
1307 if (test_bit(STATUS_FW_ERROR, &mvm->trans->status)) {
1308 struct iwl_mvm_shared_mem_cfg *mem_cfg = &mvm->shared_mem_cfg;
04fd2c28
LK		 1309
1310 fifo_data_len = 0;
1311
1312 /* Count RXF size */
1313 for (i = 0; i < ARRAY_SIZE(mem_cfg->rxfifo_size); i++) {
1314 if (!mem_cfg->rxfifo_size[i])
1315 continue;
1316
1317 /* Add header info */
1318 fifo_data_len += mem_cfg->rxfifo_size[i] +
1319 sizeof(*dump_data) +
1320 sizeof(struct iwl_fw_error_dump_fifo);
1321 }
1322
1323 for (i = 0; i < ARRAY_SIZE(mem_cfg->txfifo_size); i++) {
1324 if (!mem_cfg->txfifo_size[i])
1325 continue;
655e6d6d 1326
04fd2c28
LK		 1327 /* Add header info */
1328 fifo_data_len += mem_cfg->txfifo_size[i] +
1329 sizeof(*dump_data) +
1330 sizeof(struct iwl_fw_error_dump_fifo);
1331 }
1332 }
655e6d6d
EG		 1333
1334 file_len = sizeof(*dump_file) +
04fd2c28 1335 sizeof(*dump_data) * 2 +
a549b296 1336 sram_len + sizeof(*dump_mem) +
04fd2c28 1337 fifo_data_len +
655e6d6d
EG		 1338 sizeof(*dump_info);
1339
36fb9017
OG		 1340 /* Make room for the SMEM, if it exists */
1341 if (smem_len)
1342 file_len += sizeof(*dump_data) + sizeof(*dump_mem) + smem_len;
1343
1344 /* Make room for the secondary SRAM, if it exists */
1345 if (sram2_len)
1346 file_len += sizeof(*dump_data) + sizeof(*dump_mem) + sram2_len;
1347
f0afea54
MG		 1348 /* Make room for fw's virtual image pages, if it exists */
1349 if (mvm->fw->img[mvm->cur_ucode].paging_mem_size)
1350 file_len += mvm->num_of_paging_blk *
1351 (sizeof(*dump_data) +
1352 sizeof(struct iwl_fw_error_dump_paging) +
1353 PAGING_BLOCK_SIZE);
1354
36fb9017
OG		 1355 /* If we only want a monitor dump, reset the file length */
1356 if (monitor_dump_only) {
1357 file_len = sizeof(*dump_file) + sizeof(*dump_data) +
1358 sizeof(*dump_info);
1359 }
1360
1a616dd2
GBA		 1361 /* Make room for PRPH registers */
1362 for (i = 0; i < ARRAY_SIZE(iwl_prph_dump_addr); i++) {
1363 /* The range includes both boundaries */
1364 int num_bytes_in_chunk = iwl_prph_dump_addr[i].end -
1365 iwl_prph_dump_addr[i].start + 4;
1366
1367 file_len += sizeof(*dump_data) +
1368 sizeof(struct iwl_fw_error_dump_prph) +
1369 num_bytes_in_chunk;
1370 }
1371
e539761d
LK		 1372 /*
1373 * In 8000 HW family B-step include the ICCM (which resides separately)
1374 */
1375 if (mvm->cfg->device_family == IWL_DEVICE_FAMILY_8000 &&
1376 CSR_HW_REV_STEP(mvm->trans->hw_rev) == SILICON_B_STEP)
1377 file_len += sizeof(*dump_data) + sizeof(*dump_mem) +
1378 IWL8260_ICCM_LEN;
1379
b6eaa45a
EG		 1380 if (mvm->fw_dump_desc)
1381 file_len += sizeof(*dump_data) + sizeof(*dump_trig) +
1382 mvm->fw_dump_desc->len;
1383
5bfe6f53 1384 dump_file = vzalloc(file_len);
48eb7b34
EG		 1385 if (!dump_file) {
1386 kfree(fw_error_dump);
b6eaa45a 1387 iwl_mvm_free_fw_dump_desc(mvm);
655e6d6d 1388 return;
48eb7b34 1389 }
655e6d6d 1390
48eb7b34 1391 fw_error_dump->op_mode_ptr = dump_file;
655e6d6d
EG		 1392
1393 dump_file->barker = cpu_to_le32(IWL_FW_ERROR_DUMP_BARKER);
655e6d6d
EG		 1394 dump_data = (void *)dump_file->data;
1395
1396 dump_data->type = cpu_to_le32(IWL_FW_ERROR_DUMP_DEV_FW_INFO);
1397 dump_data->len = cpu_to_le32(sizeof(*dump_info));
1398 dump_info = (void *) dump_data->data;
1399 dump_info->device_family =
1400 mvm->cfg->device_family == IWL_DEVICE_FAMILY_7000 ?
1401 cpu_to_le32(IWL_FW_ERROR_DUMP_FAMILY_7) :
1402 cpu_to_le32(IWL_FW_ERROR_DUMP_FAMILY_8);
435da2ce 1403 dump_info->hw_step = cpu_to_le32(CSR_HW_REV_STEP(mvm->trans->hw_rev));
655e6d6d
EG		 1404 memcpy(dump_info->fw_human_readable, mvm->fw->human_readable,
1405 sizeof(dump_info->fw_human_readable));
1406 strncpy(dump_info->dev_human_readable, mvm->cfg->name,
1407 sizeof(dump_info->dev_human_readable));
1408 strncpy(dump_info->bus_human_readable, mvm->dev->bus->name,
1409 sizeof(dump_info->bus_human_readable));
1410
1411 dump_data = iwl_fw_error_next_data(dump_data);
04fd2c28
LK		 1412 /* We only dump the FIFOs if the FW is in error state */
1413 if (test_bit(STATUS_FW_ERROR, &mvm->trans->status))
1414 iwl_mvm_dump_fifos(mvm, &dump_data);
655e6d6d 1415
b6eaa45a
EG		 1416 if (mvm->fw_dump_desc) {
1417 dump_data->type = cpu_to_le32(IWL_FW_ERROR_DUMP_ERROR_INFO);
1418 dump_data->len = cpu_to_le32(sizeof(*dump_trig) +
1419 mvm->fw_dump_desc->len);
1420 dump_trig = (void *)dump_data->data;
1421 memcpy(dump_trig, &mvm->fw_dump_desc->trig_desc,
1422 sizeof(*dump_trig) + mvm->fw_dump_desc->len);
1423
1424 /* now we can free this copy */
1425 iwl_mvm_free_fw_dump_desc(mvm);
1426 dump_data = iwl_fw_error_next_data(dump_data);
1427 }
1428
36fb9017
OG		 1429 /* In case we only want monitor dump, skip to dump trasport data */
1430 if (monitor_dump_only)
1431 goto dump_trans_data;
1432
a549b296
EG		 1433 dump_data->type = cpu_to_le32(IWL_FW_ERROR_DUMP_MEM);
1434 dump_data->len = cpu_to_le32(sram_len + sizeof(*dump_mem));
1435 dump_mem = (void *)dump_data->data;
1436 dump_mem->type = cpu_to_le32(IWL_FW_ERROR_DUMP_MEM_SRAM);
1437 dump_mem->offset = cpu_to_le32(sram_ofs);
1438 iwl_trans_read_mem_bytes(mvm->trans, sram_ofs, dump_mem->data,
655e6d6d
EG		 1439 sram_len);
1440
addfaada
LK		 1441 if (smem_len) {
1442 dump_data = iwl_fw_error_next_data(dump_data);
e06d8437
EG		 1443 dump_data->type = cpu_to_le32(IWL_FW_ERROR_DUMP_MEM);
1444 dump_data->len = cpu_to_le32(smem_len + sizeof(*dump_mem));
1445 dump_mem = (void *)dump_data->data;
1446 dump_mem->type = cpu_to_le32(IWL_FW_ERROR_DUMP_MEM_SMEM);
1447 dump_mem->offset = cpu_to_le32(mvm->cfg->smem_offset);
addfaada 1448 iwl_trans_read_mem_bytes(mvm->trans, mvm->cfg->smem_offset,
e06d8437 1449 dump_mem->data, smem_len);
addfaada
LK		 1450 }
1451
86138324
IY		 1452 if (sram2_len) {
1453 dump_data = iwl_fw_error_next_data(dump_data);
1454 dump_data->type = cpu_to_le32(IWL_FW_ERROR_DUMP_MEM);
1455 dump_data->len = cpu_to_le32(sram2_len + sizeof(*dump_mem));
1456 dump_mem = (void *)dump_data->data;
1457 dump_mem->type = cpu_to_le32(IWL_FW_ERROR_DUMP_MEM_SRAM);
1458 dump_mem->offset = cpu_to_le32(mvm->cfg->dccm2_offset);
1459 iwl_trans_read_mem_bytes(mvm->trans, mvm->cfg->dccm2_offset,
1460 dump_mem->data, sram2_len);
1461 }
1462
e539761d
LK		 1463 if (mvm->cfg->device_family == IWL_DEVICE_FAMILY_8000 &&
1464 CSR_HW_REV_STEP(mvm->trans->hw_rev) == SILICON_B_STEP) {
1465 dump_data = iwl_fw_error_next_data(dump_data);
1466 dump_data->type = cpu_to_le32(IWL_FW_ERROR_DUMP_MEM);
1467 dump_data->len = cpu_to_le32(IWL8260_ICCM_LEN +
1468 sizeof(*dump_mem));
1469 dump_mem = (void *)dump_data->data;
1470 dump_mem->type = cpu_to_le32(IWL_FW_ERROR_DUMP_MEM_SRAM);
1471 dump_mem->offset = cpu_to_le32(IWL8260_ICCM_OFFSET);
1472 iwl_trans_read_mem_bytes(mvm->trans, IWL8260_ICCM_OFFSET,
1473 dump_mem->data, IWL8260_ICCM_LEN);
1474 }
1475
f0afea54
MG		 1476 /* Dump fw's virtual image */
1477 if (mvm->fw->img[mvm->cur_ucode].paging_mem_size) {
1478 u32 i;
1479
1480 for (i = 1; i < mvm->num_of_paging_blk + 1; i++) {
1481 struct iwl_fw_error_dump_paging *paging;
1482 struct page *pages =
1483 mvm->fw_paging_db[i].fw_paging_block;
1484
1485 dump_data = iwl_fw_error_next_data(dump_data);
1486 dump_data->type = cpu_to_le32(IWL_FW_ERROR_DUMP_PAGING);
1487 dump_data->len = cpu_to_le32(sizeof(*paging) +
1488 PAGING_BLOCK_SIZE);
1489 paging = (void *)dump_data->data;
1490 paging->index = cpu_to_le32(i);
1491 memcpy(paging->data, page_address(pages),
1492 PAGING_BLOCK_SIZE);
1493 }
1494 }
1495
1a616dd2
GBA		 1496 dump_data = iwl_fw_error_next_data(dump_data);
1497 iwl_dump_prph(mvm->trans, &dump_data);
1498
36fb9017
OG		 1499dump_trans_data:
1500 fw_error_dump->trans_ptr = iwl_trans_dump_data(mvm->trans,
1501 mvm->fw_dump_trig);
48eb7b34
EG		 1502 fw_error_dump->op_mode_len = file_len;
1503 if (fw_error_dump->trans_ptr)
1504 file_len += fw_error_dump->trans_ptr->len;
1505 dump_file->file_len = cpu_to_le32(file_len);
4bfa47f3 1506
aadede6e
JB		 1507 dev_coredumpm(mvm->trans->dev, THIS_MODULE, fw_error_dump, 0,
1508 GFP_KERNEL, iwl_mvm_read_coredump, iwl_mvm_free_coredump);
d2709ad7 1509
36fb9017 1510 mvm->fw_dump_trig = NULL;
d2709ad7 1511 clear_bit(IWL_MVM_STATUS_DUMPING_FW_LOG, &mvm->status);
655e6d6d 1512}
655e6d6d 1513
b6eaa45a
EG		 1514struct iwl_mvm_dump_desc iwl_mvm_dump_desc_assert = {
1515 .trig_desc = {
1516 .type = cpu_to_le32(FW_DBG_TRIGGER_FW_ASSERT),
1517 },
1518};
1519
8ca151b5
JB		 1520static void iwl_mvm_restart_cleanup(struct iwl_mvm *mvm)
1521{
58629d9d
JB		 1522 /* clear the D3 reconfig, we only need it to avoid dumping a
1523 * firmware coredump on reconfiguration, we shouldn't do that
1524 * on D3->D0 transition
1525 */
b6eaa45a
EG		 1526 if (!test_and_clear_bit(IWL_MVM_STATUS_D3_RECONFIG, &mvm->status)) {
1527 mvm->fw_dump_desc = &iwl_mvm_dump_desc_assert;
58629d9d 1528 iwl_mvm_fw_error_dump(mvm);
b6eaa45a 1529 }
1bd3cbc1 1530
744cb695
EP		 1531 /* cleanup all stale references (scan, roc), but keep the
1532 * ucode_down ref until reconfig is complete
1533 */
1534 iwl_mvm_unref_all_except(mvm, IWL_MVM_REF_UCODE_DOWN);
1535
8ca151b5 1536 iwl_trans_stop_device(mvm->trans);
8ca151b5 1537
9af91f46 1538 mvm->scan_status = 0;
b1873300 1539 mvm->ps_disabled = false;
31b8b343 1540 mvm->calibrating = false;
8ca151b5
JB		 1541
1542 /* just in case one was running */
1543 ieee80211_remain_on_channel_expired(mvm->hw);
1544
737719fe
AN		 1545 /*
1546 * cleanup all interfaces, even inactive ones, as some might have
1547 * gone down during the HW restart
1548 */
1549 ieee80211_iterate_interfaces(mvm->hw, 0, iwl_mvm_cleanup_iterator, mvm);
8ca151b5 1550
fe0f2de3 1551 mvm->p2p_device_vif = NULL;
37577fe2 1552 mvm->d0i3_ap_sta_id = IWL_MVM_STATION_COUNT;
fe0f2de3
IP		 1553
1554 iwl_mvm_reset_phy_ctxts(mvm);
8ca151b5 1555 memset(mvm->sta_drained, 0, sizeof(mvm->sta_drained));
a0f6bf2a 1556 memset(mvm->tfd_drained, 0, sizeof(mvm->tfd_drained));
8a275bad
EG		 1557 memset(&mvm->last_bt_notif, 0, sizeof(mvm->last_bt_notif));
1558 memset(&mvm->last_bt_notif_old, 0, sizeof(mvm->last_bt_notif_old));
1559 memset(&mvm->last_bt_ci_cmd, 0, sizeof(mvm->last_bt_ci_cmd));
1560 memset(&mvm->last_bt_ci_cmd_old, 0, sizeof(mvm->last_bt_ci_cmd_old));
1561 memset(&mvm->bt_ack_kill_msk, 0, sizeof(mvm->bt_ack_kill_msk));
1562 memset(&mvm->bt_cts_kill_msk, 0, sizeof(mvm->bt_cts_kill_msk));
8ca151b5
JB		 1563
1564 ieee80211_wake_queues(mvm->hw);
1565
228670b2
EP		 1566 /* clear any stale d0i3 state */
1567 clear_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status);
1568
8ca151b5 1569 mvm->vif_count = 0;
113a0447 1570 mvm->rx_ba_sessions = 0;
d2709ad7 1571 mvm->fw_dbg_conf = FW_DBG_INVALID;
91a8bcde
JB		 1572
1573 /* keep statistics ticking */
1574 iwl_mvm_accu_radio_stats(mvm);
8ca151b5
JB		 1575}
1576
a0a09243 1577int __iwl_mvm_mac_start(struct iwl_mvm *mvm)
8ca151b5 1578{
8ca151b5
JB		 1579 int ret;
1580
a0a09243 1581 lockdep_assert_held(&mvm->mutex);
8ca151b5
JB		 1582
1583 /* Clean up some internal and mac80211 state on restart */
1584 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1585 iwl_mvm_restart_cleanup(mvm);
1586
1587 ret = iwl_mvm_up(mvm);
c47af22a
JB		 1588
1589 if (ret && test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
1590 /* Something went wrong - we need to finish some cleanup
1591 * that normally iwl_mvm_mac_restart_complete() below
1592 * would do.
1593 */
1594 clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
1595 iwl_mvm_d0i3_enable_tx(mvm, NULL);
1596 }
1597
a0a09243
LC		 1598 return ret;
1599}
1600
1601static int iwl_mvm_mac_start(struct ieee80211_hw *hw)
1602{
1603 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1604 int ret;
1605
37948fcf
EP		 1606 /* Some hw restart cleanups must not hold the mutex */
1607 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
1608 /*
1609 * Make sure we are out of d0i3. This is needed
1610 * to make sure the reference accounting is correct
1611 * (and there is no stale d0i3_exit_work).
1612 */
1613 wait_event_timeout(mvm->d0i3_exit_waitq,
1614 !test_bit(IWL_MVM_STATUS_IN_D0I3,
1615 &mvm->status),
1616 HZ);
1617 }
1618
a0a09243
LC		 1619 mutex_lock(&mvm->mutex);
1620 ret = __iwl_mvm_mac_start(mvm);
8ca151b5
JB		 1621 mutex_unlock(&mvm->mutex);
1622
1623 return ret;
1624}
1625
cf2c92d8 1626static void iwl_mvm_restart_complete(struct iwl_mvm *mvm)
8ca151b5 1627{
8ca151b5
JB		 1628 int ret;
1629
1630 mutex_lock(&mvm->mutex);
1631
1632 clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
b2492501 1633 iwl_mvm_d0i3_enable_tx(mvm, NULL);
e7afe89f 1634 ret = iwl_mvm_update_quotas(mvm, true, NULL);
8ca151b5
JB		 1635 if (ret)
1636 IWL_ERR(mvm, "Failed to update quotas after restart (%d)\n",
1637 ret);
1638
7498cf4c
EP		 1639 /* allow transport/FW low power modes */
1640 iwl_mvm_unref(mvm, IWL_MVM_REF_UCODE_DOWN);
1641
cbd2ae2d
AN		 1642 /*
1643 * If we have TDLS peers, remove them. We don't know the last seqno/PN
1644 * of packets the FW sent out, so we must reconnect.
1645 */
1646 iwl_mvm_teardown_tdls_peers(mvm);
1647
8ca151b5
JB		 1648 mutex_unlock(&mvm->mutex);
1649}
1650
088070a2
EP		 1651static void iwl_mvm_resume_complete(struct iwl_mvm *mvm)
1652{
088070a2
EP		 1653 if (!iwl_mvm_is_d0i3_supported(mvm))
1654 return;
1655
6735943f
EP		 1656 if (mvm->trans->d0i3_mode == IWL_D0I3_MODE_ON_SUSPEND)
1657 if (!wait_event_timeout(mvm->d0i3_exit_waitq,
1658 !test_bit(IWL_MVM_STATUS_IN_D0I3,
1659 &mvm->status),
1660 HZ))
1661 WARN_ONCE(1, "D0i3 exit on resume timed out\n");
088070a2
EP		 1662}
1663
cf2c92d8
EP		 1664static void
1665iwl_mvm_mac_reconfig_complete(struct ieee80211_hw *hw,
1666 enum ieee80211_reconfig_type reconfig_type)
1667{
1668 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1669
1670 switch (reconfig_type) {
1671 case IEEE80211_RECONFIG_TYPE_RESTART:
1672 iwl_mvm_restart_complete(mvm);
1673 break;
1674 case IEEE80211_RECONFIG_TYPE_SUSPEND:
088070a2 1675 iwl_mvm_resume_complete(mvm);
cf2c92d8
EP		 1676 break;
1677 }
1678}
1679
a0a09243 1680void __iwl_mvm_mac_stop(struct iwl_mvm *mvm)
8ca151b5 1681{
a0a09243 1682 lockdep_assert_held(&mvm->mutex);
7498cf4c 1683
91a8bcde
JB		 1684 /* firmware counters are obviously reset now, but we shouldn't
1685 * partially track so also clear the fw_reset_accu counters.
1686 */
1687 memset(&mvm->accu_radio_stats, 0, sizeof(mvm->accu_radio_stats));
1688
0a79a0c0
EP		 1689 /*
1690 * Disallow low power states when the FW is down by taking
1691 * the UCODE_DOWN ref. in case of ongoing hw restart the
1692 * ref is already taken, so don't take it again.
1693 */
1694 if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1695 iwl_mvm_ref(mvm, IWL_MVM_REF_UCODE_DOWN);
7498cf4c 1696
8ca151b5
JB		 1697 /* async_handlers_wk is now blocked */
1698
1699 /*
1700 * The work item could be running or queued if the
1701 * ROC time event stops just as we get here.
1702 */
c779273b 1703 flush_work(&mvm->roc_done_wk);
8ca151b5
JB		 1704
1705 iwl_trans_stop_device(mvm->trans);
8ca151b5
JB		 1706
1707 iwl_mvm_async_handlers_purge(mvm);
1708 /* async_handlers_list is empty and will stay empty: HW is stopped */
1709
1710 /* the fw is stopped, the aux sta is dead: clean up driver state */
712b24ad 1711 iwl_mvm_del_aux_sta(mvm);
8ca151b5 1712
0a79a0c0
EP		 1713 /*
1714 * Clear IN_HW_RESTART flag when stopping the hw (as restart_complete()
1715 * won't be called in this case).
8b2b9fbf
AN		 1716 * But make sure to cleanup interfaces that have gone down before/during
1717 * HW restart was requested.
0a79a0c0 1718 */
8b2b9fbf
AN		 1719 if (test_and_clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1720 ieee80211_iterate_interfaces(mvm->hw, 0,
1721 iwl_mvm_cleanup_iterator, mvm);
0a79a0c0 1722
963221be
AB		 1723 /* We shouldn't have any UIDs still set. Loop over all the UIDs to
1724 * make sure there's nothing left there and warn if any is found.
1725 */
859d914c 1726 if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
963221be
AB		 1727 int i;
1728
507e4cda 1729 for (i = 0; i < mvm->max_scans; i++) {
6185af2a
LC		 1730 if (WARN_ONCE(mvm->scan_uid_status[i],
1731 "UMAC scan UID %d status was not cleaned\n",
1732 i))
1733 mvm->scan_uid_status[i] = 0;
963221be
AB		 1734 }
1735 }
1736
bc44886d 1737 mvm->ucode_loaded = false;
a0a09243 1738}
bc44886d 1739
a0a09243
LC		 1740static void iwl_mvm_mac_stop(struct ieee80211_hw *hw)
1741{
1742 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1743
1744 flush_work(&mvm->d0i3_exit_work);
1745 flush_work(&mvm->async_handlers_wk);
d2709ad7 1746 cancel_delayed_work_sync(&mvm->fw_dump_wk);
b6eaa45a 1747 iwl_mvm_free_fw_dump_desc(mvm);
a0a09243
LC		 1748
1749 mutex_lock(&mvm->mutex);
1750 __iwl_mvm_mac_stop(mvm);
8ca151b5
JB		 1751 mutex_unlock(&mvm->mutex);
1752
1753 /*
1754 * The worker might have been waiting for the mutex, let it run and
1755 * discover that its list is now empty.
1756 */
1757 cancel_work_sync(&mvm->async_handlers_wk);
1758}
1759
fe0f2de3
IP		 1760static struct iwl_mvm_phy_ctxt *iwl_mvm_get_free_phy_ctxt(struct iwl_mvm *mvm)
1761{
1762 u16 i;
1763
1764 lockdep_assert_held(&mvm->mutex);
1765
1766 for (i = 0; i < NUM_PHY_CTX; i++)
1767 if (!mvm->phy_ctxts[i].ref)
1768 return &mvm->phy_ctxts[i];
1769
1770 IWL_ERR(mvm, "No available PHY context\n");
1771 return NULL;
1772}
1773
d44c3fe6
AA		 1774static int iwl_mvm_set_tx_power(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
1775 s16 tx_power)
1776{
1777 struct iwl_dev_tx_power_cmd cmd = {
da03f029
JB		 1778 .v2.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_MAC),
1779 .v2.mac_context_id =
d44c3fe6 1780 cpu_to_le32(iwl_mvm_vif_from_mac80211(vif)->id),
da03f029 1781 .v2.pwr_restriction = cpu_to_le16(8 * tx_power),
d44c3fe6 1782 };
da03f029 1783 int len = sizeof(cmd);
d44c3fe6 1784
d44c3fe6 1785 if (tx_power == IWL_DEFAULT_MAX_TX_POWER)
da03f029 1786 cmd.v2.pwr_restriction = cpu_to_le16(IWL_DEV_MAX_TX_POWER);
d44c3fe6 1787
da03f029
JB		 1788 if (!fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_TX_POWER_CHAIN))
1789 len = sizeof(cmd.v2);
1790
1791 return iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
d44c3fe6
AA		 1792}
1793
8ca151b5
JB		 1794static int iwl_mvm_mac_add_interface(struct ieee80211_hw *hw,
1795 struct ieee80211_vif *vif)
1796{
1797 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1798 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1799 int ret;
1800
aa5e1832
EG		 1801 mvmvif->mvm = mvm;
1802
d40fc489
GG		 1803 /*
1804 * make sure D0i3 exit is completed, otherwise a target access
1805 * during tx queue configuration could be done when still in
1806 * D0i3 state.
1807 */
1808 ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_ADD_IF);
1809 if (ret)
1810 return ret;
1811
8ca151b5
JB		 1812 /*
1813 * Not much to do here. The stack will not allow interface
1814 * types or combinations that we didn't advertise, so we
1815 * don't really have to check the types.
1816 */
1817
1818 mutex_lock(&mvm->mutex);
1819
33cef925
JB		 1820 /* make sure that beacon statistics don't go backwards with FW reset */
1821 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
1822 mvmvif->beacon_stats.accu_num_beacons +=
1823 mvmvif->beacon_stats.num_beacons;
1824
e89044d7 1825 /* Allocate resources for the MAC context, and add it to the fw */
8ca151b5
JB		 1826 ret = iwl_mvm_mac_ctxt_init(mvm, vif);
1827 if (ret)
1828 goto out_unlock;
1829
1c2abf72 1830 /* Counting number of interfaces is needed for legacy PM */
ea183d02
IP		 1831 if (vif->type != NL80211_IFTYPE_P2P_DEVICE)
1832 mvm->vif_count++;
ea183d02 1833
8ca151b5
JB		 1834 /*
1835 * The AP binding flow can be done only after the beacon
1836 * template is configured (which happens only in the mac80211
1837 * start_ap() flow), and adding the broadcast station can happen
1838 * only after the binding.
1839 * In addition, since modifying the MAC before adding a bcast
1840 * station is not allowed by the FW, delay the adding of MAC context to
1841 * the point where we can also add the bcast station.
1842 * In short: there's not much we can do at this point, other than
1843 * allocating resources :)
1844 */
5023d966
JB		 1845 if (vif->type == NL80211_IFTYPE_AP ||
1846 vif->type == NL80211_IFTYPE_ADHOC) {
013290aa 1847 ret = iwl_mvm_alloc_bcast_sta(mvm, vif);
8ca151b5
JB		 1848 if (ret) {
1849 IWL_ERR(mvm, "Failed to allocate bcast sta\n");
1850 goto out_release;
1851 }
1852
77740cb4 1853 iwl_mvm_vif_dbgfs_register(mvm, vif);
8ca151b5
JB		 1854 goto out_unlock;
1855 }
1856
93190fb0
AA		 1857 mvmvif->features |= hw->netdev_features;
1858
8ca151b5
JB		 1859 ret = iwl_mvm_mac_ctxt_add(mvm, vif);
1860 if (ret)
1861 goto out_release;
1862
999609f1 1863 ret = iwl_mvm_power_update_mac(mvm);
e5e7aa8e 1864 if (ret)
fd66fc1c 1865 goto out_remove_mac;
8ca151b5 1866
7df15b1e 1867 /* beacon filtering */
a1022927 1868 ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
bd3351ba
EP		 1869 if (ret)
1870 goto out_remove_mac;
1871
7df15b1e 1872 if (!mvm->bf_allowed_vif &&
73e5f2c5 1873 vif->type == NL80211_IFTYPE_STATION && !vif->p2p) {
7df15b1e 1874 mvm->bf_allowed_vif = mvmvif;
a20fd398
AO		 1875 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
1876 IEEE80211_VIF_SUPPORTS_CQM_RSSI;
7df15b1e
HG		 1877 }
1878
8ca151b5
JB		 1879 /*
1880 * P2P_DEVICE interface does not have a channel context assigned to it,
1881 * so a dedicated PHY context is allocated to it and the corresponding
1882 * MAC context is bound to it at this stage.
1883 */
1884 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
8ca151b5 1885
fe0f2de3
IP		 1886 mvmvif->phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
1887 if (!mvmvif->phy_ctxt) {
1888 ret = -ENOSPC;
bd3351ba 1889 goto out_free_bf;
fe0f2de3 1890 }
8ca151b5 1891
53a9d61e 1892 iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
8ca151b5
JB		 1893 ret = iwl_mvm_binding_add_vif(mvm, vif);
1894 if (ret)
53a9d61e 1895 goto out_unref_phy;
8ca151b5 1896
013290aa 1897 ret = iwl_mvm_add_bcast_sta(mvm, vif);
8ca151b5
JB		 1898 if (ret)
1899 goto out_unbind;
1900
1901 /* Save a pointer to p2p device vif, so it can later be used to
1902 * update the p2p device MAC when a GO is started/stopped */
1903 mvm->p2p_device_vif = vif;
1904 }
1905
63494374 1906 iwl_mvm_vif_dbgfs_register(mvm, vif);
8ca151b5
JB		 1907 goto out_unlock;
1908
1909 out_unbind:
1910 iwl_mvm_binding_remove_vif(mvm, vif);
53a9d61e 1911 out_unref_phy:
fe0f2de3 1912 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
bd3351ba
EP		 1913 out_free_bf:
1914 if (mvm->bf_allowed_vif == mvmvif) {
1915 mvm->bf_allowed_vif = NULL;
a20fd398
AO		 1916 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER |
1917 IEEE80211_VIF_SUPPORTS_CQM_RSSI);
bd3351ba 1918 }
8ca151b5
JB		 1919 out_remove_mac:
1920 mvmvif->phy_ctxt = NULL;
1921 iwl_mvm_mac_ctxt_remove(mvm, vif);
1922 out_release:
5ee2b215
AB		 1923 if (vif->type != NL80211_IFTYPE_P2P_DEVICE)
1924 mvm->vif_count--;
1c2abf72 1925
8ca151b5
JB		 1926 iwl_mvm_mac_ctxt_release(mvm, vif);
1927 out_unlock:
1928 mutex_unlock(&mvm->mutex);
1929
d40fc489
GG		 1930 iwl_mvm_unref(mvm, IWL_MVM_REF_ADD_IF);
1931
8ca151b5
JB		 1932 return ret;
1933}
1934
38a12b5b
JB		 1935static void iwl_mvm_prepare_mac_removal(struct iwl_mvm *mvm,
1936 struct ieee80211_vif *vif)
8ca151b5 1937{
d92b732e 1938 u32 tfd_msk = iwl_mvm_mac_get_queues_mask(vif);
8ca151b5
JB		 1939
1940 if (tfd_msk) {
fe92e32a
EG		 1941 /*
1942 * mac80211 first removes all the stations of the vif and
1943 * then removes the vif. When it removes a station it also
1944 * flushes the AMPDU session. So by now, all the AMPDU sessions
1945 * of all the stations of this vif are closed, and the queues
1946 * of these AMPDU sessions are properly closed.
1947 * We still need to take care of the shared queues of the vif.
1948 * Flush them here.
1949 */
8ca151b5 1950 mutex_lock(&mvm->mutex);
5888a40c 1951 iwl_mvm_flush_tx_path(mvm, tfd_msk, 0);
8ca151b5 1952 mutex_unlock(&mvm->mutex);
fe92e32a
EG		 1953
1954 /*
1955 * There are transports that buffer a few frames in the host.
1956 * For these, the flush above isn't enough since while we were
1957 * flushing, the transport might have sent more frames to the
1958 * device. To solve this, wait here until the transport is
1959 * empty. Technically, this could have replaced the flush
1960 * above, but flush is much faster than draining. So flush
1961 * first, and drain to make sure we have no frames in the
1962 * transport anymore.
1963 * If a station still had frames on the shared queues, it is
1964 * already marked as draining, so to complete the draining, we
1965 * just need to wait until the transport is empty.
1966 */
1967 iwl_trans_wait_tx_queue_empty(mvm->trans, tfd_msk);
8ca151b5
JB		 1968 }
1969
1970 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
1971 /*
1972 * Flush the ROC worker which will flush the OFFCHANNEL queue.
1973 * We assume here that all the packets sent to the OFFCHANNEL
1974 * queue are sent in ROC session.
1975 */
1976 flush_work(&mvm->roc_done_wk);
1977 } else {
1978 /*
1979 * By now, all the AC queues are empty. The AGG queues are
1980 * empty too. We already got all the Tx responses for all the
1981 * packets in the queues. The drain work can have been
0742a75a 1982 * triggered. Flush it.
8ca151b5
JB		 1983 */
1984 flush_work(&mvm->sta_drained_wk);
1985 }
38a12b5b
JB		 1986}
1987
1988static void iwl_mvm_mac_remove_interface(struct ieee80211_hw *hw,
1989 struct ieee80211_vif *vif)
1990{
1991 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1992 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1993
1994 iwl_mvm_prepare_mac_removal(mvm, vif);
8ca151b5
JB		 1995
1996 mutex_lock(&mvm->mutex);
1997
7df15b1e
HG		 1998 if (mvm->bf_allowed_vif == mvmvif) {
1999 mvm->bf_allowed_vif = NULL;
a20fd398
AO		 2000 vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER |
2001 IEEE80211_VIF_SUPPORTS_CQM_RSSI);
7df15b1e
HG		 2002 }
2003
63494374
JB		 2004 iwl_mvm_vif_dbgfs_clean(mvm, vif);
2005
8ca151b5
JB		 2006 /*
2007 * For AP/GO interface, the tear down of the resources allocated to the
38a12b5b 2008 * interface is be handled as part of the stop_ap flow.
8ca151b5 2009 */
5023d966
JB		 2010 if (vif->type == NL80211_IFTYPE_AP ||
2011 vif->type == NL80211_IFTYPE_ADHOC) {
507cadf2
DS		 2012#ifdef CONFIG_NL80211_TESTMODE
2013 if (vif == mvm->noa_vif) {
2014 mvm->noa_vif = NULL;
2015 mvm->noa_duration = 0;
2016 }
2017#endif
013290aa 2018 iwl_mvm_dealloc_bcast_sta(mvm, vif);
8ca151b5
JB		 2019 goto out_release;
2020 }
2021
2022 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
2023 mvm->p2p_device_vif = NULL;
013290aa 2024 iwl_mvm_rm_bcast_sta(mvm, vif);
8ca151b5 2025 iwl_mvm_binding_remove_vif(mvm, vif);
fe0f2de3 2026 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
8ca151b5
JB		 2027 mvmvif->phy_ctxt = NULL;
2028 }
2029
5ee2b215 2030 if (mvm->vif_count && vif->type != NL80211_IFTYPE_P2P_DEVICE)
8ca151b5 2031 mvm->vif_count--;
1c2abf72 2032
999609f1 2033 iwl_mvm_power_update_mac(mvm);
8ca151b5
JB		 2034 iwl_mvm_mac_ctxt_remove(mvm, vif);
2035
2036out_release:
2037 iwl_mvm_mac_ctxt_release(mvm, vif);
2038 mutex_unlock(&mvm->mutex);
2039}
2040
2041static int iwl_mvm_mac_config(struct ieee80211_hw *hw, u32 changed)
88f2fd73 2042{
8ca151b5
JB		 2043 return 0;
2044}
2045
e59647ea
EP		 2046struct iwl_mvm_mc_iter_data {
2047 struct iwl_mvm *mvm;
2048 int port_id;
2049};
2050
2051static void iwl_mvm_mc_iface_iterator(void *_data, u8 *mac,
2052 struct ieee80211_vif *vif)
2053{
2054 struct iwl_mvm_mc_iter_data *data = _data;
2055 struct iwl_mvm *mvm = data->mvm;
2056 struct iwl_mcast_filter_cmd *cmd = mvm->mcast_filter_cmd;
2057 int ret, len;
2058
2059 /* if we don't have free ports, mcast frames will be dropped */
2060 if (WARN_ON_ONCE(data->port_id >= MAX_PORT_ID_NUM))
2061 return;
2062
2063 if (vif->type != NL80211_IFTYPE_STATION ||
2064 !vif->bss_conf.assoc)
2065 return;
2066
2067 cmd->port_id = data->port_id++;
2068 memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
2069 len = roundup(sizeof(*cmd) + cmd->count * ETH_ALEN, 4);
2070
1c4abec0 2071 ret = iwl_mvm_send_cmd_pdu(mvm, MCAST_FILTER_CMD, CMD_ASYNC, len, cmd);
e59647ea
EP		 2072 if (ret)
2073 IWL_ERR(mvm, "mcast filter cmd error. ret=%d\n", ret);
2074}
2075
2076static void iwl_mvm_recalc_multicast(struct iwl_mvm *mvm)
2077{
2078 struct iwl_mvm_mc_iter_data iter_data = {
2079 .mvm = mvm,
88f2fd73
MG		 2080 };
2081
e59647ea
EP		 2082 lockdep_assert_held(&mvm->mutex);
2083
2084 if (WARN_ON_ONCE(!mvm->mcast_filter_cmd))
2085 return;
2086
1c4abec0 2087 ieee80211_iterate_active_interfaces_atomic(
e59647ea
EP		 2088 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
2089 iwl_mvm_mc_iface_iterator, &iter_data);
88f2fd73
MG		 2090}
2091
e59647ea
EP		 2092static u64 iwl_mvm_prepare_multicast(struct ieee80211_hw *hw,
2093 struct netdev_hw_addr_list *mc_list)
8ca151b5 2094{
e59647ea
EP		 2095 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2096 struct iwl_mcast_filter_cmd *cmd;
2097 struct netdev_hw_addr *addr;
f3bd58f4
MS		 2098 int addr_count;
2099 bool pass_all;
e59647ea
EP		 2100 int len;
2101
f3bd58f4
MS		 2102 addr_count = netdev_hw_addr_list_count(mc_list);
2103 pass_all = addr_count > MAX_MCAST_FILTERING_ADDRESSES ||
2104 IWL_MVM_FW_MCAST_FILTER_PASS_ALL;
2105 if (pass_all)
e59647ea 2106 addr_count = 0;
e59647ea
EP		 2107
2108 len = roundup(sizeof(*cmd) + addr_count * ETH_ALEN, 4);
2109 cmd = kzalloc(len, GFP_ATOMIC);
2110 if (!cmd)
2111 return 0;
2112
2113 if (pass_all) {
2114 cmd->pass_all = 1;
2115 return (u64)(unsigned long)cmd;
2116 }
2117
2118 netdev_hw_addr_list_for_each(addr, mc_list) {
2119 IWL_DEBUG_MAC80211(mvm, "mcast addr (%d): %pM\n",
2120 cmd->count, addr->addr);
2121 memcpy(&cmd->addr_list[cmd->count * ETH_ALEN],
2122 addr->addr, ETH_ALEN);
2123 cmd->count++;
2124 }
2125
2126 return (u64)(unsigned long)cmd;
8ca151b5
JB		 2127}
2128
2129static void iwl_mvm_configure_filter(struct ieee80211_hw *hw,
2130 unsigned int changed_flags,
2131 unsigned int *total_flags,
2132 u64 multicast)
2133{
e59647ea
EP		 2134 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2135 struct iwl_mcast_filter_cmd *cmd = (void *)(unsigned long)multicast;
8ca151b5 2136
e59647ea 2137 mutex_lock(&mvm->mutex);
51b6b9e0 2138
e59647ea
EP		 2139 /* replace previous configuration */
2140 kfree(mvm->mcast_filter_cmd);
2141 mvm->mcast_filter_cmd = cmd;
51b6b9e0 2142
e59647ea
EP		 2143 if (!cmd)
2144 goto out;
51b6b9e0 2145
e59647ea
EP		 2146 iwl_mvm_recalc_multicast(mvm);
2147out:
2148 mutex_unlock(&mvm->mutex);
2149 *total_flags = 0;
51b6b9e0
EG		 2150}
2151
effd1929
AO		 2152static void iwl_mvm_config_iface_filter(struct ieee80211_hw *hw,
2153 struct ieee80211_vif *vif,
2154 unsigned int filter_flags,
2155 unsigned int changed_flags)
2156{
2157 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2158
2159 /* We support only filter for probe requests */
2160 if (!(changed_flags & FIF_PROBE_REQ))
2161 return;
2162
2163 /* Supported only for p2p client interfaces */
2164 if (vif->type != NL80211_IFTYPE_STATION || !vif->bss_conf.assoc ||
2165 !vif->p2p)
2166 return;
2167
2168 mutex_lock(&mvm->mutex);
2169 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
2170 mutex_unlock(&mvm->mutex);
2171}
2172
c87163b9
EP		 2173#ifdef CONFIG_IWLWIFI_BCAST_FILTERING
2174struct iwl_bcast_iter_data {
2175 struct iwl_mvm *mvm;
2176 struct iwl_bcast_filter_cmd *cmd;
2177 u8 current_filter;
2178};
2179
2180static void
2181iwl_mvm_set_bcast_filter(struct ieee80211_vif *vif,
2182 const struct iwl_fw_bcast_filter *in_filter,
2183 struct iwl_fw_bcast_filter *out_filter)
2184{
2185 struct iwl_fw_bcast_filter_attr *attr;
2186 int i;
2187
2188 memcpy(out_filter, in_filter, sizeof(*out_filter));
2189
2190 for (i = 0; i < ARRAY_SIZE(out_filter->attrs); i++) {
2191 attr = &out_filter->attrs[i];
2192
2193 if (!attr->mask)
2194 break;
2195
2ee8f021
EP		 2196 switch (attr->reserved1) {
2197 case cpu_to_le16(BC_FILTER_MAGIC_IP):
2198 if (vif->bss_conf.arp_addr_cnt != 1) {
2199 attr->mask = 0;
2200 continue;
2201 }
2202
2203 attr->val = vif->bss_conf.arp_addr_list[0];
2204 break;
2205 case cpu_to_le16(BC_FILTER_MAGIC_MAC):
2206 attr->val = *(__be32 *)&vif->addr[2];
2207 break;
2208 default:
2209 break;
2210 }
2211 attr->reserved1 = 0;
c87163b9
EP		 2212 out_filter->num_attrs++;
2213 }
2214}
2215
2216static void iwl_mvm_bcast_filter_iterator(void *_data, u8 *mac,
2217 struct ieee80211_vif *vif)
2218{
2219 struct iwl_bcast_iter_data *data = _data;
2220 struct iwl_mvm *mvm = data->mvm;
2221 struct iwl_bcast_filter_cmd *cmd = data->cmd;
2222 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2223 struct iwl_fw_bcast_mac *bcast_mac;
2224 int i;
2225
2226 if (WARN_ON(mvmvif->id >= ARRAY_SIZE(cmd->macs)))
2227 return;
2228
2229 bcast_mac = &cmd->macs[mvmvif->id];
2230
e48393e8
IP		 2231 /*
2232 * enable filtering only for associated stations, but not for P2P
2233 * Clients
2234 */
2235 if (vif->type != NL80211_IFTYPE_STATION || vif->p2p ||
2236 !vif->bss_conf.assoc)
c87163b9
EP		 2237 return;
2238
2239 bcast_mac->default_discard = 1;
2240
2241 /* copy all configured filters */
2242 for (i = 0; mvm->bcast_filters[i].attrs[0].mask; i++) {
2243 /*
2244 * Make sure we don't exceed our filters limit.
2245 * if there is still a valid filter to be configured,
2246 * be on the safe side and just allow bcast for this mac.
2247 */
2248 if (WARN_ON_ONCE(data->current_filter >=
2249 ARRAY_SIZE(cmd->filters))) {
2250 bcast_mac->default_discard = 0;
2251 bcast_mac->attached_filters = 0;
2252 break;
2253 }
2254
2255 iwl_mvm_set_bcast_filter(vif,
2256 &mvm->bcast_filters[i],
2257 &cmd->filters[data->current_filter]);
2258
2259 /* skip current filter if it contains no attributes */
2260 if (!cmd->filters[data->current_filter].num_attrs)
2261 continue;
2262
2263 /* attach the filter to current mac */
2264 bcast_mac->attached_filters |=
2265 cpu_to_le16(BIT(data->current_filter));
2266
2267 data->current_filter++;
2268 }
2269}
2270
de06a59e
EP		 2271bool iwl_mvm_bcast_filter_build_cmd(struct iwl_mvm *mvm,
2272 struct iwl_bcast_filter_cmd *cmd)
c87163b9 2273{
c87163b9
EP		 2274 struct iwl_bcast_iter_data iter_data = {
2275 .mvm = mvm,
de06a59e 2276 .cmd = cmd,
c87163b9
EP		 2277 };
2278
3b8983b1
MS		 2279 if (IWL_MVM_FW_BCAST_FILTER_PASS_ALL)
2280 return false;
2281
de06a59e
EP		 2282 memset(cmd, 0, sizeof(*cmd));
2283 cmd->max_bcast_filters = ARRAY_SIZE(cmd->filters);
2284 cmd->max_macs = ARRAY_SIZE(cmd->macs);
2285
2286#ifdef CONFIG_IWLWIFI_DEBUGFS
2287 /* use debugfs filters/macs if override is configured */
2288 if (mvm->dbgfs_bcast_filtering.override) {
2289 memcpy(cmd->filters, &mvm->dbgfs_bcast_filtering.cmd.filters,
2290 sizeof(cmd->filters));
2291 memcpy(cmd->macs, &mvm->dbgfs_bcast_filtering.cmd.macs,
2292 sizeof(cmd->macs));
2293 return true;
2294 }
2295#endif
c87163b9
EP		 2296
2297 /* if no filters are configured, do nothing */
2298 if (!mvm->bcast_filters)
de06a59e 2299 return false;
c87163b9
EP		 2300
2301 /* configure and attach these filters for each associated sta vif */
2302 ieee80211_iterate_active_interfaces(
2303 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
2304 iwl_mvm_bcast_filter_iterator, &iter_data);
2305
de06a59e
EP		 2306 return true;
2307}
2308static int iwl_mvm_configure_bcast_filter(struct iwl_mvm *mvm,
2309 struct ieee80211_vif *vif)
2310{
2311 struct iwl_bcast_filter_cmd cmd;
2312
2313 if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_BCAST_FILTERING))
2314 return 0;
2315
2316 if (!iwl_mvm_bcast_filter_build_cmd(mvm, &cmd))
2317 return 0;
2318
a1022927 2319 return iwl_mvm_send_cmd_pdu(mvm, BCAST_FILTER_CMD, 0,
c87163b9
EP		 2320 sizeof(cmd), &cmd);
2321}
2322#else
2323static inline int iwl_mvm_configure_bcast_filter(struct iwl_mvm *mvm,
2324 struct ieee80211_vif *vif)
2325{
2326 return 0;
2327}
2328#endif
2329
8ca151b5
JB		 2330static void iwl_mvm_bss_info_changed_station(struct iwl_mvm *mvm,
2331 struct ieee80211_vif *vif,
2332 struct ieee80211_bss_conf *bss_conf,
2333 u32 changes)
2334{
2335 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2336 int ret;
2337
6e97b0d2
IP		 2338 /*
2339 * Re-calculate the tsf id, as the master-slave relations depend on the
2340 * beacon interval, which was not known when the station interface was
2341 * added.
2342 */
2343 if (changes & BSS_CHANGED_ASSOC && bss_conf->assoc)
2344 iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif);
2345
3dfd3a97
JB		 2346 /*
2347 * If we're not associated yet, take the (new) BSSID before associating
2348 * so the firmware knows. If we're already associated, then use the old
2349 * BSSID here, and we'll send a cleared one later in the CHANGED_ASSOC
2350 * branch for disassociation below.
2351 */
2352 if (changes & BSS_CHANGED_BSSID && !mvmvif->associated)
2353 memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
2354
2355 ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, mvmvif->bssid);
8ca151b5
JB		 2356 if (ret)
2357 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr);
2358
3dfd3a97
JB		 2359 /* after sending it once, adopt mac80211 data */
2360 memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
2361 mvmvif->associated = bss_conf->assoc;
2362
8ca151b5
JB		 2363 if (changes & BSS_CHANGED_ASSOC) {
2364 if (bss_conf->assoc) {
33cef925
JB		 2365 /* clear statistics to get clean beacon counter */
2366 iwl_mvm_request_statistics(mvm, true);
2367 memset(&mvmvif->beacon_stats, 0,
2368 sizeof(mvmvif->beacon_stats));
2369
8ca151b5 2370 /* add quota for this interface */
7754ae79 2371 ret = iwl_mvm_update_quotas(mvm, true, NULL);
8ca151b5
JB		 2372 if (ret) {
2373 IWL_ERR(mvm, "failed to update quotas\n");
2374 return;
2375 }
016d27e1
JB		 2376
2377 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART,
2378 &mvm->status)) {
2379 /*
2380 * If we're restarting then the firmware will
2381 * obviously have lost synchronisation with
2382 * the AP. It will attempt to synchronise by
2383 * itself, but we can make it more reliable by
2384 * scheduling a session protection time event.
2385 *
2386 * The firmware needs to receive a beacon to
2387 * catch up with synchronisation, use 110% of
2388 * the beacon interval.
2389 *
2390 * Set a large maximum delay to allow for more
2391 * than a single interface.
2392 */
2393 u32 dur = (11 * vif->bss_conf.beacon_int) / 10;
2394 iwl_mvm_protect_session(mvm, vif, dur, dur,
d20d37bc 2395 5 * dur, false);
016d27e1 2396 }
1f3b0ff8
LE		 2397
2398 iwl_mvm_sf_update(mvm, vif, false);
175a70b7 2399 iwl_mvm_power_vif_assoc(mvm, vif);
697162a1 2400 if (vif->p2p) {
29a90a49 2401 iwl_mvm_ref(mvm, IWL_MVM_REF_P2P_CLIENT);
697162a1
EG		 2402 iwl_mvm_update_smps(mvm, vif,
2403 IWL_MVM_SMPS_REQ_PROT,
2404 IEEE80211_SMPS_DYNAMIC);
2405 }
8ca151b5 2406 } else if (mvmvif->ap_sta_id != IWL_MVM_STATION_COUNT) {
1f3b0ff8
LE		 2407 /*
2408 * If update fails - SF might be running in associated
2409 * mode while disassociated - which is forbidden.
2410 */
2411 WARN_ONCE(iwl_mvm_sf_update(mvm, vif, false),
2412 "Failed to update SF upon disassociation\n");
2413
8ca151b5
JB		 2414 /* remove AP station now that the MAC is unassoc */
2415 ret = iwl_mvm_rm_sta_id(mvm, vif, mvmvif->ap_sta_id);
2416 if (ret)
2417 IWL_ERR(mvm, "failed to remove AP station\n");
37577fe2
EP		 2418
2419 if (mvm->d0i3_ap_sta_id == mvmvif->ap_sta_id)
2420 mvm->d0i3_ap_sta_id = IWL_MVM_STATION_COUNT;
8ca151b5
JB		 2421 mvmvif->ap_sta_id = IWL_MVM_STATION_COUNT;
2422 /* remove quota for this interface */
7754ae79 2423 ret = iwl_mvm_update_quotas(mvm, false, NULL);
8ca151b5
JB		 2424 if (ret)
2425 IWL_ERR(mvm, "failed to update quotas\n");
29a90a49
EP		 2426
2427 if (vif->p2p)
2428 iwl_mvm_unref(mvm, IWL_MVM_REF_P2P_CLIENT);
3dfd3a97
JB		 2429
2430 /* this will take the cleared BSSID from bss_conf */
2431 ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
2432 if (ret)
2433 IWL_ERR(mvm,
2434 "failed to update MAC %pM (clear after unassoc)\n",
2435 vif->addr);
8ca151b5 2436 }
a20fd398 2437
e59647ea 2438 iwl_mvm_recalc_multicast(mvm);
c87163b9 2439 iwl_mvm_configure_bcast_filter(mvm, vif);
e59647ea 2440
a20fd398
AO		 2441 /* reset rssi values */
2442 mvmvif->bf_data.ave_beacon_signal = 0;
2443
8e484f0b 2444 iwl_mvm_bt_coex_vif_change(mvm);
f94045ed
EG		 2445 iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_TT,
2446 IEEE80211_SMPS_AUTOMATIC);
989c6505 2447 } else if (changes & BSS_CHANGED_BEACON_INFO) {
210a544e
JB		 2448 /*
2449 * We received a beacon _after_ association so
2450 * remove the session protection.
2451 */
2452 iwl_mvm_remove_time_event(mvm, mvmvif,
2453 &mvmvif->time_event_data);
8ca151b5 2454 }
cc87d322
EH		 2455
2456 if (changes & BSS_CHANGED_BEACON_INFO) {
2457 iwl_mvm_sf_update(mvm, vif, false);
2458 WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
2459 }
2460
1bc10d3b
JB		 2461 if (changes & (BSS_CHANGED_PS | BSS_CHANGED_P2P_PS | BSS_CHANGED_QOS)) {
2462 ret = iwl_mvm_power_update_mac(mvm);
2463 if (ret)
2464 IWL_ERR(mvm, "failed to update power mode\n");
2465 }
2466
88f2fd73
MG		 2467 if (changes & BSS_CHANGED_TXPOWER) {
2468 IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d\n",
2469 bss_conf->txpower);
2470 iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
2471 }
a20fd398
AO		 2472
2473 if (changes & BSS_CHANGED_CQM) {
3c6acb61 2474 IWL_DEBUG_MAC80211(mvm, "cqm info_changed\n");
a20fd398
AO		 2475 /* reset cqm events tracking */
2476 mvmvif->bf_data.last_cqm_event = 0;
fa7b2e7f
AA		 2477 if (mvmvif->bf_data.bf_enabled) {
2478 ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
2479 if (ret)
2480 IWL_ERR(mvm,
2481 "failed to update CQM thresholds\n");
2482 }
a20fd398 2483 }
2ee8f021
EP		 2484
2485 if (changes & BSS_CHANGED_ARP_FILTER) {
3c6acb61 2486 IWL_DEBUG_MAC80211(mvm, "arp filter changed\n");
2ee8f021
EP		 2487 iwl_mvm_configure_bcast_filter(mvm, vif);
2488 }
8ca151b5
JB		 2489}
2490
5023d966
JB		 2491static int iwl_mvm_start_ap_ibss(struct ieee80211_hw *hw,
2492 struct ieee80211_vif *vif)
8ca151b5
JB		 2493{
2494 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2495 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2496 int ret;
2497
576eeee9
EP		 2498 /*
2499 * iwl_mvm_mac_ctxt_add() might read directly from the device
2500 * (the system time), so make sure it is available.
2501 */
2502 ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_START_AP);
2503 if (ret)
2504 return ret;
2505
8ca151b5
JB		 2506 mutex_lock(&mvm->mutex);
2507
2508 /* Send the beacon template */
2509 ret = iwl_mvm_mac_ctxt_beacon_changed(mvm, vif);
2510 if (ret)
2511 goto out_unlock;
2512
6e97b0d2
IP		 2513 /*
2514 * Re-calculate the tsf id, as the master-slave relations depend on the
2515 * beacon interval, which was not known when the AP interface was added.
2516 */
2517 if (vif->type == NL80211_IFTYPE_AP)
2518 iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif);
2519
94939080
GG		 2520 mvmvif->ap_assoc_sta_count = 0;
2521
8ca151b5
JB		 2522 /* Add the mac context */
2523 ret = iwl_mvm_mac_ctxt_add(mvm, vif);
2524 if (ret)
2525 goto out_unlock;
2526
2527 /* Perform the binding */
2528 ret = iwl_mvm_binding_add_vif(mvm, vif);
2529 if (ret)
2530 goto out_remove;
2531
8ca151b5
JB		 2532 /* Send the bcast station. At this stage the TBTT and DTIM time events
2533 * are added and applied to the scheduler */
013290aa 2534 ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
8ca151b5
JB		 2535 if (ret)
2536 goto out_unbind;
2537
5691e218
IP		 2538 /* must be set before quota calculations */
2539 mvmvif->ap_ibss_active = true;
2540
a11e144e 2541 /* power updated needs to be done before quotas */
999609f1 2542 iwl_mvm_power_update_mac(mvm);
a11e144e 2543
7754ae79 2544 ret = iwl_mvm_update_quotas(mvm, false, NULL);
8ca151b5 2545 if (ret)
a11e144e 2546 goto out_quota_failed;
8ca151b5 2547
5023d966 2548 /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
8ca151b5 2549 if (vif->p2p && mvm->p2p_device_vif)
3dfd3a97 2550 iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
8ca151b5 2551
29a90a49
EP		 2552 iwl_mvm_ref(mvm, IWL_MVM_REF_AP_IBSS);
2553
8e484f0b 2554 iwl_mvm_bt_coex_vif_change(mvm);
dac94da8 2555
f697267f
AN		 2556 /* we don't support TDLS during DCM */
2557 if (iwl_mvm_phy_ctx_count(mvm) > 1)
2558 iwl_mvm_teardown_tdls_peers(mvm);
2559
939e4904 2560 goto out_unlock;
8ca151b5 2561
a11e144e 2562out_quota_failed:
999609f1 2563 iwl_mvm_power_update_mac(mvm);
5691e218 2564 mvmvif->ap_ibss_active = false;
013290aa 2565 iwl_mvm_send_rm_bcast_sta(mvm, vif);
8ca151b5
JB		 2566out_unbind:
2567 iwl_mvm_binding_remove_vif(mvm, vif);
2568out_remove:
2569 iwl_mvm_mac_ctxt_remove(mvm, vif);
2570out_unlock:
2571 mutex_unlock(&mvm->mutex);
576eeee9 2572 iwl_mvm_unref(mvm, IWL_MVM_REF_START_AP);
8ca151b5
JB		 2573 return ret;
2574}
2575
5023d966
JB		 2576static void iwl_mvm_stop_ap_ibss(struct ieee80211_hw *hw,
2577 struct ieee80211_vif *vif)
8ca151b5
JB		 2578{
2579 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2580 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2581
38a12b5b
JB		 2582 iwl_mvm_prepare_mac_removal(mvm, vif);
2583
8ca151b5
JB		 2584 mutex_lock(&mvm->mutex);
2585
664322fa 2586 /* Handle AP stop while in CSA */
7f0a7c67
AO		 2587 if (rcu_access_pointer(mvm->csa_vif) == vif) {
2588 iwl_mvm_remove_time_event(mvm, mvmvif,
2589 &mvmvif->time_event_data);
664322fa 2590 RCU_INIT_POINTER(mvm->csa_vif, NULL);
e9cb0327 2591 mvmvif->csa_countdown = false;
7f0a7c67 2592 }
664322fa 2593
003e5236
AO		 2594 if (rcu_access_pointer(mvm->csa_tx_blocked_vif) == vif) {
2595 RCU_INIT_POINTER(mvm->csa_tx_blocked_vif, NULL);
2596 mvm->csa_tx_block_bcn_timeout = 0;
2597 }
2598
5023d966 2599 mvmvif->ap_ibss_active = false;
1c87bbad 2600 mvm->ap_last_beacon_gp2 = 0;
8ca151b5 2601
8e484f0b 2602 iwl_mvm_bt_coex_vif_change(mvm);
dac94da8 2603
29a90a49
EP		 2604 iwl_mvm_unref(mvm, IWL_MVM_REF_AP_IBSS);
2605
5023d966 2606 /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
8ca151b5 2607 if (vif->p2p && mvm->p2p_device_vif)
3dfd3a97 2608 iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
8ca151b5 2609
7754ae79 2610 iwl_mvm_update_quotas(mvm, false, NULL);
013290aa 2611 iwl_mvm_send_rm_bcast_sta(mvm, vif);
8ca151b5 2612 iwl_mvm_binding_remove_vif(mvm, vif);
a11e144e 2613
999609f1 2614 iwl_mvm_power_update_mac(mvm);
a11e144e 2615
8ca151b5
JB		 2616 iwl_mvm_mac_ctxt_remove(mvm, vif);
2617
2618 mutex_unlock(&mvm->mutex);
2619}
2620
5023d966
JB		 2621static void
2622iwl_mvm_bss_info_changed_ap_ibss(struct iwl_mvm *mvm,
2623 struct ieee80211_vif *vif,
2624 struct ieee80211_bss_conf *bss_conf,
2625 u32 changes)
8ca151b5 2626{
be2056fc 2627 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
8a5e3660 2628
be2056fc
IP		 2629 /* Changes will be applied when the AP/IBSS is started */
2630 if (!mvmvif->ap_ibss_active)
2631 return;
2632
863230da 2633 if (changes & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_HT |
f7d8b702 2634 BSS_CHANGED_BANDWIDTH | BSS_CHANGED_QOS) &&
3dfd3a97 2635 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL))
863230da 2636 IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr);
8a5e3660 2637
8ca151b5 2638 /* Need to send a new beacon template to the FW */
863230da
JB		 2639 if (changes & BSS_CHANGED_BEACON &&
2640 iwl_mvm_mac_ctxt_beacon_changed(mvm, vif))
2641 IWL_WARN(mvm, "Failed updating beacon data\n");
79b7a69d
HD		 2642
2643 if (changes & BSS_CHANGED_TXPOWER) {
2644 IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d\n",
2645 bss_conf->txpower);
2646 iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
2647 }
2648
8ca151b5
JB		 2649}
2650
2651static void iwl_mvm_bss_info_changed(struct ieee80211_hw *hw,
2652 struct ieee80211_vif *vif,
2653 struct ieee80211_bss_conf *bss_conf,
2654 u32 changes)
2655{
2656 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2657
576eeee9
EP		 2658 /*
2659 * iwl_mvm_bss_info_changed_station() might call
2660 * iwl_mvm_protect_session(), which reads directly from
2661 * the device (the system time), so make sure it is available.
2662 */
2663 if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_BSS_CHANGED))
2664 return;
2665
8ca151b5
JB		 2666 mutex_lock(&mvm->mutex);
2667
723f02ed 2668 if (changes & BSS_CHANGED_IDLE && !bss_conf->idle)
c7d42480 2669 iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, true);
723f02ed 2670
8ca151b5
JB		 2671 switch (vif->type) {
2672 case NL80211_IFTYPE_STATION:
2673 iwl_mvm_bss_info_changed_station(mvm, vif, bss_conf, changes);
2674 break;
2675 case NL80211_IFTYPE_AP:
5023d966
JB		 2676 case NL80211_IFTYPE_ADHOC:
2677 iwl_mvm_bss_info_changed_ap_ibss(mvm, vif, bss_conf, changes);
8ca151b5
JB		 2678 break;
2679 default:
2680 /* shouldn't happen */
2681 WARN_ON_ONCE(1);
2682 }
2683
2684 mutex_unlock(&mvm->mutex);
576eeee9 2685 iwl_mvm_unref(mvm, IWL_MVM_REF_BSS_CHANGED);
8ca151b5
JB		 2686}
2687
2688static int iwl_mvm_mac_hw_scan(struct ieee80211_hw *hw,
2689 struct ieee80211_vif *vif,
c56ef672 2690 struct ieee80211_scan_request *hw_req)
8ca151b5
JB		 2691{
2692 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2693 int ret;
2694
6749dd80
LC		 2695 if (hw_req->req.n_channels == 0 ||
2696 hw_req->req.n_channels > mvm->fw->ucode_capa.n_scan_channels)
8ca151b5
JB		 2697 return -EINVAL;
2698
2699 mutex_lock(&mvm->mutex);
6749dd80 2700 ret = iwl_mvm_reg_scan_start(mvm, vif, &hw_req->req, &hw_req->ies);
8ca151b5 2701 mutex_unlock(&mvm->mutex);
6749dd80 2702
8ca151b5
JB		 2703 return ret;
2704}
2705
2706static void iwl_mvm_mac_cancel_hw_scan(struct ieee80211_hw *hw,
2707 struct ieee80211_vif *vif)
2708{
2709 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2710
2711 mutex_lock(&mvm->mutex);
2712
e7d3abab
LC		 2713 /* Due to a race condition, it's possible that mac80211 asks
2714 * us to stop a hw_scan when it's already stopped. This can
2715 * happen, for instance, if we stopped the scan ourselves,
2716 * called ieee80211_scan_completed() and the userspace called
2717 * cancel scan scan before ieee80211_scan_work() could run.
2718 * To handle that, simply return if the scan is not running.
2719 */
262888fc 2720 if (mvm->scan_status & IWL_MVM_SCAN_REGULAR)
c7d42480 2721 iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_REGULAR, true);
8ca151b5
JB		 2722
2723 mutex_unlock(&mvm->mutex);
2724}
2725
2726static void
2727iwl_mvm_mac_allow_buffered_frames(struct ieee80211_hw *hw,
3e56eadf 2728 struct ieee80211_sta *sta, u16 tids,
8ca151b5
JB		 2729 int num_frames,
2730 enum ieee80211_frame_release_type reason,
2731 bool more_data)
2732{
2733 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
8ca151b5 2734
3e56eadf 2735 /* Called when we need to transmit (a) frame(s) from mac80211 */
8ca151b5 2736
3e56eadf
JB		 2737 iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames,
2738 tids, more_data, false);
2739}
2740
2741static void
2742iwl_mvm_mac_release_buffered_frames(struct ieee80211_hw *hw,
2743 struct ieee80211_sta *sta, u16 tids,
2744 int num_frames,
2745 enum ieee80211_frame_release_type reason,
2746 bool more_data)
2747{
2748 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2749
2750 /* Called when we need to transmit (a) frame(s) from agg queue */
2751
2752 iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames,
2753 tids, more_data, true);
8ca151b5
JB		 2754}
2755
2756static void iwl_mvm_mac_sta_notify(struct ieee80211_hw *hw,
2757 struct ieee80211_vif *vif,
2758 enum sta_notify_cmd cmd,
2759 struct ieee80211_sta *sta)
2760{
2761 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
5b577a90 2762 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
c22b0ff5 2763 unsigned long txqs = 0, tids = 0;
3e56eadf 2764 int tid;
8ca151b5 2765
c22b0ff5
EG		 2766 spin_lock_bh(&mvmsta->lock);
2767 for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++) {
2768 struct iwl_mvm_tid_data *tid_data = &mvmsta->tid_data[tid];
2769
2770 if (tid_data->state != IWL_AGG_ON &&
2771 tid_data->state != IWL_EMPTYING_HW_QUEUE_DELBA)
2772 continue;
2773
2774 __set_bit(tid_data->txq_id, &txqs);
2775
2776 if (iwl_mvm_tid_queued(tid_data) == 0)
2777 continue;
2778
2779 __set_bit(tid, &tids);
2780 }
2781
8ca151b5
JB		 2782 switch (cmd) {
2783 case STA_NOTIFY_SLEEP:
e3d4bc8c 2784 if (atomic_read(&mvm->pending_frames[mvmsta->sta_id]) > 0)
8ca151b5 2785 ieee80211_sta_block_awake(hw, sta, true);
3e56eadf 2786
c22b0ff5 2787 for_each_set_bit(tid, &tids, IWL_MAX_TID_COUNT)
3e56eadf 2788 ieee80211_sta_set_buffered(sta, tid, true);
c22b0ff5
EG		 2789
2790 if (txqs)
2791 iwl_trans_freeze_txq_timer(mvm->trans, txqs, true);
8ca151b5
JB		 2792 /*
2793 * The fw updates the STA to be asleep. Tx packets on the Tx
2794 * queues to this station will not be transmitted. The fw will
2795 * send a Tx response with TX_STATUS_FAIL_DEST_PS.
2796 */
2797 break;
2798 case STA_NOTIFY_AWAKE:
881acd89 2799 if (WARN_ON(mvmsta->sta_id == IWL_MVM_STATION_COUNT))
8ca151b5 2800 break;
c22b0ff5
EG		 2801
2802 if (txqs)
2803 iwl_trans_freeze_txq_timer(mvm->trans, txqs, false);
9cc40712 2804 iwl_mvm_sta_modify_ps_wake(mvm, sta);
8ca151b5
JB		 2805 break;
2806 default:
2807 break;
2808 }
c22b0ff5 2809 spin_unlock_bh(&mvmsta->lock);
8ca151b5
JB		 2810}
2811
1ddbbb0c
JB		 2812static void iwl_mvm_sta_pre_rcu_remove(struct ieee80211_hw *hw,
2813 struct ieee80211_vif *vif,
2814 struct ieee80211_sta *sta)
2815{
2816 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
94939080 2817 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
9d8ce6af 2818 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
1ddbbb0c
JB		 2819
2820 /*
2821 * This is called before mac80211 does RCU synchronisation,
2822 * so here we already invalidate our internal RCU-protected
2823 * station pointer. The rest of the code will thus no longer
2824 * be able to find the station this way, and we don't rely
2825 * on further RCU synchronisation after the sta_state()
2826 * callback deleted the station.
2827 */
2828 mutex_lock(&mvm->mutex);
2829 if (sta == rcu_access_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id]))
2830 rcu_assign_pointer(mvm->fw_id_to_mac_id[mvm_sta->sta_id],
2831 ERR_PTR(-ENOENT));
94939080
GG		 2832
2833 if (mvm_sta->vif->type == NL80211_IFTYPE_AP) {
2834 mvmvif->ap_assoc_sta_count--;
f82c8339 2835 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
94939080
GG		 2836 }
2837
1ddbbb0c
JB		 2838 mutex_unlock(&mvm->mutex);
2839}
2840
bd1ba664
JB		 2841static void iwl_mvm_check_uapsd(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
2842 const u8 *bssid)
2843{
2844 if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_UAPSD_SUPPORT))
2845 return;
2846
2847 if (iwlwifi_mod_params.uapsd_disable) {
2848 vif->driver_flags &= ~IEEE80211_VIF_SUPPORTS_UAPSD;
2849 return;
2850 }
2851
2852 vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
2853}
2854
1e8f1329
GBA		 2855static void
2856iwl_mvm_tdls_check_trigger(struct iwl_mvm *mvm,
2857 struct ieee80211_vif *vif, u8 *peer_addr,
2858 enum nl80211_tdls_operation action)
2859{
2860 struct iwl_fw_dbg_trigger_tlv *trig;
2861 struct iwl_fw_dbg_trigger_tdls *tdls_trig;
2862
2863 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_TDLS))
2864 return;
2865
2866 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_TDLS);
2867 tdls_trig = (void *)trig->data;
2868 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
2869 return;
2870
2871 if (!(tdls_trig->action_bitmap & BIT(action)))
2872 return;
2873
2874 if (tdls_trig->peer_mode &&
2875 memcmp(tdls_trig->peer, peer_addr, ETH_ALEN) != 0)
2876 return;
2877
2878 iwl_mvm_fw_dbg_collect_trig(mvm, trig,
2879 "TDLS event occurred, peer %pM, action %d",
2880 peer_addr, action);
2881}
2882
8ca151b5
JB		 2883static int iwl_mvm_mac_sta_state(struct ieee80211_hw *hw,
2884 struct ieee80211_vif *vif,
2885 struct ieee80211_sta *sta,
2886 enum ieee80211_sta_state old_state,
2887 enum ieee80211_sta_state new_state)
2888{
2889 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
2890 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
2891 int ret;
2892
2893 IWL_DEBUG_MAC80211(mvm, "station %pM state change %d->%d\n",
2894 sta->addr, old_state, new_state);
2895
2896 /* this would be a mac80211 bug ... but don't crash */
2897 if (WARN_ON_ONCE(!mvmvif->phy_ctxt))
2898 return -EINVAL;
2899
2900 /* if a STA is being removed, reuse its ID */
2901 flush_work(&mvm->sta_drained_wk);
2902
2903 mutex_lock(&mvm->mutex);
2904 if (old_state == IEEE80211_STA_NOTEXIST &&
2905 new_state == IEEE80211_STA_NONE) {
48bc1307
JB		 2906 /*
2907 * Firmware bug - it'll crash if the beacon interval is less
2908 * than 16. We can't avoid connecting at all, so refuse the
2909 * station state change, this will cause mac80211 to abandon
2910 * attempts to connect to this AP, and eventually wpa_s will
2911 * blacklist the AP...
2912 */
2913 if (vif->type == NL80211_IFTYPE_STATION &&
2914 vif->bss_conf.beacon_int < 16) {
2915 IWL_ERR(mvm,
2916 "AP %pM beacon interval is %d, refusing due to firmware bug!\n",
2917 sta->addr, vif->bss_conf.beacon_int);
2918 ret = -EINVAL;
2919 goto out_unlock;
2920 }
cf7b491d
AN		 2921
2922 if (sta->tdls &&
2923 (vif->p2p ||
fa3d07e4
AN		 2924 iwl_mvm_tdls_sta_count(mvm, NULL) ==
2925 IWL_MVM_TDLS_STA_COUNT ||
cf7b491d
AN		 2926 iwl_mvm_phy_ctx_count(mvm) > 1)) {
2927 IWL_DEBUG_MAC80211(mvm, "refusing TDLS sta\n");
2928 ret = -EBUSY;
2929 goto out_unlock;
2930 }
2931
8ca151b5 2932 ret = iwl_mvm_add_sta(mvm, vif, sta);
1e8f1329 2933 if (sta->tdls && ret == 0) {
fa3d07e4 2934 iwl_mvm_recalc_tdls_state(mvm, vif, true);
1e8f1329
GBA		 2935 iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
2936 NL80211_TDLS_SETUP);
2937 }
8ca151b5
JB		 2938 } else if (old_state == IEEE80211_STA_NONE &&
2939 new_state == IEEE80211_STA_AUTH) {
e820c2da
HD		 2940 /*
2941 * EBS may be disabled due to previous failures reported by FW.
2942 * Reset EBS status here assuming environment has been changed.
2943 */
2944 mvm->last_ebs_successful = true;
bd1ba664 2945 iwl_mvm_check_uapsd(mvm, vif, sta->addr);
8ca151b5
JB		 2946 ret = 0;
2947 } else if (old_state == IEEE80211_STA_AUTH &&
2948 new_state == IEEE80211_STA_ASSOC) {
7a453973
JB		 2949 ret = iwl_mvm_update_sta(mvm, vif, sta);
2950 if (ret == 0)
2951 iwl_mvm_rs_rate_init(mvm, sta,
b87c2179
ES		 2952 mvmvif->phy_ctxt->channel->band,
2953 true);
8ca151b5
JB		 2954 } else if (old_state == IEEE80211_STA_ASSOC &&
2955 new_state == IEEE80211_STA_AUTHORIZED) {
f59e0e3c
AN		 2956
2957 /* we don't support TDLS during DCM */
2958 if (iwl_mvm_phy_ctx_count(mvm) > 1)
2959 iwl_mvm_teardown_tdls_peers(mvm);
2960
1e8f1329
GBA		 2961 if (sta->tdls)
2962 iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
2963 NL80211_TDLS_ENABLE_LINK);
2964
7df15b1e 2965 /* enable beacon filtering */
fa7b2e7f 2966 WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
8ca151b5
JB		 2967 ret = 0;
2968 } else if (old_state == IEEE80211_STA_AUTHORIZED &&
2969 new_state == IEEE80211_STA_ASSOC) {
7df15b1e 2970 /* disable beacon filtering */
a1022927 2971 WARN_ON(iwl_mvm_disable_beacon_filter(mvm, vif, 0));
8ca151b5
JB		 2972 ret = 0;
2973 } else if (old_state == IEEE80211_STA_ASSOC &&
2974 new_state == IEEE80211_STA_AUTH) {
2975 ret = 0;
2976 } else if (old_state == IEEE80211_STA_AUTH &&
2977 new_state == IEEE80211_STA_NONE) {
2978 ret = 0;
2979 } else if (old_state == IEEE80211_STA_NONE &&
2980 new_state == IEEE80211_STA_NOTEXIST) {
2981 ret = iwl_mvm_rm_sta(mvm, vif, sta);
1e8f1329 2982 if (sta->tdls) {
fa3d07e4 2983 iwl_mvm_recalc_tdls_state(mvm, vif, false);
1e8f1329
GBA		 2984 iwl_mvm_tdls_check_trigger(mvm, vif, sta->addr,
2985 NL80211_TDLS_DISABLE_LINK);
2986 }
8ca151b5
JB		 2987 } else {
2988 ret = -EIO;
2989 }
48bc1307 2990 out_unlock:
8ca151b5
JB		 2991 mutex_unlock(&mvm->mutex);
2992
9c126cd6
LK		 2993 if (sta->tdls && ret == 0) {
2994 if (old_state == IEEE80211_STA_NOTEXIST &&
2995 new_state == IEEE80211_STA_NONE)
2996 ieee80211_reserve_tid(sta, IWL_MVM_TDLS_FW_TID);
2997 else if (old_state == IEEE80211_STA_NONE &&
2998 new_state == IEEE80211_STA_NOTEXIST)
2999 ieee80211_unreserve_tid(sta, IWL_MVM_TDLS_FW_TID);
3000 }
3001
8ca151b5
JB		 3002 return ret;
3003}
3004
3005static int iwl_mvm_mac_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3006{
3007 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3008
3009 mvm->rts_threshold = value;
3010
3011 return 0;
3012}
3013
1f3b0ff8
LE		 3014static void iwl_mvm_sta_rc_update(struct ieee80211_hw *hw,
3015 struct ieee80211_vif *vif,
3016 struct ieee80211_sta *sta, u32 changed)
3017{
3018 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3019
3020 if (vif->type == NL80211_IFTYPE_STATION &&
3021 changed & IEEE80211_RC_NSS_CHANGED)
3022 iwl_mvm_sf_update(mvm, vif, false);
3023}
3024
8ca151b5
JB		 3025static int iwl_mvm_mac_conf_tx(struct ieee80211_hw *hw,
3026 struct ieee80211_vif *vif, u16 ac,
3027 const struct ieee80211_tx_queue_params *params)
3028{
3029 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3030 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3031
3032 mvmvif->queue_params[ac] = *params;
3033
3034 /*
3035 * No need to update right away, we'll get BSS_CHANGED_QOS
3036 * The exception is P2P_DEVICE interface which needs immediate update.
3037 */
3038 if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
3039 int ret;
3040
3041 mutex_lock(&mvm->mutex);
3dfd3a97 3042 ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
8ca151b5
JB		 3043 mutex_unlock(&mvm->mutex);
3044 return ret;
3045 }
3046 return 0;
3047}
3048
3049static void iwl_mvm_mac_mgd_prepare_tx(struct ieee80211_hw *hw,
3050 struct ieee80211_vif *vif)
3051{
3052 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3053 u32 duration = min(IWL_MVM_TE_SESSION_PROTECTION_MAX_TIME_MS,
3054 200 + vif->bss_conf.beacon_int);
3055 u32 min_duration = min(IWL_MVM_TE_SESSION_PROTECTION_MIN_TIME_MS,
3056 100 + vif->bss_conf.beacon_int);
3057
3058 if (WARN_ON_ONCE(vif->bss_conf.assoc))
3059 return;
3060
576eeee9
EP		 3061 /*
3062 * iwl_mvm_protect_session() reads directly from the device
3063 * (the system time), so make sure it is available.
3064 */
3065 if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PREPARE_TX))
3066 return;
3067
8ca151b5
JB		 3068 mutex_lock(&mvm->mutex);
3069 /* Try really hard to protect the session and hear a beacon */
d20d37bc 3070 iwl_mvm_protect_session(mvm, vif, duration, min_duration, 500, false);
8ca151b5 3071 mutex_unlock(&mvm->mutex);
576eeee9
EP		 3072
3073 iwl_mvm_unref(mvm, IWL_MVM_REF_PREPARE_TX);
8ca151b5
JB		 3074}
3075
35a000b7
DS		 3076static int iwl_mvm_mac_sched_scan_start(struct ieee80211_hw *hw,
3077 struct ieee80211_vif *vif,
3078 struct cfg80211_sched_scan_request *req,
633e2713 3079 struct ieee80211_scan_ies *ies)
35a000b7
DS		 3080{
3081 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
35a000b7 3082
35a000b7 3083 int ret;
4660dfbb 3084
35a000b7
DS		 3085 mutex_lock(&mvm->mutex);
3086
1f940386 3087 if (!vif->bss_conf.idle) {
bd5e4744
DS		 3088 ret = -EBUSY;
3089 goto out;
3090 }
3091
19945dfb 3092 ret = iwl_mvm_sched_scan_start(mvm, vif, req, ies, IWL_MVM_SCAN_SCHED);
d2496221 3093
35a000b7
DS		 3094out:
3095 mutex_unlock(&mvm->mutex);
3096 return ret;
3097}
3098
37e3308c
JB		 3099static int iwl_mvm_mac_sched_scan_stop(struct ieee80211_hw *hw,
3100 struct ieee80211_vif *vif)
35a000b7
DS		 3101{
3102 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
33ea27f6 3103 int ret;
35a000b7
DS		 3104
3105 mutex_lock(&mvm->mutex);
e7d3abab
LC		 3106
3107 /* Due to a race condition, it's possible that mac80211 asks
3108 * us to stop a sched_scan when it's already stopped. This
3109 * can happen, for instance, if we stopped the scan ourselves,
3110 * called ieee80211_sched_scan_stopped() and the userspace called
3111 * stop sched scan scan before ieee80211_sched_scan_stopped_work()
3112 * could run. To handle this, simply return if the scan is
3113 * not running.
3114 */
262888fc 3115 if (!(mvm->scan_status & IWL_MVM_SCAN_SCHED)) {
e7d3abab
LC		 3116 mutex_unlock(&mvm->mutex);
3117 return 0;
3118 }
3119
c7d42480 3120 ret = iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, false);
35a000b7 3121 mutex_unlock(&mvm->mutex);
33ea27f6 3122 iwl_mvm_wait_for_async_handlers(mvm);
37e3308c 3123
33ea27f6 3124 return ret;
35a000b7
DS		 3125}
3126
8ca151b5
JB		 3127static int iwl_mvm_mac_set_key(struct ieee80211_hw *hw,
3128 enum set_key_cmd cmd,
3129 struct ieee80211_vif *vif,
3130 struct ieee80211_sta *sta,
3131 struct ieee80211_key_conf *key)
3132{
3133 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3134 int ret;
d6ee54a9 3135 u8 key_offset;
8ca151b5
JB		 3136
3137 if (iwlwifi_mod_params.sw_crypto) {
3138 IWL_DEBUG_MAC80211(mvm, "leave - hwcrypto disabled\n");
3139 return -EOPNOTSUPP;
3140 }
3141
3142 switch (key->cipher) {
3143 case WLAN_CIPHER_SUITE_TKIP:
3144 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
8ca151b5
JB		 3145 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
3146 break;
ca8c0f4b
JB		 3147 case WLAN_CIPHER_SUITE_CCMP:
3148 key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
3149 break;
8ca151b5 3150 case WLAN_CIPHER_SUITE_AES_CMAC:
30686bf7 3151 WARN_ON_ONCE(!ieee80211_hw_check(hw, MFP_CAPABLE));
8ca151b5
JB		 3152 break;
3153 case WLAN_CIPHER_SUITE_WEP40:
3154 case WLAN_CIPHER_SUITE_WEP104:
ba3943b0
JB		 3155 /* For non-client mode, only use WEP keys for TX as we probably
3156 * don't have a station yet anyway and would then have to keep
3157 * track of the keys, linking them to each of the clients/peers
3158 * as they appear. For now, don't do that, for performance WEP
3159 * offload doesn't really matter much, but we need it for some
3160 * other offload features in client mode.
8ca151b5 3161 */
ba3943b0
JB		 3162 if (vif->type != NL80211_IFTYPE_STATION)
3163 return 0;
3164 break;
8ca151b5 3165 default:
e36e5433
MS		 3166 /* currently FW supports only one optional cipher scheme */
3167 if (hw->n_cipher_schemes &&
3168 hw->cipher_schemes->cipher == key->cipher)
3169 key->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
3170 else
3171 return -EOPNOTSUPP;
8ca151b5
JB		 3172 }
3173
3174 mutex_lock(&mvm->mutex);
3175
3176 switch (cmd) {
3177 case SET_KEY:
5023d966
JB		 3178 if ((vif->type == NL80211_IFTYPE_ADHOC ||
3179 vif->type == NL80211_IFTYPE_AP) && !sta) {
3180 /*
3181 * GTK on AP interface is a TX-only key, return 0;
3182 * on IBSS they're per-station and because we're lazy
3183 * we don't support them for RX, so do the same.
3184 */
6caffd4f
JB		 3185 ret = 0;
3186 key->hw_key_idx = STA_KEY_IDX_INVALID;
3187 break;
3188 }
3189
b546dcd6
JB		 3190 /* During FW restart, in order to restore the state as it was,
3191 * don't try to reprogram keys we previously failed for.
3192 */
3193 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
3194 key->hw_key_idx == STA_KEY_IDX_INVALID) {
3195 IWL_DEBUG_MAC80211(mvm,
3196 "skip invalid idx key programming during restart\n");
3197 ret = 0;
3198 break;
3199 }
3200
d6ee54a9
LC		 3201 /* in HW restart reuse the index, otherwise request a new one */
3202 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status))
3203 key_offset = key->hw_key_idx;
3204 else
3205 key_offset = STA_KEY_IDX_INVALID;
3206
8ca151b5 3207 IWL_DEBUG_MAC80211(mvm, "set hwcrypto key\n");
d6ee54a9 3208 ret = iwl_mvm_set_sta_key(mvm, vif, sta, key, key_offset);
8ca151b5
JB		 3209 if (ret) {
3210 IWL_WARN(mvm, "set key failed\n");
3211 /*
3212 * can't add key for RX, but we don't need it
3213 * in the device for TX so still return 0
3214 */
6caffd4f 3215 key->hw_key_idx = STA_KEY_IDX_INVALID;
8ca151b5
JB		 3216 ret = 0;
3217 }
3218
3219 break;
3220 case DISABLE_KEY:
6caffd4f
JB		 3221 if (key->hw_key_idx == STA_KEY_IDX_INVALID) {
3222 ret = 0;
3223 break;
3224 }
3225
8ca151b5
JB		 3226 IWL_DEBUG_MAC80211(mvm, "disable hwcrypto key\n");
3227 ret = iwl_mvm_remove_sta_key(mvm, vif, sta, key);
3228 break;
3229 default:
3230 ret = -EINVAL;
3231 }
3232
3233 mutex_unlock(&mvm->mutex);
3234 return ret;
3235}
3236
3237static void iwl_mvm_mac_update_tkip_key(struct ieee80211_hw *hw,
3238 struct ieee80211_vif *vif,
3239 struct ieee80211_key_conf *keyconf,
3240 struct ieee80211_sta *sta,
3241 u32 iv32, u16 *phase1key)
3242{
3243 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3244
5023d966
JB		 3245 if (keyconf->hw_key_idx == STA_KEY_IDX_INVALID)
3246 return;
3247
8ca151b5
JB		 3248 iwl_mvm_update_tkip_key(mvm, vif, keyconf, sta, iv32, phase1key);
3249}
3250
3251
b112889c
AM		 3252static bool iwl_mvm_rx_aux_roc(struct iwl_notif_wait_data *notif_wait,
3253 struct iwl_rx_packet *pkt, void *data)
3254{
3255 struct iwl_mvm *mvm =
3256 container_of(notif_wait, struct iwl_mvm, notif_wait);
3257 struct iwl_hs20_roc_res *resp;
3258 int resp_len = iwl_rx_packet_payload_len(pkt);
3259 struct iwl_mvm_time_event_data *te_data = data;
3260
3261 if (WARN_ON(pkt->hdr.cmd != HOT_SPOT_CMD))
3262 return true;
3263
3264 if (WARN_ON_ONCE(resp_len != sizeof(*resp))) {
3265 IWL_ERR(mvm, "Invalid HOT_SPOT_CMD response\n");
3266 return true;
3267 }
3268
3269 resp = (void *)pkt->data;
3270
3271 IWL_DEBUG_TE(mvm,
3272 "Aux ROC: Recieved response from ucode: status=%d uid=%d\n",
3273 resp->status, resp->event_unique_id);
3274
3275 te_data->uid = le32_to_cpu(resp->event_unique_id);
3276 IWL_DEBUG_TE(mvm, "TIME_EVENT_CMD response - UID = 0x%x\n",
3277 te_data->uid);
3278
3279 spin_lock_bh(&mvm->time_event_lock);
3280 list_add_tail(&te_data->list, &mvm->aux_roc_te_list);
3281 spin_unlock_bh(&mvm->time_event_lock);
3282
3283 return true;
3284}
3285
35d3dab5 3286#define AUX_ROC_MAX_DELAY_ON_CHANNEL 200
b112889c
AM		 3287static int iwl_mvm_send_aux_roc_cmd(struct iwl_mvm *mvm,
3288 struct ieee80211_channel *channel,
3289 struct ieee80211_vif *vif,
3290 int duration)
3291{
3292 int res, time_reg = DEVICE_SYSTEM_TIME_REG;
3293 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3294 struct iwl_mvm_time_event_data *te_data = &mvmvif->hs_time_event_data;
6eb031d2 3295 static const u16 time_event_response[] = { HOT_SPOT_CMD };
b112889c
AM		 3296 struct iwl_notification_wait wait_time_event;
3297 struct iwl_hs20_roc_req aux_roc_req = {
3298 .action = cpu_to_le32(FW_CTXT_ACTION_ADD),
3299 .id_and_color =
3300 cpu_to_le32(FW_CMD_ID_AND_COLOR(MAC_INDEX_AUX, 0)),
3301 .sta_id_and_color = cpu_to_le32(mvm->aux_sta.sta_id),
3302 /* Set the channel info data */
3303 .channel_info.band = (channel->band == IEEE80211_BAND_2GHZ) ?
3304 PHY_BAND_24 : PHY_BAND_5,
3305 .channel_info.channel = channel->hw_value,
3306 .channel_info.width = PHY_VHT_CHANNEL_MODE20,
3307 /* Set the time and duration */
3308 .apply_time = cpu_to_le32(iwl_read_prph(mvm->trans, time_reg)),
3309 .apply_time_max_delay =
3310 cpu_to_le32(MSEC_TO_TU(AUX_ROC_MAX_DELAY_ON_CHANNEL)),
3311 .duration = cpu_to_le32(MSEC_TO_TU(duration)),
3312 };
3313
3314 /* Set the node address */
3315 memcpy(aux_roc_req.node_addr, vif->addr, ETH_ALEN);
3316
a6cc5163
MG		 3317 lockdep_assert_held(&mvm->mutex);
3318
3319 spin_lock_bh(&mvm->time_event_lock);
3320
3321 if (WARN_ON(te_data->id == HOT_SPOT_CMD)) {
3322 spin_unlock_bh(&mvm->time_event_lock);
3323 return -EIO;
3324 }
3325
b112889c
AM		 3326 te_data->vif = vif;
3327 te_data->duration = duration;
3328 te_data->id = HOT_SPOT_CMD;
3329
b112889c
AM		 3330 spin_unlock_bh(&mvm->time_event_lock);
3331
3332 /*
3333 * Use a notification wait, which really just processes the
3334 * command response and doesn't wait for anything, in order
3335 * to be able to process the response and get the UID inside
3336 * the RX path. Using CMD_WANT_SKB doesn't work because it
3337 * stores the buffer and then wakes up this thread, by which
3338 * time another notification (that the time event started)
3339 * might already be processed unsuccessfully.
3340 */
3341 iwl_init_notification_wait(&mvm->notif_wait, &wait_time_event,
3342 time_event_response,
3343 ARRAY_SIZE(time_event_response),
3344 iwl_mvm_rx_aux_roc, te_data);
3345
3346 res = iwl_mvm_send_cmd_pdu(mvm, HOT_SPOT_CMD, 0, sizeof(aux_roc_req),
3347 &aux_roc_req);
3348
3349 if (res) {
3350 IWL_ERR(mvm, "Couldn't send HOT_SPOT_CMD: %d\n", res);
3351 iwl_remove_notification(&mvm->notif_wait, &wait_time_event);
3352 goto out_clear_te;
3353 }
3354
3355 /* No need to wait for anything, so just pass 1 (0 isn't valid) */
3356 res = iwl_wait_notification(&mvm->notif_wait, &wait_time_event, 1);
3357 /* should never fail */
3358 WARN_ON_ONCE(res);
3359
3360 if (res) {
3361 out_clear_te:
3362 spin_lock_bh(&mvm->time_event_lock);
3363 iwl_mvm_te_clear_data(mvm, te_data);
3364 spin_unlock_bh(&mvm->time_event_lock);
3365 }
3366
3367 return res;
3368}
3369
8ca151b5
JB		 3370static int iwl_mvm_roc(struct ieee80211_hw *hw,
3371 struct ieee80211_vif *vif,
3372 struct ieee80211_channel *channel,
d339d5ca
IP		 3373 int duration,
3374 enum ieee80211_roc_type type)
8ca151b5
JB		 3375{
3376 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
fe0f2de3 3377 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
8ca151b5 3378 struct cfg80211_chan_def chandef;
31d385ae
IP		 3379 struct iwl_mvm_phy_ctxt *phy_ctxt;
3380 int ret, i;
3381
3382 IWL_DEBUG_MAC80211(mvm, "enter (%d, %d, %d)\n", channel->hw_value,
3383 duration, type);
8ca151b5 3384
6ed13164
MG		 3385 flush_work(&mvm->roc_done_wk);
3386
a6cc5163
MG		 3387 mutex_lock(&mvm->mutex);
3388
b112889c
AM		 3389 switch (vif->type) {
3390 case NL80211_IFTYPE_STATION:
859d914c
JB		 3391 if (fw_has_capa(&mvm->fw->ucode_capa,
3392 IWL_UCODE_TLV_CAPA_HOTSPOT_SUPPORT)) {
5ac6c72e
LC		 3393 /* Use aux roc framework (HS20) */
3394 ret = iwl_mvm_send_aux_roc_cmd(mvm, channel,
3395 vif, duration);
3396 goto out_unlock;
3397 }
3398 IWL_ERR(mvm, "hotspot not supported\n");
3399 ret = -EINVAL;
a6cc5163 3400 goto out_unlock;
b112889c
AM		 3401 case NL80211_IFTYPE_P2P_DEVICE:
3402 /* handle below */
3403 break;
3404 default:
3405 IWL_ERR(mvm, "vif isn't P2P_DEVICE: %d\n", vif->type);
a6cc5163
MG		 3406 ret = -EINVAL;
3407 goto out_unlock;
8ca151b5
JB		 3408 }
3409
31d385ae
IP		 3410 for (i = 0; i < NUM_PHY_CTX; i++) {
3411 phy_ctxt = &mvm->phy_ctxts[i];
3412 if (phy_ctxt->ref == 0 || mvmvif->phy_ctxt == phy_ctxt)
3413 continue;
3414
3415 if (phy_ctxt->ref && channel == phy_ctxt->channel) {
3416 /*
3417 * Unbind the P2P_DEVICE from the current PHY context,
3418 * and if the PHY context is not used remove it.
3419 */
3420 ret = iwl_mvm_binding_remove_vif(mvm, vif);
3421 if (WARN(ret, "Failed unbinding P2P_DEVICE\n"))
3422 goto out_unlock;
3423
3424 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
3425
3426 /* Bind the P2P_DEVICE to the current PHY Context */
3427 mvmvif->phy_ctxt = phy_ctxt;
3428
3429 ret = iwl_mvm_binding_add_vif(mvm, vif);
3430 if (WARN(ret, "Failed binding P2P_DEVICE\n"))
3431 goto out_unlock;
3432
3433 iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
3434 goto schedule_time_event;
3435 }
3436 }
3437
3438 /* Need to update the PHY context only if the ROC channel changed */
3439 if (channel == mvmvif->phy_ctxt->channel)
3440 goto schedule_time_event;
3441
8ca151b5 3442 cfg80211_chandef_create(&chandef, channel, NL80211_CHAN_NO_HT);
8ca151b5 3443
31d385ae
IP		 3444 /*
3445 * Change the PHY context configuration as it is currently referenced
3446 * only by the P2P Device MAC
3447 */
3448 if (mvmvif->phy_ctxt->ref == 1) {
3449 ret = iwl_mvm_phy_ctxt_changed(mvm, mvmvif->phy_ctxt,
3450 &chandef, 1, 1);
3451 if (ret)
3452 goto out_unlock;
3453 } else {
3454 /*
3455 * The PHY context is shared with other MACs. Need to remove the
3456 * P2P Device from the binding, allocate an new PHY context and
3457 * create a new binding
3458 */
3459 phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
3460 if (!phy_ctxt) {
3461 ret = -ENOSPC;
3462 goto out_unlock;
3463 }
3464
3465 ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &chandef,
3466 1, 1);
3467 if (ret) {
3468 IWL_ERR(mvm, "Failed to change PHY context\n");
3469 goto out_unlock;
3470 }
3471
3472 /* Unbind the P2P_DEVICE from the current PHY context */
3473 ret = iwl_mvm_binding_remove_vif(mvm, vif);
3474 if (WARN(ret, "Failed unbinding P2P_DEVICE\n"))
3475 goto out_unlock;
3476
3477 iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
3478
3479 /* Bind the P2P_DEVICE to the new allocated PHY context */
3480 mvmvif->phy_ctxt = phy_ctxt;
3481
3482 ret = iwl_mvm_binding_add_vif(mvm, vif);
3483 if (WARN(ret, "Failed binding P2P_DEVICE\n"))
3484 goto out_unlock;
3485
3486 iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
3487 }
3488
3489schedule_time_event:
8ca151b5 3490 /* Schedule the time events */
e635c797 3491 ret = iwl_mvm_start_p2p_roc(mvm, vif, duration, type);
8ca151b5 3492
31d385ae 3493out_unlock:
8ca151b5
JB		 3494 mutex_unlock(&mvm->mutex);
3495 IWL_DEBUG_MAC80211(mvm, "leave\n");
8ca151b5
JB		 3496 return ret;
3497}
3498
3499static int iwl_mvm_cancel_roc(struct ieee80211_hw *hw)
3500{
3501 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3502
3503 IWL_DEBUG_MAC80211(mvm, "enter\n");
3504
3505 mutex_lock(&mvm->mutex);
bf5da87f 3506 iwl_mvm_stop_roc(mvm);
8ca151b5
JB		 3507 mutex_unlock(&mvm->mutex);
3508
3509 IWL_DEBUG_MAC80211(mvm, "leave\n");
3510 return 0;
3511}
3512
b08c1d97
LC		 3513static int __iwl_mvm_add_chanctx(struct iwl_mvm *mvm,
3514 struct ieee80211_chanctx_conf *ctx)
8ca151b5 3515{
fe0f2de3
IP		 3516 u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3517 struct iwl_mvm_phy_ctxt *phy_ctxt;
8ca151b5
JB		 3518 int ret;
3519
b08c1d97
LC		 3520 lockdep_assert_held(&mvm->mutex);
3521
53a9d61e 3522 IWL_DEBUG_MAC80211(mvm, "Add channel context\n");
fe0f2de3 3523
fe0f2de3
IP		 3524 phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
3525 if (!phy_ctxt) {
3526 ret = -ENOSPC;
3527 goto out;
3528 }
8ca151b5 3529
dcbc3e1a 3530 ret = iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &ctx->min_def,
53a9d61e
IP		 3531 ctx->rx_chains_static,
3532 ctx->rx_chains_dynamic);
fe0f2de3
IP		 3533 if (ret) {
3534 IWL_ERR(mvm, "Failed to add PHY context\n");
3535 goto out;
3536 }
3537
53a9d61e 3538 iwl_mvm_phy_ctxt_ref(mvm, phy_ctxt);
fe0f2de3
IP		 3539 *phy_ctxt_id = phy_ctxt->id;
3540out:
b08c1d97
LC		 3541 return ret;
3542}
3543
3544static int iwl_mvm_add_chanctx(struct ieee80211_hw *hw,
3545 struct ieee80211_chanctx_conf *ctx)
3546{
3547 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3548 int ret;
3549
3550 mutex_lock(&mvm->mutex);
3551 ret = __iwl_mvm_add_chanctx(mvm, ctx);
8ca151b5 3552 mutex_unlock(&mvm->mutex);
b08c1d97 3553
8ca151b5
JB		 3554 return ret;
3555}
3556
b08c1d97
LC		 3557static void __iwl_mvm_remove_chanctx(struct iwl_mvm *mvm,
3558 struct ieee80211_chanctx_conf *ctx)
3559{
3560 u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3561 struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
3562
3563 lockdep_assert_held(&mvm->mutex);
3564
3565 iwl_mvm_phy_ctxt_unref(mvm, phy_ctxt);
3566}
3567
8ca151b5
JB		 3568static void iwl_mvm_remove_chanctx(struct ieee80211_hw *hw,
3569 struct ieee80211_chanctx_conf *ctx)
3570{
3571 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
8ca151b5
JB		 3572
3573 mutex_lock(&mvm->mutex);
b08c1d97 3574 __iwl_mvm_remove_chanctx(mvm, ctx);
8ca151b5
JB		 3575 mutex_unlock(&mvm->mutex);
3576}
3577
3578static void iwl_mvm_change_chanctx(struct ieee80211_hw *hw,
3579 struct ieee80211_chanctx_conf *ctx,
3580 u32 changed)
3581{
3582 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
fe0f2de3
IP		 3583 u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3584 struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
8ca151b5 3585
31d385ae
IP		 3586 if (WARN_ONCE((phy_ctxt->ref > 1) &&
3587 (changed & ~(IEEE80211_CHANCTX_CHANGE_WIDTH |
3588 IEEE80211_CHANCTX_CHANGE_RX_CHAINS |
2dceedae
AN		 3589 IEEE80211_CHANCTX_CHANGE_RADAR |
3590 IEEE80211_CHANCTX_CHANGE_MIN_WIDTH)),
31d385ae
IP		 3591 "Cannot change PHY. Ref=%d, changed=0x%X\n",
3592 phy_ctxt->ref, changed))
3593 return;
3594
8ca151b5 3595 mutex_lock(&mvm->mutex);
4d66449a 3596 iwl_mvm_bt_coex_vif_change(mvm);
dcbc3e1a 3597 iwl_mvm_phy_ctxt_changed(mvm, phy_ctxt, &ctx->min_def,
8ca151b5
JB		 3598 ctx->rx_chains_static,
3599 ctx->rx_chains_dynamic);
3600 mutex_unlock(&mvm->mutex);
3601}
3602
b08c1d97
LC		 3603static int __iwl_mvm_assign_vif_chanctx(struct iwl_mvm *mvm,
3604 struct ieee80211_vif *vif,
f0c97783
LC		 3605 struct ieee80211_chanctx_conf *ctx,
3606 bool switching_chanctx)
8ca151b5 3607{
fe0f2de3
IP		 3608 u16 *phy_ctxt_id = (u16 *)ctx->drv_priv;
3609 struct iwl_mvm_phy_ctxt *phy_ctxt = &mvm->phy_ctxts[*phy_ctxt_id];
8ca151b5
JB		 3610 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
3611 int ret;
3612
b08c1d97 3613 lockdep_assert_held(&mvm->mutex);
8ca151b5 3614
fe0f2de3 3615 mvmvif->phy_ctxt = phy_ctxt;
8ca151b5
JB		 3616
3617 switch (vif->type) {
3618 case NL80211_IFTYPE_AP:
4741dd04
LC		 3619 /* only needed if we're switching chanctx (i.e. during CSA) */
3620 if (switching_chanctx) {
bd3398e2
AO		 3621 mvmvif->ap_ibss_active = true;
3622 break;
3623 }
5023d966 3624 case NL80211_IFTYPE_ADHOC:
8ca151b5
JB		 3625 /*
3626 * The AP binding flow is handled as part of the start_ap flow
5023d966 3627 * (in bss_info_changed), similarly for IBSS.
8ca151b5
JB		 3628 */
3629 ret = 0;
b08c1d97 3630 goto out;
8ca151b5 3631 case NL80211_IFTYPE_STATION:
2533edce 3632 break;
8ca151b5 3633 case NL80211_IFTYPE_MONITOR:
2533edce
LC		 3634 /* always disable PS when a monitor interface is active */
3635 mvmvif->ps_disabled = true;
8ca151b5
JB		 3636 break;
3637 default:
3638 ret = -EINVAL;
b08c1d97 3639 goto out;
8ca151b5
JB		 3640 }
3641
3642 ret = iwl_mvm_binding_add_vif(mvm, vif);
3643 if (ret)
b08c1d97 3644 goto out;
8ca151b5
JB		 3645
3646 /*
92d85562
AB		 3647 * Power state must be updated before quotas,
3648 * otherwise fw will complain.
3649 */
999609f1 3650 iwl_mvm_power_update_mac(mvm);
92d85562
AB		 3651
3652 /* Setting the quota at this stage is only required for monitor
8ca151b5
JB		 3653 * interfaces. For the other types, the bss_info changed flow
3654 * will handle quota settings.
3655 */
3656 if (vif->type == NL80211_IFTYPE_MONITOR) {
1e1391ca 3657 mvmvif->monitor_active = true;
7754ae79 3658 ret = iwl_mvm_update_quotas(mvm, false, NULL);
8ca151b5
JB		 3659 if (ret)
3660 goto out_remove_binding;
3661 }
3662
bd3398e2 3663 /* Handle binding during CSA */
a57c688d 3664 if (vif->type == NL80211_IFTYPE_AP) {
7754ae79 3665 iwl_mvm_update_quotas(mvm, false, NULL);
3dfd3a97 3666 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
bd3398e2
AO		 3667 }
3668
4741dd04 3669 if (switching_chanctx && vif->type == NL80211_IFTYPE_STATION) {
686e7fe1
LC		 3670 u32 duration = 2 * vif->bss_conf.beacon_int;
3671
3672 /* iwl_mvm_protect_session() reads directly from the
3673 * device (the system time), so make sure it is
3674 * available.
3675 */
3676 ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PROTECT_CSA);
3677 if (ret)
3678 goto out_remove_binding;
3679
3680 /* Protect the session to make sure we hear the first
3681 * beacon on the new channel.
3682 */
3683 iwl_mvm_protect_session(mvm, vif, duration, duration,
3684 vif->bss_conf.beacon_int / 2,
3685 true);
3686
3687 iwl_mvm_unref(mvm, IWL_MVM_REF_PROTECT_CSA);
3688
7754ae79 3689 iwl_mvm_update_quotas(mvm, false, NULL);
0ce04ce7
LC		 3690 }
3691
b08c1d97 3692 goto out;
8ca151b5 3693
b08c1d97 3694out_remove_binding:
8ca151b5 3695 iwl_mvm_binding_remove_vif(mvm, vif);
999609f1 3696 iwl_mvm_power_update_mac(mvm);
b08c1d97 3697out:
8ca151b5
JB		 3698 if (ret)
3699 mvmvif->phy_ctxt = NULL;
3700 return ret;
3701}
b08c1d97
LC		 3702static int iwl_mvm_assign_vif_chanctx(struct ieee80211_hw *hw,
3703 struct ieee80211_vif *vif,
3704 struct ieee80211_chanctx_conf *ctx)
8ca151b5
JB		 3705{
3706 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
b08c1d97 3707 int ret;
8ca151b5
JB		 3708
3709 mutex_lock(&mvm->mutex);
f0c97783 3710 ret = __iwl_mvm_assign_vif_chanctx(mvm, vif, ctx, false);
b08c1d97
LC		 3711 mutex_unlock(&mvm->mutex);
3712
3713 return ret;
3714}
3715
3716static void __iwl_mvm_unassign_vif_chanctx(struct iwl_mvm *mvm,
3717 struct ieee80211_vif *vif,
f0c97783
LC		 3718 struct ieee80211_chanctx_conf *ctx,
3719 bool switching_chanctx)
b08c1d97
LC		 3720{
3721 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
f0c97783 3722 struct ieee80211_vif *disabled_vif = NULL;
b08c1d97
LC		 3723
3724 lockdep_assert_held(&mvm->mutex);
8ca151b5
JB		 3725
3726 iwl_mvm_remove_time_event(mvm, mvmvif, &mvmvif->time_event_data);
3727
8ca151b5 3728 switch (vif->type) {
5023d966 3729 case NL80211_IFTYPE_ADHOC:
b08c1d97 3730 goto out;
8ca151b5 3731 case NL80211_IFTYPE_MONITOR:
1e1391ca 3732 mvmvif->monitor_active = false;
2533edce 3733 mvmvif->ps_disabled = false;
8ca151b5 3734 break;
bd3398e2
AO		 3735 case NL80211_IFTYPE_AP:
3736 /* This part is triggered only during CSA */
4741dd04 3737 if (!switching_chanctx || !mvmvif->ap_ibss_active)
b08c1d97 3738 goto out;
bd3398e2 3739
7ef0aab6
AO		 3740 mvmvif->csa_countdown = false;
3741
003e5236
AO		 3742 /* Set CS bit on all the stations */
3743 iwl_mvm_modify_all_sta_disable_tx(mvm, mvmvif, true);
3744
3745 /* Save blocked iface, the timeout is set on the next beacon */
3746 rcu_assign_pointer(mvm->csa_tx_blocked_vif, vif);
3747
bd3398e2 3748 mvmvif->ap_ibss_active = false;
f0c97783
LC		 3749 break;
3750 case NL80211_IFTYPE_STATION:
3751 if (!switching_chanctx)
3752 break;
3753
3754 disabled_vif = vif;
3755
3dfd3a97 3756 iwl_mvm_mac_ctxt_changed(mvm, vif, true, NULL);
f0c97783 3757 break;
8ca151b5
JB		 3758 default:
3759 break;
3760 }
3761
7754ae79 3762 iwl_mvm_update_quotas(mvm, false, disabled_vif);
1e1391ca 3763 iwl_mvm_binding_remove_vif(mvm, vif);
1c2abf72 3764
b08c1d97 3765out:
a11e144e 3766 mvmvif->phy_ctxt = NULL;
999609f1 3767 iwl_mvm_power_update_mac(mvm);
b08c1d97
LC		 3768}
3769
3770static void iwl_mvm_unassign_vif_chanctx(struct ieee80211_hw *hw,
3771 struct ieee80211_vif *vif,
3772 struct ieee80211_chanctx_conf *ctx)
3773{
3774 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3775
3776 mutex_lock(&mvm->mutex);
f0c97783 3777 __iwl_mvm_unassign_vif_chanctx(mvm, vif, ctx, false);
8ca151b5
JB		 3778 mutex_unlock(&mvm->mutex);
3779}
3780
50cc9574
LC		 3781static int
3782iwl_mvm_switch_vif_chanctx_swap(struct iwl_mvm *mvm,
3783 struct ieee80211_vif_chanctx_switch *vifs)
b08c1d97 3784{
b08c1d97
LC		 3785 int ret;
3786
b08c1d97 3787 mutex_lock(&mvm->mutex);
f0c97783 3788 __iwl_mvm_unassign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true);
b08c1d97
LC		 3789 __iwl_mvm_remove_chanctx(mvm, vifs[0].old_ctx);
3790
3791 ret = __iwl_mvm_add_chanctx(mvm, vifs[0].new_ctx);
3792 if (ret) {
3793 IWL_ERR(mvm, "failed to add new_ctx during channel switch\n");
3794 goto out_reassign;
3795 }
3796
f0c97783
LC		 3797 ret = __iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].new_ctx,
3798 true);
b08c1d97
LC		 3799 if (ret) {
3800 IWL_ERR(mvm,
3801 "failed to assign new_ctx during channel switch\n");
3802 goto out_remove;
3803 }
3804
f697267f
AN		 3805 /* we don't support TDLS during DCM - can be caused by channel switch */
3806 if (iwl_mvm_phy_ctx_count(mvm) > 1)
3807 iwl_mvm_teardown_tdls_peers(mvm);
3808
b08c1d97
LC		 3809 goto out;
3810
3811out_remove:
3812 __iwl_mvm_remove_chanctx(mvm, vifs[0].new_ctx);
3813
3814out_reassign:
6fd1fb63 3815 if (__iwl_mvm_add_chanctx(mvm, vifs[0].old_ctx)) {
b08c1d97
LC		 3816 IWL_ERR(mvm, "failed to add old_ctx back after failure.\n");
3817 goto out_restart;
3818 }
3819
6fd1fb63
LC		 3820 if (__iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx,
3821 true)) {
b08c1d97
LC		 3822 IWL_ERR(mvm, "failed to reassign old_ctx after failure.\n");
3823 goto out_restart;
3824 }
3825
3826 goto out;
3827
3828out_restart:
3829 /* things keep failing, better restart the hw */
3830 iwl_mvm_nic_restart(mvm, false);
3831
3832out:
3833 mutex_unlock(&mvm->mutex);
50cc9574
LC		 3834
3835 return ret;
3836}
3837
48a256e8
LC		 3838static int
3839iwl_mvm_switch_vif_chanctx_reassign(struct iwl_mvm *mvm,
3840 struct ieee80211_vif_chanctx_switch *vifs)
3841{
3842 int ret;
3843
3844 mutex_lock(&mvm->mutex);
3845 __iwl_mvm_unassign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx, true);
3846
3847 ret = __iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].new_ctx,
3848 true);
3849 if (ret) {
3850 IWL_ERR(mvm,
3851 "failed to assign new_ctx during channel switch\n");
3852 goto out_reassign;
3853 }
3854
3855 goto out;
3856
3857out_reassign:
3858 if (__iwl_mvm_assign_vif_chanctx(mvm, vifs[0].vif, vifs[0].old_ctx,
3859 true)) {
3860 IWL_ERR(mvm, "failed to reassign old_ctx after failure.\n");
3861 goto out_restart;
3862 }
3863
3864 goto out;
3865
3866out_restart:
3867 /* things keep failing, better restart the hw */
3868 iwl_mvm_nic_restart(mvm, false);
3869
3870out:
3871 mutex_unlock(&mvm->mutex);
3872
3873 return ret;
3874}
3875
50cc9574
LC		 3876static int iwl_mvm_switch_vif_chanctx(struct ieee80211_hw *hw,
3877 struct ieee80211_vif_chanctx_switch *vifs,
3878 int n_vifs,
3879 enum ieee80211_chanctx_switch_mode mode)
3880{
3881 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3882 int ret;
3883
3884 /* we only support a single-vif right now */
3885 if (n_vifs > 1)
3886 return -EOPNOTSUPP;
3887
3888 switch (mode) {
3889 case CHANCTX_SWMODE_SWAP_CONTEXTS:
3890 ret = iwl_mvm_switch_vif_chanctx_swap(mvm, vifs);
3891 break;
3892 case CHANCTX_SWMODE_REASSIGN_VIF:
48a256e8 3893 ret = iwl_mvm_switch_vif_chanctx_reassign(mvm, vifs);
50cc9574
LC		 3894 break;
3895 default:
3896 ret = -EOPNOTSUPP;
3897 break;
3898 }
3899
b08c1d97
LC		 3900 return ret;
3901}
3902
8ca151b5
JB		 3903static int iwl_mvm_set_tim(struct ieee80211_hw *hw,
3904 struct ieee80211_sta *sta,
3905 bool set)
3906{
3907 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
9d8ce6af 3908 struct iwl_mvm_sta *mvm_sta = iwl_mvm_sta_from_mac80211(sta);
8ca151b5
JB		 3909
3910 if (!mvm_sta || !mvm_sta->vif) {
3911 IWL_ERR(mvm, "Station is not associated to a vif\n");
3912 return -EINVAL;
3913 }
3914
3915 return iwl_mvm_mac_ctxt_beacon_changed(mvm, mvm_sta->vif);
3916}
3917
507cadf2
DS		 3918#ifdef CONFIG_NL80211_TESTMODE
3919static const struct nla_policy iwl_mvm_tm_policy[IWL_MVM_TM_ATTR_MAX + 1] = {
3920 [IWL_MVM_TM_ATTR_CMD] = { .type = NLA_U32 },
3921 [IWL_MVM_TM_ATTR_NOA_DURATION] = { .type = NLA_U32 },
f6c6ad42 3922 [IWL_MVM_TM_ATTR_BEACON_FILTER_STATE] = { .type = NLA_U32 },
507cadf2
DS		 3923};
3924
3925static int __iwl_mvm_mac_testmode_cmd(struct iwl_mvm *mvm,
3926 struct ieee80211_vif *vif,
3927 void *data, int len)
3928{
3929 struct nlattr *tb[IWL_MVM_TM_ATTR_MAX + 1];
3930 int err;
3931 u32 noa_duration;
3932
3933 err = nla_parse(tb, IWL_MVM_TM_ATTR_MAX, data, len, iwl_mvm_tm_policy);
3934 if (err)
3935 return err;
3936
3937 if (!tb[IWL_MVM_TM_ATTR_CMD])
3938 return -EINVAL;
3939
3940 switch (nla_get_u32(tb[IWL_MVM_TM_ATTR_CMD])) {
3941 case IWL_MVM_TM_CMD_SET_NOA:
3942 if (!vif || vif->type != NL80211_IFTYPE_AP || !vif->p2p ||
3943 !vif->bss_conf.enable_beacon ||
3944 !tb[IWL_MVM_TM_ATTR_NOA_DURATION])
3945 return -EINVAL;
3946
3947 noa_duration = nla_get_u32(tb[IWL_MVM_TM_ATTR_NOA_DURATION]);
3948 if (noa_duration >= vif->bss_conf.beacon_int)
3949 return -EINVAL;
3950
3951 mvm->noa_duration = noa_duration;
3952 mvm->noa_vif = vif;
3953
7754ae79 3954 return iwl_mvm_update_quotas(mvm, false, NULL);
f6c6ad42
JB		 3955 case IWL_MVM_TM_CMD_SET_BEACON_FILTER:
3956 /* must be associated client vif - ignore authorized */
3957 if (!vif || vif->type != NL80211_IFTYPE_STATION ||
3958 !vif->bss_conf.assoc || !vif->bss_conf.dtim_period ||
3959 !tb[IWL_MVM_TM_ATTR_BEACON_FILTER_STATE])
3960 return -EINVAL;
3961
3962 if (nla_get_u32(tb[IWL_MVM_TM_ATTR_BEACON_FILTER_STATE]))
a1022927
EG		 3963 return iwl_mvm_enable_beacon_filter(mvm, vif, 0);
3964 return iwl_mvm_disable_beacon_filter(mvm, vif, 0);
507cadf2
DS		 3965 }
3966
3967 return -EOPNOTSUPP;
3968}
3969
3970static int iwl_mvm_mac_testmode_cmd(struct ieee80211_hw *hw,
3971 struct ieee80211_vif *vif,
3972 void *data, int len)
3973{
3974 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
3975 int err;
3976
3977 mutex_lock(&mvm->mutex);
3978 err = __iwl_mvm_mac_testmode_cmd(mvm, vif, data, len);
3979 mutex_unlock(&mvm->mutex);
3980
3981 return err;
3982}
3983#endif
3984
622e3f9b
LC		 3985static void iwl_mvm_channel_switch(struct ieee80211_hw *hw,
3986 struct ieee80211_vif *vif,
3987 struct ieee80211_channel_switch *chsw)
3988{
3989 /* By implementing this operation, we prevent mac80211 from
3990 * starting its own channel switch timer, so that we can call
3991 * ieee80211_chswitch_done() ourselves at the right time
3992 * (which is when the absence time event starts).
3993 */
3994
3995 IWL_DEBUG_MAC80211(IWL_MAC80211_GET_MVM(hw),
3996 "dummy channel switch op\n");
3997}
3998
f028905c
LC		 3999static int iwl_mvm_pre_channel_switch(struct ieee80211_hw *hw,
4000 struct ieee80211_vif *vif,
4001 struct ieee80211_channel_switch *chsw)
bd3398e2
AO		 4002{
4003 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
664322fa 4004 struct ieee80211_vif *csa_vif;
f6c34820 4005 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
dc88b4ba 4006 u32 apply_time;
f028905c 4007 int ret;
bd3398e2
AO		 4008
4009 mutex_lock(&mvm->mutex);
664322fa 4010
81d62d5a
JB		 4011 mvmvif->csa_failed = false;
4012
6b20d774 4013 IWL_DEBUG_MAC80211(mvm, "pre CSA to freq %d\n",
f028905c 4014 chsw->chandef.center_freq1);
6b20d774 4015
21023b1e 4016 iwl_fw_dbg_trigger_simple_stop(mvm, vif, FW_DBG_TRIGGER_CHANNEL_SWITCH);
f35d9c55 4017
6b20d774
LC		 4018 switch (vif->type) {
4019 case NL80211_IFTYPE_AP:
4020 csa_vif =
4021 rcu_dereference_protected(mvm->csa_vif,
4022 lockdep_is_held(&mvm->mutex));
4023 if (WARN_ONCE(csa_vif && csa_vif->csa_active,
4024 "Another CSA is already in progress")) {
4025 ret = -EBUSY;
4026 goto out_unlock;
4027 }
4028
4029 rcu_assign_pointer(mvm->csa_vif, vif);
7ef0aab6 4030
7ef0aab6
AO		 4031 if (WARN_ONCE(mvmvif->csa_countdown,
4032 "Previous CSA countdown didn't complete")) {
4033 ret = -EBUSY;
4034 goto out_unlock;
4035 }
4036
6b20d774 4037 break;
dc88b4ba 4038 case NL80211_IFTYPE_STATION:
4500e133
LC		 4039 /* Schedule the time event to a bit before beacon 1,
4040 * to make sure we're in the new channel when the
4041 * GO/AP arrives.
4042 */
4043 apply_time = chsw->device_timestamp +
4044 ((vif->bss_conf.beacon_int * (chsw->count - 1) -
4045 IWL_MVM_CHANNEL_SWITCH_TIME_CLIENT) * 1024);
dc88b4ba
LC		 4046
4047 if (chsw->block_tx)
4048 iwl_mvm_csa_client_absent(mvm, vif);
4049
4500e133 4050 iwl_mvm_schedule_csa_period(mvm, vif, vif->bss_conf.beacon_int,
dc88b4ba 4051 apply_time);
c6e0a3e0
LC		 4052 if (mvmvif->bf_data.bf_enabled) {
4053 ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
4054 if (ret)
4055 goto out_unlock;
4056 }
4057
dc88b4ba 4058 break;
6b20d774
LC		 4059 default:
4060 break;
4061 }
bd3398e2 4062
f6c34820
LC		 4063 mvmvif->ps_disabled = true;
4064
4065 ret = iwl_mvm_power_update_ps(mvm);
4066 if (ret)
4067 goto out_unlock;
f028905c 4068
e198f5e7
AN		 4069 /* we won't be on this channel any longer */
4070 iwl_mvm_teardown_tdls_peers(mvm);
4071
bd3398e2
AO		 4072out_unlock:
4073 mutex_unlock(&mvm->mutex);
f028905c
LC		 4074
4075 return ret;
bd3398e2
AO		 4076}
4077
f6c34820
LC		 4078static int iwl_mvm_post_channel_switch(struct ieee80211_hw *hw,
4079 struct ieee80211_vif *vif)
4080{
4081 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
4082 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
4083 int ret;
4084
4085 mutex_lock(&mvm->mutex);
4086
81d62d5a
JB		 4087 if (mvmvif->csa_failed) {
4088 mvmvif->csa_failed = false;
4089 ret = -EIO;
4090 goto out_unlock;
4091 }
4092
a57c688d
LC		 4093 if (vif->type == NL80211_IFTYPE_STATION) {
4094 struct iwl_mvm_sta *mvmsta;
4095
4096 mvmsta = iwl_mvm_sta_from_staid_protected(mvm,
4097 mvmvif->ap_sta_id);
4098
4099 if (WARN_ON(!mvmsta)) {
4100 ret = -EIO;
4101 goto out_unlock;
4102 }
4103
4104 iwl_mvm_sta_modify_disable_tx(mvm, mvmsta, false);
4105
4106 iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
c6e0a3e0
LC		 4107
4108 ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
4109 if (ret)
4110 goto out_unlock;
686e7fe1
LC		 4111
4112 iwl_mvm_stop_session_protection(mvm, vif);
a57c688d
LC		 4113 }
4114
f6c34820
LC		 4115 mvmvif->ps_disabled = false;
4116
4117 ret = iwl_mvm_power_update_ps(mvm);
4118
a57c688d 4119out_unlock:
f6c34820
LC		 4120 mutex_unlock(&mvm->mutex);
4121
4122 return ret;
4123}
4124
c5b0e7c0
EG		 4125static void iwl_mvm_mac_flush(struct ieee80211_hw *hw,
4126 struct ieee80211_vif *vif, u32 queues, bool drop)
4127{
4128 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
4129 struct iwl_mvm_vif *mvmvif;
4130 struct iwl_mvm_sta *mvmsta;
a0f6bf2a
AN		 4131 struct ieee80211_sta *sta;
4132 int i;
4133 u32 msk = 0;
c5b0e7c0
EG		 4134
4135 if (!vif || vif->type != NL80211_IFTYPE_STATION)
4136 return;
4137
4138 mutex_lock(&mvm->mutex);
4139 mvmvif = iwl_mvm_vif_from_mac80211(vif);
c5b0e7c0 4140
a0f6bf2a
AN		 4141 /* flush the AP-station and all TDLS peers */
4142 for (i = 0; i < IWL_MVM_STATION_COUNT; i++) {
4143 sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i],
4144 lockdep_is_held(&mvm->mutex));
4145 if (IS_ERR_OR_NULL(sta))
4146 continue;
4147
4148 mvmsta = iwl_mvm_sta_from_mac80211(sta);
4149 if (mvmsta->vif != vif)
4150 continue;
4151
4152 /* make sure only TDLS peers or the AP are flushed */
4153 WARN_ON(i != mvmvif->ap_sta_id && !sta->tdls);
4154
4155 msk |= mvmsta->tfd_queue_msk;
480acbce 4156 }
c5b0e7c0 4157
6d440b25 4158 if (drop) {
5888a40c 4159 if (iwl_mvm_flush_tx_path(mvm, msk, 0))
6d440b25
EG		 4160 IWL_ERR(mvm, "flush request fail\n");
4161 mutex_unlock(&mvm->mutex);
4162 } else {
4163 mutex_unlock(&mvm->mutex);
4e6c48e0 4164
6d440b25
EG		 4165 /* this can take a while, and we may need/want other operations
4166 * to succeed while doing this, so do it without the mutex held
4167 */
4168 iwl_trans_wait_tx_queue_empty(mvm->trans, msk);
4169 }
c5b0e7c0
EG		 4170}
4171
91a8bcde
JB		 4172static int iwl_mvm_mac_get_survey(struct ieee80211_hw *hw, int idx,
4173 struct survey_info *survey)
4174{
4175 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
4176 int ret;
4177
4178 memset(survey, 0, sizeof(*survey));
4179
4180 /* only support global statistics right now */
4181 if (idx != 0)
4182 return -ENOENT;
4183
859d914c 4184 if (fw_has_capa(&mvm->fw->ucode_capa,
91a8bcde
JB		 4185 IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
4186 return -ENOENT;
4187
4188 mutex_lock(&mvm->mutex);
4189
4190 if (mvm->ucode_loaded) {
33cef925 4191 ret = iwl_mvm_request_statistics(mvm, false);
91a8bcde
JB		 4192 if (ret)
4193 goto out;
4194 }
4195
4196 survey->filled = SURVEY_INFO_TIME |
4197 SURVEY_INFO_TIME_RX |
4198 SURVEY_INFO_TIME_TX |
4199 SURVEY_INFO_TIME_SCAN;
4200 survey->time = mvm->accu_radio_stats.on_time_rf +
4201 mvm->radio_stats.on_time_rf;
4202 do_div(survey->time, USEC_PER_MSEC);
4203
4204 survey->time_rx = mvm->accu_radio_stats.rx_time +
4205 mvm->radio_stats.rx_time;
4206 do_div(survey->time_rx, USEC_PER_MSEC);
4207
4208 survey->time_tx = mvm->accu_radio_stats.tx_time +
4209 mvm->radio_stats.tx_time;
4210 do_div(survey->time_tx, USEC_PER_MSEC);
4211
4212 survey->time_scan = mvm->accu_radio_stats.on_time_scan +
4213 mvm->radio_stats.on_time_scan;
4214 do_div(survey->time_scan, USEC_PER_MSEC);
4215
10a7c028 4216 ret = 0;
91a8bcde
JB		 4217 out:
4218 mutex_unlock(&mvm->mutex);
4219 return ret;
4220}
4221
33cef925
JB		 4222static void iwl_mvm_mac_sta_statistics(struct ieee80211_hw *hw,
4223 struct ieee80211_vif *vif,
4224 struct ieee80211_sta *sta,
4225 struct station_info *sinfo)
4226{
4227 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
4228 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
4229 struct iwl_mvm_sta *mvmsta = iwl_mvm_sta_from_mac80211(sta);
4230
859d914c
JB		 4231 if (fw_has_capa(&mvm->fw->ucode_capa,
4232 IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
33cef925
JB		 4233 return;
4234
4235 /* if beacon filtering isn't on mac80211 does it anyway */
4236 if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER))
4237 return;
4238
4239 if (!vif->bss_conf.assoc)
4240 return;
4241
4242 mutex_lock(&mvm->mutex);
4243
4244 if (mvmvif->ap_sta_id != mvmsta->sta_id)
4245 goto unlock;
4246
4247 if (iwl_mvm_request_statistics(mvm, false))
4248 goto unlock;
4249
4250 sinfo->rx_beacon = mvmvif->beacon_stats.num_beacons +
4251 mvmvif->beacon_stats.accu_num_beacons;
4252 sinfo->filled |= BIT(NL80211_STA_INFO_BEACON_RX);
4253 if (mvmvif->beacon_stats.avg_signal) {
4254 /* firmware only reports a value after RXing a few beacons */
4255 sinfo->rx_beacon_signal_avg = mvmvif->beacon_stats.avg_signal;
4256 sinfo->filled |= BIT(NL80211_STA_INFO_BEACON_SIGNAL_AVG);
4257 }
4258 unlock:
4259 mutex_unlock(&mvm->mutex);
4260}
4261
4203263d
EG		 4262static void iwl_mvm_event_mlme_callback(struct iwl_mvm *mvm,
4263 struct ieee80211_vif *vif,
4264 const struct ieee80211_event *event)
d42f5350 4265{
5d4f929e 4266#define CHECK_MLME_TRIGGER(_mvm, _trig, _buf, _cnt, _fmt...) \
d42f5350
EG		 4267 do { \
4268 if ((_cnt) && --(_cnt)) \
4269 break; \
5d4f929e 4270 iwl_mvm_fw_dbg_collect_trig(_mvm, _trig, _fmt);\
d42f5350
EG		 4271 } while (0)
4272
d42f5350
EG		 4273 struct iwl_fw_dbg_trigger_tlv *trig;
4274 struct iwl_fw_dbg_trigger_mlme *trig_mlme;
d42f5350
EG		 4275
4276 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_MLME))
4277 return;
4278
d42f5350
EG		 4279 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_MLME);
4280 trig_mlme = (void *)trig->data;
4281 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
4282 return;
4283
d42f5350
EG		 4284 if (event->u.mlme.data == ASSOC_EVENT) {
4285 if (event->u.mlme.status == MLME_DENIED)
4286 CHECK_MLME_TRIGGER(mvm, trig, buf,
4287 trig_mlme->stop_assoc_denied,
4288 "DENIED ASSOC: reason %d",
4289 event->u.mlme.reason);
4290 else if (event->u.mlme.status == MLME_TIMEOUT)
4291 CHECK_MLME_TRIGGER(mvm, trig, buf,
4292 trig_mlme->stop_assoc_timeout,
4293 "ASSOC TIMEOUT");
4294 } else if (event->u.mlme.data == AUTH_EVENT) {
4295 if (event->u.mlme.status == MLME_DENIED)
4296 CHECK_MLME_TRIGGER(mvm, trig, buf,
4297 trig_mlme->stop_auth_denied,
4298 "DENIED AUTH: reason %d",
4299 event->u.mlme.reason);
4300 else if (event->u.mlme.status == MLME_TIMEOUT)
4301 CHECK_MLME_TRIGGER(mvm, trig, buf,
4302 trig_mlme->stop_auth_timeout,
4303 "AUTH TIMEOUT");
4304 } else if (event->u.mlme.data == DEAUTH_RX_EVENT) {
4305 CHECK_MLME_TRIGGER(mvm, trig, buf,
4306 trig_mlme->stop_rx_deauth,
4307 "DEAUTH RX %d", event->u.mlme.reason);
4308 } else if (event->u.mlme.data == DEAUTH_TX_EVENT) {
4309 CHECK_MLME_TRIGGER(mvm, trig, buf,
4310 trig_mlme->stop_tx_deauth,
4311 "DEAUTH TX %d", event->u.mlme.reason);
4312 }
4313#undef CHECK_MLME_TRIGGER
4314}
4315
4203263d
EG		 4316static void iwl_mvm_event_bar_rx_callback(struct iwl_mvm *mvm,
4317 struct ieee80211_vif *vif,
4318 const struct ieee80211_event *event)
4319{
4320 struct iwl_fw_dbg_trigger_tlv *trig;
4321 struct iwl_fw_dbg_trigger_ba *ba_trig;
4322
4323 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_BA))
4324 return;
4325
4326 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_BA);
4327 ba_trig = (void *)trig->data;
4328 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
4329 return;
4330
4331 if (!(le16_to_cpu(ba_trig->rx_bar) & BIT(event->u.ba.tid)))
4332 return;
4333
4334 iwl_mvm_fw_dbg_collect_trig(mvm, trig,
4335 "BAR received from %pM, tid %d, ssn %d",
4336 event->u.ba.sta->addr, event->u.ba.tid,
4337 event->u.ba.ssn);
4338}
4339
4340static void
4341iwl_mvm_event_frame_timeout_callback(struct iwl_mvm *mvm,
4342 struct ieee80211_vif *vif,
4343 const struct ieee80211_event *event)
4344{
4345 struct iwl_fw_dbg_trigger_tlv *trig;
4346 struct iwl_fw_dbg_trigger_ba *ba_trig;
4347
4348 if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_BA))
4349 return;
4350
4351 trig = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_BA);
4352 ba_trig = (void *)trig->data;
4353 if (!iwl_fw_dbg_trigger_check_stop(mvm, vif, trig))
4354 return;
4355
4356 if (!(le16_to_cpu(ba_trig->frame_timeout) & BIT(event->u.ba.tid)))
4357 return;
4358
4359 iwl_mvm_fw_dbg_collect_trig(mvm, trig,
4360 "Frame from %pM timed out, tid %d",
4361 event->u.ba.sta->addr, event->u.ba.tid);
4362}
4363
4364static void iwl_mvm_mac_event_callback(struct ieee80211_hw *hw,
4365 struct ieee80211_vif *vif,
4366 const struct ieee80211_event *event)
4367{
4368 struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
4369
4370 switch (event->type) {
4371 case MLME_EVENT:
4372 iwl_mvm_event_mlme_callback(mvm, vif, event);
4373 break;
4374 case BAR_RX_EVENT:
4375 iwl_mvm_event_bar_rx_callback(mvm, vif, event);
4376 break;
4377 case BA_FRAME_TIMEOUT:
4378 iwl_mvm_event_frame_timeout_callback(mvm, vif, event);
4379 break;
4380 default:
4381 break;
4382 }
4383}
4384
e5209263 4385const struct ieee80211_ops iwl_mvm_hw_ops = {
8ca151b5
JB		 4386 .tx = iwl_mvm_mac_tx,
4387 .ampdu_action = iwl_mvm_mac_ampdu_action,
4388 .start = iwl_mvm_mac_start,
cf2c92d8 4389 .reconfig_complete = iwl_mvm_mac_reconfig_complete,
8ca151b5
JB		 4390 .stop = iwl_mvm_mac_stop,
4391 .add_interface = iwl_mvm_mac_add_interface,
4392 .remove_interface = iwl_mvm_mac_remove_interface,
4393 .config = iwl_mvm_mac_config,
e59647ea 4394 .prepare_multicast = iwl_mvm_prepare_multicast,
8ca151b5 4395 .configure_filter = iwl_mvm_configure_filter,
effd1929 4396 .config_iface_filter = iwl_mvm_config_iface_filter,
8ca151b5
JB		 4397 .bss_info_changed = iwl_mvm_bss_info_changed,
4398 .hw_scan = iwl_mvm_mac_hw_scan,
4399 .cancel_hw_scan = iwl_mvm_mac_cancel_hw_scan,
1ddbbb0c 4400 .sta_pre_rcu_remove = iwl_mvm_sta_pre_rcu_remove,
8ca151b5
JB		 4401 .sta_state = iwl_mvm_mac_sta_state,
4402 .sta_notify = iwl_mvm_mac_sta_notify,
4403 .allow_buffered_frames = iwl_mvm_mac_allow_buffered_frames,
3e56eadf 4404 .release_buffered_frames = iwl_mvm_mac_release_buffered_frames,
8ca151b5 4405 .set_rts_threshold = iwl_mvm_mac_set_rts_threshold,
1f3b0ff8 4406 .sta_rc_update = iwl_mvm_sta_rc_update,
8ca151b5
JB		 4407 .conf_tx = iwl_mvm_mac_conf_tx,
4408 .mgd_prepare_tx = iwl_mvm_mac_mgd_prepare_tx,
07ecd897 4409 .mgd_protect_tdls_discover = iwl_mvm_mac_mgd_protect_tdls_discover,
c5b0e7c0 4410 .flush = iwl_mvm_mac_flush,
35a000b7
DS		 4411 .sched_scan_start = iwl_mvm_mac_sched_scan_start,
4412 .sched_scan_stop = iwl_mvm_mac_sched_scan_stop,
8ca151b5
JB		 4413 .set_key = iwl_mvm_mac_set_key,
4414 .update_tkip_key = iwl_mvm_mac_update_tkip_key,
4415 .remain_on_channel = iwl_mvm_roc,
4416 .cancel_remain_on_channel = iwl_mvm_cancel_roc,
8ca151b5
JB		 4417 .add_chanctx = iwl_mvm_add_chanctx,
4418 .remove_chanctx = iwl_mvm_remove_chanctx,
4419 .change_chanctx = iwl_mvm_change_chanctx,
4420 .assign_vif_chanctx = iwl_mvm_assign_vif_chanctx,
4421 .unassign_vif_chanctx = iwl_mvm_unassign_vif_chanctx,
b08c1d97 4422 .switch_vif_chanctx = iwl_mvm_switch_vif_chanctx,
8ca151b5 4423
5023d966
JB		 4424 .start_ap = iwl_mvm_start_ap_ibss,
4425 .stop_ap = iwl_mvm_stop_ap_ibss,
4426 .join_ibss = iwl_mvm_start_ap_ibss,
4427 .leave_ibss = iwl_mvm_stop_ap_ibss,
8ca151b5
JB		 4428
4429 .set_tim = iwl_mvm_set_tim,
4430
622e3f9b 4431 .channel_switch = iwl_mvm_channel_switch,
f028905c 4432 .pre_channel_switch = iwl_mvm_pre_channel_switch,
f6c34820 4433 .post_channel_switch = iwl_mvm_post_channel_switch,
bd3398e2 4434
1d3c3f63
AN		 4435 .tdls_channel_switch = iwl_mvm_tdls_channel_switch,
4436 .tdls_cancel_channel_switch = iwl_mvm_tdls_cancel_channel_switch,
4437 .tdls_recv_channel_switch = iwl_mvm_tdls_recv_channel_switch,
4438
d42f5350
EG		 4439 .event_callback = iwl_mvm_mac_event_callback,
4440
507cadf2
DS		 4441 CFG80211_TESTMODE_CMD(iwl_mvm_mac_testmode_cmd)
4442
8ca151b5
JB		 4443#ifdef CONFIG_PM_SLEEP
4444 /* look at d3.c */
4445 .suspend = iwl_mvm_suspend,
4446 .resume = iwl_mvm_resume,
4447 .set_wakeup = iwl_mvm_set_wakeup,
4448 .set_rekey_data = iwl_mvm_set_rekey_data,
4449#if IS_ENABLED(CONFIG_IPV6)
4450 .ipv6_addr_change = iwl_mvm_ipv6_addr_change,
4451#endif
4452 .set_default_unicast_key = iwl_mvm_set_default_unicast_key,
4453#endif
91a8bcde 4454 .get_survey = iwl_mvm_mac_get_survey,
33cef925 4455 .sta_statistics = iwl_mvm_mac_sta_statistics,
8ca151b5 4456};
Linux kernel - Deliverables
This page took 0.598031 seconds and 5 git commands to generate.