1 /******************************************************************************
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.
8 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
9 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
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.
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.
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,
25 * The full GNU General Public License is included in this distribution
26 * in the file called COPYING.
28 * Contact Information:
29 * Intel Linux Wireless <ilw@linux.intel.com>
30 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
34 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
35 * Copyright(c) 2013 - 2014 Intel Mobile Communications GmbH
36 * All rights reserved.
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
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
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.
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.
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>
71 #include <linux/if_arp.h>
72 #include <linux/devcoredump.h>
73 #include <net/mac80211.h>
74 #include <net/ieee80211_radiotap.h>
77 #include "iwl-op-mode.h"
81 #include "time-event.h"
82 #include "iwl-eeprom-parse.h"
83 #include "fw-api-scan.h"
84 #include "iwl-phy-db.h"
86 #include "iwl-fw-error-dump.h"
89 #include "iwl-nvm-parse.h"
91 static const struct ieee80211_iface_limit iwl_mvm_limits
[] = {
94 .types
= BIT(NL80211_IFTYPE_STATION
),
98 .types
= BIT(NL80211_IFTYPE_AP
) |
99 BIT(NL80211_IFTYPE_P2P_CLIENT
) |
100 BIT(NL80211_IFTYPE_P2P_GO
),
104 .types
= BIT(NL80211_IFTYPE_P2P_DEVICE
),
108 static const struct ieee80211_iface_combination iwl_mvm_iface_combinations
[] = {
110 .num_different_channels
= 2,
112 .limits
= iwl_mvm_limits
,
113 .n_limits
= ARRAY_SIZE(iwl_mvm_limits
),
117 #ifdef CONFIG_PM_SLEEP
118 static const struct nl80211_wowlan_tcp_data_token_feature
119 iwl_mvm_wowlan_tcp_token_feature
= {
122 .bufsize
= IWL_WOWLAN_REMOTE_WAKE_MAX_TOKENS
,
125 static const struct wiphy_wowlan_tcp_support iwl_mvm_wowlan_tcp_support
= {
126 .tok
= &iwl_mvm_wowlan_tcp_token_feature
,
127 .data_payload_max
= IWL_WOWLAN_TCP_MAX_PACKET_LEN
-
128 sizeof(struct ethhdr
) -
129 sizeof(struct iphdr
) -
130 sizeof(struct tcphdr
),
131 .data_interval_max
= 65535, /* __le16 in API */
132 .wake_payload_max
= IWL_WOWLAN_REMOTE_WAKE_MAX_PACKET_LEN
-
133 sizeof(struct ethhdr
) -
134 sizeof(struct iphdr
) -
135 sizeof(struct tcphdr
),
140 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING
142 * Use the reserved field to indicate magic values.
143 * these values will only be used internally by the driver,
144 * and won't make it to the fw (reserved will be 0).
145 * BC_FILTER_MAGIC_IP - configure the val of this attribute to
146 * be the vif's ip address. in case there is not a single
147 * ip address (0, or more than 1), this attribute will
149 * BC_FILTER_MAGIC_MAC - set the val of this attribute to
150 * the LSB bytes of the vif's mac address
153 BC_FILTER_MAGIC_NONE
= 0,
158 static const struct iwl_fw_bcast_filter iwl_mvm_default_bcast_filters
[] = {
162 .frame_type
= BCAST_FILTER_FRAME_TYPE_ALL
,
165 /* frame type - arp, hw type - ethernet */
167 BCAST_FILTER_OFFSET_PAYLOAD_START
,
168 .offset
= sizeof(rfc1042_header
),
169 .val
= cpu_to_be32(0x08060001),
170 .mask
= cpu_to_be32(0xffffffff),
175 BCAST_FILTER_OFFSET_PAYLOAD_START
,
176 .offset
= sizeof(rfc1042_header
) + 2 +
177 sizeof(struct arphdr
) +
178 ETH_ALEN
+ sizeof(__be32
) +
180 .mask
= cpu_to_be32(0xffffffff),
181 /* mark it as special field */
182 .reserved1
= cpu_to_le16(BC_FILTER_MAGIC_IP
),
187 /* dhcp offer bcast */
189 .frame_type
= BCAST_FILTER_FRAME_TYPE_IPV4
,
192 /* udp dest port - 68 (bootp client)*/
193 .offset_type
= BCAST_FILTER_OFFSET_IP_END
,
194 .offset
= offsetof(struct udphdr
, dest
),
195 .val
= cpu_to_be32(0x00440000),
196 .mask
= cpu_to_be32(0xffff0000),
199 /* dhcp - lsb bytes of client hw address */
200 .offset_type
= BCAST_FILTER_OFFSET_IP_END
,
202 .mask
= cpu_to_be32(0xffffffff),
203 /* mark it as special field */
204 .reserved1
= cpu_to_le16(BC_FILTER_MAGIC_MAC
),
208 /* last filter must be empty */
213 void iwl_mvm_ref(struct iwl_mvm
*mvm
, enum iwl_mvm_ref_type ref_type
)
215 if (!iwl_mvm_is_d0i3_supported(mvm
))
218 IWL_DEBUG_RPM(mvm
, "Take mvm reference - type %d\n", ref_type
);
219 spin_lock_bh(&mvm
->refs_lock
);
220 mvm
->refs
[ref_type
]++;
221 spin_unlock_bh(&mvm
->refs_lock
);
222 iwl_trans_ref(mvm
->trans
);
225 void iwl_mvm_unref(struct iwl_mvm
*mvm
, enum iwl_mvm_ref_type ref_type
)
227 if (!iwl_mvm_is_d0i3_supported(mvm
))
230 IWL_DEBUG_RPM(mvm
, "Leave mvm reference - type %d\n", ref_type
);
231 spin_lock_bh(&mvm
->refs_lock
);
232 WARN_ON(!mvm
->refs
[ref_type
]--);
233 spin_unlock_bh(&mvm
->refs_lock
);
234 iwl_trans_unref(mvm
->trans
);
237 static void iwl_mvm_unref_all_except(struct iwl_mvm
*mvm
,
238 enum iwl_mvm_ref_type except_ref
)
242 if (!iwl_mvm_is_d0i3_supported(mvm
))
245 spin_lock_bh(&mvm
->refs_lock
);
246 for (i
= 0; i
< IWL_MVM_REF_COUNT
; i
++) {
247 if (except_ref
== i
|| !mvm
->refs
[i
])
250 IWL_DEBUG_RPM(mvm
, "Cleanup: remove mvm ref type %d (%d)\n",
252 for (j
= 0; j
< mvm
->refs
[i
]; j
++)
253 iwl_trans_unref(mvm
->trans
);
256 spin_unlock_bh(&mvm
->refs_lock
);
259 bool iwl_mvm_ref_taken(struct iwl_mvm
*mvm
)
264 if (!iwl_mvm_is_d0i3_supported(mvm
))
267 spin_lock_bh(&mvm
->refs_lock
);
268 for (i
= 0; i
< IWL_MVM_REF_COUNT
; i
++) {
274 spin_unlock_bh(&mvm
->refs_lock
);
279 int iwl_mvm_ref_sync(struct iwl_mvm
*mvm
, enum iwl_mvm_ref_type ref_type
)
281 iwl_mvm_ref(mvm
, ref_type
);
283 if (!wait_event_timeout(mvm
->d0i3_exit_waitq
,
284 !test_bit(IWL_MVM_STATUS_IN_D0I3
, &mvm
->status
),
287 iwl_mvm_unref(mvm
, ref_type
);
294 static void iwl_mvm_reset_phy_ctxts(struct iwl_mvm
*mvm
)
298 memset(mvm
->phy_ctxts
, 0, sizeof(mvm
->phy_ctxts
));
299 for (i
= 0; i
< NUM_PHY_CTX
; i
++) {
300 mvm
->phy_ctxts
[i
].id
= i
;
301 mvm
->phy_ctxts
[i
].ref
= 0;
305 struct ieee80211_regdomain
*iwl_mvm_get_regdomain(struct wiphy
*wiphy
,
307 enum iwl_mcc_source src_id
,
310 struct ieee80211_regdomain
*regd
= NULL
;
311 struct ieee80211_hw
*hw
= wiphy_to_ieee80211_hw(wiphy
);
312 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
313 struct iwl_mcc_update_resp
*resp
;
315 IWL_DEBUG_LAR(mvm
, "Getting regdomain data for %s from FW\n", alpha2
);
317 lockdep_assert_held(&mvm
->mutex
);
319 resp
= iwl_mvm_update_mcc(mvm
, alpha2
, src_id
);
320 if (IS_ERR_OR_NULL(resp
)) {
321 IWL_DEBUG_LAR(mvm
, "Could not get update from FW %d\n",
327 *changed
= (resp
->status
== MCC_RESP_NEW_CHAN_PROFILE
);
329 regd
= iwl_parse_nvm_mcc_info(mvm
->trans
->dev
, mvm
->cfg
,
330 __le32_to_cpu(resp
->n_channels
),
332 __le16_to_cpu(resp
->mcc
));
333 /* Store the return source id */
334 src_id
= resp
->source_id
;
336 if (IS_ERR_OR_NULL(regd
)) {
337 IWL_DEBUG_LAR(mvm
, "Could not get parse update from FW %d\n",
342 IWL_DEBUG_LAR(mvm
, "setting alpha2 from FW to %s (0x%x, 0x%x) src=%d\n",
343 regd
->alpha2
, regd
->alpha2
[0], regd
->alpha2
[1], src_id
);
344 mvm
->lar_regdom_set
= true;
345 mvm
->mcc_src
= src_id
;
351 void iwl_mvm_update_changed_regdom(struct iwl_mvm
*mvm
)
354 struct ieee80211_regdomain
*regd
;
356 if (!iwl_mvm_is_lar_supported(mvm
))
359 regd
= iwl_mvm_get_current_regdomain(mvm
, &changed
);
360 if (!IS_ERR_OR_NULL(regd
)) {
361 /* only update the regulatory core if changed */
363 regulatory_set_wiphy_regd(mvm
->hw
->wiphy
, regd
);
369 struct ieee80211_regdomain
*iwl_mvm_get_current_regdomain(struct iwl_mvm
*mvm
,
372 return iwl_mvm_get_regdomain(mvm
->hw
->wiphy
, "ZZ",
373 iwl_mvm_is_wifi_mcc_supported(mvm
) ?
374 MCC_SOURCE_GET_CURRENT
:
375 MCC_SOURCE_OLD_FW
, changed
);
378 int iwl_mvm_init_fw_regd(struct iwl_mvm
*mvm
)
380 enum iwl_mcc_source used_src
;
381 struct ieee80211_regdomain
*regd
;
382 const struct ieee80211_regdomain
*r
=
383 rtnl_dereference(mvm
->hw
->wiphy
->regd
);
388 /* save the last source in case we overwrite it below */
389 used_src
= mvm
->mcc_src
;
390 if (iwl_mvm_is_wifi_mcc_supported(mvm
)) {
391 /* Notify the firmware we support wifi location updates */
392 regd
= iwl_mvm_get_current_regdomain(mvm
, NULL
);
393 if (!IS_ERR_OR_NULL(regd
))
397 /* Now set our last stored MCC and source */
398 regd
= iwl_mvm_get_regdomain(mvm
->hw
->wiphy
, r
->alpha2
, used_src
, NULL
);
399 if (IS_ERR_OR_NULL(regd
))
402 regulatory_set_wiphy_regd(mvm
->hw
->wiphy
, regd
);
408 int iwl_mvm_mac_setup_register(struct iwl_mvm
*mvm
)
410 struct ieee80211_hw
*hw
= mvm
->hw
;
413 /* Tell mac80211 our characteristics */
414 hw
->flags
= IEEE80211_HW_SIGNAL_DBM
|
415 IEEE80211_HW_SPECTRUM_MGMT
|
416 IEEE80211_HW_REPORTS_TX_ACK_STATUS
|
417 IEEE80211_HW_QUEUE_CONTROL
|
418 IEEE80211_HW_WANT_MONITOR_VIF
|
419 IEEE80211_HW_SUPPORTS_PS
|
420 IEEE80211_HW_SUPPORTS_DYNAMIC_PS
|
421 IEEE80211_HW_AMPDU_AGGREGATION
|
422 IEEE80211_HW_TIMING_BEACON_ONLY
|
423 IEEE80211_HW_CONNECTION_MONITOR
|
424 IEEE80211_HW_CHANCTX_STA_CSA
|
425 IEEE80211_HW_SUPPORTS_CLONED_SKBS
;
427 hw
->queues
= mvm
->first_agg_queue
;
428 hw
->offchannel_tx_hw_queue
= IWL_MVM_OFFCHANNEL_QUEUE
;
429 hw
->radiotap_mcs_details
|= IEEE80211_RADIOTAP_MCS_HAVE_FEC
|
430 IEEE80211_RADIOTAP_MCS_HAVE_STBC
;
431 hw
->radiotap_vht_details
|= IEEE80211_RADIOTAP_VHT_KNOWN_STBC
|
432 IEEE80211_RADIOTAP_VHT_KNOWN_BEAMFORMED
;
433 hw
->rate_control_algorithm
= "iwl-mvm-rs";
434 hw
->uapsd_queues
= IWL_MVM_UAPSD_QUEUES
;
435 hw
->uapsd_max_sp_len
= IWL_UAPSD_MAX_SP
;
438 * Enable 11w if advertised by firmware and software crypto
439 * is not enabled (as the firmware will interpret some mgmt
440 * packets, so enabling it with software crypto isn't safe)
442 if (mvm
->fw
->ucode_capa
.flags
& IWL_UCODE_TLV_FLAGS_MFP
&&
443 !iwlwifi_mod_params
.sw_crypto
)
444 hw
->flags
|= IEEE80211_HW_MFP_CAPABLE
;
446 hw
->flags
|= IEEE80211_SINGLE_HW_SCAN_ON_ALL_BANDS
;
447 hw
->wiphy
->features
|=
448 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR
|
449 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR
;
451 hw
->sta_data_size
= sizeof(struct iwl_mvm_sta
);
452 hw
->vif_data_size
= sizeof(struct iwl_mvm_vif
);
453 hw
->chanctx_data_size
= sizeof(u16
);
455 hw
->wiphy
->interface_modes
= BIT(NL80211_IFTYPE_STATION
) |
456 BIT(NL80211_IFTYPE_P2P_CLIENT
) |
457 BIT(NL80211_IFTYPE_AP
) |
458 BIT(NL80211_IFTYPE_P2P_GO
) |
459 BIT(NL80211_IFTYPE_P2P_DEVICE
) |
460 BIT(NL80211_IFTYPE_ADHOC
);
462 hw
->wiphy
->flags
|= WIPHY_FLAG_IBSS_RSN
;
463 hw
->wiphy
->regulatory_flags
|= REGULATORY_ENABLE_RELAX_NO_IR
;
464 if (iwl_mvm_is_lar_supported(mvm
))
465 hw
->wiphy
->regulatory_flags
|= REGULATORY_WIPHY_SELF_MANAGED
;
467 hw
->wiphy
->regulatory_flags
|= REGULATORY_CUSTOM_REG
|
468 REGULATORY_DISABLE_BEACON_HINTS
;
470 if (mvm
->fw
->ucode_capa
.flags
& IWL_UCODE_TLV_FLAGS_GO_UAPSD
)
471 hw
->wiphy
->flags
|= WIPHY_FLAG_AP_UAPSD
;
473 hw
->wiphy
->flags
|= WIPHY_FLAG_HAS_CHANNEL_SWITCH
;
475 hw
->wiphy
->iface_combinations
= iwl_mvm_iface_combinations
;
476 hw
->wiphy
->n_iface_combinations
=
477 ARRAY_SIZE(iwl_mvm_iface_combinations
);
479 hw
->wiphy
->max_remain_on_channel_duration
= 10000;
480 hw
->max_listen_interval
= IWL_CONN_MAX_LISTEN_INTERVAL
;
481 /* we can compensate an offset of up to 3 channels = 15 MHz */
482 hw
->wiphy
->max_adj_channel_rssi_comp
= 3 * 5;
484 /* Extract MAC address */
485 memcpy(mvm
->addresses
[0].addr
, mvm
->nvm_data
->hw_addr
, ETH_ALEN
);
486 hw
->wiphy
->addresses
= mvm
->addresses
;
487 hw
->wiphy
->n_addresses
= 1;
489 /* Extract additional MAC addresses if available */
490 num_mac
= (mvm
->nvm_data
->n_hw_addrs
> 1) ?
491 min(IWL_MVM_MAX_ADDRESSES
, mvm
->nvm_data
->n_hw_addrs
) : 1;
493 for (i
= 1; i
< num_mac
; i
++) {
494 memcpy(mvm
->addresses
[i
].addr
, mvm
->addresses
[i
-1].addr
,
496 mvm
->addresses
[i
].addr
[5]++;
497 hw
->wiphy
->n_addresses
++;
500 iwl_mvm_reset_phy_ctxts(mvm
);
502 hw
->wiphy
->max_scan_ie_len
= iwl_mvm_max_scan_ie_len(mvm
, false);
504 hw
->wiphy
->max_scan_ssids
= PROBE_OPTION_MAX
;
506 if (mvm
->nvm_data
->bands
[IEEE80211_BAND_2GHZ
].n_channels
)
507 hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] =
508 &mvm
->nvm_data
->bands
[IEEE80211_BAND_2GHZ
];
509 if (mvm
->nvm_data
->bands
[IEEE80211_BAND_5GHZ
].n_channels
) {
510 hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] =
511 &mvm
->nvm_data
->bands
[IEEE80211_BAND_5GHZ
];
513 if (mvm
->fw
->ucode_capa
.capa
[0] & IWL_UCODE_TLV_CAPA_BEAMFORMER
)
514 hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
]->vht_cap
.cap
|=
515 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE
;
518 hw
->wiphy
->hw_version
= mvm
->trans
->hw_id
;
520 if (iwlmvm_mod_params
.power_scheme
!= IWL_POWER_SCHEME_CAM
)
521 hw
->wiphy
->flags
|= WIPHY_FLAG_PS_ON_BY_DEFAULT
;
523 hw
->wiphy
->flags
&= ~WIPHY_FLAG_PS_ON_BY_DEFAULT
;
525 if (IWL_UCODE_API(mvm
->fw
->ucode_ver
) >= 10) {
526 hw
->wiphy
->flags
|= WIPHY_FLAG_SUPPORTS_SCHED_SCAN
;
527 hw
->wiphy
->max_sched_scan_ssids
= PROBE_OPTION_MAX
;
528 hw
->wiphy
->max_match_sets
= IWL_SCAN_MAX_PROFILES
;
529 /* we create the 802.11 header and zero length SSID IE. */
530 hw
->wiphy
->max_sched_scan_ie_len
=
531 SCAN_OFFLOAD_PROBE_REQ_SIZE
- 24 - 2;
534 hw
->wiphy
->features
|= NL80211_FEATURE_P2P_GO_CTWIN
|
535 NL80211_FEATURE_LOW_PRIORITY_SCAN
|
536 NL80211_FEATURE_P2P_GO_OPPPS
|
537 NL80211_FEATURE_DYNAMIC_SMPS
|
538 NL80211_FEATURE_STATIC_SMPS
|
539 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION
;
541 if (mvm
->fw
->ucode_capa
.capa
[0] &
542 IWL_UCODE_TLV_CAPA_TXPOWER_INSERTION_SUPPORT
)
543 hw
->wiphy
->features
|= NL80211_FEATURE_TX_POWER_INSERTION
;
544 if (mvm
->fw
->ucode_capa
.capa
[0] &
545 IWL_UCODE_TLV_CAPA_QUIET_PERIOD_SUPPORT
)
546 hw
->wiphy
->features
|= NL80211_FEATURE_QUIET
;
548 if (mvm
->fw
->ucode_capa
.capa
[0] &
549 IWL_UCODE_TLV_CAPA_DS_PARAM_SET_IE_SUPPORT
)
550 hw
->wiphy
->features
|=
551 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES
;
553 if (mvm
->fw
->ucode_capa
.capa
[0] &
554 IWL_UCODE_TLV_CAPA_WFA_TPC_REP_IE_SUPPORT
)
555 hw
->wiphy
->features
|= NL80211_FEATURE_WFA_TPC_IE_IN_PROBES
;
557 mvm
->rts_threshold
= IEEE80211_MAX_RTS_THRESHOLD
;
559 /* currently FW API supports only one optional cipher scheme */
560 if (mvm
->fw
->cs
[0].cipher
) {
561 mvm
->hw
->n_cipher_schemes
= 1;
562 mvm
->hw
->cipher_schemes
= &mvm
->fw
->cs
[0];
565 #ifdef CONFIG_PM_SLEEP
566 if (iwl_mvm_is_d0i3_supported(mvm
) &&
567 device_can_wakeup(mvm
->trans
->dev
)) {
568 mvm
->wowlan
.flags
= WIPHY_WOWLAN_ANY
;
569 hw
->wiphy
->wowlan
= &mvm
->wowlan
;
572 if (mvm
->fw
->img
[IWL_UCODE_WOWLAN
].sec
[0].len
&&
573 mvm
->trans
->ops
->d3_suspend
&&
574 mvm
->trans
->ops
->d3_resume
&&
575 device_can_wakeup(mvm
->trans
->dev
)) {
576 mvm
->wowlan
.flags
|= WIPHY_WOWLAN_MAGIC_PKT
|
577 WIPHY_WOWLAN_DISCONNECT
|
578 WIPHY_WOWLAN_EAP_IDENTITY_REQ
|
579 WIPHY_WOWLAN_RFKILL_RELEASE
|
580 WIPHY_WOWLAN_NET_DETECT
;
581 if (!iwlwifi_mod_params
.sw_crypto
)
582 mvm
->wowlan
.flags
|= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY
|
583 WIPHY_WOWLAN_GTK_REKEY_FAILURE
|
584 WIPHY_WOWLAN_4WAY_HANDSHAKE
;
586 mvm
->wowlan
.n_patterns
= IWL_WOWLAN_MAX_PATTERNS
;
587 mvm
->wowlan
.pattern_min_len
= IWL_WOWLAN_MIN_PATTERN_LEN
;
588 mvm
->wowlan
.pattern_max_len
= IWL_WOWLAN_MAX_PATTERN_LEN
;
589 mvm
->wowlan
.max_nd_match_sets
= IWL_SCAN_MAX_PROFILES
;
590 mvm
->wowlan
.tcp
= &iwl_mvm_wowlan_tcp_support
;
591 hw
->wiphy
->wowlan
= &mvm
->wowlan
;
595 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING
596 /* assign default bcast filtering configuration */
597 mvm
->bcast_filters
= iwl_mvm_default_bcast_filters
;
600 ret
= iwl_mvm_leds_init(mvm
);
604 if (mvm
->fw
->ucode_capa
.capa
[0] & IWL_UCODE_TLV_CAPA_TDLS_SUPPORT
) {
605 IWL_DEBUG_TDLS(mvm
, "TDLS supported\n");
606 hw
->wiphy
->flags
|= WIPHY_FLAG_SUPPORTS_TDLS
;
609 if (mvm
->fw
->ucode_capa
.capa
[0] &
610 IWL_UCODE_TLV_CAPA_TDLS_CHANNEL_SWITCH
) {
611 IWL_DEBUG_TDLS(mvm
, "TDLS channel switch supported\n");
612 hw
->wiphy
->features
|= NL80211_FEATURE_TDLS_CHANNEL_SWITCH
;
615 ret
= ieee80211_register_hw(mvm
->hw
);
617 iwl_mvm_leds_exit(mvm
);
622 static bool iwl_mvm_defer_tx(struct iwl_mvm
*mvm
,
623 struct ieee80211_sta
*sta
,
626 struct iwl_mvm_sta
*mvmsta
;
630 * double check the IN_D0I3 flag both before and after
631 * taking the spinlock, in order to prevent taking
632 * the spinlock when not needed.
634 if (likely(!test_bit(IWL_MVM_STATUS_IN_D0I3
, &mvm
->status
)))
637 spin_lock(&mvm
->d0i3_tx_lock
);
639 * testing the flag again ensures the skb dequeue
640 * loop (on d0i3 exit) hasn't run yet.
642 if (!test_bit(IWL_MVM_STATUS_IN_D0I3
, &mvm
->status
))
645 mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
646 if (mvmsta
->sta_id
== IWL_MVM_STATION_COUNT
||
647 mvmsta
->sta_id
!= mvm
->d0i3_ap_sta_id
)
650 __skb_queue_tail(&mvm
->d0i3_tx
, skb
);
651 ieee80211_stop_queues(mvm
->hw
);
654 iwl_mvm_ref(mvm
, IWL_MVM_REF_TX
);
655 iwl_mvm_unref(mvm
, IWL_MVM_REF_TX
);
659 spin_unlock(&mvm
->d0i3_tx_lock
);
663 static void iwl_mvm_mac_tx(struct ieee80211_hw
*hw
,
664 struct ieee80211_tx_control
*control
,
667 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
668 struct ieee80211_sta
*sta
= control
->sta
;
669 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
670 struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
672 if (iwl_mvm_is_radio_killed(mvm
)) {
673 IWL_DEBUG_DROP(mvm
, "Dropping - RF/CT KILL\n");
677 if (IEEE80211_SKB_CB(skb
)->hw_queue
== IWL_MVM_OFFCHANNEL_QUEUE
&&
678 !test_bit(IWL_MVM_STATUS_ROC_RUNNING
, &mvm
->status
) &&
679 !test_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING
, &mvm
->status
))
682 /* treat non-bufferable MMPDUs as broadcast if sta is sleeping */
683 if (unlikely(info
->flags
& IEEE80211_TX_CTL_NO_PS_BUFFER
&&
684 ieee80211_is_mgmt(hdr
->frame_control
) &&
685 !ieee80211_is_deauth(hdr
->frame_control
) &&
686 !ieee80211_is_disassoc(hdr
->frame_control
) &&
687 !ieee80211_is_action(hdr
->frame_control
)))
691 if (iwl_mvm_defer_tx(mvm
, sta
, skb
))
693 if (iwl_mvm_tx_skb(mvm
, skb
, sta
))
698 if (iwl_mvm_tx_skb_non_sta(mvm
, skb
))
702 ieee80211_free_txskb(hw
, skb
);
705 static inline bool iwl_enable_rx_ampdu(const struct iwl_cfg
*cfg
)
707 if (iwlwifi_mod_params
.disable_11n
& IWL_DISABLE_HT_RXAGG
)
712 static inline bool iwl_enable_tx_ampdu(const struct iwl_cfg
*cfg
)
714 if (iwlwifi_mod_params
.disable_11n
& IWL_DISABLE_HT_TXAGG
)
716 if (iwlwifi_mod_params
.disable_11n
& IWL_ENABLE_HT_TXAGG
)
719 /* enabled by default */
723 static int iwl_mvm_mac_ampdu_action(struct ieee80211_hw
*hw
,
724 struct ieee80211_vif
*vif
,
725 enum ieee80211_ampdu_mlme_action action
,
726 struct ieee80211_sta
*sta
, u16 tid
,
727 u16
*ssn
, u8 buf_size
)
729 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
731 bool tx_agg_ref
= false;
733 IWL_DEBUG_HT(mvm
, "A-MPDU action on addr %pM tid %d: action %d\n",
734 sta
->addr
, tid
, action
);
736 if (!(mvm
->nvm_data
->sku_cap_11n_enable
))
739 /* return from D0i3 before starting a new Tx aggregation */
741 case IEEE80211_AMPDU_TX_START
:
742 case IEEE80211_AMPDU_TX_STOP_CONT
:
743 case IEEE80211_AMPDU_TX_STOP_FLUSH
:
744 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT
:
745 case IEEE80211_AMPDU_TX_OPERATIONAL
:
747 * for tx start, wait synchronously until D0i3 exit to
748 * get the correct sequence number for the tid.
749 * additionally, some other ampdu actions use direct
750 * target access, which is not handled automatically
751 * by the trans layer (unlike commands), so wait for
752 * d0i3 exit in these cases as well.
754 ret
= iwl_mvm_ref_sync(mvm
, IWL_MVM_REF_TX_AGG
);
764 mutex_lock(&mvm
->mutex
);
767 case IEEE80211_AMPDU_RX_START
:
768 if (!iwl_enable_rx_ampdu(mvm
->cfg
)) {
772 ret
= iwl_mvm_sta_rx_agg(mvm
, sta
, tid
, *ssn
, true);
774 case IEEE80211_AMPDU_RX_STOP
:
775 ret
= iwl_mvm_sta_rx_agg(mvm
, sta
, tid
, 0, false);
777 case IEEE80211_AMPDU_TX_START
:
778 if (!iwl_enable_tx_ampdu(mvm
->cfg
)) {
782 ret
= iwl_mvm_sta_tx_agg_start(mvm
, vif
, sta
, tid
, ssn
);
784 case IEEE80211_AMPDU_TX_STOP_CONT
:
785 ret
= iwl_mvm_sta_tx_agg_stop(mvm
, vif
, sta
, tid
);
787 case IEEE80211_AMPDU_TX_STOP_FLUSH
:
788 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT
:
789 ret
= iwl_mvm_sta_tx_agg_flush(mvm
, vif
, sta
, tid
);
791 case IEEE80211_AMPDU_TX_OPERATIONAL
:
792 ret
= iwl_mvm_sta_tx_agg_oper(mvm
, vif
, sta
, tid
, buf_size
);
799 mutex_unlock(&mvm
->mutex
);
802 * If the tid is marked as started, we won't use it for offloaded
803 * traffic on the next D0i3 entry. It's safe to unref.
806 iwl_mvm_unref(mvm
, IWL_MVM_REF_TX_AGG
);
811 static void iwl_mvm_cleanup_iterator(void *data
, u8
*mac
,
812 struct ieee80211_vif
*vif
)
814 struct iwl_mvm
*mvm
= data
;
815 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
817 mvmvif
->uploaded
= false;
818 mvmvif
->ap_sta_id
= IWL_MVM_STATION_COUNT
;
820 spin_lock_bh(&mvm
->time_event_lock
);
821 iwl_mvm_te_clear_data(mvm
, &mvmvif
->time_event_data
);
822 spin_unlock_bh(&mvm
->time_event_lock
);
824 mvmvif
->phy_ctxt
= NULL
;
825 memset(&mvmvif
->bf_data
, 0, sizeof(mvmvif
->bf_data
));
828 static ssize_t
iwl_mvm_read_coredump(char *buffer
, loff_t offset
, size_t count
,
829 const void *data
, size_t datalen
)
831 const struct iwl_mvm_dump_ptrs
*dump_ptrs
= data
;
833 ssize_t bytes_read_trans
;
835 if (offset
< dump_ptrs
->op_mode_len
) {
836 bytes_read
= min_t(ssize_t
, count
,
837 dump_ptrs
->op_mode_len
- offset
);
838 memcpy(buffer
, (u8
*)dump_ptrs
->op_mode_ptr
+ offset
,
840 offset
+= bytes_read
;
849 if (!dump_ptrs
->trans_ptr
)
852 offset
-= dump_ptrs
->op_mode_len
;
853 bytes_read_trans
= min_t(ssize_t
, count
,
854 dump_ptrs
->trans_ptr
->len
- offset
);
855 memcpy(buffer
+ bytes_read
,
856 (u8
*)dump_ptrs
->trans_ptr
->data
+ offset
,
859 return bytes_read
+ bytes_read_trans
;
862 static void iwl_mvm_free_coredump(const void *data
)
864 const struct iwl_mvm_dump_ptrs
*fw_error_dump
= data
;
866 vfree(fw_error_dump
->op_mode_ptr
);
867 vfree(fw_error_dump
->trans_ptr
);
868 kfree(fw_error_dump
);
871 static void iwl_mvm_dump_fifos(struct iwl_mvm
*mvm
,
872 struct iwl_fw_error_dump_data
**dump_data
)
874 struct iwl_fw_error_dump_fifo
*fifo_hdr
;
880 if (!iwl_trans_grab_nic_access(mvm
->trans
, false, &flags
))
883 /* Pull RXF data from all RXFs */
884 for (i
= 0; i
< ARRAY_SIZE(mvm
->shared_mem_cfg
.rxfifo_size
); i
++) {
886 * Keep aside the additional offset that might be needed for
889 u32 offset_diff
= RXF_DIFF_FROM_PREV
* i
;
891 fifo_hdr
= (void *)(*dump_data
)->data
;
892 fifo_data
= (void *)fifo_hdr
->data
;
893 fifo_len
= mvm
->shared_mem_cfg
.rxfifo_size
[i
];
895 /* No need to try to read the data if the length is 0 */
899 /* Add a TLV for the RXF */
900 (*dump_data
)->type
= cpu_to_le32(IWL_FW_ERROR_DUMP_RXF
);
901 (*dump_data
)->len
= cpu_to_le32(fifo_len
+ sizeof(*fifo_hdr
));
903 fifo_hdr
->fifo_num
= cpu_to_le32(i
);
904 fifo_hdr
->available_bytes
=
905 cpu_to_le32(iwl_trans_read_prph(mvm
->trans
,
909 cpu_to_le32(iwl_trans_read_prph(mvm
->trans
,
913 cpu_to_le32(iwl_trans_read_prph(mvm
->trans
,
916 fifo_hdr
->fence_ptr
=
917 cpu_to_le32(iwl_trans_read_prph(mvm
->trans
,
920 fifo_hdr
->fence_mode
=
921 cpu_to_le32(iwl_trans_read_prph(mvm
->trans
,
926 iwl_trans_write_prph(mvm
->trans
,
927 RXF_SET_FENCE_MODE
+ offset_diff
, 0x1);
928 /* Set fence pointer to the same place like WR pointer */
929 iwl_trans_write_prph(mvm
->trans
,
930 RXF_LD_WR2FENCE
+ offset_diff
, 0x1);
931 /* Set fence offset */
932 iwl_trans_write_prph(mvm
->trans
,
933 RXF_LD_FENCE_OFFSET_ADDR
+ offset_diff
,
937 fifo_len
/= sizeof(u32
); /* Size in DWORDS */
938 for (j
= 0; j
< fifo_len
; j
++)
939 fifo_data
[j
] = iwl_trans_read_prph(mvm
->trans
,
940 RXF_FIFO_RD_FENCE_INC
+
942 *dump_data
= iwl_fw_error_next_data(*dump_data
);
945 /* Pull TXF data from all TXFs */
946 for (i
= 0; i
< ARRAY_SIZE(mvm
->shared_mem_cfg
.txfifo_size
); i
++) {
947 /* Mark the number of TXF we're pulling now */
948 iwl_trans_write_prph(mvm
->trans
, TXF_LARC_NUM
, i
);
950 fifo_hdr
= (void *)(*dump_data
)->data
;
951 fifo_data
= (void *)fifo_hdr
->data
;
952 fifo_len
= mvm
->shared_mem_cfg
.txfifo_size
[i
];
954 /* No need to try to read the data if the length is 0 */
958 /* Add a TLV for the FIFO */
959 (*dump_data
)->type
= cpu_to_le32(IWL_FW_ERROR_DUMP_TXF
);
960 (*dump_data
)->len
= cpu_to_le32(fifo_len
+ sizeof(*fifo_hdr
));
962 fifo_hdr
->fifo_num
= cpu_to_le32(i
);
963 fifo_hdr
->available_bytes
=
964 cpu_to_le32(iwl_trans_read_prph(mvm
->trans
,
967 cpu_to_le32(iwl_trans_read_prph(mvm
->trans
,
970 cpu_to_le32(iwl_trans_read_prph(mvm
->trans
,
972 fifo_hdr
->fence_ptr
=
973 cpu_to_le32(iwl_trans_read_prph(mvm
->trans
,
975 fifo_hdr
->fence_mode
=
976 cpu_to_le32(iwl_trans_read_prph(mvm
->trans
,
979 /* Set the TXF_READ_MODIFY_ADDR to TXF_WR_PTR */
980 iwl_trans_write_prph(mvm
->trans
, TXF_READ_MODIFY_ADDR
,
983 /* Dummy-read to advance the read pointer to the head */
984 iwl_trans_read_prph(mvm
->trans
, TXF_READ_MODIFY_DATA
);
987 fifo_len
/= sizeof(u32
); /* Size in DWORDS */
988 for (j
= 0; j
< fifo_len
; j
++)
989 fifo_data
[j
] = iwl_trans_read_prph(mvm
->trans
,
990 TXF_READ_MODIFY_DATA
);
991 *dump_data
= iwl_fw_error_next_data(*dump_data
);
994 iwl_trans_release_nic_access(mvm
->trans
, &flags
);
997 void iwl_mvm_free_fw_dump_desc(struct iwl_mvm
*mvm
)
999 if (mvm
->fw_dump_desc
== &iwl_mvm_dump_desc_assert
||
1003 kfree(mvm
->fw_dump_desc
);
1004 mvm
->fw_dump_desc
= NULL
;
1007 void iwl_mvm_fw_error_dump(struct iwl_mvm
*mvm
)
1009 struct iwl_fw_error_dump_file
*dump_file
;
1010 struct iwl_fw_error_dump_data
*dump_data
;
1011 struct iwl_fw_error_dump_info
*dump_info
;
1012 struct iwl_fw_error_dump_mem
*dump_mem
;
1013 struct iwl_fw_error_dump_trigger_desc
*dump_trig
;
1014 struct iwl_mvm_dump_ptrs
*fw_error_dump
;
1015 u32 sram_len
, sram_ofs
;
1016 u32 file_len
, fifo_data_len
= 0;
1017 u32 smem_len
= mvm
->cfg
->smem_len
;
1018 u32 sram2_len
= mvm
->cfg
->dccm2_len
;
1020 lockdep_assert_held(&mvm
->mutex
);
1022 /* W/A for 8000 HW family A-step */
1023 if (mvm
->cfg
->device_family
== IWL_DEVICE_FAMILY_8000
&&
1024 CSR_HW_REV_STEP(mvm
->trans
->hw_rev
) == SILICON_A_STEP
) {
1029 sram2_len
= 0x10000;
1032 fw_error_dump
= kzalloc(sizeof(*fw_error_dump
), GFP_KERNEL
);
1036 /* SRAM - include stack CCM if driver knows the values for it */
1037 if (!mvm
->cfg
->dccm_offset
|| !mvm
->cfg
->dccm_len
) {
1038 const struct fw_img
*img
;
1040 img
= &mvm
->fw
->img
[mvm
->cur_ucode
];
1041 sram_ofs
= img
->sec
[IWL_UCODE_SECTION_DATA
].offset
;
1042 sram_len
= img
->sec
[IWL_UCODE_SECTION_DATA
].len
;
1044 sram_ofs
= mvm
->cfg
->dccm_offset
;
1045 sram_len
= mvm
->cfg
->dccm_len
;
1048 /* reading RXF/TXF sizes */
1049 if (test_bit(STATUS_FW_ERROR
, &mvm
->trans
->status
)) {
1050 struct iwl_mvm_shared_mem_cfg
*mem_cfg
= &mvm
->shared_mem_cfg
;
1055 /* Count RXF size */
1056 for (i
= 0; i
< ARRAY_SIZE(mem_cfg
->rxfifo_size
); i
++) {
1057 if (!mem_cfg
->rxfifo_size
[i
])
1060 /* Add header info */
1061 fifo_data_len
+= mem_cfg
->rxfifo_size
[i
] +
1062 sizeof(*dump_data
) +
1063 sizeof(struct iwl_fw_error_dump_fifo
);
1066 for (i
= 0; i
< ARRAY_SIZE(mem_cfg
->txfifo_size
); i
++) {
1067 if (!mem_cfg
->txfifo_size
[i
])
1070 /* Add header info */
1071 fifo_data_len
+= mem_cfg
->txfifo_size
[i
] +
1072 sizeof(*dump_data
) +
1073 sizeof(struct iwl_fw_error_dump_fifo
);
1077 file_len
= sizeof(*dump_file
) +
1078 sizeof(*dump_data
) * 2 +
1079 sram_len
+ sizeof(*dump_mem
) +
1083 if (mvm
->fw_dump_desc
)
1084 file_len
+= sizeof(*dump_data
) + sizeof(*dump_trig
) +
1085 mvm
->fw_dump_desc
->len
;
1087 /* Make room for the SMEM, if it exists */
1089 file_len
+= sizeof(*dump_data
) + sizeof(*dump_mem
) + smem_len
;
1091 /* Make room for the secondary SRAM, if it exists */
1093 file_len
+= sizeof(*dump_data
) + sizeof(*dump_mem
) + sram2_len
;
1095 dump_file
= vzalloc(file_len
);
1097 kfree(fw_error_dump
);
1098 iwl_mvm_free_fw_dump_desc(mvm
);
1102 fw_error_dump
->op_mode_ptr
= dump_file
;
1104 dump_file
->barker
= cpu_to_le32(IWL_FW_ERROR_DUMP_BARKER
);
1105 dump_data
= (void *)dump_file
->data
;
1107 dump_data
->type
= cpu_to_le32(IWL_FW_ERROR_DUMP_DEV_FW_INFO
);
1108 dump_data
->len
= cpu_to_le32(sizeof(*dump_info
));
1109 dump_info
= (void *) dump_data
->data
;
1110 dump_info
->device_family
=
1111 mvm
->cfg
->device_family
== IWL_DEVICE_FAMILY_7000
?
1112 cpu_to_le32(IWL_FW_ERROR_DUMP_FAMILY_7
) :
1113 cpu_to_le32(IWL_FW_ERROR_DUMP_FAMILY_8
);
1114 dump_info
->hw_step
= cpu_to_le32(CSR_HW_REV_STEP(mvm
->trans
->hw_rev
));
1115 memcpy(dump_info
->fw_human_readable
, mvm
->fw
->human_readable
,
1116 sizeof(dump_info
->fw_human_readable
));
1117 strncpy(dump_info
->dev_human_readable
, mvm
->cfg
->name
,
1118 sizeof(dump_info
->dev_human_readable
));
1119 strncpy(dump_info
->bus_human_readable
, mvm
->dev
->bus
->name
,
1120 sizeof(dump_info
->bus_human_readable
));
1122 dump_data
= iwl_fw_error_next_data(dump_data
);
1123 /* We only dump the FIFOs if the FW is in error state */
1124 if (test_bit(STATUS_FW_ERROR
, &mvm
->trans
->status
))
1125 iwl_mvm_dump_fifos(mvm
, &dump_data
);
1127 if (mvm
->fw_dump_desc
) {
1128 dump_data
->type
= cpu_to_le32(IWL_FW_ERROR_DUMP_ERROR_INFO
);
1129 dump_data
->len
= cpu_to_le32(sizeof(*dump_trig
) +
1130 mvm
->fw_dump_desc
->len
);
1131 dump_trig
= (void *)dump_data
->data
;
1132 memcpy(dump_trig
, &mvm
->fw_dump_desc
->trig_desc
,
1133 sizeof(*dump_trig
) + mvm
->fw_dump_desc
->len
);
1135 /* now we can free this copy */
1136 iwl_mvm_free_fw_dump_desc(mvm
);
1137 dump_data
= iwl_fw_error_next_data(dump_data
);
1140 dump_data
->type
= cpu_to_le32(IWL_FW_ERROR_DUMP_MEM
);
1141 dump_data
->len
= cpu_to_le32(sram_len
+ sizeof(*dump_mem
));
1142 dump_mem
= (void *)dump_data
->data
;
1143 dump_mem
->type
= cpu_to_le32(IWL_FW_ERROR_DUMP_MEM_SRAM
);
1144 dump_mem
->offset
= cpu_to_le32(sram_ofs
);
1145 iwl_trans_read_mem_bytes(mvm
->trans
, sram_ofs
, dump_mem
->data
,
1149 dump_data
= iwl_fw_error_next_data(dump_data
);
1150 dump_data
->type
= cpu_to_le32(IWL_FW_ERROR_DUMP_MEM
);
1151 dump_data
->len
= cpu_to_le32(smem_len
+ sizeof(*dump_mem
));
1152 dump_mem
= (void *)dump_data
->data
;
1153 dump_mem
->type
= cpu_to_le32(IWL_FW_ERROR_DUMP_MEM_SMEM
);
1154 dump_mem
->offset
= cpu_to_le32(mvm
->cfg
->smem_offset
);
1155 iwl_trans_read_mem_bytes(mvm
->trans
, mvm
->cfg
->smem_offset
,
1156 dump_mem
->data
, smem_len
);
1160 dump_data
= iwl_fw_error_next_data(dump_data
);
1161 dump_data
->type
= cpu_to_le32(IWL_FW_ERROR_DUMP_MEM
);
1162 dump_data
->len
= cpu_to_le32(sram2_len
+ sizeof(*dump_mem
));
1163 dump_mem
= (void *)dump_data
->data
;
1164 dump_mem
->type
= cpu_to_le32(IWL_FW_ERROR_DUMP_MEM_SRAM
);
1165 dump_mem
->offset
= cpu_to_le32(mvm
->cfg
->dccm2_offset
);
1166 iwl_trans_read_mem_bytes(mvm
->trans
, mvm
->cfg
->dccm2_offset
,
1167 dump_mem
->data
, sram2_len
);
1170 fw_error_dump
->trans_ptr
= iwl_trans_dump_data(mvm
->trans
);
1171 fw_error_dump
->op_mode_len
= file_len
;
1172 if (fw_error_dump
->trans_ptr
)
1173 file_len
+= fw_error_dump
->trans_ptr
->len
;
1174 dump_file
->file_len
= cpu_to_le32(file_len
);
1176 dev_coredumpm(mvm
->trans
->dev
, THIS_MODULE
, fw_error_dump
, 0,
1177 GFP_KERNEL
, iwl_mvm_read_coredump
, iwl_mvm_free_coredump
);
1179 clear_bit(IWL_MVM_STATUS_DUMPING_FW_LOG
, &mvm
->status
);
1182 struct iwl_mvm_dump_desc iwl_mvm_dump_desc_assert
= {
1184 .type
= cpu_to_le32(FW_DBG_TRIGGER_FW_ASSERT
),
1188 static void iwl_mvm_restart_cleanup(struct iwl_mvm
*mvm
)
1190 /* clear the D3 reconfig, we only need it to avoid dumping a
1191 * firmware coredump on reconfiguration, we shouldn't do that
1192 * on D3->D0 transition
1194 if (!test_and_clear_bit(IWL_MVM_STATUS_D3_RECONFIG
, &mvm
->status
)) {
1195 mvm
->fw_dump_desc
= &iwl_mvm_dump_desc_assert
;
1196 iwl_mvm_fw_error_dump(mvm
);
1199 /* cleanup all stale references (scan, roc), but keep the
1200 * ucode_down ref until reconfig is complete
1202 iwl_mvm_unref_all_except(mvm
, IWL_MVM_REF_UCODE_DOWN
);
1204 iwl_trans_stop_device(mvm
->trans
);
1206 mvm
->scan_status
= IWL_MVM_SCAN_NONE
;
1207 mvm
->ps_disabled
= false;
1208 mvm
->calibrating
= false;
1210 /* just in case one was running */
1211 ieee80211_remain_on_channel_expired(mvm
->hw
);
1213 ieee80211_iterate_active_interfaces_atomic(
1214 mvm
->hw
, IEEE80211_IFACE_ITER_RESUME_ALL
,
1215 iwl_mvm_cleanup_iterator
, mvm
);
1217 mvm
->p2p_device_vif
= NULL
;
1218 mvm
->d0i3_ap_sta_id
= IWL_MVM_STATION_COUNT
;
1220 iwl_mvm_reset_phy_ctxts(mvm
);
1221 memset(mvm
->fw_key_table
, 0, sizeof(mvm
->fw_key_table
));
1222 memset(mvm
->sta_drained
, 0, sizeof(mvm
->sta_drained
));
1223 memset(mvm
->tfd_drained
, 0, sizeof(mvm
->tfd_drained
));
1224 memset(&mvm
->last_bt_notif
, 0, sizeof(mvm
->last_bt_notif
));
1225 memset(&mvm
->last_bt_notif_old
, 0, sizeof(mvm
->last_bt_notif_old
));
1226 memset(&mvm
->last_bt_ci_cmd
, 0, sizeof(mvm
->last_bt_ci_cmd
));
1227 memset(&mvm
->last_bt_ci_cmd_old
, 0, sizeof(mvm
->last_bt_ci_cmd_old
));
1228 memset(&mvm
->bt_ack_kill_msk
, 0, sizeof(mvm
->bt_ack_kill_msk
));
1229 memset(&mvm
->bt_cts_kill_msk
, 0, sizeof(mvm
->bt_cts_kill_msk
));
1231 ieee80211_wake_queues(mvm
->hw
);
1233 /* clear any stale d0i3 state */
1234 clear_bit(IWL_MVM_STATUS_IN_D0I3
, &mvm
->status
);
1237 mvm
->rx_ba_sessions
= 0;
1238 mvm
->fw_dbg_conf
= FW_DBG_INVALID
;
1240 /* keep statistics ticking */
1241 iwl_mvm_accu_radio_stats(mvm
);
1244 int __iwl_mvm_mac_start(struct iwl_mvm
*mvm
)
1248 lockdep_assert_held(&mvm
->mutex
);
1250 /* Clean up some internal and mac80211 state on restart */
1251 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART
, &mvm
->status
))
1252 iwl_mvm_restart_cleanup(mvm
);
1254 ret
= iwl_mvm_up(mvm
);
1256 if (ret
&& test_bit(IWL_MVM_STATUS_IN_HW_RESTART
, &mvm
->status
)) {
1257 /* Something went wrong - we need to finish some cleanup
1258 * that normally iwl_mvm_mac_restart_complete() below
1261 clear_bit(IWL_MVM_STATUS_IN_HW_RESTART
, &mvm
->status
);
1262 iwl_mvm_d0i3_enable_tx(mvm
, NULL
);
1268 static int iwl_mvm_mac_start(struct ieee80211_hw
*hw
)
1270 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
1273 /* Some hw restart cleanups must not hold the mutex */
1274 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART
, &mvm
->status
)) {
1276 * Make sure we are out of d0i3. This is needed
1277 * to make sure the reference accounting is correct
1278 * (and there is no stale d0i3_exit_work).
1280 wait_event_timeout(mvm
->d0i3_exit_waitq
,
1281 !test_bit(IWL_MVM_STATUS_IN_D0I3
,
1286 mutex_lock(&mvm
->mutex
);
1287 ret
= __iwl_mvm_mac_start(mvm
);
1288 mutex_unlock(&mvm
->mutex
);
1293 static void iwl_mvm_restart_complete(struct iwl_mvm
*mvm
)
1297 mutex_lock(&mvm
->mutex
);
1299 clear_bit(IWL_MVM_STATUS_IN_HW_RESTART
, &mvm
->status
);
1300 iwl_mvm_d0i3_enable_tx(mvm
, NULL
);
1301 ret
= iwl_mvm_update_quotas(mvm
, false, NULL
);
1303 IWL_ERR(mvm
, "Failed to update quotas after restart (%d)\n",
1306 /* allow transport/FW low power modes */
1307 iwl_mvm_unref(mvm
, IWL_MVM_REF_UCODE_DOWN
);
1310 * If we have TDLS peers, remove them. We don't know the last seqno/PN
1311 * of packets the FW sent out, so we must reconnect.
1313 iwl_mvm_teardown_tdls_peers(mvm
);
1315 mutex_unlock(&mvm
->mutex
);
1318 static void iwl_mvm_resume_complete(struct iwl_mvm
*mvm
)
1322 if (!iwl_mvm_is_d0i3_supported(mvm
))
1325 mutex_lock(&mvm
->d0i3_suspend_mutex
);
1326 __clear_bit(D0I3_DEFER_WAKEUP
, &mvm
->d0i3_suspend_flags
);
1327 exit_now
= __test_and_clear_bit(D0I3_PENDING_WAKEUP
,
1328 &mvm
->d0i3_suspend_flags
);
1329 mutex_unlock(&mvm
->d0i3_suspend_mutex
);
1332 IWL_DEBUG_RPM(mvm
, "Run deferred d0i3 exit\n");
1333 _iwl_mvm_exit_d0i3(mvm
);
1336 if (mvm
->trans
->d0i3_mode
== IWL_D0I3_MODE_ON_SUSPEND
)
1337 if (!wait_event_timeout(mvm
->d0i3_exit_waitq
,
1338 !test_bit(IWL_MVM_STATUS_IN_D0I3
,
1341 WARN_ONCE(1, "D0i3 exit on resume timed out\n");
1345 iwl_mvm_mac_reconfig_complete(struct ieee80211_hw
*hw
,
1346 enum ieee80211_reconfig_type reconfig_type
)
1348 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
1350 switch (reconfig_type
) {
1351 case IEEE80211_RECONFIG_TYPE_RESTART
:
1352 iwl_mvm_restart_complete(mvm
);
1354 case IEEE80211_RECONFIG_TYPE_SUSPEND
:
1355 iwl_mvm_resume_complete(mvm
);
1360 void __iwl_mvm_mac_stop(struct iwl_mvm
*mvm
)
1362 lockdep_assert_held(&mvm
->mutex
);
1364 /* firmware counters are obviously reset now, but we shouldn't
1365 * partially track so also clear the fw_reset_accu counters.
1367 memset(&mvm
->accu_radio_stats
, 0, sizeof(mvm
->accu_radio_stats
));
1370 * Disallow low power states when the FW is down by taking
1371 * the UCODE_DOWN ref. in case of ongoing hw restart the
1372 * ref is already taken, so don't take it again.
1374 if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART
, &mvm
->status
))
1375 iwl_mvm_ref(mvm
, IWL_MVM_REF_UCODE_DOWN
);
1377 /* async_handlers_wk is now blocked */
1380 * The work item could be running or queued if the
1381 * ROC time event stops just as we get here.
1383 cancel_work_sync(&mvm
->roc_done_wk
);
1385 iwl_trans_stop_device(mvm
->trans
);
1387 iwl_mvm_async_handlers_purge(mvm
);
1388 /* async_handlers_list is empty and will stay empty: HW is stopped */
1390 /* the fw is stopped, the aux sta is dead: clean up driver state */
1391 iwl_mvm_del_aux_sta(mvm
);
1394 * Clear IN_HW_RESTART flag when stopping the hw (as restart_complete()
1395 * won't be called in this case).
1397 clear_bit(IWL_MVM_STATUS_IN_HW_RESTART
, &mvm
->status
);
1399 mvm
->ucode_loaded
= false;
1402 static void iwl_mvm_mac_stop(struct ieee80211_hw
*hw
)
1404 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
1406 flush_work(&mvm
->d0i3_exit_work
);
1407 flush_work(&mvm
->async_handlers_wk
);
1408 cancel_delayed_work_sync(&mvm
->fw_dump_wk
);
1409 iwl_mvm_free_fw_dump_desc(mvm
);
1411 mutex_lock(&mvm
->mutex
);
1412 __iwl_mvm_mac_stop(mvm
);
1413 mutex_unlock(&mvm
->mutex
);
1416 * The worker might have been waiting for the mutex, let it run and
1417 * discover that its list is now empty.
1419 cancel_work_sync(&mvm
->async_handlers_wk
);
1422 static struct iwl_mvm_phy_ctxt
*iwl_mvm_get_free_phy_ctxt(struct iwl_mvm
*mvm
)
1426 lockdep_assert_held(&mvm
->mutex
);
1428 for (i
= 0; i
< NUM_PHY_CTX
; i
++)
1429 if (!mvm
->phy_ctxts
[i
].ref
)
1430 return &mvm
->phy_ctxts
[i
];
1432 IWL_ERR(mvm
, "No available PHY context\n");
1436 static int iwl_mvm_set_tx_power(struct iwl_mvm
*mvm
, struct ieee80211_vif
*vif
,
1439 /* FW is in charge of regulatory enforcement */
1440 struct iwl_reduce_tx_power_cmd reduce_txpwr_cmd
= {
1441 .mac_context_id
= iwl_mvm_vif_from_mac80211(vif
)->id
,
1442 .pwr_restriction
= cpu_to_le16(tx_power
),
1445 return iwl_mvm_send_cmd_pdu(mvm
, REDUCE_TX_POWER_CMD
, 0,
1446 sizeof(reduce_txpwr_cmd
),
1450 static int iwl_mvm_mac_add_interface(struct ieee80211_hw
*hw
,
1451 struct ieee80211_vif
*vif
)
1453 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
1454 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
1460 * make sure D0i3 exit is completed, otherwise a target access
1461 * during tx queue configuration could be done when still in
1464 ret
= iwl_mvm_ref_sync(mvm
, IWL_MVM_REF_ADD_IF
);
1469 * Not much to do here. The stack will not allow interface
1470 * types or combinations that we didn't advertise, so we
1471 * don't really have to check the types.
1474 mutex_lock(&mvm
->mutex
);
1476 /* make sure that beacon statistics don't go backwards with FW reset */
1477 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART
, &mvm
->status
))
1478 mvmvif
->beacon_stats
.accu_num_beacons
+=
1479 mvmvif
->beacon_stats
.num_beacons
;
1481 /* Allocate resources for the MAC context, and add it to the fw */
1482 ret
= iwl_mvm_mac_ctxt_init(mvm
, vif
);
1486 /* Counting number of interfaces is needed for legacy PM */
1487 if (vif
->type
!= NL80211_IFTYPE_P2P_DEVICE
)
1491 * The AP binding flow can be done only after the beacon
1492 * template is configured (which happens only in the mac80211
1493 * start_ap() flow), and adding the broadcast station can happen
1494 * only after the binding.
1495 * In addition, since modifying the MAC before adding a bcast
1496 * station is not allowed by the FW, delay the adding of MAC context to
1497 * the point where we can also add the bcast station.
1498 * In short: there's not much we can do at this point, other than
1499 * allocating resources :)
1501 if (vif
->type
== NL80211_IFTYPE_AP
||
1502 vif
->type
== NL80211_IFTYPE_ADHOC
) {
1503 ret
= iwl_mvm_alloc_bcast_sta(mvm
, vif
);
1505 IWL_ERR(mvm
, "Failed to allocate bcast sta\n");
1509 iwl_mvm_vif_dbgfs_register(mvm
, vif
);
1513 ret
= iwl_mvm_mac_ctxt_add(mvm
, vif
);
1517 ret
= iwl_mvm_power_update_mac(mvm
);
1519 goto out_remove_mac
;
1521 /* beacon filtering */
1522 ret
= iwl_mvm_disable_beacon_filter(mvm
, vif
, 0);
1524 goto out_remove_mac
;
1526 if (!mvm
->bf_allowed_vif
&&
1527 vif
->type
== NL80211_IFTYPE_STATION
&& !vif
->p2p
) {
1528 mvm
->bf_allowed_vif
= mvmvif
;
1529 vif
->driver_flags
|= IEEE80211_VIF_BEACON_FILTER
|
1530 IEEE80211_VIF_SUPPORTS_CQM_RSSI
;
1534 * P2P_DEVICE interface does not have a channel context assigned to it,
1535 * so a dedicated PHY context is allocated to it and the corresponding
1536 * MAC context is bound to it at this stage.
1538 if (vif
->type
== NL80211_IFTYPE_P2P_DEVICE
) {
1540 mvmvif
->phy_ctxt
= iwl_mvm_get_free_phy_ctxt(mvm
);
1541 if (!mvmvif
->phy_ctxt
) {
1546 iwl_mvm_phy_ctxt_ref(mvm
, mvmvif
->phy_ctxt
);
1547 ret
= iwl_mvm_binding_add_vif(mvm
, vif
);
1551 ret
= iwl_mvm_add_bcast_sta(mvm
, vif
);
1555 /* Save a pointer to p2p device vif, so it can later be used to
1556 * update the p2p device MAC when a GO is started/stopped */
1557 mvm
->p2p_device_vif
= vif
;
1560 iwl_mvm_vif_dbgfs_register(mvm
, vif
);
1564 iwl_mvm_binding_remove_vif(mvm
, vif
);
1566 iwl_mvm_phy_ctxt_unref(mvm
, mvmvif
->phy_ctxt
);
1568 if (mvm
->bf_allowed_vif
== mvmvif
) {
1569 mvm
->bf_allowed_vif
= NULL
;
1570 vif
->driver_flags
&= ~(IEEE80211_VIF_BEACON_FILTER
|
1571 IEEE80211_VIF_SUPPORTS_CQM_RSSI
);
1574 mvmvif
->phy_ctxt
= NULL
;
1575 iwl_mvm_mac_ctxt_remove(mvm
, vif
);
1577 if (vif
->type
!= NL80211_IFTYPE_P2P_DEVICE
)
1580 iwl_mvm_mac_ctxt_release(mvm
, vif
);
1582 mutex_unlock(&mvm
->mutex
);
1584 iwl_mvm_unref(mvm
, IWL_MVM_REF_ADD_IF
);
1589 static void iwl_mvm_prepare_mac_removal(struct iwl_mvm
*mvm
,
1590 struct ieee80211_vif
*vif
)
1592 u32 tfd_msk
= iwl_mvm_mac_get_queues_mask(vif
);
1595 mutex_lock(&mvm
->mutex
);
1596 iwl_mvm_flush_tx_path(mvm
, tfd_msk
, true);
1597 mutex_unlock(&mvm
->mutex
);
1600 if (vif
->type
== NL80211_IFTYPE_P2P_DEVICE
) {
1602 * Flush the ROC worker which will flush the OFFCHANNEL queue.
1603 * We assume here that all the packets sent to the OFFCHANNEL
1604 * queue are sent in ROC session.
1606 flush_work(&mvm
->roc_done_wk
);
1609 * By now, all the AC queues are empty. The AGG queues are
1610 * empty too. We already got all the Tx responses for all the
1611 * packets in the queues. The drain work can have been
1612 * triggered. Flush it.
1614 flush_work(&mvm
->sta_drained_wk
);
1618 static void iwl_mvm_mac_remove_interface(struct ieee80211_hw
*hw
,
1619 struct ieee80211_vif
*vif
)
1621 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
1622 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
1624 iwl_mvm_prepare_mac_removal(mvm
, vif
);
1626 mutex_lock(&mvm
->mutex
);
1628 if (mvm
->bf_allowed_vif
== mvmvif
) {
1629 mvm
->bf_allowed_vif
= NULL
;
1630 vif
->driver_flags
&= ~(IEEE80211_VIF_BEACON_FILTER
|
1631 IEEE80211_VIF_SUPPORTS_CQM_RSSI
);
1634 iwl_mvm_vif_dbgfs_clean(mvm
, vif
);
1637 * For AP/GO interface, the tear down of the resources allocated to the
1638 * interface is be handled as part of the stop_ap flow.
1640 if (vif
->type
== NL80211_IFTYPE_AP
||
1641 vif
->type
== NL80211_IFTYPE_ADHOC
) {
1642 #ifdef CONFIG_NL80211_TESTMODE
1643 if (vif
== mvm
->noa_vif
) {
1644 mvm
->noa_vif
= NULL
;
1645 mvm
->noa_duration
= 0;
1648 iwl_mvm_dealloc_bcast_sta(mvm
, vif
);
1652 if (vif
->type
== NL80211_IFTYPE_P2P_DEVICE
) {
1653 mvm
->p2p_device_vif
= NULL
;
1654 iwl_mvm_rm_bcast_sta(mvm
, vif
);
1655 iwl_mvm_binding_remove_vif(mvm
, vif
);
1656 iwl_mvm_phy_ctxt_unref(mvm
, mvmvif
->phy_ctxt
);
1657 mvmvif
->phy_ctxt
= NULL
;
1660 if (mvm
->vif_count
&& vif
->type
!= NL80211_IFTYPE_P2P_DEVICE
)
1663 iwl_mvm_power_update_mac(mvm
);
1664 iwl_mvm_mac_ctxt_remove(mvm
, vif
);
1667 iwl_mvm_mac_ctxt_release(mvm
, vif
);
1668 mutex_unlock(&mvm
->mutex
);
1671 static int iwl_mvm_mac_config(struct ieee80211_hw
*hw
, u32 changed
)
1676 struct iwl_mvm_mc_iter_data
{
1677 struct iwl_mvm
*mvm
;
1681 static void iwl_mvm_mc_iface_iterator(void *_data
, u8
*mac
,
1682 struct ieee80211_vif
*vif
)
1684 struct iwl_mvm_mc_iter_data
*data
= _data
;
1685 struct iwl_mvm
*mvm
= data
->mvm
;
1686 struct iwl_mcast_filter_cmd
*cmd
= mvm
->mcast_filter_cmd
;
1689 /* if we don't have free ports, mcast frames will be dropped */
1690 if (WARN_ON_ONCE(data
->port_id
>= MAX_PORT_ID_NUM
))
1693 if (vif
->type
!= NL80211_IFTYPE_STATION
||
1694 !vif
->bss_conf
.assoc
)
1697 cmd
->port_id
= data
->port_id
++;
1698 memcpy(cmd
->bssid
, vif
->bss_conf
.bssid
, ETH_ALEN
);
1699 len
= roundup(sizeof(*cmd
) + cmd
->count
* ETH_ALEN
, 4);
1701 ret
= iwl_mvm_send_cmd_pdu(mvm
, MCAST_FILTER_CMD
, CMD_ASYNC
, len
, cmd
);
1703 IWL_ERR(mvm
, "mcast filter cmd error. ret=%d\n", ret
);
1706 static void iwl_mvm_recalc_multicast(struct iwl_mvm
*mvm
)
1708 struct iwl_mvm_mc_iter_data iter_data
= {
1712 lockdep_assert_held(&mvm
->mutex
);
1714 if (WARN_ON_ONCE(!mvm
->mcast_filter_cmd
))
1717 ieee80211_iterate_active_interfaces_atomic(
1718 mvm
->hw
, IEEE80211_IFACE_ITER_NORMAL
,
1719 iwl_mvm_mc_iface_iterator
, &iter_data
);
1722 static u64
iwl_mvm_prepare_multicast(struct ieee80211_hw
*hw
,
1723 struct netdev_hw_addr_list
*mc_list
)
1725 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
1726 struct iwl_mcast_filter_cmd
*cmd
;
1727 struct netdev_hw_addr
*addr
;
1732 addr_count
= netdev_hw_addr_list_count(mc_list
);
1733 pass_all
= addr_count
> MAX_MCAST_FILTERING_ADDRESSES
||
1734 IWL_MVM_FW_MCAST_FILTER_PASS_ALL
;
1738 len
= roundup(sizeof(*cmd
) + addr_count
* ETH_ALEN
, 4);
1739 cmd
= kzalloc(len
, GFP_ATOMIC
);
1745 return (u64
)(unsigned long)cmd
;
1748 netdev_hw_addr_list_for_each(addr
, mc_list
) {
1749 IWL_DEBUG_MAC80211(mvm
, "mcast addr (%d): %pM\n",
1750 cmd
->count
, addr
->addr
);
1751 memcpy(&cmd
->addr_list
[cmd
->count
* ETH_ALEN
],
1752 addr
->addr
, ETH_ALEN
);
1756 return (u64
)(unsigned long)cmd
;
1759 static void iwl_mvm_configure_filter(struct ieee80211_hw
*hw
,
1760 unsigned int changed_flags
,
1761 unsigned int *total_flags
,
1764 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
1765 struct iwl_mcast_filter_cmd
*cmd
= (void *)(unsigned long)multicast
;
1767 mutex_lock(&mvm
->mutex
);
1769 /* replace previous configuration */
1770 kfree(mvm
->mcast_filter_cmd
);
1771 mvm
->mcast_filter_cmd
= cmd
;
1776 iwl_mvm_recalc_multicast(mvm
);
1778 mutex_unlock(&mvm
->mutex
);
1782 #ifdef CONFIG_IWLWIFI_BCAST_FILTERING
1783 struct iwl_bcast_iter_data
{
1784 struct iwl_mvm
*mvm
;
1785 struct iwl_bcast_filter_cmd
*cmd
;
1790 iwl_mvm_set_bcast_filter(struct ieee80211_vif
*vif
,
1791 const struct iwl_fw_bcast_filter
*in_filter
,
1792 struct iwl_fw_bcast_filter
*out_filter
)
1794 struct iwl_fw_bcast_filter_attr
*attr
;
1797 memcpy(out_filter
, in_filter
, sizeof(*out_filter
));
1799 for (i
= 0; i
< ARRAY_SIZE(out_filter
->attrs
); i
++) {
1800 attr
= &out_filter
->attrs
[i
];
1805 switch (attr
->reserved1
) {
1806 case cpu_to_le16(BC_FILTER_MAGIC_IP
):
1807 if (vif
->bss_conf
.arp_addr_cnt
!= 1) {
1812 attr
->val
= vif
->bss_conf
.arp_addr_list
[0];
1814 case cpu_to_le16(BC_FILTER_MAGIC_MAC
):
1815 attr
->val
= *(__be32
*)&vif
->addr
[2];
1820 attr
->reserved1
= 0;
1821 out_filter
->num_attrs
++;
1825 static void iwl_mvm_bcast_filter_iterator(void *_data
, u8
*mac
,
1826 struct ieee80211_vif
*vif
)
1828 struct iwl_bcast_iter_data
*data
= _data
;
1829 struct iwl_mvm
*mvm
= data
->mvm
;
1830 struct iwl_bcast_filter_cmd
*cmd
= data
->cmd
;
1831 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
1832 struct iwl_fw_bcast_mac
*bcast_mac
;
1835 if (WARN_ON(mvmvif
->id
>= ARRAY_SIZE(cmd
->macs
)))
1838 bcast_mac
= &cmd
->macs
[mvmvif
->id
];
1841 * enable filtering only for associated stations, but not for P2P
1844 if (vif
->type
!= NL80211_IFTYPE_STATION
|| vif
->p2p
||
1845 !vif
->bss_conf
.assoc
)
1848 bcast_mac
->default_discard
= 1;
1850 /* copy all configured filters */
1851 for (i
= 0; mvm
->bcast_filters
[i
].attrs
[0].mask
; i
++) {
1853 * Make sure we don't exceed our filters limit.
1854 * if there is still a valid filter to be configured,
1855 * be on the safe side and just allow bcast for this mac.
1857 if (WARN_ON_ONCE(data
->current_filter
>=
1858 ARRAY_SIZE(cmd
->filters
))) {
1859 bcast_mac
->default_discard
= 0;
1860 bcast_mac
->attached_filters
= 0;
1864 iwl_mvm_set_bcast_filter(vif
,
1865 &mvm
->bcast_filters
[i
],
1866 &cmd
->filters
[data
->current_filter
]);
1868 /* skip current filter if it contains no attributes */
1869 if (!cmd
->filters
[data
->current_filter
].num_attrs
)
1872 /* attach the filter to current mac */
1873 bcast_mac
->attached_filters
|=
1874 cpu_to_le16(BIT(data
->current_filter
));
1876 data
->current_filter
++;
1880 bool iwl_mvm_bcast_filter_build_cmd(struct iwl_mvm
*mvm
,
1881 struct iwl_bcast_filter_cmd
*cmd
)
1883 struct iwl_bcast_iter_data iter_data
= {
1888 if (IWL_MVM_FW_BCAST_FILTER_PASS_ALL
)
1891 memset(cmd
, 0, sizeof(*cmd
));
1892 cmd
->max_bcast_filters
= ARRAY_SIZE(cmd
->filters
);
1893 cmd
->max_macs
= ARRAY_SIZE(cmd
->macs
);
1895 #ifdef CONFIG_IWLWIFI_DEBUGFS
1896 /* use debugfs filters/macs if override is configured */
1897 if (mvm
->dbgfs_bcast_filtering
.override
) {
1898 memcpy(cmd
->filters
, &mvm
->dbgfs_bcast_filtering
.cmd
.filters
,
1899 sizeof(cmd
->filters
));
1900 memcpy(cmd
->macs
, &mvm
->dbgfs_bcast_filtering
.cmd
.macs
,
1906 /* if no filters are configured, do nothing */
1907 if (!mvm
->bcast_filters
)
1910 /* configure and attach these filters for each associated sta vif */
1911 ieee80211_iterate_active_interfaces(
1912 mvm
->hw
, IEEE80211_IFACE_ITER_NORMAL
,
1913 iwl_mvm_bcast_filter_iterator
, &iter_data
);
1917 static int iwl_mvm_configure_bcast_filter(struct iwl_mvm
*mvm
,
1918 struct ieee80211_vif
*vif
)
1920 struct iwl_bcast_filter_cmd cmd
;
1922 if (!(mvm
->fw
->ucode_capa
.flags
& IWL_UCODE_TLV_FLAGS_BCAST_FILTERING
))
1925 if (!iwl_mvm_bcast_filter_build_cmd(mvm
, &cmd
))
1928 return iwl_mvm_send_cmd_pdu(mvm
, BCAST_FILTER_CMD
, 0,
1932 static inline int iwl_mvm_configure_bcast_filter(struct iwl_mvm
*mvm
,
1933 struct ieee80211_vif
*vif
)
1939 static void iwl_mvm_bss_info_changed_station(struct iwl_mvm
*mvm
,
1940 struct ieee80211_vif
*vif
,
1941 struct ieee80211_bss_conf
*bss_conf
,
1944 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
1948 * Re-calculate the tsf id, as the master-slave relations depend on the
1949 * beacon interval, which was not known when the station interface was
1952 if (changes
& BSS_CHANGED_ASSOC
&& bss_conf
->assoc
)
1953 iwl_mvm_mac_ctxt_recalc_tsf_id(mvm
, vif
);
1956 * If we're not associated yet, take the (new) BSSID before associating
1957 * so the firmware knows. If we're already associated, then use the old
1958 * BSSID here, and we'll send a cleared one later in the CHANGED_ASSOC
1959 * branch for disassociation below.
1961 if (changes
& BSS_CHANGED_BSSID
&& !mvmvif
->associated
)
1962 memcpy(mvmvif
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
1964 ret
= iwl_mvm_mac_ctxt_changed(mvm
, vif
, false, mvmvif
->bssid
);
1966 IWL_ERR(mvm
, "failed to update MAC %pM\n", vif
->addr
);
1968 /* after sending it once, adopt mac80211 data */
1969 memcpy(mvmvif
->bssid
, bss_conf
->bssid
, ETH_ALEN
);
1970 mvmvif
->associated
= bss_conf
->assoc
;
1972 if (changes
& BSS_CHANGED_ASSOC
) {
1973 if (bss_conf
->assoc
) {
1974 /* clear statistics to get clean beacon counter */
1975 iwl_mvm_request_statistics(mvm
, true);
1976 memset(&mvmvif
->beacon_stats
, 0,
1977 sizeof(mvmvif
->beacon_stats
));
1979 /* add quota for this interface */
1980 ret
= iwl_mvm_update_quotas(mvm
, true, NULL
);
1982 IWL_ERR(mvm
, "failed to update quotas\n");
1986 if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART
,
1989 * If we're restarting then the firmware will
1990 * obviously have lost synchronisation with
1991 * the AP. It will attempt to synchronise by
1992 * itself, but we can make it more reliable by
1993 * scheduling a session protection time event.
1995 * The firmware needs to receive a beacon to
1996 * catch up with synchronisation, use 110% of
1997 * the beacon interval.
1999 * Set a large maximum delay to allow for more
2000 * than a single interface.
2002 u32 dur
= (11 * vif
->bss_conf
.beacon_int
) / 10;
2003 iwl_mvm_protect_session(mvm
, vif
, dur
, dur
,
2007 iwl_mvm_sf_update(mvm
, vif
, false);
2008 iwl_mvm_power_vif_assoc(mvm
, vif
);
2010 iwl_mvm_ref(mvm
, IWL_MVM_REF_P2P_CLIENT
);
2011 iwl_mvm_update_smps(mvm
, vif
,
2012 IWL_MVM_SMPS_REQ_PROT
,
2013 IEEE80211_SMPS_DYNAMIC
);
2015 } else if (mvmvif
->ap_sta_id
!= IWL_MVM_STATION_COUNT
) {
2017 * If update fails - SF might be running in associated
2018 * mode while disassociated - which is forbidden.
2020 WARN_ONCE(iwl_mvm_sf_update(mvm
, vif
, false),
2021 "Failed to update SF upon disassociation\n");
2023 /* remove AP station now that the MAC is unassoc */
2024 ret
= iwl_mvm_rm_sta_id(mvm
, vif
, mvmvif
->ap_sta_id
);
2026 IWL_ERR(mvm
, "failed to remove AP station\n");
2028 if (mvm
->d0i3_ap_sta_id
== mvmvif
->ap_sta_id
)
2029 mvm
->d0i3_ap_sta_id
= IWL_MVM_STATION_COUNT
;
2030 mvmvif
->ap_sta_id
= IWL_MVM_STATION_COUNT
;
2031 /* remove quota for this interface */
2032 ret
= iwl_mvm_update_quotas(mvm
, false, NULL
);
2034 IWL_ERR(mvm
, "failed to update quotas\n");
2037 iwl_mvm_unref(mvm
, IWL_MVM_REF_P2P_CLIENT
);
2039 /* this will take the cleared BSSID from bss_conf */
2040 ret
= iwl_mvm_mac_ctxt_changed(mvm
, vif
, false, NULL
);
2043 "failed to update MAC %pM (clear after unassoc)\n",
2047 iwl_mvm_recalc_multicast(mvm
);
2048 iwl_mvm_configure_bcast_filter(mvm
, vif
);
2050 /* reset rssi values */
2051 mvmvif
->bf_data
.ave_beacon_signal
= 0;
2053 iwl_mvm_bt_coex_vif_change(mvm
);
2054 iwl_mvm_update_smps(mvm
, vif
, IWL_MVM_SMPS_REQ_TT
,
2055 IEEE80211_SMPS_AUTOMATIC
);
2056 } else if (changes
& BSS_CHANGED_BEACON_INFO
) {
2058 * We received a beacon _after_ association so
2059 * remove the session protection.
2061 iwl_mvm_remove_time_event(mvm
, mvmvif
,
2062 &mvmvif
->time_event_data
);
2065 if (changes
& BSS_CHANGED_BEACON_INFO
) {
2066 iwl_mvm_sf_update(mvm
, vif
, false);
2067 WARN_ON(iwl_mvm_enable_beacon_filter(mvm
, vif
, 0));
2070 if (changes
& (BSS_CHANGED_PS
| BSS_CHANGED_P2P_PS
| BSS_CHANGED_QOS
)) {
2071 ret
= iwl_mvm_power_update_mac(mvm
);
2073 IWL_ERR(mvm
, "failed to update power mode\n");
2076 if (changes
& BSS_CHANGED_TXPOWER
) {
2077 IWL_DEBUG_CALIB(mvm
, "Changing TX Power to %d\n",
2079 iwl_mvm_set_tx_power(mvm
, vif
, bss_conf
->txpower
);
2082 if (changes
& BSS_CHANGED_CQM
) {
2083 IWL_DEBUG_MAC80211(mvm
, "cqm info_changed\n");
2084 /* reset cqm events tracking */
2085 mvmvif
->bf_data
.last_cqm_event
= 0;
2086 if (mvmvif
->bf_data
.bf_enabled
) {
2087 ret
= iwl_mvm_enable_beacon_filter(mvm
, vif
, 0);
2090 "failed to update CQM thresholds\n");
2094 if (changes
& BSS_CHANGED_ARP_FILTER
) {
2095 IWL_DEBUG_MAC80211(mvm
, "arp filter changed\n");
2096 iwl_mvm_configure_bcast_filter(mvm
, vif
);
2100 static int iwl_mvm_start_ap_ibss(struct ieee80211_hw
*hw
,
2101 struct ieee80211_vif
*vif
)
2103 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2104 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
2108 * iwl_mvm_mac_ctxt_add() might read directly from the device
2109 * (the system time), so make sure it is available.
2111 ret
= iwl_mvm_ref_sync(mvm
, IWL_MVM_REF_START_AP
);
2115 mutex_lock(&mvm
->mutex
);
2117 /* Send the beacon template */
2118 ret
= iwl_mvm_mac_ctxt_beacon_changed(mvm
, vif
);
2123 * Re-calculate the tsf id, as the master-slave relations depend on the
2124 * beacon interval, which was not known when the AP interface was added.
2126 if (vif
->type
== NL80211_IFTYPE_AP
)
2127 iwl_mvm_mac_ctxt_recalc_tsf_id(mvm
, vif
);
2129 /* Add the mac context */
2130 ret
= iwl_mvm_mac_ctxt_add(mvm
, vif
);
2134 /* Perform the binding */
2135 ret
= iwl_mvm_binding_add_vif(mvm
, vif
);
2139 /* Send the bcast station. At this stage the TBTT and DTIM time events
2140 * are added and applied to the scheduler */
2141 ret
= iwl_mvm_send_add_bcast_sta(mvm
, vif
);
2145 /* must be set before quota calculations */
2146 mvmvif
->ap_ibss_active
= true;
2148 /* power updated needs to be done before quotas */
2149 iwl_mvm_power_update_mac(mvm
);
2151 ret
= iwl_mvm_update_quotas(mvm
, false, NULL
);
2153 goto out_quota_failed
;
2155 /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
2156 if (vif
->p2p
&& mvm
->p2p_device_vif
)
2157 iwl_mvm_mac_ctxt_changed(mvm
, mvm
->p2p_device_vif
, false, NULL
);
2159 iwl_mvm_ref(mvm
, IWL_MVM_REF_AP_IBSS
);
2161 iwl_mvm_bt_coex_vif_change(mvm
);
2163 /* we don't support TDLS during DCM */
2164 if (iwl_mvm_phy_ctx_count(mvm
) > 1)
2165 iwl_mvm_teardown_tdls_peers(mvm
);
2167 mutex_unlock(&mvm
->mutex
);
2171 iwl_mvm_power_update_mac(mvm
);
2172 mvmvif
->ap_ibss_active
= false;
2173 iwl_mvm_send_rm_bcast_sta(mvm
, vif
);
2175 iwl_mvm_binding_remove_vif(mvm
, vif
);
2177 iwl_mvm_mac_ctxt_remove(mvm
, vif
);
2179 mutex_unlock(&mvm
->mutex
);
2180 iwl_mvm_unref(mvm
, IWL_MVM_REF_START_AP
);
2184 static void iwl_mvm_stop_ap_ibss(struct ieee80211_hw
*hw
,
2185 struct ieee80211_vif
*vif
)
2187 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2188 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
2190 iwl_mvm_prepare_mac_removal(mvm
, vif
);
2192 mutex_lock(&mvm
->mutex
);
2194 /* Handle AP stop while in CSA */
2195 if (rcu_access_pointer(mvm
->csa_vif
) == vif
) {
2196 iwl_mvm_remove_time_event(mvm
, mvmvif
,
2197 &mvmvif
->time_event_data
);
2198 RCU_INIT_POINTER(mvm
->csa_vif
, NULL
);
2201 if (rcu_access_pointer(mvm
->csa_tx_blocked_vif
) == vif
) {
2202 RCU_INIT_POINTER(mvm
->csa_tx_blocked_vif
, NULL
);
2203 mvm
->csa_tx_block_bcn_timeout
= 0;
2206 mvmvif
->ap_ibss_active
= false;
2207 mvm
->ap_last_beacon_gp2
= 0;
2209 iwl_mvm_bt_coex_vif_change(mvm
);
2211 iwl_mvm_unref(mvm
, IWL_MVM_REF_AP_IBSS
);
2213 /* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
2214 if (vif
->p2p
&& mvm
->p2p_device_vif
)
2215 iwl_mvm_mac_ctxt_changed(mvm
, mvm
->p2p_device_vif
, false, NULL
);
2217 iwl_mvm_update_quotas(mvm
, false, NULL
);
2218 iwl_mvm_send_rm_bcast_sta(mvm
, vif
);
2219 iwl_mvm_binding_remove_vif(mvm
, vif
);
2221 iwl_mvm_power_update_mac(mvm
);
2223 iwl_mvm_mac_ctxt_remove(mvm
, vif
);
2225 mutex_unlock(&mvm
->mutex
);
2229 iwl_mvm_bss_info_changed_ap_ibss(struct iwl_mvm
*mvm
,
2230 struct ieee80211_vif
*vif
,
2231 struct ieee80211_bss_conf
*bss_conf
,
2234 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
2236 /* Changes will be applied when the AP/IBSS is started */
2237 if (!mvmvif
->ap_ibss_active
)
2240 if (changes
& (BSS_CHANGED_ERP_CTS_PROT
| BSS_CHANGED_HT
|
2241 BSS_CHANGED_BANDWIDTH
| BSS_CHANGED_QOS
) &&
2242 iwl_mvm_mac_ctxt_changed(mvm
, vif
, false, NULL
))
2243 IWL_ERR(mvm
, "failed to update MAC %pM\n", vif
->addr
);
2245 /* Need to send a new beacon template to the FW */
2246 if (changes
& BSS_CHANGED_BEACON
&&
2247 iwl_mvm_mac_ctxt_beacon_changed(mvm
, vif
))
2248 IWL_WARN(mvm
, "Failed updating beacon data\n");
2250 if (changes
& BSS_CHANGED_TXPOWER
) {
2251 IWL_DEBUG_CALIB(mvm
, "Changing TX Power to %d\n",
2253 iwl_mvm_set_tx_power(mvm
, vif
, bss_conf
->txpower
);
2258 static void iwl_mvm_bss_info_changed(struct ieee80211_hw
*hw
,
2259 struct ieee80211_vif
*vif
,
2260 struct ieee80211_bss_conf
*bss_conf
,
2263 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2266 * iwl_mvm_bss_info_changed_station() might call
2267 * iwl_mvm_protect_session(), which reads directly from
2268 * the device (the system time), so make sure it is available.
2270 if (iwl_mvm_ref_sync(mvm
, IWL_MVM_REF_BSS_CHANGED
))
2273 mutex_lock(&mvm
->mutex
);
2275 if (changes
& BSS_CHANGED_IDLE
&& !bss_conf
->idle
)
2276 iwl_mvm_scan_offload_stop(mvm
, true);
2278 switch (vif
->type
) {
2279 case NL80211_IFTYPE_STATION
:
2280 iwl_mvm_bss_info_changed_station(mvm
, vif
, bss_conf
, changes
);
2282 case NL80211_IFTYPE_AP
:
2283 case NL80211_IFTYPE_ADHOC
:
2284 iwl_mvm_bss_info_changed_ap_ibss(mvm
, vif
, bss_conf
, changes
);
2287 /* shouldn't happen */
2291 mutex_unlock(&mvm
->mutex
);
2292 iwl_mvm_unref(mvm
, IWL_MVM_REF_BSS_CHANGED
);
2295 static int iwl_mvm_cancel_scan_wait_notif(struct iwl_mvm
*mvm
,
2296 enum iwl_scan_status scan_type
)
2299 bool wait_for_handlers
= false;
2301 mutex_lock(&mvm
->mutex
);
2303 if (mvm
->scan_status
!= scan_type
) {
2305 /* make sure there are no pending notifications */
2306 wait_for_handlers
= true;
2310 switch (scan_type
) {
2311 case IWL_MVM_SCAN_SCHED
:
2312 ret
= iwl_mvm_scan_offload_stop(mvm
, true);
2314 case IWL_MVM_SCAN_OS
:
2315 ret
= iwl_mvm_cancel_scan(mvm
);
2317 case IWL_MVM_SCAN_NONE
:
2326 wait_for_handlers
= true;
2328 mutex_unlock(&mvm
->mutex
);
2330 /* make sure we consume the completion notification */
2331 if (wait_for_handlers
)
2332 iwl_mvm_wait_for_async_handlers(mvm
);
2336 static int iwl_mvm_mac_hw_scan(struct ieee80211_hw
*hw
,
2337 struct ieee80211_vif
*vif
,
2338 struct ieee80211_scan_request
*hw_req
)
2340 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2341 struct cfg80211_scan_request
*req
= &hw_req
->req
;
2344 if (req
->n_channels
== 0 ||
2345 req
->n_channels
> mvm
->fw
->ucode_capa
.n_scan_channels
)
2348 if (!(mvm
->fw
->ucode_capa
.capa
[0] & IWL_UCODE_TLV_CAPA_UMAC_SCAN
)) {
2349 ret
= iwl_mvm_cancel_scan_wait_notif(mvm
, IWL_MVM_SCAN_SCHED
);
2354 mutex_lock(&mvm
->mutex
);
2356 if (iwl_mvm_is_lar_supported(mvm
) && !mvm
->lar_regdom_set
) {
2357 IWL_ERR(mvm
, "scan while LAR regdomain is not set\n");
2362 if (mvm
->scan_status
!= IWL_MVM_SCAN_NONE
) {
2367 iwl_mvm_ref(mvm
, IWL_MVM_REF_SCAN
);
2369 if (mvm
->fw
->ucode_capa
.capa
[0] & IWL_UCODE_TLV_CAPA_UMAC_SCAN
)
2370 ret
= iwl_mvm_scan_umac(mvm
, vif
, hw_req
);
2372 ret
= iwl_mvm_unified_scan_lmac(mvm
, vif
, hw_req
);
2375 iwl_mvm_unref(mvm
, IWL_MVM_REF_SCAN
);
2377 mutex_unlock(&mvm
->mutex
);
2381 static void iwl_mvm_mac_cancel_hw_scan(struct ieee80211_hw
*hw
,
2382 struct ieee80211_vif
*vif
)
2384 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2386 mutex_lock(&mvm
->mutex
);
2388 iwl_mvm_cancel_scan(mvm
);
2390 mutex_unlock(&mvm
->mutex
);
2394 iwl_mvm_mac_allow_buffered_frames(struct ieee80211_hw
*hw
,
2395 struct ieee80211_sta
*sta
, u16 tids
,
2397 enum ieee80211_frame_release_type reason
,
2400 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2402 /* Called when we need to transmit (a) frame(s) from mac80211 */
2404 iwl_mvm_sta_modify_sleep_tx_count(mvm
, sta
, reason
, num_frames
,
2405 tids
, more_data
, false);
2409 iwl_mvm_mac_release_buffered_frames(struct ieee80211_hw
*hw
,
2410 struct ieee80211_sta
*sta
, u16 tids
,
2412 enum ieee80211_frame_release_type reason
,
2415 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2417 /* Called when we need to transmit (a) frame(s) from agg queue */
2419 iwl_mvm_sta_modify_sleep_tx_count(mvm
, sta
, reason
, num_frames
,
2420 tids
, more_data
, true);
2423 static void iwl_mvm_mac_sta_notify(struct ieee80211_hw
*hw
,
2424 struct ieee80211_vif
*vif
,
2425 enum sta_notify_cmd cmd
,
2426 struct ieee80211_sta
*sta
)
2428 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2429 struct iwl_mvm_sta
*mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
2433 case STA_NOTIFY_SLEEP
:
2434 if (atomic_read(&mvm
->pending_frames
[mvmsta
->sta_id
]) > 0)
2435 ieee80211_sta_block_awake(hw
, sta
, true);
2436 spin_lock_bh(&mvmsta
->lock
);
2437 for (tid
= 0; tid
< IWL_MAX_TID_COUNT
; tid
++) {
2438 struct iwl_mvm_tid_data
*tid_data
;
2440 tid_data
= &mvmsta
->tid_data
[tid
];
2441 if (tid_data
->state
!= IWL_AGG_ON
&&
2442 tid_data
->state
!= IWL_EMPTYING_HW_QUEUE_DELBA
)
2444 if (iwl_mvm_tid_queued(tid_data
) == 0)
2446 ieee80211_sta_set_buffered(sta
, tid
, true);
2448 spin_unlock_bh(&mvmsta
->lock
);
2450 * The fw updates the STA to be asleep. Tx packets on the Tx
2451 * queues to this station will not be transmitted. The fw will
2452 * send a Tx response with TX_STATUS_FAIL_DEST_PS.
2455 case STA_NOTIFY_AWAKE
:
2456 if (WARN_ON(mvmsta
->sta_id
== IWL_MVM_STATION_COUNT
))
2458 iwl_mvm_sta_modify_ps_wake(mvm
, sta
);
2465 static void iwl_mvm_sta_pre_rcu_remove(struct ieee80211_hw
*hw
,
2466 struct ieee80211_vif
*vif
,
2467 struct ieee80211_sta
*sta
)
2469 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2470 struct iwl_mvm_sta
*mvm_sta
= iwl_mvm_sta_from_mac80211(sta
);
2473 * This is called before mac80211 does RCU synchronisation,
2474 * so here we already invalidate our internal RCU-protected
2475 * station pointer. The rest of the code will thus no longer
2476 * be able to find the station this way, and we don't rely
2477 * on further RCU synchronisation after the sta_state()
2478 * callback deleted the station.
2480 mutex_lock(&mvm
->mutex
);
2481 if (sta
== rcu_access_pointer(mvm
->fw_id_to_mac_id
[mvm_sta
->sta_id
]))
2482 rcu_assign_pointer(mvm
->fw_id_to_mac_id
[mvm_sta
->sta_id
],
2484 mutex_unlock(&mvm
->mutex
);
2487 static void iwl_mvm_check_uapsd(struct iwl_mvm
*mvm
, struct ieee80211_vif
*vif
,
2490 if (!(mvm
->fw
->ucode_capa
.flags
& IWL_UCODE_TLV_FLAGS_UAPSD_SUPPORT
))
2493 if (iwlwifi_mod_params
.uapsd_disable
) {
2494 vif
->driver_flags
&= ~IEEE80211_VIF_SUPPORTS_UAPSD
;
2498 vif
->driver_flags
|= IEEE80211_VIF_SUPPORTS_UAPSD
;
2501 static int iwl_mvm_mac_sta_state(struct ieee80211_hw
*hw
,
2502 struct ieee80211_vif
*vif
,
2503 struct ieee80211_sta
*sta
,
2504 enum ieee80211_sta_state old_state
,
2505 enum ieee80211_sta_state new_state
)
2507 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2508 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
2511 IWL_DEBUG_MAC80211(mvm
, "station %pM state change %d->%d\n",
2512 sta
->addr
, old_state
, new_state
);
2514 /* this would be a mac80211 bug ... but don't crash */
2515 if (WARN_ON_ONCE(!mvmvif
->phy_ctxt
))
2518 /* if a STA is being removed, reuse its ID */
2519 flush_work(&mvm
->sta_drained_wk
);
2521 mutex_lock(&mvm
->mutex
);
2522 if (old_state
== IEEE80211_STA_NOTEXIST
&&
2523 new_state
== IEEE80211_STA_NONE
) {
2525 * Firmware bug - it'll crash if the beacon interval is less
2526 * than 16. We can't avoid connecting at all, so refuse the
2527 * station state change, this will cause mac80211 to abandon
2528 * attempts to connect to this AP, and eventually wpa_s will
2529 * blacklist the AP...
2531 if (vif
->type
== NL80211_IFTYPE_STATION
&&
2532 vif
->bss_conf
.beacon_int
< 16) {
2534 "AP %pM beacon interval is %d, refusing due to firmware bug!\n",
2535 sta
->addr
, vif
->bss_conf
.beacon_int
);
2542 iwl_mvm_tdls_sta_count(mvm
, NULL
) ==
2543 IWL_MVM_TDLS_STA_COUNT
||
2544 iwl_mvm_phy_ctx_count(mvm
) > 1)) {
2545 IWL_DEBUG_MAC80211(mvm
, "refusing TDLS sta\n");
2550 ret
= iwl_mvm_add_sta(mvm
, vif
, sta
);
2551 if (sta
->tdls
&& ret
== 0)
2552 iwl_mvm_recalc_tdls_state(mvm
, vif
, true);
2553 } else if (old_state
== IEEE80211_STA_NONE
&&
2554 new_state
== IEEE80211_STA_AUTH
) {
2556 * EBS may be disabled due to previous failures reported by FW.
2557 * Reset EBS status here assuming environment has been changed.
2559 mvm
->last_ebs_successful
= true;
2560 iwl_mvm_check_uapsd(mvm
, vif
, sta
->addr
);
2562 } else if (old_state
== IEEE80211_STA_AUTH
&&
2563 new_state
== IEEE80211_STA_ASSOC
) {
2564 ret
= iwl_mvm_update_sta(mvm
, vif
, sta
);
2566 iwl_mvm_rs_rate_init(mvm
, sta
,
2567 mvmvif
->phy_ctxt
->channel
->band
,
2569 } else if (old_state
== IEEE80211_STA_ASSOC
&&
2570 new_state
== IEEE80211_STA_AUTHORIZED
) {
2572 /* we don't support TDLS during DCM */
2573 if (iwl_mvm_phy_ctx_count(mvm
) > 1)
2574 iwl_mvm_teardown_tdls_peers(mvm
);
2576 /* enable beacon filtering */
2577 WARN_ON(iwl_mvm_enable_beacon_filter(mvm
, vif
, 0));
2579 } else if (old_state
== IEEE80211_STA_AUTHORIZED
&&
2580 new_state
== IEEE80211_STA_ASSOC
) {
2581 /* disable beacon filtering */
2582 WARN_ON(iwl_mvm_disable_beacon_filter(mvm
, vif
, 0));
2584 } else if (old_state
== IEEE80211_STA_ASSOC
&&
2585 new_state
== IEEE80211_STA_AUTH
) {
2587 } else if (old_state
== IEEE80211_STA_AUTH
&&
2588 new_state
== IEEE80211_STA_NONE
) {
2590 } else if (old_state
== IEEE80211_STA_NONE
&&
2591 new_state
== IEEE80211_STA_NOTEXIST
) {
2592 ret
= iwl_mvm_rm_sta(mvm
, vif
, sta
);
2594 iwl_mvm_recalc_tdls_state(mvm
, vif
, false);
2599 mutex_unlock(&mvm
->mutex
);
2601 if (sta
->tdls
&& ret
== 0) {
2602 if (old_state
== IEEE80211_STA_NOTEXIST
&&
2603 new_state
== IEEE80211_STA_NONE
)
2604 ieee80211_reserve_tid(sta
, IWL_MVM_TDLS_FW_TID
);
2605 else if (old_state
== IEEE80211_STA_NONE
&&
2606 new_state
== IEEE80211_STA_NOTEXIST
)
2607 ieee80211_unreserve_tid(sta
, IWL_MVM_TDLS_FW_TID
);
2613 static int iwl_mvm_mac_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
2615 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2617 mvm
->rts_threshold
= value
;
2622 static void iwl_mvm_sta_rc_update(struct ieee80211_hw
*hw
,
2623 struct ieee80211_vif
*vif
,
2624 struct ieee80211_sta
*sta
, u32 changed
)
2626 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2628 if (vif
->type
== NL80211_IFTYPE_STATION
&&
2629 changed
& IEEE80211_RC_NSS_CHANGED
)
2630 iwl_mvm_sf_update(mvm
, vif
, false);
2633 static int iwl_mvm_mac_conf_tx(struct ieee80211_hw
*hw
,
2634 struct ieee80211_vif
*vif
, u16 ac
,
2635 const struct ieee80211_tx_queue_params
*params
)
2637 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2638 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
2640 mvmvif
->queue_params
[ac
] = *params
;
2643 * No need to update right away, we'll get BSS_CHANGED_QOS
2644 * The exception is P2P_DEVICE interface which needs immediate update.
2646 if (vif
->type
== NL80211_IFTYPE_P2P_DEVICE
) {
2649 mutex_lock(&mvm
->mutex
);
2650 ret
= iwl_mvm_mac_ctxt_changed(mvm
, vif
, false, NULL
);
2651 mutex_unlock(&mvm
->mutex
);
2657 static void iwl_mvm_mac_mgd_prepare_tx(struct ieee80211_hw
*hw
,
2658 struct ieee80211_vif
*vif
)
2660 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2661 u32 duration
= min(IWL_MVM_TE_SESSION_PROTECTION_MAX_TIME_MS
,
2662 200 + vif
->bss_conf
.beacon_int
);
2663 u32 min_duration
= min(IWL_MVM_TE_SESSION_PROTECTION_MIN_TIME_MS
,
2664 100 + vif
->bss_conf
.beacon_int
);
2666 if (WARN_ON_ONCE(vif
->bss_conf
.assoc
))
2670 * iwl_mvm_protect_session() reads directly from the device
2671 * (the system time), so make sure it is available.
2673 if (iwl_mvm_ref_sync(mvm
, IWL_MVM_REF_PREPARE_TX
))
2676 mutex_lock(&mvm
->mutex
);
2677 /* Try really hard to protect the session and hear a beacon */
2678 iwl_mvm_protect_session(mvm
, vif
, duration
, min_duration
, 500, false);
2679 mutex_unlock(&mvm
->mutex
);
2681 iwl_mvm_unref(mvm
, IWL_MVM_REF_PREPARE_TX
);
2684 static int iwl_mvm_mac_sched_scan_start(struct ieee80211_hw
*hw
,
2685 struct ieee80211_vif
*vif
,
2686 struct cfg80211_sched_scan_request
*req
,
2687 struct ieee80211_scan_ies
*ies
)
2689 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2692 if (!(mvm
->fw
->ucode_capa
.capa
[0] & IWL_UCODE_TLV_CAPA_UMAC_SCAN
)) {
2693 ret
= iwl_mvm_cancel_scan_wait_notif(mvm
, IWL_MVM_SCAN_OS
);
2698 mutex_lock(&mvm
->mutex
);
2700 if (iwl_mvm_is_lar_supported(mvm
) && !mvm
->lar_regdom_set
) {
2701 IWL_ERR(mvm
, "sched-scan while LAR regdomain is not set\n");
2706 if (!vif
->bss_conf
.idle
) {
2711 if (mvm
->scan_status
!= IWL_MVM_SCAN_NONE
) {
2716 ret
= iwl_mvm_scan_offload_start(mvm
, vif
, req
, ies
);
2718 mvm
->scan_status
= IWL_MVM_SCAN_NONE
;
2721 mutex_unlock(&mvm
->mutex
);
2725 static int iwl_mvm_mac_sched_scan_stop(struct ieee80211_hw
*hw
,
2726 struct ieee80211_vif
*vif
)
2728 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2731 mutex_lock(&mvm
->mutex
);
2732 ret
= iwl_mvm_scan_offload_stop(mvm
, false);
2733 mutex_unlock(&mvm
->mutex
);
2734 iwl_mvm_wait_for_async_handlers(mvm
);
2740 static int iwl_mvm_mac_set_key(struct ieee80211_hw
*hw
,
2741 enum set_key_cmd cmd
,
2742 struct ieee80211_vif
*vif
,
2743 struct ieee80211_sta
*sta
,
2744 struct ieee80211_key_conf
*key
)
2746 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2749 if (iwlwifi_mod_params
.sw_crypto
) {
2750 IWL_DEBUG_MAC80211(mvm
, "leave - hwcrypto disabled\n");
2754 switch (key
->cipher
) {
2755 case WLAN_CIPHER_SUITE_TKIP
:
2756 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_MMIC
;
2758 case WLAN_CIPHER_SUITE_CCMP
:
2759 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
2761 case WLAN_CIPHER_SUITE_AES_CMAC
:
2762 WARN_ON_ONCE(!(hw
->flags
& IEEE80211_HW_MFP_CAPABLE
));
2764 case WLAN_CIPHER_SUITE_WEP40
:
2765 case WLAN_CIPHER_SUITE_WEP104
:
2766 /* For non-client mode, only use WEP keys for TX as we probably
2767 * don't have a station yet anyway and would then have to keep
2768 * track of the keys, linking them to each of the clients/peers
2769 * as they appear. For now, don't do that, for performance WEP
2770 * offload doesn't really matter much, but we need it for some
2771 * other offload features in client mode.
2773 if (vif
->type
!= NL80211_IFTYPE_STATION
)
2777 /* currently FW supports only one optional cipher scheme */
2778 if (hw
->n_cipher_schemes
&&
2779 hw
->cipher_schemes
->cipher
== key
->cipher
)
2780 key
->flags
|= IEEE80211_KEY_FLAG_PUT_IV_SPACE
;
2785 mutex_lock(&mvm
->mutex
);
2789 if ((vif
->type
== NL80211_IFTYPE_ADHOC
||
2790 vif
->type
== NL80211_IFTYPE_AP
) && !sta
) {
2792 * GTK on AP interface is a TX-only key, return 0;
2793 * on IBSS they're per-station and because we're lazy
2794 * we don't support them for RX, so do the same.
2797 key
->hw_key_idx
= STA_KEY_IDX_INVALID
;
2801 IWL_DEBUG_MAC80211(mvm
, "set hwcrypto key\n");
2802 ret
= iwl_mvm_set_sta_key(mvm
, vif
, sta
, key
, false);
2804 IWL_WARN(mvm
, "set key failed\n");
2806 * can't add key for RX, but we don't need it
2807 * in the device for TX so still return 0
2809 key
->hw_key_idx
= STA_KEY_IDX_INVALID
;
2815 if (key
->hw_key_idx
== STA_KEY_IDX_INVALID
) {
2820 IWL_DEBUG_MAC80211(mvm
, "disable hwcrypto key\n");
2821 ret
= iwl_mvm_remove_sta_key(mvm
, vif
, sta
, key
);
2827 mutex_unlock(&mvm
->mutex
);
2831 static void iwl_mvm_mac_update_tkip_key(struct ieee80211_hw
*hw
,
2832 struct ieee80211_vif
*vif
,
2833 struct ieee80211_key_conf
*keyconf
,
2834 struct ieee80211_sta
*sta
,
2835 u32 iv32
, u16
*phase1key
)
2837 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2839 if (keyconf
->hw_key_idx
== STA_KEY_IDX_INVALID
)
2842 iwl_mvm_update_tkip_key(mvm
, vif
, keyconf
, sta
, iv32
, phase1key
);
2846 static bool iwl_mvm_rx_aux_roc(struct iwl_notif_wait_data
*notif_wait
,
2847 struct iwl_rx_packet
*pkt
, void *data
)
2849 struct iwl_mvm
*mvm
=
2850 container_of(notif_wait
, struct iwl_mvm
, notif_wait
);
2851 struct iwl_hs20_roc_res
*resp
;
2852 int resp_len
= iwl_rx_packet_payload_len(pkt
);
2853 struct iwl_mvm_time_event_data
*te_data
= data
;
2855 if (WARN_ON(pkt
->hdr
.cmd
!= HOT_SPOT_CMD
))
2858 if (WARN_ON_ONCE(resp_len
!= sizeof(*resp
))) {
2859 IWL_ERR(mvm
, "Invalid HOT_SPOT_CMD response\n");
2863 resp
= (void *)pkt
->data
;
2866 "Aux ROC: Recieved response from ucode: status=%d uid=%d\n",
2867 resp
->status
, resp
->event_unique_id
);
2869 te_data
->uid
= le32_to_cpu(resp
->event_unique_id
);
2870 IWL_DEBUG_TE(mvm
, "TIME_EVENT_CMD response - UID = 0x%x\n",
2873 spin_lock_bh(&mvm
->time_event_lock
);
2874 list_add_tail(&te_data
->list
, &mvm
->aux_roc_te_list
);
2875 spin_unlock_bh(&mvm
->time_event_lock
);
2880 #define AUX_ROC_MAX_DELAY_ON_CHANNEL 5000
2881 static int iwl_mvm_send_aux_roc_cmd(struct iwl_mvm
*mvm
,
2882 struct ieee80211_channel
*channel
,
2883 struct ieee80211_vif
*vif
,
2886 int res
, time_reg
= DEVICE_SYSTEM_TIME_REG
;
2887 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
2888 struct iwl_mvm_time_event_data
*te_data
= &mvmvif
->hs_time_event_data
;
2889 static const u8 time_event_response
[] = { HOT_SPOT_CMD
};
2890 struct iwl_notification_wait wait_time_event
;
2891 struct iwl_hs20_roc_req aux_roc_req
= {
2892 .action
= cpu_to_le32(FW_CTXT_ACTION_ADD
),
2894 cpu_to_le32(FW_CMD_ID_AND_COLOR(MAC_INDEX_AUX
, 0)),
2895 .sta_id_and_color
= cpu_to_le32(mvm
->aux_sta
.sta_id
),
2896 /* Set the channel info data */
2897 .channel_info
.band
= (channel
->band
== IEEE80211_BAND_2GHZ
) ?
2898 PHY_BAND_24
: PHY_BAND_5
,
2899 .channel_info
.channel
= channel
->hw_value
,
2900 .channel_info
.width
= PHY_VHT_CHANNEL_MODE20
,
2901 /* Set the time and duration */
2902 .apply_time
= cpu_to_le32(iwl_read_prph(mvm
->trans
, time_reg
)),
2903 .apply_time_max_delay
=
2904 cpu_to_le32(MSEC_TO_TU(AUX_ROC_MAX_DELAY_ON_CHANNEL
)),
2905 .duration
= cpu_to_le32(MSEC_TO_TU(duration
)),
2908 /* Set the node address */
2909 memcpy(aux_roc_req
.node_addr
, vif
->addr
, ETH_ALEN
);
2911 lockdep_assert_held(&mvm
->mutex
);
2913 spin_lock_bh(&mvm
->time_event_lock
);
2915 if (WARN_ON(te_data
->id
== HOT_SPOT_CMD
)) {
2916 spin_unlock_bh(&mvm
->time_event_lock
);
2921 te_data
->duration
= duration
;
2922 te_data
->id
= HOT_SPOT_CMD
;
2924 spin_unlock_bh(&mvm
->time_event_lock
);
2927 * Use a notification wait, which really just processes the
2928 * command response and doesn't wait for anything, in order
2929 * to be able to process the response and get the UID inside
2930 * the RX path. Using CMD_WANT_SKB doesn't work because it
2931 * stores the buffer and then wakes up this thread, by which
2932 * time another notification (that the time event started)
2933 * might already be processed unsuccessfully.
2935 iwl_init_notification_wait(&mvm
->notif_wait
, &wait_time_event
,
2936 time_event_response
,
2937 ARRAY_SIZE(time_event_response
),
2938 iwl_mvm_rx_aux_roc
, te_data
);
2940 res
= iwl_mvm_send_cmd_pdu(mvm
, HOT_SPOT_CMD
, 0, sizeof(aux_roc_req
),
2944 IWL_ERR(mvm
, "Couldn't send HOT_SPOT_CMD: %d\n", res
);
2945 iwl_remove_notification(&mvm
->notif_wait
, &wait_time_event
);
2949 /* No need to wait for anything, so just pass 1 (0 isn't valid) */
2950 res
= iwl_wait_notification(&mvm
->notif_wait
, &wait_time_event
, 1);
2951 /* should never fail */
2956 spin_lock_bh(&mvm
->time_event_lock
);
2957 iwl_mvm_te_clear_data(mvm
, te_data
);
2958 spin_unlock_bh(&mvm
->time_event_lock
);
2964 static int iwl_mvm_roc(struct ieee80211_hw
*hw
,
2965 struct ieee80211_vif
*vif
,
2966 struct ieee80211_channel
*channel
,
2968 enum ieee80211_roc_type type
)
2970 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
2971 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
2972 struct cfg80211_chan_def chandef
;
2973 struct iwl_mvm_phy_ctxt
*phy_ctxt
;
2976 IWL_DEBUG_MAC80211(mvm
, "enter (%d, %d, %d)\n", channel
->hw_value
,
2979 mutex_lock(&mvm
->mutex
);
2981 switch (vif
->type
) {
2982 case NL80211_IFTYPE_STATION
:
2983 if (mvm
->fw
->ucode_capa
.capa
[0] &
2984 IWL_UCODE_TLV_CAPA_HOTSPOT_SUPPORT
) {
2985 /* Use aux roc framework (HS20) */
2986 ret
= iwl_mvm_send_aux_roc_cmd(mvm
, channel
,
2990 IWL_ERR(mvm
, "hotspot not supported\n");
2993 case NL80211_IFTYPE_P2P_DEVICE
:
2997 IWL_ERR(mvm
, "vif isn't P2P_DEVICE: %d\n", vif
->type
);
3002 for (i
= 0; i
< NUM_PHY_CTX
; i
++) {
3003 phy_ctxt
= &mvm
->phy_ctxts
[i
];
3004 if (phy_ctxt
->ref
== 0 || mvmvif
->phy_ctxt
== phy_ctxt
)
3007 if (phy_ctxt
->ref
&& channel
== phy_ctxt
->channel
) {
3009 * Unbind the P2P_DEVICE from the current PHY context,
3010 * and if the PHY context is not used remove it.
3012 ret
= iwl_mvm_binding_remove_vif(mvm
, vif
);
3013 if (WARN(ret
, "Failed unbinding P2P_DEVICE\n"))
3016 iwl_mvm_phy_ctxt_unref(mvm
, mvmvif
->phy_ctxt
);
3018 /* Bind the P2P_DEVICE to the current PHY Context */
3019 mvmvif
->phy_ctxt
= phy_ctxt
;
3021 ret
= iwl_mvm_binding_add_vif(mvm
, vif
);
3022 if (WARN(ret
, "Failed binding P2P_DEVICE\n"))
3025 iwl_mvm_phy_ctxt_ref(mvm
, mvmvif
->phy_ctxt
);
3026 goto schedule_time_event
;
3030 /* Need to update the PHY context only if the ROC channel changed */
3031 if (channel
== mvmvif
->phy_ctxt
->channel
)
3032 goto schedule_time_event
;
3034 cfg80211_chandef_create(&chandef
, channel
, NL80211_CHAN_NO_HT
);
3037 * Change the PHY context configuration as it is currently referenced
3038 * only by the P2P Device MAC
3040 if (mvmvif
->phy_ctxt
->ref
== 1) {
3041 ret
= iwl_mvm_phy_ctxt_changed(mvm
, mvmvif
->phy_ctxt
,
3047 * The PHY context is shared with other MACs. Need to remove the
3048 * P2P Device from the binding, allocate an new PHY context and
3049 * create a new binding
3051 phy_ctxt
= iwl_mvm_get_free_phy_ctxt(mvm
);
3057 ret
= iwl_mvm_phy_ctxt_changed(mvm
, phy_ctxt
, &chandef
,
3060 IWL_ERR(mvm
, "Failed to change PHY context\n");
3064 /* Unbind the P2P_DEVICE from the current PHY context */
3065 ret
= iwl_mvm_binding_remove_vif(mvm
, vif
);
3066 if (WARN(ret
, "Failed unbinding P2P_DEVICE\n"))
3069 iwl_mvm_phy_ctxt_unref(mvm
, mvmvif
->phy_ctxt
);
3071 /* Bind the P2P_DEVICE to the new allocated PHY context */
3072 mvmvif
->phy_ctxt
= phy_ctxt
;
3074 ret
= iwl_mvm_binding_add_vif(mvm
, vif
);
3075 if (WARN(ret
, "Failed binding P2P_DEVICE\n"))
3078 iwl_mvm_phy_ctxt_ref(mvm
, mvmvif
->phy_ctxt
);
3081 schedule_time_event
:
3082 /* Schedule the time events */
3083 ret
= iwl_mvm_start_p2p_roc(mvm
, vif
, duration
, type
);
3086 mutex_unlock(&mvm
->mutex
);
3087 IWL_DEBUG_MAC80211(mvm
, "leave\n");
3091 static int iwl_mvm_cancel_roc(struct ieee80211_hw
*hw
)
3093 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3095 IWL_DEBUG_MAC80211(mvm
, "enter\n");
3097 mutex_lock(&mvm
->mutex
);
3098 iwl_mvm_stop_roc(mvm
);
3099 mutex_unlock(&mvm
->mutex
);
3101 IWL_DEBUG_MAC80211(mvm
, "leave\n");
3105 static int __iwl_mvm_add_chanctx(struct iwl_mvm
*mvm
,
3106 struct ieee80211_chanctx_conf
*ctx
)
3108 u16
*phy_ctxt_id
= (u16
*)ctx
->drv_priv
;
3109 struct iwl_mvm_phy_ctxt
*phy_ctxt
;
3112 lockdep_assert_held(&mvm
->mutex
);
3114 IWL_DEBUG_MAC80211(mvm
, "Add channel context\n");
3116 phy_ctxt
= iwl_mvm_get_free_phy_ctxt(mvm
);
3122 ret
= iwl_mvm_phy_ctxt_changed(mvm
, phy_ctxt
, &ctx
->min_def
,
3123 ctx
->rx_chains_static
,
3124 ctx
->rx_chains_dynamic
);
3126 IWL_ERR(mvm
, "Failed to add PHY context\n");
3130 iwl_mvm_phy_ctxt_ref(mvm
, phy_ctxt
);
3131 *phy_ctxt_id
= phy_ctxt
->id
;
3136 static int iwl_mvm_add_chanctx(struct ieee80211_hw
*hw
,
3137 struct ieee80211_chanctx_conf
*ctx
)
3139 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3142 mutex_lock(&mvm
->mutex
);
3143 ret
= __iwl_mvm_add_chanctx(mvm
, ctx
);
3144 mutex_unlock(&mvm
->mutex
);
3149 static void __iwl_mvm_remove_chanctx(struct iwl_mvm
*mvm
,
3150 struct ieee80211_chanctx_conf
*ctx
)
3152 u16
*phy_ctxt_id
= (u16
*)ctx
->drv_priv
;
3153 struct iwl_mvm_phy_ctxt
*phy_ctxt
= &mvm
->phy_ctxts
[*phy_ctxt_id
];
3155 lockdep_assert_held(&mvm
->mutex
);
3157 iwl_mvm_phy_ctxt_unref(mvm
, phy_ctxt
);
3160 static void iwl_mvm_remove_chanctx(struct ieee80211_hw
*hw
,
3161 struct ieee80211_chanctx_conf
*ctx
)
3163 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3165 mutex_lock(&mvm
->mutex
);
3166 __iwl_mvm_remove_chanctx(mvm
, ctx
);
3167 mutex_unlock(&mvm
->mutex
);
3170 static void iwl_mvm_change_chanctx(struct ieee80211_hw
*hw
,
3171 struct ieee80211_chanctx_conf
*ctx
,
3174 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3175 u16
*phy_ctxt_id
= (u16
*)ctx
->drv_priv
;
3176 struct iwl_mvm_phy_ctxt
*phy_ctxt
= &mvm
->phy_ctxts
[*phy_ctxt_id
];
3178 if (WARN_ONCE((phy_ctxt
->ref
> 1) &&
3179 (changed
& ~(IEEE80211_CHANCTX_CHANGE_WIDTH
|
3180 IEEE80211_CHANCTX_CHANGE_RX_CHAINS
|
3181 IEEE80211_CHANCTX_CHANGE_RADAR
|
3182 IEEE80211_CHANCTX_CHANGE_MIN_WIDTH
)),
3183 "Cannot change PHY. Ref=%d, changed=0x%X\n",
3184 phy_ctxt
->ref
, changed
))
3187 mutex_lock(&mvm
->mutex
);
3188 iwl_mvm_bt_coex_vif_change(mvm
);
3189 iwl_mvm_phy_ctxt_changed(mvm
, phy_ctxt
, &ctx
->min_def
,
3190 ctx
->rx_chains_static
,
3191 ctx
->rx_chains_dynamic
);
3192 mutex_unlock(&mvm
->mutex
);
3195 static int __iwl_mvm_assign_vif_chanctx(struct iwl_mvm
*mvm
,
3196 struct ieee80211_vif
*vif
,
3197 struct ieee80211_chanctx_conf
*ctx
,
3198 bool switching_chanctx
)
3200 u16
*phy_ctxt_id
= (u16
*)ctx
->drv_priv
;
3201 struct iwl_mvm_phy_ctxt
*phy_ctxt
= &mvm
->phy_ctxts
[*phy_ctxt_id
];
3202 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
3205 lockdep_assert_held(&mvm
->mutex
);
3207 mvmvif
->phy_ctxt
= phy_ctxt
;
3209 switch (vif
->type
) {
3210 case NL80211_IFTYPE_AP
:
3211 /* only needed if we're switching chanctx (i.e. during CSA) */
3212 if (switching_chanctx
) {
3213 mvmvif
->ap_ibss_active
= true;
3216 case NL80211_IFTYPE_ADHOC
:
3218 * The AP binding flow is handled as part of the start_ap flow
3219 * (in bss_info_changed), similarly for IBSS.
3223 case NL80211_IFTYPE_STATION
:
3225 case NL80211_IFTYPE_MONITOR
:
3226 /* always disable PS when a monitor interface is active */
3227 mvmvif
->ps_disabled
= true;
3234 ret
= iwl_mvm_binding_add_vif(mvm
, vif
);
3239 * Power state must be updated before quotas,
3240 * otherwise fw will complain.
3242 iwl_mvm_power_update_mac(mvm
);
3244 /* Setting the quota at this stage is only required for monitor
3245 * interfaces. For the other types, the bss_info changed flow
3246 * will handle quota settings.
3248 if (vif
->type
== NL80211_IFTYPE_MONITOR
) {
3249 mvmvif
->monitor_active
= true;
3250 ret
= iwl_mvm_update_quotas(mvm
, false, NULL
);
3252 goto out_remove_binding
;
3255 /* Handle binding during CSA */
3256 if (vif
->type
== NL80211_IFTYPE_AP
) {
3257 iwl_mvm_update_quotas(mvm
, false, NULL
);
3258 iwl_mvm_mac_ctxt_changed(mvm
, vif
, false, NULL
);
3261 if (switching_chanctx
&& vif
->type
== NL80211_IFTYPE_STATION
) {
3262 u32 duration
= 2 * vif
->bss_conf
.beacon_int
;
3264 /* iwl_mvm_protect_session() reads directly from the
3265 * device (the system time), so make sure it is
3268 ret
= iwl_mvm_ref_sync(mvm
, IWL_MVM_REF_PROTECT_CSA
);
3270 goto out_remove_binding
;
3272 /* Protect the session to make sure we hear the first
3273 * beacon on the new channel.
3275 iwl_mvm_protect_session(mvm
, vif
, duration
, duration
,
3276 vif
->bss_conf
.beacon_int
/ 2,
3279 iwl_mvm_unref(mvm
, IWL_MVM_REF_PROTECT_CSA
);
3281 iwl_mvm_update_quotas(mvm
, false, NULL
);
3287 iwl_mvm_binding_remove_vif(mvm
, vif
);
3288 iwl_mvm_power_update_mac(mvm
);
3291 mvmvif
->phy_ctxt
= NULL
;
3294 static int iwl_mvm_assign_vif_chanctx(struct ieee80211_hw
*hw
,
3295 struct ieee80211_vif
*vif
,
3296 struct ieee80211_chanctx_conf
*ctx
)
3298 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3301 mutex_lock(&mvm
->mutex
);
3302 ret
= __iwl_mvm_assign_vif_chanctx(mvm
, vif
, ctx
, false);
3303 mutex_unlock(&mvm
->mutex
);
3308 static void __iwl_mvm_unassign_vif_chanctx(struct iwl_mvm
*mvm
,
3309 struct ieee80211_vif
*vif
,
3310 struct ieee80211_chanctx_conf
*ctx
,
3311 bool switching_chanctx
)
3313 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
3314 struct ieee80211_vif
*disabled_vif
= NULL
;
3316 lockdep_assert_held(&mvm
->mutex
);
3318 iwl_mvm_remove_time_event(mvm
, mvmvif
, &mvmvif
->time_event_data
);
3320 switch (vif
->type
) {
3321 case NL80211_IFTYPE_ADHOC
:
3323 case NL80211_IFTYPE_MONITOR
:
3324 mvmvif
->monitor_active
= false;
3325 mvmvif
->ps_disabled
= false;
3327 case NL80211_IFTYPE_AP
:
3328 /* This part is triggered only during CSA */
3329 if (!switching_chanctx
|| !mvmvif
->ap_ibss_active
)
3332 mvmvif
->csa_countdown
= false;
3334 /* Set CS bit on all the stations */
3335 iwl_mvm_modify_all_sta_disable_tx(mvm
, mvmvif
, true);
3337 /* Save blocked iface, the timeout is set on the next beacon */
3338 rcu_assign_pointer(mvm
->csa_tx_blocked_vif
, vif
);
3340 mvmvif
->ap_ibss_active
= false;
3342 case NL80211_IFTYPE_STATION
:
3343 if (!switching_chanctx
)
3348 iwl_mvm_mac_ctxt_changed(mvm
, vif
, true, NULL
);
3354 iwl_mvm_update_quotas(mvm
, false, disabled_vif
);
3355 iwl_mvm_binding_remove_vif(mvm
, vif
);
3358 mvmvif
->phy_ctxt
= NULL
;
3359 iwl_mvm_power_update_mac(mvm
);
3362 static void iwl_mvm_unassign_vif_chanctx(struct ieee80211_hw
*hw
,
3363 struct ieee80211_vif
*vif
,
3364 struct ieee80211_chanctx_conf
*ctx
)
3366 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3368 mutex_lock(&mvm
->mutex
);
3369 __iwl_mvm_unassign_vif_chanctx(mvm
, vif
, ctx
, false);
3370 mutex_unlock(&mvm
->mutex
);
3374 iwl_mvm_switch_vif_chanctx_swap(struct iwl_mvm
*mvm
,
3375 struct ieee80211_vif_chanctx_switch
*vifs
)
3379 mutex_lock(&mvm
->mutex
);
3380 __iwl_mvm_unassign_vif_chanctx(mvm
, vifs
[0].vif
, vifs
[0].old_ctx
, true);
3381 __iwl_mvm_remove_chanctx(mvm
, vifs
[0].old_ctx
);
3383 ret
= __iwl_mvm_add_chanctx(mvm
, vifs
[0].new_ctx
);
3385 IWL_ERR(mvm
, "failed to add new_ctx during channel switch\n");
3389 ret
= __iwl_mvm_assign_vif_chanctx(mvm
, vifs
[0].vif
, vifs
[0].new_ctx
,
3393 "failed to assign new_ctx during channel switch\n");
3397 /* we don't support TDLS during DCM - can be caused by channel switch */
3398 if (iwl_mvm_phy_ctx_count(mvm
) > 1)
3399 iwl_mvm_teardown_tdls_peers(mvm
);
3404 __iwl_mvm_remove_chanctx(mvm
, vifs
[0].new_ctx
);
3407 if (__iwl_mvm_add_chanctx(mvm
, vifs
[0].old_ctx
)) {
3408 IWL_ERR(mvm
, "failed to add old_ctx back after failure.\n");
3412 if (__iwl_mvm_assign_vif_chanctx(mvm
, vifs
[0].vif
, vifs
[0].old_ctx
,
3414 IWL_ERR(mvm
, "failed to reassign old_ctx after failure.\n");
3421 /* things keep failing, better restart the hw */
3422 iwl_mvm_nic_restart(mvm
, false);
3425 mutex_unlock(&mvm
->mutex
);
3431 iwl_mvm_switch_vif_chanctx_reassign(struct iwl_mvm
*mvm
,
3432 struct ieee80211_vif_chanctx_switch
*vifs
)
3436 mutex_lock(&mvm
->mutex
);
3437 __iwl_mvm_unassign_vif_chanctx(mvm
, vifs
[0].vif
, vifs
[0].old_ctx
, true);
3439 ret
= __iwl_mvm_assign_vif_chanctx(mvm
, vifs
[0].vif
, vifs
[0].new_ctx
,
3443 "failed to assign new_ctx during channel switch\n");
3450 if (__iwl_mvm_assign_vif_chanctx(mvm
, vifs
[0].vif
, vifs
[0].old_ctx
,
3452 IWL_ERR(mvm
, "failed to reassign old_ctx after failure.\n");
3459 /* things keep failing, better restart the hw */
3460 iwl_mvm_nic_restart(mvm
, false);
3463 mutex_unlock(&mvm
->mutex
);
3468 static int iwl_mvm_switch_vif_chanctx(struct ieee80211_hw
*hw
,
3469 struct ieee80211_vif_chanctx_switch
*vifs
,
3471 enum ieee80211_chanctx_switch_mode mode
)
3473 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3476 /* we only support a single-vif right now */
3481 case CHANCTX_SWMODE_SWAP_CONTEXTS
:
3482 ret
= iwl_mvm_switch_vif_chanctx_swap(mvm
, vifs
);
3484 case CHANCTX_SWMODE_REASSIGN_VIF
:
3485 ret
= iwl_mvm_switch_vif_chanctx_reassign(mvm
, vifs
);
3495 static int iwl_mvm_set_tim(struct ieee80211_hw
*hw
,
3496 struct ieee80211_sta
*sta
,
3499 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3500 struct iwl_mvm_sta
*mvm_sta
= iwl_mvm_sta_from_mac80211(sta
);
3502 if (!mvm_sta
|| !mvm_sta
->vif
) {
3503 IWL_ERR(mvm
, "Station is not associated to a vif\n");
3507 return iwl_mvm_mac_ctxt_beacon_changed(mvm
, mvm_sta
->vif
);
3510 #ifdef CONFIG_NL80211_TESTMODE
3511 static const struct nla_policy iwl_mvm_tm_policy
[IWL_MVM_TM_ATTR_MAX
+ 1] = {
3512 [IWL_MVM_TM_ATTR_CMD
] = { .type
= NLA_U32
},
3513 [IWL_MVM_TM_ATTR_NOA_DURATION
] = { .type
= NLA_U32
},
3514 [IWL_MVM_TM_ATTR_BEACON_FILTER_STATE
] = { .type
= NLA_U32
},
3517 static int __iwl_mvm_mac_testmode_cmd(struct iwl_mvm
*mvm
,
3518 struct ieee80211_vif
*vif
,
3519 void *data
, int len
)
3521 struct nlattr
*tb
[IWL_MVM_TM_ATTR_MAX
+ 1];
3525 err
= nla_parse(tb
, IWL_MVM_TM_ATTR_MAX
, data
, len
, iwl_mvm_tm_policy
);
3529 if (!tb
[IWL_MVM_TM_ATTR_CMD
])
3532 switch (nla_get_u32(tb
[IWL_MVM_TM_ATTR_CMD
])) {
3533 case IWL_MVM_TM_CMD_SET_NOA
:
3534 if (!vif
|| vif
->type
!= NL80211_IFTYPE_AP
|| !vif
->p2p
||
3535 !vif
->bss_conf
.enable_beacon
||
3536 !tb
[IWL_MVM_TM_ATTR_NOA_DURATION
])
3539 noa_duration
= nla_get_u32(tb
[IWL_MVM_TM_ATTR_NOA_DURATION
]);
3540 if (noa_duration
>= vif
->bss_conf
.beacon_int
)
3543 mvm
->noa_duration
= noa_duration
;
3546 return iwl_mvm_update_quotas(mvm
, false, NULL
);
3547 case IWL_MVM_TM_CMD_SET_BEACON_FILTER
:
3548 /* must be associated client vif - ignore authorized */
3549 if (!vif
|| vif
->type
!= NL80211_IFTYPE_STATION
||
3550 !vif
->bss_conf
.assoc
|| !vif
->bss_conf
.dtim_period
||
3551 !tb
[IWL_MVM_TM_ATTR_BEACON_FILTER_STATE
])
3554 if (nla_get_u32(tb
[IWL_MVM_TM_ATTR_BEACON_FILTER_STATE
]))
3555 return iwl_mvm_enable_beacon_filter(mvm
, vif
, 0);
3556 return iwl_mvm_disable_beacon_filter(mvm
, vif
, 0);
3562 static int iwl_mvm_mac_testmode_cmd(struct ieee80211_hw
*hw
,
3563 struct ieee80211_vif
*vif
,
3564 void *data
, int len
)
3566 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3569 mutex_lock(&mvm
->mutex
);
3570 err
= __iwl_mvm_mac_testmode_cmd(mvm
, vif
, data
, len
);
3571 mutex_unlock(&mvm
->mutex
);
3577 static void iwl_mvm_channel_switch(struct ieee80211_hw
*hw
,
3578 struct ieee80211_vif
*vif
,
3579 struct ieee80211_channel_switch
*chsw
)
3581 /* By implementing this operation, we prevent mac80211 from
3582 * starting its own channel switch timer, so that we can call
3583 * ieee80211_chswitch_done() ourselves at the right time
3584 * (which is when the absence time event starts).
3587 IWL_DEBUG_MAC80211(IWL_MAC80211_GET_MVM(hw
),
3588 "dummy channel switch op\n");
3591 static int iwl_mvm_pre_channel_switch(struct ieee80211_hw
*hw
,
3592 struct ieee80211_vif
*vif
,
3593 struct ieee80211_channel_switch
*chsw
)
3595 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3596 struct ieee80211_vif
*csa_vif
;
3597 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
3601 mutex_lock(&mvm
->mutex
);
3603 IWL_DEBUG_MAC80211(mvm
, "pre CSA to freq %d\n",
3604 chsw
->chandef
.center_freq1
);
3606 iwl_fw_dbg_trigger_simple_stop(mvm
, vif
, FW_DBG_TRIGGER_CHANNEL_SWITCH
,
3609 switch (vif
->type
) {
3610 case NL80211_IFTYPE_AP
:
3612 rcu_dereference_protected(mvm
->csa_vif
,
3613 lockdep_is_held(&mvm
->mutex
));
3614 if (WARN_ONCE(csa_vif
&& csa_vif
->csa_active
,
3615 "Another CSA is already in progress")) {
3620 rcu_assign_pointer(mvm
->csa_vif
, vif
);
3622 if (WARN_ONCE(mvmvif
->csa_countdown
,
3623 "Previous CSA countdown didn't complete")) {
3629 case NL80211_IFTYPE_STATION
:
3630 /* Schedule the time event to a bit before beacon 1,
3631 * to make sure we're in the new channel when the
3634 apply_time
= chsw
->device_timestamp
+
3635 ((vif
->bss_conf
.beacon_int
* (chsw
->count
- 1) -
3636 IWL_MVM_CHANNEL_SWITCH_TIME_CLIENT
) * 1024);
3639 iwl_mvm_csa_client_absent(mvm
, vif
);
3641 iwl_mvm_schedule_csa_period(mvm
, vif
, vif
->bss_conf
.beacon_int
,
3643 if (mvmvif
->bf_data
.bf_enabled
) {
3644 ret
= iwl_mvm_disable_beacon_filter(mvm
, vif
, 0);
3654 mvmvif
->ps_disabled
= true;
3656 ret
= iwl_mvm_power_update_ps(mvm
);
3660 /* we won't be on this channel any longer */
3661 iwl_mvm_teardown_tdls_peers(mvm
);
3664 mutex_unlock(&mvm
->mutex
);
3669 static int iwl_mvm_post_channel_switch(struct ieee80211_hw
*hw
,
3670 struct ieee80211_vif
*vif
)
3672 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
3673 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3676 mutex_lock(&mvm
->mutex
);
3678 if (vif
->type
== NL80211_IFTYPE_STATION
) {
3679 struct iwl_mvm_sta
*mvmsta
;
3681 mvmsta
= iwl_mvm_sta_from_staid_protected(mvm
,
3684 if (WARN_ON(!mvmsta
)) {
3689 iwl_mvm_sta_modify_disable_tx(mvm
, mvmsta
, false);
3691 iwl_mvm_mac_ctxt_changed(mvm
, vif
, false, NULL
);
3693 ret
= iwl_mvm_enable_beacon_filter(mvm
, vif
, 0);
3697 iwl_mvm_stop_session_protection(mvm
, vif
);
3700 mvmvif
->ps_disabled
= false;
3702 ret
= iwl_mvm_power_update_ps(mvm
);
3705 mutex_unlock(&mvm
->mutex
);
3710 static void iwl_mvm_mac_flush(struct ieee80211_hw
*hw
,
3711 struct ieee80211_vif
*vif
, u32 queues
, bool drop
)
3713 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3714 struct iwl_mvm_vif
*mvmvif
;
3715 struct iwl_mvm_sta
*mvmsta
;
3716 struct ieee80211_sta
*sta
;
3720 if (!vif
|| vif
->type
!= NL80211_IFTYPE_STATION
)
3723 mutex_lock(&mvm
->mutex
);
3724 mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
3726 /* flush the AP-station and all TDLS peers */
3727 for (i
= 0; i
< IWL_MVM_STATION_COUNT
; i
++) {
3728 sta
= rcu_dereference_protected(mvm
->fw_id_to_mac_id
[i
],
3729 lockdep_is_held(&mvm
->mutex
));
3730 if (IS_ERR_OR_NULL(sta
))
3733 mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
3734 if (mvmsta
->vif
!= vif
)
3737 /* make sure only TDLS peers or the AP are flushed */
3738 WARN_ON(i
!= mvmvif
->ap_sta_id
&& !sta
->tdls
);
3740 msk
|= mvmsta
->tfd_queue_msk
;
3744 if (iwl_mvm_flush_tx_path(mvm
, msk
, true))
3745 IWL_ERR(mvm
, "flush request fail\n");
3746 mutex_unlock(&mvm
->mutex
);
3748 mutex_unlock(&mvm
->mutex
);
3750 /* this can take a while, and we may need/want other operations
3751 * to succeed while doing this, so do it without the mutex held
3753 iwl_trans_wait_tx_queue_empty(mvm
->trans
, msk
);
3757 static int iwl_mvm_mac_get_survey(struct ieee80211_hw
*hw
, int idx
,
3758 struct survey_info
*survey
)
3760 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3763 memset(survey
, 0, sizeof(*survey
));
3765 /* only support global statistics right now */
3769 if (!(mvm
->fw
->ucode_capa
.capa
[0] &
3770 IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS
))
3773 mutex_lock(&mvm
->mutex
);
3775 if (mvm
->ucode_loaded
) {
3776 ret
= iwl_mvm_request_statistics(mvm
, false);
3781 survey
->filled
= SURVEY_INFO_TIME
|
3782 SURVEY_INFO_TIME_RX
|
3783 SURVEY_INFO_TIME_TX
|
3784 SURVEY_INFO_TIME_SCAN
;
3785 survey
->time
= mvm
->accu_radio_stats
.on_time_rf
+
3786 mvm
->radio_stats
.on_time_rf
;
3787 do_div(survey
->time
, USEC_PER_MSEC
);
3789 survey
->time_rx
= mvm
->accu_radio_stats
.rx_time
+
3790 mvm
->radio_stats
.rx_time
;
3791 do_div(survey
->time_rx
, USEC_PER_MSEC
);
3793 survey
->time_tx
= mvm
->accu_radio_stats
.tx_time
+
3794 mvm
->radio_stats
.tx_time
;
3795 do_div(survey
->time_tx
, USEC_PER_MSEC
);
3797 survey
->time_scan
= mvm
->accu_radio_stats
.on_time_scan
+
3798 mvm
->radio_stats
.on_time_scan
;
3799 do_div(survey
->time_scan
, USEC_PER_MSEC
);
3802 mutex_unlock(&mvm
->mutex
);
3806 static void iwl_mvm_mac_sta_statistics(struct ieee80211_hw
*hw
,
3807 struct ieee80211_vif
*vif
,
3808 struct ieee80211_sta
*sta
,
3809 struct station_info
*sinfo
)
3811 struct iwl_mvm
*mvm
= IWL_MAC80211_GET_MVM(hw
);
3812 struct iwl_mvm_vif
*mvmvif
= iwl_mvm_vif_from_mac80211(vif
);
3813 struct iwl_mvm_sta
*mvmsta
= iwl_mvm_sta_from_mac80211(sta
);
3815 if (!(mvm
->fw
->ucode_capa
.capa
[0] &
3816 IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS
))
3819 /* if beacon filtering isn't on mac80211 does it anyway */
3820 if (!(vif
->driver_flags
& IEEE80211_VIF_BEACON_FILTER
))
3823 if (!vif
->bss_conf
.assoc
)
3826 mutex_lock(&mvm
->mutex
);
3828 if (mvmvif
->ap_sta_id
!= mvmsta
->sta_id
)
3831 if (iwl_mvm_request_statistics(mvm
, false))
3834 sinfo
->rx_beacon
= mvmvif
->beacon_stats
.num_beacons
+
3835 mvmvif
->beacon_stats
.accu_num_beacons
;
3836 sinfo
->filled
|= BIT(NL80211_STA_INFO_BEACON_RX
);
3837 if (mvmvif
->beacon_stats
.avg_signal
) {
3838 /* firmware only reports a value after RXing a few beacons */
3839 sinfo
->rx_beacon_signal_avg
= mvmvif
->beacon_stats
.avg_signal
;
3840 sinfo
->filled
|= BIT(NL80211_STA_INFO_BEACON_SIGNAL_AVG
);
3843 mutex_unlock(&mvm
->mutex
);
3846 const struct ieee80211_ops iwl_mvm_hw_ops
= {
3847 .tx
= iwl_mvm_mac_tx
,
3848 .ampdu_action
= iwl_mvm_mac_ampdu_action
,
3849 .start
= iwl_mvm_mac_start
,
3850 .reconfig_complete
= iwl_mvm_mac_reconfig_complete
,
3851 .stop
= iwl_mvm_mac_stop
,
3852 .add_interface
= iwl_mvm_mac_add_interface
,
3853 .remove_interface
= iwl_mvm_mac_remove_interface
,
3854 .config
= iwl_mvm_mac_config
,
3855 .prepare_multicast
= iwl_mvm_prepare_multicast
,
3856 .configure_filter
= iwl_mvm_configure_filter
,
3857 .bss_info_changed
= iwl_mvm_bss_info_changed
,
3858 .hw_scan
= iwl_mvm_mac_hw_scan
,
3859 .cancel_hw_scan
= iwl_mvm_mac_cancel_hw_scan
,
3860 .sta_pre_rcu_remove
= iwl_mvm_sta_pre_rcu_remove
,
3861 .sta_state
= iwl_mvm_mac_sta_state
,
3862 .sta_notify
= iwl_mvm_mac_sta_notify
,
3863 .allow_buffered_frames
= iwl_mvm_mac_allow_buffered_frames
,
3864 .release_buffered_frames
= iwl_mvm_mac_release_buffered_frames
,
3865 .set_rts_threshold
= iwl_mvm_mac_set_rts_threshold
,
3866 .sta_rc_update
= iwl_mvm_sta_rc_update
,
3867 .conf_tx
= iwl_mvm_mac_conf_tx
,
3868 .mgd_prepare_tx
= iwl_mvm_mac_mgd_prepare_tx
,
3869 .mgd_protect_tdls_discover
= iwl_mvm_mac_mgd_protect_tdls_discover
,
3870 .flush
= iwl_mvm_mac_flush
,
3871 .sched_scan_start
= iwl_mvm_mac_sched_scan_start
,
3872 .sched_scan_stop
= iwl_mvm_mac_sched_scan_stop
,
3873 .set_key
= iwl_mvm_mac_set_key
,
3874 .update_tkip_key
= iwl_mvm_mac_update_tkip_key
,
3875 .remain_on_channel
= iwl_mvm_roc
,
3876 .cancel_remain_on_channel
= iwl_mvm_cancel_roc
,
3877 .add_chanctx
= iwl_mvm_add_chanctx
,
3878 .remove_chanctx
= iwl_mvm_remove_chanctx
,
3879 .change_chanctx
= iwl_mvm_change_chanctx
,
3880 .assign_vif_chanctx
= iwl_mvm_assign_vif_chanctx
,
3881 .unassign_vif_chanctx
= iwl_mvm_unassign_vif_chanctx
,
3882 .switch_vif_chanctx
= iwl_mvm_switch_vif_chanctx
,
3884 .start_ap
= iwl_mvm_start_ap_ibss
,
3885 .stop_ap
= iwl_mvm_stop_ap_ibss
,
3886 .join_ibss
= iwl_mvm_start_ap_ibss
,
3887 .leave_ibss
= iwl_mvm_stop_ap_ibss
,
3889 .set_tim
= iwl_mvm_set_tim
,
3891 .channel_switch
= iwl_mvm_channel_switch
,
3892 .pre_channel_switch
= iwl_mvm_pre_channel_switch
,
3893 .post_channel_switch
= iwl_mvm_post_channel_switch
,
3895 .tdls_channel_switch
= iwl_mvm_tdls_channel_switch
,
3896 .tdls_cancel_channel_switch
= iwl_mvm_tdls_cancel_channel_switch
,
3897 .tdls_recv_channel_switch
= iwl_mvm_tdls_recv_channel_switch
,
3899 CFG80211_TESTMODE_CMD(iwl_mvm_mac_testmode_cmd
)
3901 #ifdef CONFIG_PM_SLEEP
3903 .suspend
= iwl_mvm_suspend
,
3904 .resume
= iwl_mvm_resume
,
3905 .set_wakeup
= iwl_mvm_set_wakeup
,
3906 .set_rekey_data
= iwl_mvm_set_rekey_data
,
3907 #if IS_ENABLED(CONFIG_IPV6)
3908 .ipv6_addr_change
= iwl_mvm_ipv6_addr_change
,
3910 .set_default_unicast_key
= iwl_mvm_set_default_unicast_key
,
3912 .get_survey
= iwl_mvm_mac_get_survey
,
3913 .sta_statistics
= iwl_mvm_mac_sta_statistics
,