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