blob: 8aab3ca57ae4b134a5c6cb05df4740285d627112 [file] [log] [blame]
/******************************************************************************
*
* Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
* Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
* Copyright(c) 2016 - 2017 Intel Deutschland GmbH
* Copyright(c) 2018 Intel Corporation
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*****************************************************************************/
#include <fuchsia/hardware/wlan/info/c/banjo.h>
#include <string.h>
#include <zircon/status.h>
#include <ddk/hw/wlan/ieee80211/c/banjo.h>
#include "src/iwlwifi/fw/api/nan.h"
#include "src/iwlwifi/fw/error-dump.h"
#include "src/iwlwifi/iwl-eeprom-parse.h"
#include "src/iwlwifi/iwl-io.h"
#include "src/iwlwifi/iwl-nvm-parse.h"
#include "src/iwlwifi/iwl-op-mode.h"
#include "src/iwlwifi/iwl-phy-db.h"
#include "src/iwlwifi/iwl-prph.h"
#include "src/iwlwifi/iwl-vendor-cmd.h"
#include "src/iwlwifi/mvm/mvm.h"
#include "src/iwlwifi/mvm/sta.h"
#include "src/iwlwifi/mvm/time-event.h"
#include "src/iwlwifi/mvm/tof.h"
#include "src/iwlwifi/platform/ieee80211.h"
#ifdef CPTCFG_IWLWIFI_DEVICE_TESTMODE
#include "src/iwlwifi/iwl-dnt-cfg.h"
#include "src/iwlwifi/iwl-dnt-dispatch.h"
#endif
#ifdef CPTCFG_NL80211_TESTMODE
#include "src/iwlwifi/fw/testmode.h"
#endif
#if 0 // NEEDS_PORTING
static const struct ieee80211_iface_limit iwl_mvm_limits[] = {
{
.max = CPTCFG_IWLWIFI_NUM_STA_INTERFACES,
.types = BIT(NL80211_IFTYPE_STATION),
},
{
.max = 1,
.types =
BIT(NL80211_IFTYPE_AP) | BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO),
},
{
.max = 1,
.types = BIT(NL80211_IFTYPE_P2P_DEVICE),
},
};
static const struct ieee80211_iface_combination iwl_mvm_iface_combinations[] = {
{
.num_different_channels = CPTCFG_IWLWIFI_NUM_CHANNELS,
.max_interfaces = CPTCFG_IWLWIFI_NUM_STA_INTERFACES + 2,
.limits = iwl_mvm_limits,
.n_limits = ARRAY_SIZE(iwl_mvm_limits),
},
};
static const struct ieee80211_iface_limit iwl_mvm_limits_nan[] = {
{
.max = CPTCFG_IWLWIFI_NUM_STA_INTERFACES,
.types = BIT(NL80211_IFTYPE_STATION),
},
{
.max = 1,
.types =
BIT(NL80211_IFTYPE_AP) | BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO),
},
{
.max = 1,
.types = BIT(NL80211_IFTYPE_P2P_DEVICE),
},
{
.max = 1,
.types = BIT(NL80211_IFTYPE_NAN),
},
};
static const struct ieee80211_iface_combination iwl_mvm_iface_combinations_nan[] = {
{
.num_different_channels = CPTCFG_IWLWIFI_NUM_CHANNELS,
.max_interfaces = CPTCFG_IWLWIFI_NUM_STA_INTERFACES + 3,
.limits = iwl_mvm_limits_nan,
.n_limits = ARRAY_SIZE(iwl_mvm_limits_nan),
},
};
#ifdef CPTCFG_IWLWIFI_BCAST_FILTERING
/*
* Use the reserved field to indicate magic values.
* these values will only be used internally by the driver,
* and won't make it to the fw (reserved will be 0).
* BC_FILTER_MAGIC_IP - configure the val of this attribute to
* be the vif's ip address. in case there is not a single
* ip address (0, or more than 1), this attribute will
* be skipped.
* BC_FILTER_MAGIC_MAC - set the val of this attribute to
* the LSB bytes of the vif's mac address
*/
enum {
BC_FILTER_MAGIC_NONE = 0,
BC_FILTER_MAGIC_IP,
BC_FILTER_MAGIC_MAC,
};
static const struct iwl_fw_bcast_filter iwl_mvm_default_bcast_filters[] = {
{
/* arp */
.discard = 0,
.frame_type = BCAST_FILTER_FRAME_TYPE_ALL,
.attrs =
{
{
/* frame type - arp, hw type - ethernet */
.offset_type = BCAST_FILTER_OFFSET_PAYLOAD_START,
.offset = sizeof(rfc1042_header),
.val = cpu_to_be32(0x08060001),
.mask = cpu_to_be32(0xffffffff),
},
{
/* arp dest ip */
.offset_type = BCAST_FILTER_OFFSET_PAYLOAD_START,
.offset = sizeof(rfc1042_header) + 2 + sizeof(struct arphdr) + ETH_ALEN +
sizeof(__be32) + ETH_ALEN,
.mask = cpu_to_be32(0xffffffff),
/* mark it as special field */
.reserved1 = cpu_to_le16(BC_FILTER_MAGIC_IP),
},
},
},
{
/* dhcp offer bcast */
.discard = 0,
.frame_type = BCAST_FILTER_FRAME_TYPE_IPV4,
.attrs =
{
{
/* udp dest port - 68 (bootp client)*/
.offset_type = BCAST_FILTER_OFFSET_IP_END,
.offset = offsetof(struct udphdr, dest),
.val = cpu_to_be32(0x00440000),
.mask = cpu_to_be32(0xffff0000),
},
{
/* dhcp - lsb bytes of client hw address */
.offset_type = BCAST_FILTER_OFFSET_IP_END,
.offset = 38,
.mask = cpu_to_be32(0xffffffff),
/* mark it as special field */
.reserved1 = cpu_to_le16(BC_FILTER_MAGIC_MAC),
},
},
},
/* last filter must be empty */
{},
};
#endif
#endif // NEEDS_PORTING
void iwl_mvm_ref(struct iwl_mvm* mvm, enum iwl_mvm_ref_type ref_type) {
if (!iwl_mvm_is_d0i3_supported(mvm)) {
return;
}
IWL_DEBUG_RPM(mvm, "Take mvm reference - type %d\n", ref_type);
mtx_lock(&mvm->refs_lock);
mvm->refs[ref_type]++;
mtx_unlock(&mvm->refs_lock);
iwl_trans_ref(mvm->trans);
}
void iwl_mvm_unref(struct iwl_mvm* mvm, enum iwl_mvm_ref_type ref_type) {
if (!iwl_mvm_is_d0i3_supported(mvm)) {
return;
}
IWL_DEBUG_RPM(mvm, "Leave mvm reference - type %d\n", ref_type);
mtx_lock(&mvm->refs_lock);
if (WARN_ON(!mvm->refs[ref_type])) {
mtx_unlock(&mvm->refs_lock);
return;
}
mvm->refs[ref_type]--;
mtx_unlock(&mvm->refs_lock);
iwl_trans_unref(mvm->trans);
}
static void iwl_mvm_unref_all_except(struct iwl_mvm* mvm, enum iwl_mvm_ref_type except_ref) {
enum iwl_mvm_ref_type i, j;
if (!iwl_mvm_is_d0i3_supported(mvm)) {
return;
}
mtx_lock(&mvm->refs_lock);
for (i = 0; i < IWL_MVM_REF_COUNT; i++) {
if (except_ref == i || !mvm->refs[i]) {
continue;
}
IWL_DEBUG_RPM(mvm, "Cleanup: remove mvm ref type %d (%d)\n", i, mvm->refs[i]);
for (j = 0; j < mvm->refs[i]; j++) {
iwl_trans_unref(mvm->trans);
}
mvm->refs[i] = 0;
}
mtx_unlock(&mvm->refs_lock);
}
bool iwl_mvm_ref_taken(struct iwl_mvm* mvm) {
int i;
bool taken = false;
if (!iwl_mvm_is_d0i3_supported(mvm)) {
return true;
}
mtx_lock(&mvm->refs_lock);
for (i = 0; i < IWL_MVM_REF_COUNT; i++) {
if (mvm->refs[i]) {
taken = true;
break;
}
}
mtx_unlock(&mvm->refs_lock);
return taken;
}
zx_status_t iwl_mvm_ref_sync(struct iwl_mvm* mvm, enum iwl_mvm_ref_type ref_type) {
iwl_mvm_ref(mvm, ref_type);
#if 0 // NEEDS_PORTING
if (!wait_event_timeout(mvm->d0i3_exit_waitq, !test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status),
HZ)) {
WARN_ON_ONCE(1);
iwl_mvm_unref(mvm, ref_type);
return -EIO;
}
#endif // NEEDS_PORTING
return ZX_OK;
}
static void iwl_mvm_reset_phy_ctxts(struct iwl_mvm* mvm) {
int i;
memset(mvm->phy_ctxts, 0, sizeof(mvm->phy_ctxts));
for (i = 0; i < NUM_PHY_CTX; i++) {
mvm->phy_ctxts[i].id = i;
mvm->phy_ctxts[i].ref = 0;
}
}
#if 0 // NEEDS_PORTING
struct ieee80211_regdomain* iwl_mvm_get_regdomain(struct wiphy* wiphy, const char* alpha2,
enum iwl_mcc_source src_id, bool* changed) {
struct ieee80211_regdomain* regd = NULL;
struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
struct iwl_mcc_update_resp* resp;
IWL_DEBUG_LAR(mvm, "Getting regdomain data for %s from FW\n", alpha2);
iwl_assert_lock_held(&mvm->mutex);
resp = iwl_mvm_update_mcc(mvm, alpha2, src_id);
if (IS_ERR_OR_NULL(resp)) {
IWL_DEBUG_LAR(mvm, "Could not get update from FW %d\n", PTR_ERR_OR_ZERO(resp));
goto out;
}
if (changed) {
uint32_t status = le32_to_cpu(resp->status);
*changed = (status == MCC_RESP_NEW_CHAN_PROFILE || status == MCC_RESP_ILLEGAL);
}
regd = iwl_parse_nvm_mcc_info(mvm->trans->dev, mvm->cfg, __le32_to_cpu(resp->n_channels),
resp->channels, __le16_to_cpu(resp->mcc),
__le16_to_cpu(resp->geo_info));
/* Store the return source id */
src_id = resp->source_id;
kfree(resp);
if (IS_ERR_OR_NULL(regd)) {
IWL_DEBUG_LAR(mvm, "Could not get parse update from FW %d\n", PTR_ERR_OR_ZERO(regd));
goto out;
}
IWL_DEBUG_LAR(mvm, "setting alpha2 from FW to %s (0x%x, 0x%x) src=%d\n", regd->alpha2,
regd->alpha2[0], regd->alpha2[1], src_id);
mvm->lar_regdom_set = true;
mvm->mcc_src = src_id;
out:
return regd;
}
void iwl_mvm_update_changed_regdom(struct iwl_mvm* mvm) {
bool changed;
struct ieee80211_regdomain* regd;
if (!iwl_mvm_is_lar_supported(mvm)) { return; }
regd = iwl_mvm_get_current_regdomain(mvm, &changed);
if (!IS_ERR_OR_NULL(regd)) {
/* only update the regulatory core if changed */
if (changed) { regulatory_set_wiphy_regd(mvm->hw->wiphy, regd); }
kfree(regd);
}
}
struct ieee80211_regdomain* iwl_mvm_get_current_regdomain(struct iwl_mvm* mvm, bool* changed) {
return iwl_mvm_get_regdomain(
mvm->hw->wiphy, "ZZ",
iwl_mvm_is_wifi_mcc_supported(mvm) ? MCC_SOURCE_GET_CURRENT : MCC_SOURCE_OLD_FW, changed);
}
int iwl_mvm_init_fw_regd(struct iwl_mvm* mvm) {
enum iwl_mcc_source used_src;
struct ieee80211_regdomain* regd;
int ret;
bool changed;
const struct ieee80211_regdomain* r = rtnl_dereference(mvm->hw->wiphy->regd);
if (!r) { return -ENOENT; }
/* save the last source in case we overwrite it below */
used_src = mvm->mcc_src;
if (iwl_mvm_is_wifi_mcc_supported(mvm)) {
/* Notify the firmware we support wifi location updates */
regd = iwl_mvm_get_current_regdomain(mvm, NULL);
if (!IS_ERR_OR_NULL(regd)) { kfree(regd); }
}
/* Now set our last stored MCC and source */
regd = iwl_mvm_get_regdomain(mvm->hw->wiphy, r->alpha2, used_src, &changed);
if (IS_ERR_OR_NULL(regd)) { return -EIO; }
/* update cfg80211 if the regdomain was changed */
if (changed) {
ret = regulatory_set_wiphy_regd_sync_rtnl(mvm->hw->wiphy, regd);
} else {
ret = 0;
}
kfree(regd);
return ret;
}
const static uint8_t he_if_types_ext_capa_sta[] = {
[0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
[7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
[9] = WLAN_EXT_CAPA10_TWT_REQUESTER_SUPPORT,
};
#ifdef CPTCFG_IWLMVM_AX_SOFTAP_TESTMODE
const static uint8_t he_if_types_ext_capa_ap[] = {
[0] = WLAN_EXT_CAPA1_EXT_CHANNEL_SWITCHING,
[7] = WLAN_EXT_CAPA8_OPMODE_NOTIF,
[9] = WLAN_EXT_CAPA10_TWT_RESPONDER_SUPPORT,
};
#endif /* CPTCFG_IWLMVM_AX_SOFTAP_TESTMODE */
const static struct wiphy_iftype_ext_capab he_iftypes_ext_capa[] = {
{
.iftype = NL80211_IFTYPE_STATION,
.extended_capabilities = he_if_types_ext_capa_sta,
.extended_capabilities_mask = he_if_types_ext_capa_sta,
.extended_capabilities_len = sizeof(he_if_types_ext_capa_sta),
},
#ifdef CPTCFG_IWLMVM_AX_SOFTAP_TESTMODE
{
.iftype = NL80211_IFTYPE_AP,
.extended_capabilities = he_if_types_ext_capa_ap,
.extended_capabilities_mask = he_if_types_ext_capa_ap,
.extended_capabilities_len = sizeof(he_if_types_ext_capa_ap),
},
#endif /* CPTCFG_IWLMVM_AX_SOFTAP_TESTMODE */
};
#endif // NEEDS_PORTING
zx_status_t iwl_mvm_mac_setup_register(struct iwl_mvm* mvm) {
#if 0 // NEEDS_PORTING: for cipher
BUILD_BUG_ON(ARRAY_SIZE(mvm->ciphers) < ARRAY_SIZE(mvm_ciphers) + 6);
memcpy(mvm->ciphers, mvm_ciphers, sizeof(mvm_ciphers));
hw->wiphy->n_cipher_suites = ARRAY_SIZE(mvm_ciphers);
hw->wiphy->cipher_suites = mvm->ciphers;
if (iwl_mvm_has_new_rx_api(mvm)) {
mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_GCMP;
hw->wiphy->n_cipher_suites++;
mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_GCMP_256;
hw->wiphy->n_cipher_suites++;
}
/* Enable 11w if software crypto is not enabled (as the
* firmware will interpret some mgmt packets, so enabling it
* with software crypto isn't safe).
*/
if (!iwlwifi_mod_params.swcrypto) {
ieee80211_hw_set(hw, MFP_CAPABLE);
mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_AES_CMAC;
hw->wiphy->n_cipher_suites++;
if (iwl_mvm_has_new_rx_api(mvm)) {
mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_BIP_GMAC_128;
hw->wiphy->n_cipher_suites++;
mvm->ciphers[hw->wiphy->n_cipher_suites] = WLAN_CIPHER_SUITE_BIP_GMAC_256;
hw->wiphy->n_cipher_suites++;
}
}
/* currently FW API supports only one optional cipher scheme */
if (mvm->fw->cs[0].cipher) {
const struct iwl_fw_cipher_scheme* fwcs = &mvm->fw->cs[0];
struct ieee80211_cipher_scheme* cs = &mvm->cs[0];
mvm->hw->n_cipher_schemes = 1;
cs->cipher = le32_to_cpu(fwcs->cipher);
cs->iftype = BIT(NL80211_IFTYPE_STATION);
cs->hdr_len = fwcs->hdr_len;
cs->pn_len = fwcs->pn_len;
cs->pn_off = fwcs->pn_off;
cs->key_idx_off = fwcs->key_idx_off;
cs->key_idx_mask = fwcs->key_idx_mask;
cs->key_idx_shift = fwcs->key_idx_shift;
cs->mic_len = fwcs->mic_len;
mvm->hw->cipher_schemes = mvm->cs;
mvm->ciphers[hw->wiphy->n_cipher_suites] = cs->cipher;
hw->wiphy->n_cipher_suites++;
}
#endif // NEEDS_PORTING
#if 0 // TODO(fxbug.dev/36682): We need nvm.c porting iwl_nvm_init()
/* Extract MAC address */
memcpy(mvm->addresses[0].addr, mvm->nvm_data->hw_addr, ETH_ALEN);
/* Extract additional MAC addresses if available */
size_t num_mac =
(mvm->nvm_data->n_hw_addrs > 1) ? MIN(IWL_MVM_MAX_ADDRESSES, mvm->nvm_data->n_hw_addrs) : 1;
for (size_t i = 1; i < num_mac; i++) {
memcpy(mvm->addresses[i].addr, mvm->addresses[i - 1].addr, ETH_ALEN);
mvm->addresses[i].addr[5]++;
}
#endif
iwl_mvm_reset_phy_ctxts(mvm);
BUILD_BUG_ON(IWL_MVM_SCAN_STOPPING_MASK & IWL_MVM_SCAN_MASK);
BUILD_BUG_ON(IWL_MVM_MAX_UMAC_SCANS > IWL_MVM_SCAN_MASK_HWEIGHT32 ||
IWL_MVM_MAX_LMAC_SCANS > IWL_MVM_SCAN_MASK_HWEIGHT32);
if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
mvm->max_scans = IWL_MVM_MAX_UMAC_SCANS;
} else {
mvm->max_scans = IWL_MVM_MAX_LMAC_SCANS;
}
mvm->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
#ifdef CONFIG_PM_SLEEP
if (iwl_mvm_is_d0i3_supported(mvm) && device_can_wakeup(mvm->trans->dev)) {
mvm->wowlan.flags = WIPHY_WOWLAN_ANY;
hw->wiphy->wowlan = &mvm->wowlan;
}
if (mvm->fw->img[IWL_UCODE_WOWLAN].num_sec && mvm->trans->ops->d3_suspend &&
mvm->trans->ops->d3_resume && device_can_wakeup(mvm->trans->dev)) {
mvm->wowlan.flags |= WIPHY_WOWLAN_MAGIC_PKT | WIPHY_WOWLAN_DISCONNECT |
WIPHY_WOWLAN_EAP_IDENTITY_REQ | WIPHY_WOWLAN_RFKILL_RELEASE |
WIPHY_WOWLAN_NET_DETECT;
if (!iwlwifi_mod_params.swcrypto)
mvm->wowlan.flags |= WIPHY_WOWLAN_SUPPORTS_GTK_REKEY | WIPHY_WOWLAN_GTK_REKEY_FAILURE |
WIPHY_WOWLAN_4WAY_HANDSHAKE;
mvm->wowlan.n_patterns = IWL_WOWLAN_MAX_PATTERNS;
mvm->wowlan.pattern_min_len = IWL_WOWLAN_MIN_PATTERN_LEN;
mvm->wowlan.pattern_max_len = IWL_WOWLAN_MAX_PATTERN_LEN;
mvm->wowlan.max_nd_match_sets = IWL_SCAN_MAX_PROFILES;
hw->wiphy->wowlan = &mvm->wowlan;
}
#endif
#ifdef CPTCFG_IWLWIFI_BCAST_FILTERING
/* assign default bcast filtering configuration */
mvm->bcast_filters = iwl_mvm_default_bcast_filters;
#endif
#ifdef CPTCFG_IWLMVM_VENDOR_CMDS
iwl_mvm_set_wiphy_vendor_commands(hw->wiphy);
#endif
zx_status_t ret = iwl_mvm_leds_init(mvm);
if (ret) {
return ret;
}
mvm->init_status |= IWL_MVM_INIT_STATUS_REG_HW_INIT_COMPLETE;
return ZX_OK;
}
#if 0 // NEEDS_PORTING
static bool iwl_mvm_defer_tx(struct iwl_mvm* mvm, struct ieee80211_sta* sta, struct sk_buff* skb) {
struct iwl_mvm_sta* mvmsta;
bool defer = false;
/*
* double check the IN_D0I3 flag both before and after
* taking the spinlock, in order to prevent taking
* the spinlock when not needed.
*/
if (likely(!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status))) { return false; }
spin_lock(&mvm->d0i3_tx_lock);
/*
* testing the flag again ensures the skb dequeue
* loop (on d0i3 exit) hasn't run yet.
*/
if (!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status)) { goto out; }
mvmsta = iwl_mvm_sta_from_mac80211(sta);
if (mvmsta->sta_id == IWL_MVM_INVALID_STA || mvmsta->sta_id != mvm->d0i3_ap_sta_id) {
goto out;
}
__skb_queue_tail(&mvm->d0i3_tx, skb);
/* trigger wakeup */
iwl_mvm_ref(mvm, IWL_MVM_REF_TX);
iwl_mvm_unref(mvm, IWL_MVM_REF_TX);
defer = true;
out:
spin_unlock(&mvm->d0i3_tx_lock);
return defer;
}
#endif // NEEDS_PORTING
zx_status_t iwl_mvm_mac_tx(struct iwl_mvm_vif* mvmvif, struct ieee80211_mac_packet* pkt) {
iwl_assert_lock_held(&mvmvif->mvm->mutex);
if (mvmvif->mac_role != WLAN_INFO_MAC_ROLE_CLIENT) {
IWL_ERR(mvmvif, "%s(): not supported MAC role %d yet\n", __func__, mvmvif->mac_role);
return ZX_ERR_INVALID_ARGS;
}
struct iwl_mvm_sta* mvmsta = mvmvif->mvm->fw_id_to_mac_id[mvmvif->ap_sta_id];
if (!mvmsta) {
IWL_ERR(mvmvif, "%s(): mvmsta is NULL. mvmvif->ap_sta_id=%d\n", __func__, mvmvif->ap_sta_id);
return ZX_ERR_INTERNAL;
}
return iwl_mvm_tx_skb(mvmvif->mvm, pkt, mvmsta);
#if 0 // NEEDS_PORTING
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
struct ieee80211_sta* sta = control->sta;
struct ieee80211_tx_info* info = IEEE80211_SKB_CB(skb);
struct ieee80211_hdr* hdr = (void*)skb->data;
bool offchannel = IEEE80211_SKB_CB(skb)->flags & IEEE80211_TX_CTL_TX_OFFCHAN;
if (iwl_mvm_is_radio_killed(mvm)) {
IWL_DEBUG_DROP(mvm, "Dropping - RF/CT KILL\n");
goto drop;
}
if (offchannel && !test_bit(IWL_MVM_STATUS_ROC_RUNNING, &mvm->status) &&
!test_bit(IWL_MVM_STATUS_ROC_AUX_RUNNING, &mvm->status)) {
goto drop;
}
/* treat non-bufferable MMPDUs on AP interfaces as broadcast */
if ((info->control.vif->type == NL80211_IFTYPE_AP ||
info->control.vif->type == NL80211_IFTYPE_ADHOC) &&
ieee80211_is_mgmt(hdr->frame_control) &&
!ieee80211_is_bufferable_mmpdu(hdr->frame_control)) {
sta = NULL;
}
/* If there is no sta, and it's not offchannel - send through AP */
if (!sta && info->control.vif->type == NL80211_IFTYPE_STATION && !offchannel) {
struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(info->control.vif);
uint8_t ap_sta_id = READ_ONCE(mvmvif->ap_sta_id);
if (ap_sta_id < IWL_MVM_STATION_COUNT) {
/* mac80211 holds rcu read lock */
sta = rcu_dereference(mvm->fw_id_to_mac_id[ap_sta_id]);
if (IS_ERR_OR_NULL(sta)) { goto drop; }
}
}
if (sta) {
if (iwl_mvm_defer_tx(mvm, sta, skb)) { return; }
if (iwl_mvm_tx_skb(mvm, skb, sta)) { goto drop; }
return;
}
if (iwl_mvm_tx_skb_non_sta(mvm, skb)) { goto drop; }
return;
drop:
ieee80211_free_txskb(hw, skb);
#endif // NEEDS_PORTING
}
void iwl_mvm_mac_itxq_xmit(struct ieee80211_hw* hw, struct ieee80211_txq* txq) {
#if 0 // NEEDS_PORTING
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
struct iwl_mvm_txq* mvmtxq = iwl_mvm_txq_from_mac80211(txq);
struct sk_buff* skb = NULL;
spin_lock(&mvmtxq->tx_path_lock);
rcu_read_lock();
while (likely(!mvmtxq->stopped && (mvm->trans->system_pm_mode == IWL_PLAT_PM_MODE_DISABLED))) {
skb = ieee80211_tx_dequeue(hw, txq);
if (!skb) { break; }
if (!txq->sta) {
iwl_mvm_tx_skb_non_sta(mvm, skb);
} else {
iwl_mvm_tx_skb(mvm, skb, txq->sta);
}
}
rcu_read_unlock();
spin_unlock(&mvmtxq->tx_path_lock);
#endif // NEEDS_PORTING
}
#if 0 // NEEDS_PORTING
static void iwl_mvm_mac_wake_tx_queue(struct ieee80211_hw* hw, struct ieee80211_txq* txq) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
struct iwl_mvm_txq* mvmtxq = iwl_mvm_txq_from_mac80211(txq);
/*
* Please note that racing is handled very carefully here:
* mvmtxq->txq_id is updated during allocation, and mvmtxq->list is
* deleted afterwards.
* This means that if:
* mvmtxq->txq_id != INVALID_QUEUE && list_empty(&mvmtxq->list):
* queue is allocated and we can TX.
* mvmtxq->txq_id != INVALID_QUEUE && !list_empty(&mvmtxq->list):
* a race, should defer the frame.
* mvmtxq->txq_id == INVALID_QUEUE && list_empty(&mvmtxq->list):
* need to allocate the queue and defer the frame.
* mvmtxq->txq_id == INVALID_QUEUE && !list_empty(&mvmtxq->list):
* queue is already scheduled for allocation, no need to allocate,
* should defer the frame.
*/
/* If the queue is allocated TX and return. */
if (!txq->sta || mvmtxq->txq_id != IWL_MVM_INVALID_QUEUE) {
/*
* Check that list is empty to avoid a race where txq_id is
* already updated, but the queue allocation work wasn't
* finished
*/
if (unlikely(txq->sta && !list_empty(&mvmtxq->list))) { return; }
iwl_mvm_mac_itxq_xmit(hw, txq);
return;
}
/* The list is being deleted only after the queue is fully allocated. */
if (!list_empty(&mvmtxq->list)) { return; }
list_add_tail(&mvmtxq->list, &mvm->add_stream_txqs);
schedule_work(&mvm->add_stream_wk);
}
static inline bool iwl_enable_rx_ampdu(const struct iwl_cfg* cfg) {
if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_RXAGG) { return false; }
return true;
}
static inline bool iwl_enable_tx_ampdu(const struct iwl_cfg* cfg) {
if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_TXAGG) { return false; }
if (iwlwifi_mod_params.disable_11n & IWL_ENABLE_HT_TXAGG) { return true; }
/* enabled by default */
return true;
}
#define CHECK_BA_TRIGGER(_mvm, _trig, _tid_bm, _tid, _fmt...) \
do { \
if (!(le16_to_cpu(_tid_bm) & BIT(_tid))) \
break; \
iwl_fw_dbg_collect_trig(&(_mvm)->fwrt, _trig, _fmt); \
} while (0)
static void iwl_mvm_ampdu_check_trigger(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
struct ieee80211_sta* sta, uint16_t tid, uint16_t rx_ba_ssn,
enum ieee80211_ampdu_mlme_action action) {
struct iwl_fw_dbg_trigger_tlv* trig;
struct iwl_fw_dbg_trigger_ba* ba_trig;
trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif), FW_DBG_TRIGGER_BA);
if (!trig) { return; }
ba_trig = (void*)trig->data;
switch (action) {
case IEEE80211_AMPDU_TX_OPERATIONAL: {
struct iwl_mvm_sta* mvmsta = iwl_mvm_sta_from_mac80211(sta);
struct iwl_mvm_tid_data* tid_data = &mvmsta->tid_data[tid];
CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_start, tid,
"TX AGG START: MAC %pM tid %d ssn %d\n", sta->addr, tid, tid_data->ssn);
break;
}
case IEEE80211_AMPDU_TX_STOP_CONT:
CHECK_BA_TRIGGER(mvm, trig, ba_trig->tx_ba_stop, tid, "TX AGG STOP: MAC %pM tid %d\n",
sta->addr, tid);
break;
case IEEE80211_AMPDU_RX_START:
CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_start, tid,
"RX AGG START: MAC %pM tid %d ssn %d\n", sta->addr, tid, rx_ba_ssn);
break;
case IEEE80211_AMPDU_RX_STOP:
CHECK_BA_TRIGGER(mvm, trig, ba_trig->rx_ba_stop, tid, "RX AGG STOP: MAC %pM tid %d\n",
sta->addr, tid);
break;
default:
break;
}
}
static int iwl_mvm_mac_ampdu_action(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
struct ieee80211_ampdu_params* params) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
int ret;
bool tx_agg_ref = false;
struct ieee80211_sta* sta = params->sta;
enum ieee80211_ampdu_mlme_action action = params->action;
uint16_t tid = params->tid;
uint16_t* ssn = &params->ssn;
uint16_t buf_size = params->buf_size;
bool amsdu = params->amsdu;
uint16_t timeout = params->timeout;
IWL_DEBUG_HT(mvm, "A-MPDU action on addr %pM tid %d: action %d\n", sta->addr, tid, action);
if (!(mvm->nvm_data->sku_cap_11n_enable)) { return -EACCES; }
/* return from D0i3 before starting a new Tx aggregation */
switch (action) {
case IEEE80211_AMPDU_TX_START:
case IEEE80211_AMPDU_TX_STOP_CONT:
case IEEE80211_AMPDU_TX_STOP_FLUSH:
case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
case IEEE80211_AMPDU_TX_OPERATIONAL:
/*
* for tx start, wait synchronously until D0i3 exit to
* get the correct sequence number for the tid.
* additionally, some other ampdu actions use direct
* target access, which is not handled automatically
* by the trans layer (unlike commands), so wait for
* d0i3 exit in these cases as well.
*/
ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_TX_AGG);
if (ret) { return ret; }
tx_agg_ref = true;
break;
default:
break;
}
mutex_lock(&mvm->mutex);
switch (action) {
case IEEE80211_AMPDU_RX_START:
if (iwl_mvm_vif_from_mac80211(vif)->ap_sta_id == iwl_mvm_sta_from_mac80211(sta)->sta_id) {
struct iwl_mvm_vif* mvmvif;
uint16_t macid = iwl_mvm_vif_from_mac80211(vif)->id;
struct iwl_mvm_tcm_mac* mdata = &mvm->tcm.data[macid];
mdata->opened_rx_ba_sessions = true;
mvmvif = iwl_mvm_vif_from_mac80211(vif);
cancel_delayed_work(&mvmvif->uapsd_nonagg_detected_wk);
}
if (!iwl_enable_rx_ampdu(mvm->cfg)) {
ret = -EINVAL;
break;
}
ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, *ssn, true, buf_size, timeout);
break;
case IEEE80211_AMPDU_RX_STOP:
ret = iwl_mvm_sta_rx_agg(mvm, sta, tid, 0, false, buf_size, timeout);
break;
case IEEE80211_AMPDU_TX_START:
if (!iwl_enable_tx_ampdu(mvm->cfg)) {
ret = -EINVAL;
break;
}
ret = iwl_mvm_sta_tx_agg_start(mvm, vif, sta, tid, ssn);
break;
case IEEE80211_AMPDU_TX_STOP_CONT:
ret = iwl_mvm_sta_tx_agg_stop(mvm, vif, sta, tid);
break;
case IEEE80211_AMPDU_TX_STOP_FLUSH:
case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
ret = iwl_mvm_sta_tx_agg_flush(mvm, vif, sta, tid);
break;
case IEEE80211_AMPDU_TX_OPERATIONAL:
ret = iwl_mvm_sta_tx_agg_oper(mvm, vif, sta, tid, buf_size, amsdu);
break;
default:
WARN_ON_ONCE(1);
ret = -EINVAL;
break;
}
if (!ret) {
uint16_t rx_ba_ssn = 0;
if (action == IEEE80211_AMPDU_RX_START) { rx_ba_ssn = *ssn; }
iwl_mvm_ampdu_check_trigger(mvm, vif, sta, tid, rx_ba_ssn, action);
}
mutex_unlock(&mvm->mutex);
/*
* If the tid is marked as started, we won't use it for offloaded
* traffic on the next D0i3 entry. It's safe to unref.
*/
if (tx_agg_ref) { iwl_mvm_unref(mvm, IWL_MVM_REF_TX_AGG); }
return ret;
}
static void iwl_mvm_cleanup_iterator(void* data, uint8_t* mac, struct ieee80211_vif* vif) {
struct iwl_mvm* mvm = data;
struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
mvmvif->uploaded = false;
mvmvif->ap_sta_id = IWL_MVM_INVALID_STA;
spin_lock_bh(&mvm->time_event_lock);
iwl_mvm_te_clear_data(mvm, &mvmvif->time_event_data);
spin_unlock_bh(&mvm->time_event_lock);
mvmvif->phy_ctxt = NULL;
memset(&mvmvif->bf_data, 0, sizeof(mvmvif->bf_data));
memset(&mvmvif->probe_resp_data, 0, sizeof(mvmvif->probe_resp_data));
}
#endif // NEEDS_PORTING
static void iwl_mvm_restart_cleanup(struct iwl_mvm* mvm) {
#if 0 // NEEDS_PORTING
/* clear the D3 reconfig, we only need it to avoid dumping a
* firmware coredump on reconfiguration, we shouldn't do that
* on D3->D0 transition
*/
if (!test_and_clear_bit(IWL_MVM_STATUS_D3_RECONFIG, &mvm->status)) {
mvm->fwrt.dump.desc = &iwl_dump_desc_assert;
iwl_fw_error_dump(&mvm->fwrt);
#ifdef CPTCFG_IWLWIFI_DEVICE_TESTMODE
iwl_dnt_dispatch_handle_nic_err(mvm->trans);
#endif
}
#endif // NEEDS_PORTING
/* cleanup all stale references (scan, roc), but keep the
* ucode_down ref until reconfig is complete
*/
iwl_mvm_unref_all_except(mvm, IWL_MVM_REF_UCODE_DOWN);
iwl_mvm_stop_device(mvm);
mvm->scan_status = 0;
mvm->ps_disabled = false;
mvm->calibrating = false;
#ifdef CPTCFG_IWLWIFI_FRQ_MGR
/*
* In case that 2g coex was enabled - and now the FW is being
* restarted, we need to disable 2g coex mode in the driver as well
* so that the fw & driver will be synced on the mode.
*/
mvm->coex_2g_enabled = false;
#endif
#if 0 // NEEDS_PORTING
/* just in case one was running */
iwl_mvm_cleanup_roc_te(mvm);
ieee80211_remain_on_channel_expired(mvm->hw);
#endif // NEEDS_PORTING
#if 0 // NEEDS_PORTING
/*
* cleanup all interfaces, even inactive ones, as some might have
* gone down during the HW restart
*/
ieee80211_iterate_interfaces(mvm->hw, 0, iwl_mvm_cleanup_iterator, mvm);
#endif // NEEDS_PORTING
mvm->p2p_device_vif = NULL;
mvm->d0i3_ap_sta_id = IWL_MVM_INVALID_STA;
iwl_mvm_reset_phy_ctxts(mvm);
memset(mvm->fw_key_table, 0, sizeof(mvm->fw_key_table));
memset(&mvm->last_bt_notif, 0, sizeof(mvm->last_bt_notif));
memset(&mvm->last_bt_ci_cmd, 0, sizeof(mvm->last_bt_ci_cmd));
#if 0 // NEEDS_PORTING
ieee80211_wake_queues(mvm->hw);
#endif // NEEDS_PORTING
/* clear any stale d0i3 state */
clear_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status);
mvm->vif_count = 0;
mvm->rx_ba_sessions = 0;
mvm->fwrt.dump.conf = FW_DBG_INVALID;
mvm->monitor_on = false;
/* keep statistics ticking */
iwl_mvm_accu_radio_stats(mvm);
}
zx_status_t __iwl_mvm_mac_start(struct iwl_mvm* mvm) {
zx_status_t ret;
iwl_assert_lock_held(&mvm->mutex);
if (test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status)) {
/*
* Now convert the HW_RESTART_REQUESTED flag to IN_HW_RESTART
* so later code will - from now on - see that we're doing it.
*/
set_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
clear_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status);
/* Clean up some internal and mac80211 state on restart */
iwl_mvm_restart_cleanup(mvm);
} else {
/* Hold the reference to prevent runtime suspend while
* the start procedure runs. It's a bit confusing
* that the UCODE_DOWN reference is taken, but it just
* means "UCODE is not UP yet". ( TODO: rename this
* reference).
*/
iwl_mvm_ref(mvm, IWL_MVM_REF_UCODE_DOWN);
}
ret = iwl_mvm_up(mvm);
#if 0 // NEEDS_PORTING
iwl_fw_dbg_apply_point(&mvm->fwrt, IWL_FW_INI_APPLY_POST_INIT);
#endif // NEEDS_PORTING
if (ret && test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
/* Something went wrong - we need to finish some cleanup
* that normally iwl_mvm_mac_restart_complete() below
* would do.
*/
clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
#ifdef CONFIG_PM
iwl_mvm_d0i3_enable_tx(mvm, NULL);
#endif
}
return ret;
}
zx_status_t iwl_mvm_mac_start(struct iwl_mvm* mvm) {
zx_status_t ret;
#if 0 // NEEDS_PORTING
/* Some hw restart cleanups must not hold the mutex */
if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
/*
* Make sure we are out of d0i3. This is needed
* to make sure the reference accounting is correct
* (and there is no stale d0i3_exit_work).
*/
wait_event_timeout(mvm->d0i3_exit_waitq, !test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status),
HZ);
}
#endif // NEEDS_PORTING
mtx_lock(&mvm->mutex);
ret = __iwl_mvm_mac_start(mvm);
mtx_unlock(&mvm->mutex);
return ret;
}
#if 0 // NEEDS_PORTING
static void iwl_mvm_restart_complete(struct iwl_mvm* mvm) {
int ret;
mutex_lock(&mvm->mutex);
clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status);
#ifdef CONFIG_PM
iwl_mvm_d0i3_enable_tx(mvm, NULL);
#endif
ret = iwl_mvm_update_quotas(mvm, true, NULL);
if (ret) { IWL_ERR(mvm, "Failed to update quotas after restart (%d)\n", ret); }
/* allow transport/FW low power modes */
iwl_mvm_unref(mvm, IWL_MVM_REF_UCODE_DOWN);
/*
* If we have TDLS peers, remove them. We don't know the last seqno/PN
* of packets the FW sent out, so we must reconnect.
*/
iwl_mvm_teardown_tdls_peers(mvm);
mutex_unlock(&mvm->mutex);
}
static void iwl_mvm_resume_complete(struct iwl_mvm* mvm) {
if (iwl_mvm_is_d0i3_supported(mvm) && iwl_mvm_enter_d0i3_on_suspend(mvm))
WARN_ONCE(!wait_event_timeout(mvm->d0i3_exit_waitq,
!test_bit(IWL_MVM_STATUS_IN_D0I3, &mvm->status), HZ),
"D0i3 exit on resume timed out\n");
}
static void iwl_mvm_mac_reconfig_complete(struct ieee80211_hw* hw,
enum ieee80211_reconfig_type reconfig_type) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
switch (reconfig_type) {
case IEEE80211_RECONFIG_TYPE_RESTART:
iwl_mvm_restart_complete(mvm);
break;
case IEEE80211_RECONFIG_TYPE_SUSPEND:
iwl_mvm_resume_complete(mvm);
break;
}
}
#endif // NEEDS_PORTING
void __iwl_mvm_mac_stop(struct iwl_mvm* mvm) {
iwl_assert_lock_held(&mvm->mutex);
/* firmware counters are obviously reset now, but we shouldn't
* partially track so also clear the fw_reset_accu counters.
*/
memset(&mvm->accu_radio_stats, 0, sizeof(mvm->accu_radio_stats));
/* async_handlers_wk is now blocked */
#if 0 // NEEDS_PORTING
/*
* The work item could be running or queued if the
* ROC time event stops just as we get here.
*/
flush_work(&mvm->roc_done_wk);
#endif // NEEDS_PORTING
iwl_mvm_stop_device(mvm);
iwl_mvm_async_handlers_purge(mvm);
/* async_handlers_list is empty and will stay empty: HW is stopped */
#if 0 // NEEDS_PORTING
/* the fw is stopped, the aux sta is dead: clean up driver state */
iwl_mvm_del_aux_sta(mvm);
/*
* Clear IN_HW_RESTART and HW_RESTART_REQUESTED flag when stopping the
* hw (as restart_complete() won't be called in this case) and mac80211
* won't execute the restart.
* But make sure to cleanup interfaces that have gone down before/during
* HW restart was requested.
*/
if (test_and_clear_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) ||
test_and_clear_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status)) {
ieee80211_iterate_interfaces(mvm->hw, 0, iwl_mvm_cleanup_iterator, mvm);
}
#endif // NEEDS_PORTING
/* We shouldn't have any UIDs still set. Loop over all the UIDs to
* make sure there's nothing left there and warn if any is found.
*/
if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
for (unsigned int i = 0; i < mvm->max_scans; i++) {
if (mvm->scan_uid_status[i]) {
IWL_WARN(mvm, "UMAC scan UID %d status was not cleaned\n", i);
mvm->scan_uid_status[i] = 0;
}
}
}
}
void iwl_mvm_mac_stop(struct iwl_mvm* mvm) {
#if 0 // NEEDS_PORTING
flush_work(&mvm->d0i3_exit_work);
flush_work(&mvm->async_handlers_wk);
flush_work(&mvm->add_stream_wk);
#endif // NEEDS_PORTING
/*
* Lock and clear the firmware running bit here already, so that
* new commands coming in elsewhere, e.g. from debugfs, will not
* be able to proceed. This is important here because one of those
* debugfs files causes the firmware dump to be triggered, and if we
* don't stop debugfs accesses before canceling that it could be
* retriggered after we flush it but before we've cleared the bit.
*/
clear_bit(IWL_MVM_STATUS_FIRMWARE_RUNNING, &mvm->status);
iwl_fw_cancel_dump(&mvm->fwrt);
#if 0 // NEEDS_PORTING
#ifdef CPTCFG_MAC80211_LATENCY_MEASUREMENTS
cancel_delayed_work_sync(&mvm->tx_latency_watchdog_wk);
#endif /* CPTCFG_MAC80211_LATENCY_MEASUREMENTS */
cancel_delayed_work_sync(&mvm->cs_tx_unblock_dwork);
#endif // NEEDS_PORTING
iwl_task_release_sync(mvm->scan_timeout_task);
mvm->scan_timeout_task = NULL;
iwl_fw_free_dump_desc(&mvm->fwrt);
mtx_lock(&mvm->mutex);
__iwl_mvm_mac_stop(mvm);
mtx_unlock(&mvm->mutex);
#if 0 // NEEDS_PORTING
/*
* The worker might have been waiting for the mutex, let it run and
* discover that its list is now empty.
*/
cancel_work_sync(&mvm->async_handlers_wk);
#endif // NEEDS_PORTING
}
static struct iwl_mvm_phy_ctxt* iwl_mvm_get_free_phy_ctxt(struct iwl_mvm* mvm) {
uint16_t i;
iwl_assert_lock_held(&mvm->mutex);
for (i = 0; i < NUM_PHY_CTX; i++) {
if (!mvm->phy_ctxts[i].ref) {
return &mvm->phy_ctxts[i];
}
}
IWL_ERR(mvm, "No available PHY context\n");
return NULL;
}
#if 0 // NEEDS_PORTING
static int iwl_mvm_set_tx_power(struct iwl_mvm* mvm, struct ieee80211_vif* vif, int16_t tx_power) {
int len;
union {
struct iwl_dev_tx_power_cmd v5;
struct iwl_dev_tx_power_cmd_v4 v4;
} cmd = {
.v5.v3.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_MAC),
.v5.v3.mac_context_id = cpu_to_le32(iwl_mvm_vif_from_mac80211(vif)->id),
.v5.v3.pwr_restriction = cpu_to_le16(8 * tx_power),
};
#ifdef CPTCFG_IWLWIFI_FRQ_MGR
struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
/*
* if set Tx power request did not come from Frequency Manager(FM)
* Take minimum between wanted Tx power to FM Tx power limit
*/
if (mvmvif->phy_ctxt && tx_power > mvmvif->phy_ctxt->fm_tx_power_limit) {
cmd.v5.v3.pwr_restriction = cpu_to_le16(mvmvif->phy_ctxt->fm_tx_power_limit);
}
#endif
if (tx_power == IWL_DEFAULT_MAX_TX_POWER) {
cmd.v5.v3.pwr_restriction = cpu_to_le16(IWL_DEV_MAX_TX_POWER);
}
if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_REDUCE_TX_POWER)) {
len = sizeof(cmd.v5);
} else if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TX_POWER_ACK)) {
len = sizeof(cmd.v4);
} else {
len = sizeof(cmd.v4.v3);
}
return iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
}
#ifdef CPTCFG_IWLWIFI_FRQ_MGR
int iwl_mvm_fm_set_tx_power(struct iwl_mvm* mvm, struct ieee80211_vif* vif, int8_t txpower) {
int ret;
mutex_lock(&mvm->mutex);
/* set Tx power to min between drivers limit and FM limit */
ret = iwl_mvm_set_tx_power(mvm, vif, min_t(int8_t, txpower, vif->bss_conf.txpower));
mutex_unlock(&mvm->mutex);
return ret;
}
/*
* Updates Tx power limitation for the mac if FM has already limited
* the Tx power on the channel that this mac is using.
*/
static void iwl_mvm_update_ctx_tx_power_limit(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
struct iwl_mvm_phy_ctxt* phy_ctxt) {
/* Tx power has not been limited by FM */
if (phy_ctxt->fm_tx_power_limit == IWL_DEFAULT_MAX_TX_POWER) { return; }
iwl_mvm_set_tx_power(mvm, vif, phy_ctxt->fm_tx_power_limit);
}
#endif
#endif // NEEDS_PORTING
zx_status_t iwl_mvm_find_free_mvmvif_slot(struct iwl_mvm* mvm, int* ret_idx) {
int idx;
ZX_ASSERT(ret_idx);
iwl_assert_lock_held(&mvm->mutex);
for (idx = 0; idx < MAX_NUM_MVMVIF; idx++) {
if (!mvm->mvmvif[idx]) {
*ret_idx = idx;
return ZX_OK;
}
}
return ZX_ERR_NO_RESOURCES;
}
// This function doesn't take the ownership of the mvmvif after binding. It just adds a reference
// from mvm to the mvmvif instance.
zx_status_t iwl_mvm_bind_mvmvif(struct iwl_mvm* mvm, int idx, struct iwl_mvm_vif* mvmvif) {
iwl_assert_lock_held(&mvm->mutex);
ZX_ASSERT(mvmvif);
if (mvm->mvmvif[idx]) {
IWL_ERR(mvm, "mvm->mvmvif[%d] has been binded.\n", idx);
return ZX_ERR_ALREADY_EXISTS;
}
mvm->mvmvif[idx] = mvmvif;
return ZX_OK;
}
void iwl_mvm_unbind_mvmvif(struct iwl_mvm* mvm, int idx) {
iwl_assert_lock_held(&mvm->mutex);
mvm->mvmvif[idx] = NULL;
}
zx_status_t iwl_mvm_mac_add_interface(struct iwl_mvm_vif* mvmvif) {
struct iwl_mvm* mvm = mvmvif->mvm;
mvmvif->probe_resp_data = NULL;
/*
* make sure D0i3 exit is completed, otherwise a target access
* during tx queue configuration could be done when still in
* D0i3 state.
*/
zx_status_t ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_ADD_IF);
if (ret != ZX_OK) {
return ret;
}
/*
* Not much to do here. The stack will not allow interface
* types or combinations that we didn't advertise, so we
* don't really have to check the types.
*/
mtx_lock(&mvm->mutex);
/* make sure that beacon statistics don't go backwards with FW reset */
if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
mvmvif->beacon_stats.accu_num_beacons += mvmvif->beacon_stats.num_beacons;
}
/* Allocate resources for the MAC context, and add it to the fw */
ret = iwl_mvm_mac_ctxt_init(mvmvif);
if (ret != ZX_OK) {
goto out_unlock;
}
#if 0 // NEEDS_PORTING
/* Currently not much to do for NAN */
if (vif->type == NL80211_IFTYPE_NAN) { goto out_unlock; }
/* Counting number of interfaces is needed for legacy PM */
if (vif->type != NL80211_IFTYPE_P2P_DEVICE) { mvm->vif_count++; }
/*
* The AP binding flow can be done only after the beacon
* template is configured (which happens only in the mac80211
* start_ap() flow), and adding the broadcast station can happen
* only after the binding.
* In addition, since modifying the MAC before adding a bcast
* station is not allowed by the FW, delay the adding of MAC context to
* the point where we can also add the bcast station.
* In short: there's not much we can do at this point, other than
* allocating resources :)
*/
if (vif->type == NL80211_IFTYPE_AP || vif->type == NL80211_IFTYPE_ADHOC) {
ret = iwl_mvm_alloc_bcast_sta(mvm, vif);
if (ret) {
IWL_ERR(mvm, "Failed to allocate bcast sta\n");
goto out_release;
}
/*
* Only queue for this station is the mcast queue,
* which shouldn't be in TFD mask anyway
*/
ret = iwl_mvm_allocate_int_sta(mvm, &mvmvif->mcast_sta, 0, vif->type, IWL_STA_MULTICAST);
if (ret) { goto out_release; }
iwl_mvm_vif_dbgfs_register(mvm, vif);
goto out_unlock;
}
mvmvif->features |= hw->netdev_features;
#endif // NEEDS_PORTING
mvm->vif_count++;
ret = iwl_mvm_mac_ctxt_add(mvmvif);
if (ret != ZX_OK) {
goto out_release;
}
#if 0 // NEEDS_PORTING
ret = iwl_mvm_power_update_mac(mvm);
if (ret) { goto out_remove_mac; }
/* beacon filtering */
ret = iwl_mvm_disable_beacon_filter(mvm, vif, 0);
if (ret != ZX_OK) { goto out_remove_mac; }
if (!mvm->bf_allowed_vif && vif->type == NL80211_IFTYPE_STATION && !vif->p2p) {
mvm->bf_allowed_vif = mvmvif;
vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER | IEEE80211_VIF_SUPPORTS_CQM_RSSI;
}
/*
* P2P_DEVICE interface does not have a channel context assigned to it,
* so a dedicated PHY context is allocated to it and the corresponding
* MAC context is bound to it at this stage.
*/
if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
mvmvif->phy_ctxt = iwl_mvm_get_free_phy_ctxt(mvm);
if (!mvmvif->phy_ctxt) {
ret = -ENOSPC;
goto out_free_bf;
}
iwl_mvm_phy_ctxt_ref(mvm, mvmvif->phy_ctxt);
ret = iwl_mvm_binding_add_vif(mvm, vif);
if (ret) { goto out_unref_phy; }
#ifdef CPTCFG_IWLWIFI_FRQ_MGR
iwl_mvm_update_ctx_tx_power_limit(mvm, vif, mvmvif->phy_ctxt);
#endif
ret = iwl_mvm_add_p2p_bcast_sta(mvm, vif);
if (ret) { goto out_unbind; }
/* Save a pointer to p2p device vif, so it can later be used to
* update the p2p device MAC when a GO is started/stopped */
mvm->p2p_device_vif = vif;
}
iwl_mvm_tcm_add_vif(mvm, vif);
if (vif->type == NL80211_IFTYPE_MONITOR) { mvm->monitor_on = true; }
iwl_mvm_vif_dbgfs_register(mvm, vif);
#endif // NEEDS_PORTING
goto out_unlock;
#if 0 // NEEDS_PORTING
out_unbind:
iwl_mvm_binding_remove_vif(mvm, vif);
out_unref_phy:
iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
out_free_bf:
if (mvm->bf_allowed_vif == mvmvif) {
mvm->bf_allowed_vif = NULL;
vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER | IEEE80211_VIF_SUPPORTS_CQM_RSSI);
}
out_remove_mac:
#endif // NEEDS_PORTING
mvmvif->phy_ctxt = NULL;
iwl_mvm_mac_ctxt_remove(mvmvif);
out_release:
#if 0 // NEEDS_PORTING
if (vif->type != NL80211_IFTYPE_P2P_DEVICE) { mvm->vif_count--; }
#endif // NEEDS_PORTING
mvm->vif_count--;
out_unlock:
mtx_unlock(&mvm->mutex);
iwl_mvm_unref(mvm, IWL_MVM_REF_ADD_IF);
return ret;
}
#if 0 // NEEDS_PORTING
static void iwl_mvm_prepare_mac_removal(struct iwl_mvm* mvm, struct ieee80211_vif* vif) {
if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
/*
* Flush the ROC worker which will flush the OFFCHANNEL queue.
* We assume here that all the packets sent to the OFFCHANNEL
* queue are sent in ROC session.
*/
flush_work(&mvm->roc_done_wk);
}
}
#endif // NEEDS_PORTING
zx_status_t iwl_mvm_mac_remove_interface(struct iwl_mvm_vif* mvmvif) {
struct iwl_mvm* mvm = mvmvif->mvm;
#if 0 // NEEDS_PORTING
iwl_mvm_prepare_mac_removal(mvm, vif);
if (vif->type == NL80211_IFTYPE_NAN) {
struct wireless_dev* wdev = ieee80211_vif_to_wdev(vif);
/* cfg80211 should stop NAN before interface removal */
if (wdev && WARN_ON(wdev_running(wdev))) { iwl_mvm_stop_nan(hw, vif); }
return;
}
if (!(vif->type == NL80211_IFTYPE_AP || vif->type == NL80211_IFTYPE_ADHOC)) {
iwl_mvm_tcm_rm_vif(mvm, vif);
}
#endif // NEEDS_PORTING
mtx_lock(&mvm->mutex);
free(mvmvif->probe_resp_data);
mvmvif->probe_resp_data = NULL;
#if 0 // NEEDS_PORTING
if (mvm->bf_allowed_vif == mvmvif) {
mvm->bf_allowed_vif = NULL;
vif->driver_flags &= ~(IEEE80211_VIF_BEACON_FILTER | IEEE80211_VIF_SUPPORTS_CQM_RSSI);
}
iwl_mvm_vif_dbgfs_clean(mvm, vif);
/*
* For AP/GO interface, the tear down of the resources allocated to the
* interface is be handled as part of the stop_ap flow.
*/
if (vif->type == NL80211_IFTYPE_AP || vif->type == NL80211_IFTYPE_ADHOC) {
#ifdef CPTCFG_NL80211_TESTMODE
if (vif == mvm->noa_vif) {
mvm->noa_vif = NULL;
mvm->noa_duration = 0;
}
#endif
iwl_mvm_dealloc_int_sta(mvm, &mvmvif->mcast_sta);
iwl_mvm_dealloc_bcast_sta(mvm, vif);
goto out_release;
}
#endif // NEEDS_PORTING
#ifdef CPTCFG_IWLMVM_P2P_OPPPS_TEST_WA
if (mvmvif == mvm->p2p_opps_test_wa_vif) {
mvm->p2p_opps_test_wa_vif = NULL;
}
#endif
#if 0 // NEEDS_PORTING
if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
mvm->p2p_device_vif = NULL;
iwl_mvm_rm_p2p_bcast_sta(mvm, vif);
iwl_mvm_binding_remove_vif(mvm, vif);
iwl_mvm_phy_ctxt_unref(mvm, mvmvif->phy_ctxt);
mvmvif->phy_ctxt = NULL;
}
if (mvm->vif_count && vif->type != NL80211_IFTYPE_P2P_DEVICE) { mvm->vif_count--; }
#endif // NEEDS_PORTING
if (mvm->vif_count) {
mvm->vif_count--;
}
#if 0 // NEEDS_PORTING
iwl_mvm_power_update_mac(mvm);
#endif // NEEDS_PORTING
zx_status_t ret = iwl_mvm_mac_ctxt_remove(mvmvif);
#if 0 // NEEDS_PORTING
if (vif->type == NL80211_IFTYPE_MONITOR) { mvm->monitor_on = false; }
#endif // NEEDS_PORTING
#ifdef CPTCFG_IWLMVM_TDLS_PEER_CACHE
iwl_mvm_tdls_peer_cache_clear(mvm, vif);
#endif /* CPTCFG_IWLMVM_TDLS_PEER_CACHE */
#if 0 // NEEDS_PORTING
out_release:
#endif // NEEDS_PORTING
mtx_unlock(&mvm->mutex);
return ret;
}
#if 0 // NEEDS_PORTING
static int iwl_mvm_mac_config(struct ieee80211_hw* hw, uint32_t changed) {
return 0;
}
#endif // NEEDS_PORTING
struct iwl_mvm_mc_iter_data {
struct iwl_mvm* mvm;
int port_id;
};
// Once the interface becomes an associated client interface, the driver uses the pre-configured
// MCAST_FILTER_CMD to tell firmware the multicast packets it is interested so that the firmware
// can forward them to driver when the firmware receives them.
//
static void iwl_mvm_mc_iface_iterator(void* _data, struct iwl_mvm_vif* mvmvif) {
struct iwl_mvm_mc_iter_data* data = _data;
struct iwl_mvm* mvm = data->mvm;
struct iwl_mcast_filter_cmd* cmd = mvm->mcast_filter_cmd;
struct iwl_host_cmd hcmd = {
.id = MCAST_FILTER_CMD,
.flags = CMD_ASYNC,
.dataflags[0] = IWL_HCMD_DFL_NOCOPY,
};
int ret, len;
#ifdef CPTCFG_IWLMVM_VENDOR_CMDS
if (!(mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_EINVAL) && mvm->mcast_active_filter_cmd) {
cmd = mvm->mcast_active_filter_cmd;
}
#endif
/* if we don't have free ports, mcast frames will be dropped */
if (data->port_id >= MAX_PORT_ID_NUM) {
IWL_WARN(mvmvif, "%s(): port id (%d) is larger than max port number (%d)\n", __func__,
data->port_id, MAX_PORT_ID_NUM);
return;
}
// Only associated client interface can continue. Other interfaces will be ignored.
if (mvmvif->mac_role != WLAN_INFO_MAC_ROLE_CLIENT ||
mvmvif->mvm->fw_id_to_mac_id[0]->sta_state != IWL_STA_AUTHORIZED) {
IWL_ERR(mvmvif, "unexpected state while setting mcast filter. role: %d!=%d or state: %d!=%d\n",
mvmvif->mac_role, WLAN_INFO_MAC_ROLE_CLIENT, mvmvif->mvm->fw_id_to_mac_id[0]->sta_state,
IWL_STA_AUTHORIZED);
return;
}
cmd->port_id = data->port_id++;
memcpy(cmd->bssid, mvmvif->bss_conf.bssid, ETH_ALEN);
len = ROUND_UP(sizeof(*cmd) + cmd->count * ETH_ALEN, 4);
hcmd.len[0] = len;
hcmd.data[0] = cmd;
ret = iwl_mvm_send_cmd(mvm, &hcmd);
if (ret != ZX_OK) {
IWL_ERR(mvmvif, "mcast filter cmd error. ret=%s\n", zx_status_get_string(ret));
}
}
// Traverse all interfaces and set the multicast filter for associated client interface.
static void iwl_mvm_recalc_multicast(struct iwl_mvm* mvm) {
struct iwl_mvm_mc_iter_data iter_data = {
.mvm = mvm,
};
iwl_assert_lock_held(&mvm->mutex);
if (!mvm->mcast_filter_cmd) {
IWL_WARN(mvm, "%s(): mcast_filter_cmd is NULL\n", __func__);
return;
}
ieee80211_iterate_active_interfaces_atomic(mvm, iwl_mvm_mc_iface_iterator, &iter_data);
}
#if 0 // NEEDS_PORTING
// TODO(51238): implement iwl_mvm_prepare_multicast()
static uint64_t iwl_mvm_prepare_multicast(struct ieee80211_hw* hw,
struct netdev_hw_addr_list* mc_list) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
struct iwl_mcast_filter_cmd* cmd;
struct netdev_hw_addr* addr;
int addr_count;
bool pass_all;
int len;
addr_count = netdev_hw_addr_list_count(mc_list);
pass_all = addr_count > MAX_MCAST_FILTERING_ADDRESSES || IWL_MVM_FW_MCAST_FILTER_PASS_ALL;
if (pass_all) { addr_count = 0; }
len = roundup(sizeof(*cmd) + addr_count * ETH_ALEN, 4);
cmd = kzalloc(len, GFP_ATOMIC);
if (!cmd) { return 0; }
if (pass_all) {
cmd->pass_all = 1;
return (uint64_t)(unsigned long)cmd;
}
netdev_hw_addr_list_for_each(addr, mc_list) {
IWL_DEBUG_MAC80211(mvm, "mcast addr (%d): %pM\n", cmd->count, addr->addr);
memcpy(&cmd->addr_list[cmd->count * ETH_ALEN], addr->addr, ETH_ALEN);
cmd->count++;
}
return (uint64_t)(unsigned long)cmd;
}
#endif // NEEDS_PORTING
void iwl_mvm_configure_filter(struct iwl_mvm* mvm) {
// There are 3 multicast addresses we want firmware to pass it to driver.
// TODO(51238): remove the hardcoded mcast_addrs after iwl_mvm_prepare_multicast() is implemented.
uint8_t mcast_addrs[][ETH_ALEN] = {
{
// IPv6 mutlicast address
0x33,
0x33,
0x00,
0x00,
0x00,
0x01,
},
{
// IPv6 mutlicast address
0x33,
0x33,
0x00,
0x00,
0x00,
0x02,
},
{
// IPv4 mutlicast address
0x01,
0x00,
0x5e,
0x00,
0x00,
0x01,
},
};
struct iwl_mcast_filter_cmd* cmd =
calloc(1, sizeof(struct iwl_mcast_filter_cmd) + sizeof(mcast_addrs));
mtx_lock(&mvm->mutex);
/* replace previous configuration */
free(mvm->mcast_filter_cmd);
mvm->mcast_filter_cmd = cmd;
if (!cmd) {
goto out;
}
if (cmd->pass_all) {
cmd->count = 0;
}
for (size_t i = 0; i < ARRAY_SIZE(mcast_addrs); i++) {
size_t offset = i * ETH_ALEN;
memcpy(&cmd->addr_list[offset], mcast_addrs[i], ETH_ALEN);
}
cmd->count = ARRAY_SIZE(mcast_addrs);
#ifdef CPTCFG_IWLMVM_VENDOR_CMDS
iwl_mvm_active_rx_filters(mvm);
#endif
iwl_mvm_recalc_multicast(mvm);
out:
mtx_unlock(&mvm->mutex);
}
#if 0 // NEEDS_PORTING
static void iwl_mvm_config_iface_filter(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
unsigned int filter_flags, unsigned int changed_flags) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
/* We support only filter for probe requests */
if (!(changed_flags & FIF_PROBE_REQ)) { return; }
/* Supported only for p2p client interfaces */
if (vif->type != NL80211_IFTYPE_STATION || !vif->bss_conf.assoc || !vif->p2p) { return; }
mutex_lock(&mvm->mutex);
iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
mutex_unlock(&mvm->mutex);
}
#ifdef CPTCFG_IWLWIFI_BCAST_FILTERING
struct iwl_bcast_iter_data {
struct iwl_mvm* mvm;
struct iwl_bcast_filter_cmd* cmd;
uint8_t current_filter;
};
static void iwl_mvm_set_bcast_filter(struct ieee80211_vif* vif,
const struct iwl_fw_bcast_filter* in_filter,
struct iwl_fw_bcast_filter* out_filter) {
struct iwl_fw_bcast_filter_attr* attr;
int i;
memcpy(out_filter, in_filter, sizeof(*out_filter));
for (i = 0; i < ARRAY_SIZE(out_filter->attrs); i++) {
attr = &out_filter->attrs[i];
if (!attr->mask) { break; }
switch (attr->reserved1) {
case cpu_to_le16(BC_FILTER_MAGIC_IP):
if (vif->bss_conf.arp_addr_cnt != 1) {
attr->mask = 0;
continue;
}
attr->val = vif->bss_conf.arp_addr_list[0];
break;
case cpu_to_le16(BC_FILTER_MAGIC_MAC):
attr->val = *(__be32*)&vif->addr[2];
break;
default:
break;
}
attr->reserved1 = 0;
out_filter->num_attrs++;
}
}
static void iwl_mvm_bcast_filter_iterator(void* _data, uint8_t* mac, struct ieee80211_vif* vif) {
struct iwl_bcast_iter_data* data = _data;
struct iwl_mvm* mvm = data->mvm;
struct iwl_bcast_filter_cmd* cmd = data->cmd;
struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
struct iwl_fw_bcast_mac* bcast_mac;
int i;
if (WARN_ON(mvmvif->id >= ARRAY_SIZE(cmd->macs))) { return; }
bcast_mac = &cmd->macs[mvmvif->id];
/*
* enable filtering only for associated stations, but not for P2P
* Clients
*/
if (vif->type != NL80211_IFTYPE_STATION || vif->p2p || !vif->bss_conf.assoc) { return; }
bcast_mac->default_discard = 1;
/* copy all configured filters */
for (i = 0; mvm->bcast_filters[i].attrs[0].mask; i++) {
/*
* Make sure we don't exceed our filters limit.
* if there is still a valid filter to be configured,
* be on the safe side and just allow bcast for this mac.
*/
if (WARN_ON_ONCE(data->current_filter >= ARRAY_SIZE(cmd->filters))) {
bcast_mac->default_discard = 0;
bcast_mac->attached_filters = 0;
break;
}
iwl_mvm_set_bcast_filter(vif, &mvm->bcast_filters[i], &cmd->filters[data->current_filter]);
/* skip current filter if it contains no attributes */
if (!cmd->filters[data->current_filter].num_attrs) { continue; }
/* attach the filter to current mac */
bcast_mac->attached_filters |= cpu_to_le16(BIT(data->current_filter));
data->current_filter++;
}
}
bool iwl_mvm_bcast_filter_build_cmd(struct iwl_mvm* mvm, struct iwl_bcast_filter_cmd* cmd) {
struct iwl_bcast_iter_data iter_data = {
.mvm = mvm,
.cmd = cmd,
};
if (IWL_MVM_FW_BCAST_FILTER_PASS_ALL) { return false; }
memset(cmd, 0, sizeof(*cmd));
cmd->max_bcast_filters = ARRAY_SIZE(cmd->filters);
cmd->max_macs = ARRAY_SIZE(cmd->macs);
#ifdef CPTCFG_IWLWIFI_DEBUGFS
/* use debugfs filters/macs if override is configured */
if (mvm->dbgfs_bcast_filtering.override) {
memcpy(cmd->filters, &mvm->dbgfs_bcast_filtering.cmd.filters, sizeof(cmd->filters));
memcpy(cmd->macs, &mvm->dbgfs_bcast_filtering.cmd.macs, sizeof(cmd->macs));
return true;
}
#endif
/* if no filters are configured, do nothing */
if (!mvm->bcast_filters) { return false; }
#ifdef CPTCFG_IWLMVM_VENDOR_CMDS
if (!(mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_EINVAL) &&
mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_BCAST) {
cmd->disable = 1;
return true;
}
#endif
/* configure and attach these filters for each associated sta vif */
ieee80211_iterate_active_interfaces(mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
iwl_mvm_bcast_filter_iterator, &iter_data);
return true;
}
int iwl_mvm_configure_bcast_filter(struct iwl_mvm* mvm) {
struct iwl_bcast_filter_cmd cmd;
if (!(mvm->fw->ucode_capa.flags & IWL_UCODE_TLV_FLAGS_BCAST_FILTERING)) { return 0; }
if (!iwl_mvm_bcast_filter_build_cmd(mvm, &cmd)) { return 0; }
return iwl_mvm_send_cmd_pdu(mvm, BCAST_FILTER_CMD, 0, sizeof(cmd), &cmd);
}
#else
inline int iwl_mvm_configure_bcast_filter(struct iwl_mvm* mvm) {
return 0;
}
#endif
static int iwl_mvm_update_mu_groups(struct iwl_mvm* mvm, struct ieee80211_vif* vif) {
struct iwl_mu_group_mgmt_cmd cmd = {};
memcpy(cmd.membership_status, vif->bss_conf.mu_group.membership, WLAN_MEMBERSHIP_LEN);
memcpy(cmd.user_position, vif->bss_conf.mu_group.position, WLAN_USER_POSITION_LEN);
return iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(DATA_PATH_GROUP, UPDATE_MU_GROUPS_CMD), 0, sizeof(cmd),
&cmd);
}
static void iwl_mvm_mu_mimo_iface_iterator(void* _data, uint8_t* mac, struct ieee80211_vif* vif) {
if (vif->mu_mimo_owner) {
struct iwl_mu_group_mgmt_notif* notif = _data;
/*
* MU-MIMO Group Id action frame is little endian. We treat
* the data received from firmware as if it came from the
* action frame, so no conversion is needed.
*/
ieee80211_update_mu_groups(vif, (uint8_t*)&notif->membership_status,
(uint8_t*)&notif->user_position);
}
}
void iwl_mvm_mu_mimo_grp_notif(struct iwl_mvm* mvm, struct iwl_rx_cmd_buffer* rxb) {
struct iwl_rx_packet* pkt = rxb_addr(rxb);
struct iwl_mu_group_mgmt_notif* notif = (void*)pkt->data;
ieee80211_iterate_active_interfaces_atomic(mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
iwl_mvm_mu_mimo_iface_iterator, notif);
}
static uint8_t iwl_mvm_he_get_ppe_val(uint8_t* ppe, uint8_t ppe_pos_bit) {
uint8_t byte_num = ppe_pos_bit / 8;
uint8_t bit_num = ppe_pos_bit % 8;
uint8_t residue_bits;
uint8_t res;
if (bit_num <= 5) {
return (ppe[byte_num] >> bit_num) & (BIT(IEEE80211_PPE_THRES_INFO_PPET_SIZE) - 1);
}
/*
* If bit_num > 5, we have to combine bits with next byte.
* Calculate how many bits we need to take from current byte (called
* here "residue_bits"), and add them to bits from next byte.
*/
residue_bits = 8 - bit_num;
res = (ppe[byte_num + 1] & (BIT(IEEE80211_PPE_THRES_INFO_PPET_SIZE - residue_bits) - 1))
<< residue_bits;
res += (ppe[byte_num] >> bit_num) & (BIT(residue_bits) - 1);
return res;
}
static const uint8_t mac80211_ac_to_ucode_ac[] = {AC_VO, AC_VI, AC_BE, AC_BK};
static void iwl_mvm_cfg_he_sta(struct iwl_mvm* mvm, struct ieee80211_vif* vif, uint8_t sta_id) {
struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
struct iwl_he_sta_context_cmd sta_ctxt_cmd = {
.sta_id = sta_id,
.tid_limit = IWL_MAX_TID_COUNT,
.bss_color = vif->bss_conf.bss_color,
.htc_trig_based_pkt_ext = vif->bss_conf.htc_trig_based_pkt_ext,
.frame_time_rts_th = cpu_to_le16(vif->bss_conf.frame_time_rts_th),
};
struct ieee80211_sta* sta;
uint32_t flags;
int i;
rcu_read_lock();
sta = rcu_dereference(mvm->fw_id_to_mac_id[sta_ctxt_cmd.sta_id]);
if (IS_ERR(sta)) {
rcu_read_unlock();
WARN(1, "Can't find STA to configure HE\n");
return;
}
if (!sta->he_cap.has_he) {
rcu_read_unlock();
return;
}
flags = 0;
/* HTC flags */
if (sta->he_cap.he_cap_elem.mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_HTC_HE) {
sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_SUPPORT);
}
if ((sta->he_cap.he_cap_elem.mac_cap_info[1] & IEEE80211_HE_MAC_CAP1_LINK_ADAPTATION) ||
(sta->he_cap.he_cap_elem.mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_LINK_ADAPTATION)) {
uint8_t link_adap =
((sta->he_cap.he_cap_elem.mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_LINK_ADAPTATION)
<< 1) +
(sta->he_cap.he_cap_elem.mac_cap_info[1] & IEEE80211_HE_MAC_CAP1_LINK_ADAPTATION);
if (link_adap == 2) {
sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_LINK_ADAP_UNSOLICITED);
} else if (link_adap == 3) {
sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_LINK_ADAP_BOTH);
}
}
if (sta->he_cap.he_cap_elem.mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_BSR) {
sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_BSR_SUPP);
}
if (sta->he_cap.he_cap_elem.mac_cap_info[3] & IEEE80211_HE_MAC_CAP3_OMI_CONTROL) {
sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_OMI_SUPP);
}
if (sta->he_cap.he_cap_elem.mac_cap_info[4] & IEEE80211_HE_MAC_CAP4_BQR) {
sta_ctxt_cmd.htc_flags |= cpu_to_le32(IWL_HE_HTC_BQR_SUPP);
}
/*
* Initialize the PPE thresholds to "None" (7), as described in Table
* 9-262ac of 80211.ax/D3.0.
*/
memset(&sta_ctxt_cmd.pkt_ext, 7, sizeof(sta_ctxt_cmd.pkt_ext));
/* If PPE Thresholds exist, parse them into a FW-familiar format. */
if (sta->he_cap.he_cap_elem.phy_cap_info[6] & IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
uint8_t nss = (sta->he_cap.ppe_thres[0] & IEEE80211_PPE_THRES_NSS_MASK) + 1;
uint8_t ru_index_bitmap =
(sta->he_cap.ppe_thres[0] & IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK) >>
IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS;
uint8_t* ppe = &sta->he_cap.ppe_thres[0];
uint8_t ppe_pos_bit = 7; /* Starting after PPE header */
/*
* FW currently supports only nss == MAX_HE_SUPP_NSS
*
* If nss > MAX: we can ignore values we don't support
* If nss < MAX: we can set zeros in other streams
*/
if (nss > MAX_HE_SUPP_NSS) {
IWL_INFO(mvm, "Got NSS = %d - trimming to %d\n", nss, MAX_HE_SUPP_NSS);
nss = MAX_HE_SUPP_NSS;
}
for (i = 0; i < nss; i++) {
uint8_t ru_index_tmp = ru_index_bitmap << 1;
uint8_t bw;
for (bw = 0; bw < MAX_HE_CHANNEL_BW_INDX; bw++) {
ru_index_tmp >>= 1;
if (!(ru_index_tmp & 1)) { continue; }
sta_ctxt_cmd.pkt_ext.pkt_ext_qam_th[i][bw][1] =
iwl_mvm_he_get_ppe_val(ppe, ppe_pos_bit);
ppe_pos_bit += IEEE80211_PPE_THRES_INFO_PPET_SIZE;
sta_ctxt_cmd.pkt_ext.pkt_ext_qam_th[i][bw][0] =
iwl_mvm_he_get_ppe_val(ppe, ppe_pos_bit);
ppe_pos_bit += IEEE80211_PPE_THRES_INFO_PPET_SIZE;
}
}
flags |= STA_CTXT_HE_PACKET_EXT;
}
rcu_read_unlock();
/* Mark MU EDCA as enabled, unless none detected on some AC */
flags |= STA_CTXT_HE_MU_EDCA_CW;
for (i = 0; i < IEEE80211_AC_MAX; i++) {
struct ieee80211_he_mu_edca_param_ac_rec* mu_edca =
&mvmvif->queue_params[i].mu_edca_param_rec;
uint8_t ac = mac80211_ac_to_ucode_ac[i];
if (!mvmvif->queue_params[i].mu_edca) {
flags &= ~STA_CTXT_HE_MU_EDCA_CW;
break;
}
sta_ctxt_cmd.trig_based_txf[ac].cwmin = cpu_to_le16(mu_edca->ecw_min_max & 0xf);
sta_ctxt_cmd.trig_based_txf[ac].cwmax = cpu_to_le16((mu_edca->ecw_min_max & 0xf0) >> 4);
sta_ctxt_cmd.trig_based_txf[ac].aifsn = cpu_to_le16(mu_edca->aifsn & 0xf);
sta_ctxt_cmd.trig_based_txf[ac].mu_time = cpu_to_le16(mu_edca->mu_edca_timer);
}
if (vif->bss_conf.multi_sta_back_32bit) { flags |= STA_CTXT_HE_32BIT_BA_BITMAP; }
if (vif->bss_conf.ack_enabled) { flags |= STA_CTXT_HE_ACK_ENABLED; }
if (vif->bss_conf.uora_exists) {
flags |= STA_CTXT_HE_TRIG_RND_ALLOC;
sta_ctxt_cmd.rand_alloc_ecwmin = vif->bss_conf.uora_ocw_range & 0x7;
sta_ctxt_cmd.rand_alloc_ecwmax = (vif->bss_conf.uora_ocw_range >> 3) & 0x7;
}
if (!(sta->he_cap.he_cap_elem.mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_ACK_EN)) {
flags |= STA_CTXT_HE_NIC_NOT_ACK_ENABLED;
}
#ifdef CPTCFG_IWLWIFI_SUPPORT_DEBUG_OVERRIDES
if (mvm->trans->dbg_cfg.no_ack_en & 0x2) { flags &= ~STA_CTXT_HE_ACK_ENABLED; }
#endif
/* TODO: support Multi BSSID IE */
sta_ctxt_cmd.flags = cpu_to_le32(flags);
if (iwl_mvm_send_cmd_pdu(mvm, iwl_cmd_id(STA_HE_CTXT_CMD, DATA_PATH_GROUP, 0), 0,
sizeof(sta_ctxt_cmd), &sta_ctxt_cmd)) {
IWL_ERR(mvm, "Failed to config FW to work HE!\n");
}
}
static void iwl_mvm_bss_info_changed_station(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
struct ieee80211_bss_conf* bss_conf,
uint32_t changes) {
struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
int ret;
/*
* Re-calculate the tsf id, as the master-slave relations depend on the
* beacon interval, which was not known when the station interface was
* added.
*/
if (changes & BSS_CHANGED_ASSOC && bss_conf->assoc) {
if (vif->bss_conf.he_support && !iwlwifi_mod_params.disable_11ax) {
iwl_mvm_cfg_he_sta(mvm, vif, mvmvif->ap_sta_id);
}
iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif);
}
/*
* If we're not associated yet, take the (new) BSSID before associating
* so the firmware knows. If we're already associated, then use the old
* BSSID here, and we'll send a cleared one later in the CHANGED_ASSOC
* branch for disassociation below.
*/
if (changes & BSS_CHANGED_BSSID && !mvmvif->associated) {
memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
}
ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, mvmvif->bssid);
if (ret) { IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr); }
/* after sending it once, adopt mac80211 data */
memcpy(mvmvif->bssid, bss_conf->bssid, ETH_ALEN);
mvmvif->associated = bss_conf->assoc;
if (changes & BSS_CHANGED_ASSOC) {
if (bss_conf->assoc) {
/* clear statistics to get clean beacon counter */
iwl_mvm_request_statistics(mvm, true);
memset(&mvmvif->beacon_stats, 0, sizeof(mvmvif->beacon_stats));
/* add quota for this interface */
ret = iwl_mvm_update_quotas(mvm, true, NULL);
if (ret) {
IWL_ERR(mvm, "failed to update quotas\n");
return;
}
if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
/*
* If we're restarting then the firmware will
* obviously have lost synchronisation with
* the AP. It will attempt to synchronise by
* itself, but we can make it more reliable by
* scheduling a session protection time event.
*
* The firmware needs to receive a beacon to
* catch up with synchronisation, use 110% of
* the beacon interval.
*
* Set a large maximum delay to allow for more
* than a single interface.
*/
uint32_t dur = (11 * vif->bss_conf.beacon_int) / 10;
iwl_mvm_protect_session(mvm, vif, dur, dur, 5 * dur, false);
}
iwl_mvm_sf_update(mvm, vif, false);
iwl_mvm_power_vif_assoc(mvm, vif);
if (vif->p2p) {
iwl_mvm_ref(mvm, IWL_MVM_REF_P2P_CLIENT);
iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_PROT, IEEE80211_SMPS_DYNAMIC);
}
} else if (mvmvif->ap_sta_id != IWL_MVM_INVALID_STA) {
/*
* If update fails - SF might be running in associated
* mode while disassociated - which is forbidden.
*/
WARN_ONCE(iwl_mvm_sf_update(mvm, vif, false),
"Failed to update SF upon disassociation\n");
/*
* If we get an assert during the connection (after the
* station has been added, but before the vif is set
* to associated), mac80211 will re-add the station and
* then configure the vif. Since the vif is not
* associated, we would remove the station here and
* this would fail the recovery.
*/
if (!test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
/*
* Remove AP station now that
* the MAC is unassoc
*/
ret = iwl_mvm_rm_sta_id(mvm, vif, mvmvif->ap_sta_id);
if (ret) { IWL_ERR(mvm, "failed to remove AP station\n"); }
if (mvm->d0i3_ap_sta_id == mvmvif->ap_sta_id) {
mvm->d0i3_ap_sta_id = IWL_MVM_INVALID_STA;
}
mvmvif->ap_sta_id = IWL_MVM_INVALID_STA;
}
/* remove quota for this interface */
ret = iwl_mvm_update_quotas(mvm, false, NULL);
if (ret) { IWL_ERR(mvm, "failed to update quotas\n"); }
if (vif->p2p) { iwl_mvm_unref(mvm, IWL_MVM_REF_P2P_CLIENT); }
/* this will take the cleared BSSID from bss_conf */
ret = iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL);
if (ret) {
IWL_ERR(mvm, "failed to update MAC %pM (clear after unassoc)\n", vif->addr);
}
}
/*
* The firmware tracks the MU-MIMO group on its own.
* However, on HW restart we should restore this data.
*/
if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status) &&
(changes & BSS_CHANGED_MU_GROUPS) && vif->mu_mimo_owner) {
ret = iwl_mvm_update_mu_groups(mvm, vif);
if (ret) { IWL_ERR(mvm, "failed to update VHT MU_MIMO groups\n"); }
}
iwl_mvm_recalc_multicast(mvm);
iwl_mvm_configure_bcast_filter(mvm);
/* reset rssi values */
mvmvif->bf_data.ave_beacon_signal = 0;
iwl_mvm_bt_coex_vif_change(mvm);
iwl_mvm_update_smps(mvm, vif, IWL_MVM_SMPS_REQ_TT, IEEE80211_SMPS_AUTOMATIC);
if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN)) {
iwl_mvm_config_scan(mvm);
}
}
if (changes & BSS_CHANGED_BEACON_INFO) {
/*
* We received a beacon from the associated AP so
* remove the session protection.
*/
iwl_mvm_stop_session_protection(mvm, vif);
iwl_mvm_sf_update(mvm, vif, false);
WARN_ON(iwl_mvm_enable_beacon_filter(mvm, vif, 0));
}
if (changes & (BSS_CHANGED_PS | BSS_CHANGED_P2P_PS | BSS_CHANGED_QOS |
/*
* Send power command on every beacon change,
* because we may have not enabled beacon abort yet.
*/
BSS_CHANGED_BEACON_INFO)) {
ret = iwl_mvm_power_update_mac(mvm);
if (ret) { IWL_ERR(mvm, "failed to update power mode\n"); }
}
if (changes & BSS_CHANGED_TXPOWER) {
IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d\n", bss_conf->txpower);
iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
}
if (changes & BSS_CHANGED_CQM) {
IWL_DEBUG_MAC80211(mvm, "cqm info_changed\n");
/* reset cqm events tracking */
mvmvif->bf_data.last_cqm_event = 0;
if (mvmvif->bf_data.bf_enabled) {
ret = iwl_mvm_enable_beacon_filter(mvm, vif, 0);
if (ret) { IWL_ERR(mvm, "failed to update CQM thresholds\n"); }
}
}
if (changes & BSS_CHANGED_ARP_FILTER) {
IWL_DEBUG_MAC80211(mvm, "arp filter changed\n");
iwl_mvm_configure_bcast_filter(mvm);
}
}
static int iwl_mvm_start_ap_ibss(struct ieee80211_hw* hw, struct ieee80211_vif* vif) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
int ret;
/*
* iwl_mvm_mac_ctxt_add() might read directly from the device
* (the system time), so make sure it is available.
*/
ret = iwl_mvm_ref_sync(mvm, IWL_MVM_REF_START_AP);
if (ret) { return ret; }
mutex_lock(&mvm->mutex);
/* Send the beacon template */
ret = iwl_mvm_mac_ctxt_beacon_changed(mvm, vif);
if (ret) { goto out_unlock; }
/*
* Re-calculate the tsf id, as the master-slave relations depend on the
* beacon interval, which was not known when the AP interface was added.
*/
if (vif->type == NL80211_IFTYPE_AP) { iwl_mvm_mac_ctxt_recalc_tsf_id(mvm, vif); }
mvmvif->ap_assoc_sta_count = 0;
/* Add the mac context */
ret = iwl_mvm_mac_ctxt_add(mvm, vif);
if (ret) { goto out_unlock; }
/* Perform the binding */
ret = iwl_mvm_binding_add_vif(mvm, vif);
if (ret) { goto out_remove; }
#ifdef CPTCFG_IWLWIFI_FRQ_MGR
iwl_mvm_update_ctx_tx_power_limit(mvm, vif, mvmvif->phy_ctxt);
#endif
/*
* This is not very nice, but the simplest:
* For older FWs adding the mcast sta before the bcast station may
* cause assert 0x2b00.
* This is fixed in later FW so make the order of removal depend on
* the TLV
*/
if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE)) {
ret = iwl_mvm_add_mcast_sta(mvm, vif);
if (ret) { goto out_unbind; }
/*
* Send the bcast station. At this stage the TBTT and DTIM time
* events are added and applied to the scheduler
*/
ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
if (ret) {
iwl_mvm_rm_mcast_sta(mvm, vif);
goto out_unbind;
}
} else {
/*
* Send the bcast station. At this stage the TBTT and DTIM time
* events are added and applied to the scheduler
*/
ret = iwl_mvm_send_add_bcast_sta(mvm, vif);
if (ret) { goto out_unbind; }
ret = iwl_mvm_add_mcast_sta(mvm, vif);
if (ret) {
iwl_mvm_send_rm_bcast_sta(mvm, vif);
goto out_unbind;
}
}
/* must be set before quota calculations */
mvmvif->ap_ibss_active = true;
if (vif->type == NL80211_IFTYPE_AP && !vif->p2p) {
iwl_mvm_vif_set_low_latency(mvmvif, true, LOW_LATENCY_VIF_TYPE);
iwl_mvm_send_low_latency_cmd(mvm, true, mvmvif->id);
}
/* power updated needs to be done before quotas */
iwl_mvm_power_update_mac(mvm);
ret = iwl_mvm_update_quotas(mvm, false, NULL);
if (ret) { goto out_quota_failed; }
/* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
if (vif->p2p && mvm->p2p_device_vif) {
iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
}
iwl_mvm_ref(mvm, IWL_MVM_REF_AP_IBSS);
iwl_mvm_bt_coex_vif_change(mvm);
/* we don't support TDLS during DCM */
if (iwl_mvm_phy_ctx_count(mvm) > 1) { iwl_mvm_teardown_tdls_peers(mvm); }
goto out_unlock;
out_quota_failed:
iwl_mvm_power_update_mac(mvm);
mvmvif->ap_ibss_active = false;
iwl_mvm_send_rm_bcast_sta(mvm, vif);
iwl_mvm_rm_mcast_sta(mvm, vif);
out_unbind:
iwl_mvm_binding_remove_vif(mvm, vif);
out_remove:
iwl_mvm_mac_ctxt_remove(mvm, vif);
out_unlock:
mutex_unlock(&mvm->mutex);
iwl_mvm_unref(mvm, IWL_MVM_REF_START_AP);
return ret;
}
static void iwl_mvm_stop_ap_ibss(struct ieee80211_hw* hw, struct ieee80211_vif* vif) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
iwl_mvm_prepare_mac_removal(mvm, vif);
mutex_lock(&mvm->mutex);
/* Handle AP stop while in CSA */
if (rcu_access_pointer(mvm->csa_vif) == vif) {
iwl_mvm_remove_time_event(mvm, mvmvif, &mvmvif->time_event_data);
RCU_INIT_POINTER(mvm->csa_vif, NULL);
mvmvif->csa_countdown = false;
}
if (rcu_access_pointer(mvm->csa_tx_blocked_vif) == vif) {
RCU_INIT_POINTER(mvm->csa_tx_blocked_vif, NULL);
mvm->csa_tx_block_bcn_timeout = 0;
}
mvmvif->ap_ibss_active = false;
mvm->ap_last_beacon_gp2 = 0;
if (vif->type == NL80211_IFTYPE_AP && !vif->p2p) {
iwl_mvm_vif_set_low_latency(mvmvif, false, LOW_LATENCY_VIF_TYPE);
iwl_mvm_send_low_latency_cmd(mvm, false, mvmvif->id);
}
iwl_mvm_bt_coex_vif_change(mvm);
iwl_mvm_unref(mvm, IWL_MVM_REF_AP_IBSS);
/* Need to update the P2P Device MAC (only GO, IBSS is single vif) */
if (vif->p2p && mvm->p2p_device_vif) {
iwl_mvm_mac_ctxt_changed(mvm, mvm->p2p_device_vif, false, NULL);
}
iwl_mvm_update_quotas(mvm, false, NULL);
/*
* This is not very nice, but the simplest:
* For older FWs removing the mcast sta before the bcast station may
* cause assert 0x2b00.
* This is fixed in later FW (which will stop beaconing when removing
* bcast station).
* So make the order of removal depend on the TLV
*/
if (!fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE)) {
iwl_mvm_rm_mcast_sta(mvm, vif);
}
iwl_mvm_send_rm_bcast_sta(mvm, vif);
if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_STA_TYPE)) {
iwl_mvm_rm_mcast_sta(mvm, vif);
}
iwl_mvm_binding_remove_vif(mvm, vif);
iwl_mvm_power_update_mac(mvm);
iwl_mvm_mac_ctxt_remove(mvm, vif);
kfree(mvmvif->ap_wep_key);
mvmvif->ap_wep_key = NULL;
mutex_unlock(&mvm->mutex);
}
static void iwl_mvm_bss_info_changed_ap_ibss(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
struct ieee80211_bss_conf* bss_conf,
uint32_t changes) {
struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
/* Changes will be applied when the AP/IBSS is started */
if (!mvmvif->ap_ibss_active) { return; }
if (changes &
(BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_HT | BSS_CHANGED_BANDWIDTH | BSS_CHANGED_QOS) &&
iwl_mvm_mac_ctxt_changed(mvm, vif, false, NULL)) {
IWL_ERR(mvm, "failed to update MAC %pM\n", vif->addr);
}
/* Need to send a new beacon template to the FW */
if (changes & BSS_CHANGED_BEACON && iwl_mvm_mac_ctxt_beacon_changed(mvm, vif)) {
IWL_WARN(mvm, "Failed updating beacon data\n");
}
if (changes & BSS_CHANGED_TXPOWER) {
IWL_DEBUG_CALIB(mvm, "Changing TX Power to %d\n", bss_conf->txpower);
iwl_mvm_set_tx_power(mvm, vif, bss_conf->txpower);
}
}
static void iwl_mvm_bss_info_changed(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
struct ieee80211_bss_conf* bss_conf, uint32_t changes) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
/*
* iwl_mvm_bss_info_changed_station() might call
* iwl_mvm_protect_session(), which reads directly from
* the device (the system time), so make sure it is available.
*/
if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_BSS_CHANGED)) { return; }
mutex_lock(&mvm->mutex);
if (changes & BSS_CHANGED_IDLE && !bss_conf->idle) {
iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_SCHED, true);
}
switch (vif->type) {
case NL80211_IFTYPE_STATION:
iwl_mvm_bss_info_changed_station(mvm, vif, bss_conf, changes);
break;
case NL80211_IFTYPE_AP:
case NL80211_IFTYPE_ADHOC:
iwl_mvm_bss_info_changed_ap_ibss(mvm, vif, bss_conf, changes);
break;
case NL80211_IFTYPE_MONITOR:
if (changes & BSS_CHANGED_MU_GROUPS) { iwl_mvm_update_mu_groups(mvm, vif); }
break;
default:
/* shouldn't happen */
WARN_ON_ONCE(1);
}
mutex_unlock(&mvm->mutex);
iwl_mvm_unref(mvm, IWL_MVM_REF_BSS_CHANGED);
}
#endif // NEEDS_PORTING
zx_status_t iwl_mvm_mac_hw_scan(struct iwl_mvm_vif* mvmvif,
const wlan_hw_scan_config_t* scan_config) {
struct iwl_mvm* mvm = mvmvif->mvm;
zx_status_t ret;
if (scan_config->num_channels == 0 ||
scan_config->num_channels > mvm->fw->ucode_capa.n_scan_channels) {
IWL_WARN(mvmvif, "Cannot scan: invalid #channel (%d). FW's cap (%d)\n",
scan_config->num_channels, mvm->fw->ucode_capa.n_scan_channels);
return ZX_ERR_INVALID_ARGS;
}
mtx_lock(&mvm->mutex);
ret = iwl_mvm_reg_scan_start(mvmvif, scan_config);
mtx_unlock(&mvm->mutex);
return ret;
}
#if 0 // NEEDS_PORTING
static void iwl_mvm_mac_cancel_hw_scan(struct ieee80211_hw* hw, struct ieee80211_vif* vif) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
mutex_lock(&mvm->mutex);
/* Due to a race condition, it's possible that mac80211 asks
* us to stop a hw_scan when it's already stopped. This can
* happen, for instance, if we stopped the scan ourselves,
* called ieee80211_scan_completed() and the userspace called
* cancel scan scan before ieee80211_scan_work() could run.
* To handle that, simply return if the scan is not running.
*/
if (mvm->scan_status & IWL_MVM_SCAN_REGULAR) {
iwl_mvm_scan_stop(mvm, IWL_MVM_SCAN_REGULAR, true);
}
mutex_unlock(&mvm->mutex);
}
static void iwl_mvm_mac_allow_buffered_frames(struct ieee80211_hw* hw, struct ieee80211_sta* sta,
uint16_t tids, int num_frames,
enum ieee80211_frame_release_type reason,
bool more_data) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
/* Called when we need to transmit (a) frame(s) from mac80211 */
iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames, tids, more_data, false);
}
static void iwl_mvm_mac_release_buffered_frames(struct ieee80211_hw* hw, struct ieee80211_sta* sta,
uint16_t tids, int num_frames,
enum ieee80211_frame_release_type reason,
bool more_data) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
/* Called when we need to transmit (a) frame(s) from agg or dqa queue */
iwl_mvm_sta_modify_sleep_tx_count(mvm, sta, reason, num_frames, tids, more_data, true);
}
static void __iwl_mvm_mac_sta_notify(struct ieee80211_hw* hw, enum sta_notify_cmd cmd,
struct ieee80211_sta* sta) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
struct iwl_mvm_sta* mvmsta = iwl_mvm_sta_from_mac80211(sta);
unsigned long txqs = 0, tids = 0;
int tid;
/*
* If we have TVQM then we get too high queue numbers - luckily
* we really shouldn't get here with that because such hardware
* should have firmware supporting buffer station offload.
*/
if (WARN_ON(iwl_mvm_has_new_tx_api(mvm))) { return; }
spin_lock_bh(&mvmsta->lock);
for (tid = 0; tid < IWL_MAX_TID_COUNT; tid++) {
struct iwl_mvm_tid_data* tid_data = &mvmsta->tid_data[tid];
if (tid_data->txq_id == IWL_MVM_INVALID_QUEUE) { continue; }
__set_bit(tid_data->txq_id, &txqs);
if (iwl_mvm_tid_queued(mvm, tid_data) == 0) { continue; }
__set_bit(tid, &tids);
}
switch (cmd) {
case STA_NOTIFY_SLEEP:
for_each_set_bit(tid, &tids, IWL_MAX_TID_COUNT) ieee80211_sta_set_buffered(sta, tid, true);
if (txqs) { iwl_trans_freeze_txq_timer(mvm->trans, txqs, true); }
/*
* The fw updates the STA to be asleep. Tx packets on the Tx
* queues to this station will not be transmitted. The fw will
* send a Tx response with TX_STATUS_FAIL_DEST_PS.
*/
break;
case STA_NOTIFY_AWAKE:
if (WARN_ON(mvmsta->sta_id == IWL_MVM_INVALID_STA)) { break; }
if (txqs) { iwl_trans_freeze_txq_timer(mvm->trans, txqs, false); }
iwl_mvm_sta_modify_ps_wake(mvm, sta);
break;
default:
break;
}
spin_unlock_bh(&mvmsta->lock);
}
static void iwl_mvm_mac_sta_notify(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
enum sta_notify_cmd cmd, struct ieee80211_sta* sta) {
__iwl_mvm_mac_sta_notify(hw, cmd, sta);
}
void iwl_mvm_sta_pm_notif(struct iwl_mvm* mvm, struct iwl_rx_cmd_buffer* rxb) {
struct iwl_rx_packet* pkt = rxb_addr(rxb);
struct iwl_mvm_pm_state_notification* notif = (void*)pkt->data;
struct ieee80211_sta* sta;
struct iwl_mvm_sta* mvmsta;
bool sleeping = (notif->type != IWL_MVM_PM_EVENT_AWAKE);
if (WARN_ON(notif->sta_id >= ARRAY_SIZE(mvm->fw_id_to_mac_id))) { return; }
rcu_read_lock();
sta = rcu_dereference(mvm->fw_id_to_mac_id[notif->sta_id]);
if (WARN_ON(IS_ERR_OR_NULL(sta))) {
rcu_read_unlock();
return;
}
mvmsta = iwl_mvm_sta_from_mac80211(sta);
if (!mvmsta->vif || mvmsta->vif->type != NL80211_IFTYPE_AP) {
rcu_read_unlock();
return;
}
if (mvmsta->sleeping != sleeping) {
mvmsta->sleeping = sleeping;
__iwl_mvm_mac_sta_notify(mvm->hw, sleeping ? STA_NOTIFY_SLEEP : STA_NOTIFY_AWAKE, sta);
ieee80211_sta_ps_transition(sta, sleeping);
}
if (sleeping) {
switch (notif->type) {
case IWL_MVM_PM_EVENT_AWAKE:
case IWL_MVM_PM_EVENT_ASLEEP:
break;
case IWL_MVM_PM_EVENT_UAPSD:
ieee80211_sta_uapsd_trigger(sta, IEEE80211_TIDS_MAX);
break;
case IWL_MVM_PM_EVENT_PS_POLL:
ieee80211_sta_pspoll(sta);
break;
default:
break;
}
}
rcu_read_unlock();
}
static void iwl_mvm_sta_pre_rcu_remove(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
struct ieee80211_sta* sta) {
struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);