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