1// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2/* 3 * Copyright (C) 2012-2014, 2018-2019, 2021-2023 Intel Corporation 4 * Copyright (C) 2013-2014 Intel Mobile Communications GmbH 5 * Copyright (C) 2015-2017 Intel Deutschland GmbH 6 */ 7#include <linux/kernel.h> 8#include <linux/module.h> 9#include <linux/slab.h> 10#include <linux/etherdevice.h> 11 12#include <net/mac80211.h> 13 14#include "iwl-debug.h" 15#include "mvm.h" 16#include "iwl-modparams.h" 17#include "fw/api/power.h" 18 19#define POWER_KEEP_ALIVE_PERIOD_SEC 25 20 21static 22int iwl_mvm_beacon_filter_send_cmd(struct iwl_mvm *mvm, 23 struct iwl_beacon_filter_cmd *cmd, 24 u32 flags) 25{ 26 u16 len; 27 28 IWL_DEBUG_POWER(mvm, "ba_enable_beacon_abort is: %d\n", 29 le32_to_cpu(cmd->ba_enable_beacon_abort)); 30 IWL_DEBUG_POWER(mvm, "ba_escape_timer is: %d\n", 31 le32_to_cpu(cmd->ba_escape_timer)); 32 IWL_DEBUG_POWER(mvm, "bf_debug_flag is: %d\n", 33 le32_to_cpu(cmd->bf_debug_flag)); 34 IWL_DEBUG_POWER(mvm, "bf_enable_beacon_filter is: %d\n", 35 le32_to_cpu(cmd->bf_enable_beacon_filter)); 36 IWL_DEBUG_POWER(mvm, "bf_energy_delta is: %d\n", 37 le32_to_cpu(cmd->bf_energy_delta)); 38 IWL_DEBUG_POWER(mvm, "bf_escape_timer is: %d\n", 39 le32_to_cpu(cmd->bf_escape_timer)); 40 IWL_DEBUG_POWER(mvm, "bf_roaming_energy_delta is: %d\n", 41 le32_to_cpu(cmd->bf_roaming_energy_delta)); 42 IWL_DEBUG_POWER(mvm, "bf_roaming_state is: %d\n", 43 le32_to_cpu(cmd->bf_roaming_state)); 44 IWL_DEBUG_POWER(mvm, "bf_temp_threshold is: %d\n", 45 le32_to_cpu(cmd->bf_temp_threshold)); 46 IWL_DEBUG_POWER(mvm, "bf_temp_fast_filter is: %d\n", 47 le32_to_cpu(cmd->bf_temp_fast_filter)); 48 IWL_DEBUG_POWER(mvm, "bf_temp_slow_filter is: %d\n", 49 le32_to_cpu(cmd->bf_temp_slow_filter)); 50 IWL_DEBUG_POWER(mvm, "bf_threshold_absolute_low is: %d, %d\n", 51 le32_to_cpu(cmd->bf_threshold_absolute_low[0]), 52 le32_to_cpu(cmd->bf_threshold_absolute_low[1])); 53 54 IWL_DEBUG_POWER(mvm, "bf_threshold_absolute_high is: %d, %d\n", 55 le32_to_cpu(cmd->bf_threshold_absolute_high[0]), 56 le32_to_cpu(cmd->bf_threshold_absolute_high[1])); 57 58 if (fw_has_api(&mvm->fw->ucode_capa, 59 IWL_UCODE_TLV_API_BEACON_FILTER_V4)) 60 len = sizeof(struct iwl_beacon_filter_cmd); 61 else 62 len = offsetof(struct iwl_beacon_filter_cmd, 63 bf_threshold_absolute_low); 64 65 return iwl_mvm_send_cmd_pdu(mvm, REPLY_BEACON_FILTERING_CMD, flags, 66 len, cmd); 67} 68 69static 70void iwl_mvm_beacon_filter_set_cqm_params(struct iwl_mvm *mvm, 71 struct ieee80211_vif *vif, 72 struct iwl_beacon_filter_cmd *cmd) 73{ 74 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 75 76 if (vif->bss_conf.cqm_rssi_thold) { 77 cmd->bf_energy_delta = 78 cpu_to_le32(vif->bss_conf.cqm_rssi_hyst); 79 /* fw uses an absolute value for this */ 80 cmd->bf_roaming_state = 81 cpu_to_le32(-vif->bss_conf.cqm_rssi_thold); 82 } 83 cmd->ba_enable_beacon_abort = cpu_to_le32(mvmvif->bf_data.ba_enabled); 84} 85 86static void iwl_mvm_power_log(struct iwl_mvm *mvm, 87 struct iwl_mac_power_cmd *cmd) 88{ 89 IWL_DEBUG_POWER(mvm, 90 "Sending power table command on mac id 0x%X for power level %d, flags = 0x%X\n", 91 cmd->id_and_color, iwlmvm_mod_params.power_scheme, 92 le16_to_cpu(cmd->flags)); 93 IWL_DEBUG_POWER(mvm, "Keep alive = %u sec\n", 94 le16_to_cpu(cmd->keep_alive_seconds)); 95 96 if (!(cmd->flags & cpu_to_le16(POWER_FLAGS_POWER_MANAGEMENT_ENA_MSK))) { 97 IWL_DEBUG_POWER(mvm, "Disable power management\n"); 98 return; 99 } 100 101 IWL_DEBUG_POWER(mvm, "Rx timeout = %u usec\n", 102 le32_to_cpu(cmd->rx_data_timeout)); 103 IWL_DEBUG_POWER(mvm, "Tx timeout = %u usec\n", 104 le32_to_cpu(cmd->tx_data_timeout)); 105 if (cmd->flags & cpu_to_le16(POWER_FLAGS_SKIP_OVER_DTIM_MSK)) 106 IWL_DEBUG_POWER(mvm, "DTIM periods to skip = %u\n", 107 cmd->skip_dtim_periods); 108 if (cmd->flags & cpu_to_le16(POWER_FLAGS_LPRX_ENA_MSK)) 109 IWL_DEBUG_POWER(mvm, "LP RX RSSI threshold = %u\n", 110 cmd->lprx_rssi_threshold); 111 if (cmd->flags & cpu_to_le16(POWER_FLAGS_ADVANCE_PM_ENA_MSK)) { 112 IWL_DEBUG_POWER(mvm, "uAPSD enabled\n"); 113 IWL_DEBUG_POWER(mvm, "Rx timeout (uAPSD) = %u usec\n", 114 le32_to_cpu(cmd->rx_data_timeout_uapsd)); 115 IWL_DEBUG_POWER(mvm, "Tx timeout (uAPSD) = %u usec\n", 116 le32_to_cpu(cmd->tx_data_timeout_uapsd)); 117 IWL_DEBUG_POWER(mvm, "QNDP TID = %d\n", cmd->qndp_tid); 118 IWL_DEBUG_POWER(mvm, "ACs flags = 0x%x\n", cmd->uapsd_ac_flags); 119 IWL_DEBUG_POWER(mvm, "Max SP = %d\n", cmd->uapsd_max_sp); 120 } 121} 122 123static void iwl_mvm_power_configure_uapsd(struct iwl_mvm *mvm, 124 struct ieee80211_vif *vif, 125 struct iwl_mac_power_cmd *cmd) 126{ 127 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 128 enum ieee80211_ac_numbers ac; 129 bool tid_found = false; 130 131 if (test_bit(IWL_MVM_STATUS_IN_D3, &mvm->status) || 132 cmd->flags & cpu_to_le16(POWER_FLAGS_SNOOZE_ENA_MSK)) { 133 cmd->rx_data_timeout_uapsd = 134 cpu_to_le32(IWL_MVM_WOWLAN_PS_RX_DATA_TIMEOUT); 135 cmd->tx_data_timeout_uapsd = 136 cpu_to_le32(IWL_MVM_WOWLAN_PS_TX_DATA_TIMEOUT); 137 } else { 138 cmd->rx_data_timeout_uapsd = 139 cpu_to_le32(IWL_MVM_UAPSD_RX_DATA_TIMEOUT); 140 cmd->tx_data_timeout_uapsd = 141 cpu_to_le32(IWL_MVM_UAPSD_TX_DATA_TIMEOUT); 142 } 143 144#ifdef CONFIG_IWLWIFI_DEBUGFS 145 /* set advanced pm flag with no uapsd ACs to enable ps-poll */ 146 if (mvmvif->dbgfs_pm.use_ps_poll) { 147 cmd->flags |= cpu_to_le16(POWER_FLAGS_ADVANCE_PM_ENA_MSK); 148 return; 149 } 150#endif 151 152 for (ac = IEEE80211_AC_VO; ac <= IEEE80211_AC_BK; ac++) { 153 if (!mvmvif->deflink.queue_params[ac].uapsd) 154 continue; 155 156 if (!test_bit(IWL_MVM_STATUS_IN_D3, &mvm->status)) 157 cmd->flags |= 158 cpu_to_le16(POWER_FLAGS_ADVANCE_PM_ENA_MSK); 159 160 cmd->uapsd_ac_flags |= BIT(ac); 161 162 /* QNDP TID - the highest TID with no admission control */ 163 if (!tid_found && !mvmvif->deflink.queue_params[ac].acm) { 164 tid_found = true; 165 switch (ac) { 166 case IEEE80211_AC_VO: 167 cmd->qndp_tid = 6; 168 break; 169 case IEEE80211_AC_VI: 170 cmd->qndp_tid = 5; 171 break; 172 case IEEE80211_AC_BE: 173 cmd->qndp_tid = 0; 174 break; 175 case IEEE80211_AC_BK: 176 cmd->qndp_tid = 1; 177 break; 178 } 179 } 180 } 181 182 cmd->flags |= cpu_to_le16(POWER_FLAGS_UAPSD_MISBEHAVING_ENA_MSK); 183 184 if (cmd->uapsd_ac_flags == (BIT(IEEE80211_AC_VO) | 185 BIT(IEEE80211_AC_VI) | 186 BIT(IEEE80211_AC_BE) | 187 BIT(IEEE80211_AC_BK))) { 188 cmd->flags |= cpu_to_le16(POWER_FLAGS_SNOOZE_ENA_MSK); 189 cmd->snooze_interval = cpu_to_le16(IWL_MVM_PS_SNOOZE_INTERVAL); 190 cmd->snooze_window = 191 test_bit(IWL_MVM_STATUS_IN_D3, &mvm->status) ? 192 cpu_to_le16(IWL_MVM_WOWLAN_PS_SNOOZE_WINDOW) : 193 cpu_to_le16(IWL_MVM_PS_SNOOZE_WINDOW); 194 } 195 196 cmd->uapsd_max_sp = mvm->hw->uapsd_max_sp_len; 197 198 if (cmd->flags & cpu_to_le16(POWER_FLAGS_SNOOZE_ENA_MSK)) { 199 cmd->heavy_tx_thld_packets = 200 IWL_MVM_PS_SNOOZE_HEAVY_TX_THLD_PACKETS; 201 cmd->heavy_rx_thld_packets = 202 IWL_MVM_PS_SNOOZE_HEAVY_RX_THLD_PACKETS; 203 } else { 204 cmd->heavy_tx_thld_packets = 205 IWL_MVM_PS_HEAVY_TX_THLD_PACKETS; 206 cmd->heavy_rx_thld_packets = 207 IWL_MVM_PS_HEAVY_RX_THLD_PACKETS; 208 } 209 cmd->heavy_tx_thld_percentage = 210 IWL_MVM_PS_HEAVY_TX_THLD_PERCENT; 211 cmd->heavy_rx_thld_percentage = 212 IWL_MVM_PS_HEAVY_RX_THLD_PERCENT; 213} 214 215static void iwl_mvm_p2p_standalone_iterator(void *_data, u8 *mac, 216 struct ieee80211_vif *vif) 217{ 218 bool *is_p2p_standalone = _data; 219 220 switch (ieee80211_vif_type_p2p(vif)) { 221 case NL80211_IFTYPE_P2P_GO: 222 case NL80211_IFTYPE_AP: 223 *is_p2p_standalone = false; 224 break; 225 case NL80211_IFTYPE_STATION: 226 if (vif->cfg.assoc) 227 *is_p2p_standalone = false; 228 break; 229 230 default: 231 break; 232 } 233} 234 235static bool iwl_mvm_power_allow_uapsd(struct iwl_mvm *mvm, 236 struct ieee80211_vif *vif) 237{ 238 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 239 240 if (ether_addr_equal(mvmvif->uapsd_misbehaving_ap_addr, 241 vif->cfg.ap_addr)) 242 return false; 243 244 /* 245 * Avoid using uAPSD if P2P client is associated to GO that uses 246 * opportunistic power save. This is due to current FW limitation. 247 */ 248 if (vif->p2p && 249 (vif->bss_conf.p2p_noa_attr.oppps_ctwindow & 250 IEEE80211_P2P_OPPPS_ENABLE_BIT)) 251 return false; 252 253 /* 254 * Avoid using uAPSD if client is in DCM - 255 * low latency issue in Miracast 256 */ 257 if (iwl_mvm_phy_ctx_count(mvm) >= 2) 258 return false; 259 260 if (vif->p2p) { 261 /* Allow U-APSD only if p2p is stand alone */ 262 bool is_p2p_standalone = true; 263 264 if (!iwl_mvm_is_p2p_scm_uapsd_supported(mvm)) 265 return false; 266 267 ieee80211_iterate_active_interfaces_atomic(mvm->hw, 268 IEEE80211_IFACE_ITER_NORMAL, 269 iwl_mvm_p2p_standalone_iterator, 270 &is_p2p_standalone); 271 272 if (!is_p2p_standalone) 273 return false; 274 } 275 276 return true; 277} 278 279static bool iwl_mvm_power_is_radar(struct ieee80211_vif *vif) 280{ 281 struct ieee80211_chanctx_conf *chanctx_conf; 282 struct ieee80211_bss_conf *link_conf; 283 bool radar_detect = false; 284 unsigned int link_id; 285 286 rcu_read_lock(); 287 for_each_vif_active_link(vif, link_conf, link_id) { 288 chanctx_conf = rcu_dereference(link_conf->chanctx_conf); 289 /* this happens on link switching, just ignore inactive ones */ 290 if (!chanctx_conf) 291 continue; 292 293 radar_detect = !!(chanctx_conf->def.chan->flags & 294 IEEE80211_CHAN_RADAR); 295 if (radar_detect) 296 goto out; 297 } 298 299out: 300 rcu_read_unlock(); 301 return radar_detect; 302} 303 304static void iwl_mvm_power_config_skip_dtim(struct iwl_mvm *mvm, 305 struct ieee80211_vif *vif, 306 struct iwl_mac_power_cmd *cmd) 307{ 308 int dtimper = vif->bss_conf.dtim_period ?: 1; 309 int skip; 310 311 /* disable, in case we're supposed to override */ 312 cmd->skip_dtim_periods = 0; 313 cmd->flags &= ~cpu_to_le16(POWER_FLAGS_SKIP_OVER_DTIM_MSK); 314 315 if (iwl_mvm_power_is_radar(vif)) 316 return; 317 318 if (dtimper >= 10) 319 return; 320 321 if (!test_bit(IWL_MVM_STATUS_IN_D3, &mvm->status)) { 322 if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_LP) 323 return; 324 skip = 2; 325 } else { 326 int dtimper_tu = dtimper * vif->bss_conf.beacon_int; 327 328 if (WARN_ON(!dtimper_tu)) 329 return; 330 /* configure skip over dtim up to 900 TU DTIM interval */ 331 skip = max_t(u8, 1, 900 / dtimper_tu); 332 } 333 334 cmd->skip_dtim_periods = skip; 335 cmd->flags |= cpu_to_le16(POWER_FLAGS_SKIP_OVER_DTIM_MSK); 336} 337 338static void iwl_mvm_power_build_cmd(struct iwl_mvm *mvm, 339 struct ieee80211_vif *vif, 340 struct iwl_mac_power_cmd *cmd) 341{ 342 int dtimper, bi; 343 int keep_alive; 344 struct iwl_mvm_vif *mvmvif __maybe_unused = 345 iwl_mvm_vif_from_mac80211(vif); 346 347 cmd->id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, 348 mvmvif->color)); 349 dtimper = vif->bss_conf.dtim_period; 350 bi = vif->bss_conf.beacon_int; 351 352 /* 353 * Regardless of power management state the driver must set 354 * keep alive period. FW will use it for sending keep alive NDPs 355 * immediately after association. Check that keep alive period 356 * is at least 3 * DTIM 357 */ 358 keep_alive = DIV_ROUND_UP(ieee80211_tu_to_usec(3 * dtimper * bi), 359 USEC_PER_SEC); 360 keep_alive = max(keep_alive, POWER_KEEP_ALIVE_PERIOD_SEC); 361 cmd->keep_alive_seconds = cpu_to_le16(keep_alive); 362 363 if (mvm->ps_disabled) 364 return; 365 366 cmd->flags |= cpu_to_le16(POWER_FLAGS_POWER_SAVE_ENA_MSK); 367 368 if (!vif->cfg.ps || !mvmvif->pm_enabled) 369 return; 370 371 if (iwl_mvm_vif_low_latency(mvmvif) && vif->p2p && 372 (!fw_has_capa(&mvm->fw->ucode_capa, 373 IWL_UCODE_TLV_CAPA_SHORT_PM_TIMEOUTS) || 374 !IWL_MVM_P2P_LOWLATENCY_PS_ENABLE)) 375 return; 376 377 cmd->flags |= cpu_to_le16(POWER_FLAGS_POWER_MANAGEMENT_ENA_MSK); 378 379 if (vif->bss_conf.beacon_rate && 380 (vif->bss_conf.beacon_rate->bitrate == 10 || 381 vif->bss_conf.beacon_rate->bitrate == 60)) { 382 cmd->flags |= cpu_to_le16(POWER_FLAGS_LPRX_ENA_MSK); 383 cmd->lprx_rssi_threshold = POWER_LPRX_RSSI_THRESHOLD; 384 } 385 386 iwl_mvm_power_config_skip_dtim(mvm, vif, cmd); 387 388 if (test_bit(IWL_MVM_STATUS_IN_D3, &mvm->status)) { 389 cmd->rx_data_timeout = 390 cpu_to_le32(IWL_MVM_WOWLAN_PS_RX_DATA_TIMEOUT); 391 cmd->tx_data_timeout = 392 cpu_to_le32(IWL_MVM_WOWLAN_PS_TX_DATA_TIMEOUT); 393 } else if (iwl_mvm_vif_low_latency(mvmvif) && vif->p2p && 394 fw_has_capa(&mvm->fw->ucode_capa, 395 IWL_UCODE_TLV_CAPA_SHORT_PM_TIMEOUTS)) { 396 cmd->tx_data_timeout = 397 cpu_to_le32(IWL_MVM_SHORT_PS_TX_DATA_TIMEOUT); 398 cmd->rx_data_timeout = 399 cpu_to_le32(IWL_MVM_SHORT_PS_RX_DATA_TIMEOUT); 400 } else { 401 cmd->rx_data_timeout = 402 cpu_to_le32(IWL_MVM_DEFAULT_PS_RX_DATA_TIMEOUT); 403 cmd->tx_data_timeout = 404 cpu_to_le32(IWL_MVM_DEFAULT_PS_TX_DATA_TIMEOUT); 405 } 406 407 if (iwl_mvm_power_allow_uapsd(mvm, vif)) 408 iwl_mvm_power_configure_uapsd(mvm, vif, cmd); 409 410#ifdef CONFIG_IWLWIFI_DEBUGFS 411 if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_KEEP_ALIVE) 412 cmd->keep_alive_seconds = 413 cpu_to_le16(mvmvif->dbgfs_pm.keep_alive_seconds); 414 if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_SKIP_OVER_DTIM) { 415 if (mvmvif->dbgfs_pm.skip_over_dtim) 416 cmd->flags |= 417 cpu_to_le16(POWER_FLAGS_SKIP_OVER_DTIM_MSK); 418 else 419 cmd->flags &= 420 cpu_to_le16(~POWER_FLAGS_SKIP_OVER_DTIM_MSK); 421 } 422 if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_RX_DATA_TIMEOUT) 423 cmd->rx_data_timeout = 424 cpu_to_le32(mvmvif->dbgfs_pm.rx_data_timeout); 425 if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_TX_DATA_TIMEOUT) 426 cmd->tx_data_timeout = 427 cpu_to_le32(mvmvif->dbgfs_pm.tx_data_timeout); 428 if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_SKIP_DTIM_PERIODS) 429 cmd->skip_dtim_periods = mvmvif->dbgfs_pm.skip_dtim_periods; 430 if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_LPRX_ENA) { 431 if (mvmvif->dbgfs_pm.lprx_ena) 432 cmd->flags |= cpu_to_le16(POWER_FLAGS_LPRX_ENA_MSK); 433 else 434 cmd->flags &= cpu_to_le16(~POWER_FLAGS_LPRX_ENA_MSK); 435 } 436 if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_LPRX_RSSI_THRESHOLD) 437 cmd->lprx_rssi_threshold = mvmvif->dbgfs_pm.lprx_rssi_threshold; 438 if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_SNOOZE_ENABLE) { 439 if (mvmvif->dbgfs_pm.snooze_ena) 440 cmd->flags |= 441 cpu_to_le16(POWER_FLAGS_SNOOZE_ENA_MSK); 442 else 443 cmd->flags &= 444 cpu_to_le16(~POWER_FLAGS_SNOOZE_ENA_MSK); 445 } 446 if (mvmvif->dbgfs_pm.mask & MVM_DEBUGFS_PM_UAPSD_MISBEHAVING) { 447 u16 flag = POWER_FLAGS_UAPSD_MISBEHAVING_ENA_MSK; 448 if (mvmvif->dbgfs_pm.uapsd_misbehaving) 449 cmd->flags |= cpu_to_le16(flag); 450 else 451 cmd->flags &= cpu_to_le16(flag); 452 } 453#endif /* CONFIG_IWLWIFI_DEBUGFS */ 454} 455 456static int iwl_mvm_power_send_cmd(struct iwl_mvm *mvm, 457 struct ieee80211_vif *vif) 458{ 459 struct iwl_mac_power_cmd cmd = {}; 460 461 iwl_mvm_power_build_cmd(mvm, vif, &cmd); 462 iwl_mvm_power_log(mvm, &cmd); 463#ifdef CONFIG_IWLWIFI_DEBUGFS 464 memcpy(&iwl_mvm_vif_from_mac80211(vif)->mac_pwr_cmd, &cmd, sizeof(cmd)); 465#endif 466 467 return iwl_mvm_send_cmd_pdu(mvm, MAC_PM_POWER_TABLE, 0, 468 sizeof(cmd), &cmd); 469} 470 471int iwl_mvm_power_update_device(struct iwl_mvm *mvm) 472{ 473 struct iwl_device_power_cmd cmd = { 474 .flags = 0, 475 }; 476 477 if (iwlmvm_mod_params.power_scheme == IWL_POWER_SCHEME_CAM) 478 mvm->ps_disabled = true; 479 480 if (!mvm->ps_disabled) 481 cmd.flags |= cpu_to_le16(DEVICE_POWER_FLAGS_POWER_SAVE_ENA_MSK); 482 483#ifdef CONFIG_IWLWIFI_DEBUGFS 484 if (test_bit(IWL_MVM_STATUS_IN_D3, &mvm->status) ? 485 mvm->disable_power_off_d3 : mvm->disable_power_off) 486 cmd.flags &= 487 cpu_to_le16(~DEVICE_POWER_FLAGS_POWER_SAVE_ENA_MSK); 488#endif 489 if (mvm->ext_clock_valid) 490 cmd.flags |= cpu_to_le16(DEVICE_POWER_FLAGS_32K_CLK_VALID_MSK); 491 492 IWL_DEBUG_POWER(mvm, 493 "Sending device power command with flags = 0x%X\n", 494 cmd.flags); 495 496 return iwl_mvm_send_cmd_pdu(mvm, POWER_TABLE_CMD, 0, sizeof(cmd), 497 &cmd); 498} 499 500void iwl_mvm_power_vif_assoc(struct iwl_mvm *mvm, struct ieee80211_vif *vif) 501{ 502 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 503 504 if (!ether_addr_equal(mvmvif->uapsd_misbehaving_ap_addr, 505 vif->cfg.ap_addr)) 506 eth_zero_addr(mvmvif->uapsd_misbehaving_ap_addr); 507} 508 509static void iwl_mvm_power_uapsd_misbehav_ap_iterator(void *_data, u8 *mac, 510 struct ieee80211_vif *vif) 511{ 512 u8 *ap_sta_id = _data; 513 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 514 struct ieee80211_bss_conf *link_conf; 515 unsigned int link_id; 516 517 rcu_read_lock(); 518 for_each_vif_active_link(vif, link_conf, link_id) { 519 struct iwl_mvm_vif_link_info *link_info = mvmvif->link[link_id]; 520 521 /* The ap_sta_id is not expected to change during current 522 * association so no explicit protection is needed 523 */ 524 if (link_info->ap_sta_id == *ap_sta_id) { 525 ether_addr_copy(mvmvif->uapsd_misbehaving_ap_addr, 526 vif->cfg.ap_addr); 527 break; 528 } 529 } 530 rcu_read_unlock(); 531} 532 533void iwl_mvm_power_uapsd_misbehaving_ap_notif(struct iwl_mvm *mvm, 534 struct iwl_rx_cmd_buffer *rxb) 535{ 536 struct iwl_rx_packet *pkt = rxb_addr(rxb); 537 struct iwl_uapsd_misbehaving_ap_notif *notif = (void *)pkt->data; 538 u8 ap_sta_id = le32_to_cpu(notif->sta_id); 539 540 ieee80211_iterate_active_interfaces_atomic( 541 mvm->hw, IEEE80211_IFACE_ITER_NORMAL, 542 iwl_mvm_power_uapsd_misbehav_ap_iterator, &ap_sta_id); 543} 544 545struct iwl_power_vifs { 546 struct iwl_mvm *mvm; 547 struct ieee80211_vif *bss_vif; 548 struct ieee80211_vif *p2p_vif; 549 struct ieee80211_vif *ap_vif; 550 struct ieee80211_vif *monitor_vif; 551 bool p2p_active; 552 bool bss_active; 553 bool ap_active; 554 bool monitor_active; 555}; 556 557static void iwl_mvm_power_disable_pm_iterator(void *_data, u8* mac, 558 struct ieee80211_vif *vif) 559{ 560 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 561 562 mvmvif->pm_enabled = false; 563} 564 565static void iwl_mvm_power_ps_disabled_iterator(void *_data, u8* mac, 566 struct ieee80211_vif *vif) 567{ 568 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 569 bool *disable_ps = _data; 570 571 if (iwl_mvm_vif_is_active(mvmvif)) 572 *disable_ps |= mvmvif->ps_disabled; 573} 574 575static void iwl_mvm_power_get_vifs_iterator(void *_data, u8 *mac, 576 struct ieee80211_vif *vif) 577{ 578 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 579 struct iwl_power_vifs *power_iterator = _data; 580 bool active; 581 582 if (!mvmvif->uploaded) 583 return; 584 585 active = iwl_mvm_vif_is_active(mvmvif); 586 587 switch (ieee80211_vif_type_p2p(vif)) { 588 case NL80211_IFTYPE_P2P_DEVICE: 589 break; 590 591 case NL80211_IFTYPE_P2P_GO: 592 case NL80211_IFTYPE_AP: 593 /* only a single MAC of the same type */ 594 WARN_ON(power_iterator->ap_vif); 595 power_iterator->ap_vif = vif; 596 if (active) 597 power_iterator->ap_active = true; 598 break; 599 600 case NL80211_IFTYPE_MONITOR: 601 /* only a single MAC of the same type */ 602 WARN_ON(power_iterator->monitor_vif); 603 power_iterator->monitor_vif = vif; 604 if (active) 605 power_iterator->monitor_active = true; 606 break; 607 608 case NL80211_IFTYPE_P2P_CLIENT: 609 /* only a single MAC of the same type */ 610 WARN_ON(power_iterator->p2p_vif); 611 power_iterator->p2p_vif = vif; 612 if (active) 613 power_iterator->p2p_active = true; 614 break; 615 616 case NL80211_IFTYPE_STATION: 617 power_iterator->bss_vif = vif; 618 if (active) 619 power_iterator->bss_active = true; 620 break; 621 622 default: 623 break; 624 } 625} 626 627static void iwl_mvm_power_set_pm(struct iwl_mvm *mvm, 628 struct iwl_power_vifs *vifs) 629{ 630 struct iwl_mvm_vif *bss_mvmvif = NULL; 631 struct iwl_mvm_vif *p2p_mvmvif = NULL; 632 struct iwl_mvm_vif *ap_mvmvif = NULL; 633 bool client_same_channel = false; 634 bool ap_same_channel = false; 635 636 lockdep_assert_held(&mvm->mutex); 637 638 /* set pm_enable to false */ 639 ieee80211_iterate_active_interfaces_atomic(mvm->hw, 640 IEEE80211_IFACE_ITER_NORMAL, 641 iwl_mvm_power_disable_pm_iterator, 642 NULL); 643 644 if (vifs->bss_vif) 645 bss_mvmvif = iwl_mvm_vif_from_mac80211(vifs->bss_vif); 646 647 if (vifs->p2p_vif) 648 p2p_mvmvif = iwl_mvm_vif_from_mac80211(vifs->p2p_vif); 649 650 if (vifs->ap_vif) 651 ap_mvmvif = iwl_mvm_vif_from_mac80211(vifs->ap_vif); 652 653 /* don't allow PM if any TDLS stations exist */ 654 if (iwl_mvm_tdls_sta_count(mvm, NULL)) 655 return; 656 657 /* enable PM on bss if bss stand alone */ 658 if (bss_mvmvif && vifs->bss_active && !vifs->p2p_active && 659 !vifs->ap_active) { 660 bss_mvmvif->pm_enabled = true; 661 return; 662 } 663 664 /* enable PM on p2p if p2p stand alone */ 665 if (p2p_mvmvif && vifs->p2p_active && !vifs->bss_active && 666 !vifs->ap_active) { 667 p2p_mvmvif->pm_enabled = true; 668 return; 669 } 670 671 if (p2p_mvmvif && bss_mvmvif && vifs->bss_active && vifs->p2p_active) 672 client_same_channel = 673 iwl_mvm_have_links_same_channel(bss_mvmvif, p2p_mvmvif); 674 675 if (bss_mvmvif && ap_mvmvif && vifs->bss_active && vifs->ap_active) 676 ap_same_channel = 677 iwl_mvm_have_links_same_channel(bss_mvmvif, ap_mvmvif); 678 679 /* clients are not stand alone: enable PM if DCM */ 680 if (!(client_same_channel || ap_same_channel)) { 681 if (bss_mvmvif && vifs->bss_active) 682 bss_mvmvif->pm_enabled = true; 683 if (p2p_mvmvif && vifs->p2p_active) 684 p2p_mvmvif->pm_enabled = true; 685 return; 686 } 687 688 /* 689 * There is only one channel in the system and there are only 690 * bss and p2p clients that share it 691 */ 692 if (client_same_channel && !vifs->ap_active) { 693 /* share same channel*/ 694 bss_mvmvif->pm_enabled = true; 695 p2p_mvmvif->pm_enabled = true; 696 } 697} 698 699#ifdef CONFIG_IWLWIFI_DEBUGFS 700int iwl_mvm_power_mac_dbgfs_read(struct iwl_mvm *mvm, 701 struct ieee80211_vif *vif, char *buf, 702 int bufsz) 703{ 704 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 705 struct iwl_mac_power_cmd cmd = {}; 706 int pos = 0; 707 708 mutex_lock(&mvm->mutex); 709 memcpy(&cmd, &mvmvif->mac_pwr_cmd, sizeof(cmd)); 710 mutex_unlock(&mvm->mutex); 711 712 pos += scnprintf(buf+pos, bufsz-pos, "power_scheme = %d\n", 713 iwlmvm_mod_params.power_scheme); 714 pos += scnprintf(buf+pos, bufsz-pos, "flags = 0x%x\n", 715 le16_to_cpu(cmd.flags)); 716 pos += scnprintf(buf+pos, bufsz-pos, "keep_alive = %d\n", 717 le16_to_cpu(cmd.keep_alive_seconds)); 718 719 if (!(cmd.flags & cpu_to_le16(POWER_FLAGS_POWER_MANAGEMENT_ENA_MSK))) 720 return pos; 721 722 pos += scnprintf(buf+pos, bufsz-pos, "skip_over_dtim = %d\n", 723 (cmd.flags & 724 cpu_to_le16(POWER_FLAGS_SKIP_OVER_DTIM_MSK)) ? 1 : 0); 725 pos += scnprintf(buf+pos, bufsz-pos, "skip_dtim_periods = %d\n", 726 cmd.skip_dtim_periods); 727 if (!(cmd.flags & cpu_to_le16(POWER_FLAGS_ADVANCE_PM_ENA_MSK))) { 728 pos += scnprintf(buf+pos, bufsz-pos, "rx_data_timeout = %d\n", 729 le32_to_cpu(cmd.rx_data_timeout)); 730 pos += scnprintf(buf+pos, bufsz-pos, "tx_data_timeout = %d\n", 731 le32_to_cpu(cmd.tx_data_timeout)); 732 } 733 if (cmd.flags & cpu_to_le16(POWER_FLAGS_LPRX_ENA_MSK)) 734 pos += scnprintf(buf+pos, bufsz-pos, 735 "lprx_rssi_threshold = %d\n", 736 cmd.lprx_rssi_threshold); 737 738 if (!(cmd.flags & cpu_to_le16(POWER_FLAGS_ADVANCE_PM_ENA_MSK))) 739 return pos; 740 741 pos += scnprintf(buf+pos, bufsz-pos, "rx_data_timeout_uapsd = %d\n", 742 le32_to_cpu(cmd.rx_data_timeout_uapsd)); 743 pos += scnprintf(buf+pos, bufsz-pos, "tx_data_timeout_uapsd = %d\n", 744 le32_to_cpu(cmd.tx_data_timeout_uapsd)); 745 pos += scnprintf(buf+pos, bufsz-pos, "qndp_tid = %d\n", cmd.qndp_tid); 746 pos += scnprintf(buf+pos, bufsz-pos, "uapsd_ac_flags = 0x%x\n", 747 cmd.uapsd_ac_flags); 748 pos += scnprintf(buf+pos, bufsz-pos, "uapsd_max_sp = %d\n", 749 cmd.uapsd_max_sp); 750 pos += scnprintf(buf+pos, bufsz-pos, "heavy_tx_thld_packets = %d\n", 751 cmd.heavy_tx_thld_packets); 752 pos += scnprintf(buf+pos, bufsz-pos, "heavy_rx_thld_packets = %d\n", 753 cmd.heavy_rx_thld_packets); 754 pos += scnprintf(buf+pos, bufsz-pos, "heavy_tx_thld_percentage = %d\n", 755 cmd.heavy_tx_thld_percentage); 756 pos += scnprintf(buf+pos, bufsz-pos, "heavy_rx_thld_percentage = %d\n", 757 cmd.heavy_rx_thld_percentage); 758 pos += scnprintf(buf+pos, bufsz-pos, "uapsd_misbehaving_enable = %d\n", 759 (cmd.flags & 760 cpu_to_le16(POWER_FLAGS_UAPSD_MISBEHAVING_ENA_MSK)) ? 761 1 : 0); 762 763 if (!(cmd.flags & cpu_to_le16(POWER_FLAGS_SNOOZE_ENA_MSK))) 764 return pos; 765 766 pos += scnprintf(buf+pos, bufsz-pos, "snooze_interval = %d\n", 767 cmd.snooze_interval); 768 pos += scnprintf(buf+pos, bufsz-pos, "snooze_window = %d\n", 769 cmd.snooze_window); 770 771 return pos; 772} 773 774void 775iwl_mvm_beacon_filter_debugfs_parameters(struct ieee80211_vif *vif, 776 struct iwl_beacon_filter_cmd *cmd) 777{ 778 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 779 struct iwl_dbgfs_bf *dbgfs_bf = &mvmvif->dbgfs_bf; 780 781 if (dbgfs_bf->mask & MVM_DEBUGFS_BF_ENERGY_DELTA) 782 cmd->bf_energy_delta = cpu_to_le32(dbgfs_bf->bf_energy_delta); 783 if (dbgfs_bf->mask & MVM_DEBUGFS_BF_ROAMING_ENERGY_DELTA) 784 cmd->bf_roaming_energy_delta = 785 cpu_to_le32(dbgfs_bf->bf_roaming_energy_delta); 786 if (dbgfs_bf->mask & MVM_DEBUGFS_BF_ROAMING_STATE) 787 cmd->bf_roaming_state = cpu_to_le32(dbgfs_bf->bf_roaming_state); 788 if (dbgfs_bf->mask & MVM_DEBUGFS_BF_TEMP_THRESHOLD) 789 cmd->bf_temp_threshold = 790 cpu_to_le32(dbgfs_bf->bf_temp_threshold); 791 if (dbgfs_bf->mask & MVM_DEBUGFS_BF_TEMP_FAST_FILTER) 792 cmd->bf_temp_fast_filter = 793 cpu_to_le32(dbgfs_bf->bf_temp_fast_filter); 794 if (dbgfs_bf->mask & MVM_DEBUGFS_BF_TEMP_SLOW_FILTER) 795 cmd->bf_temp_slow_filter = 796 cpu_to_le32(dbgfs_bf->bf_temp_slow_filter); 797 if (dbgfs_bf->mask & MVM_DEBUGFS_BF_DEBUG_FLAG) 798 cmd->bf_debug_flag = cpu_to_le32(dbgfs_bf->bf_debug_flag); 799 if (dbgfs_bf->mask & MVM_DEBUGFS_BF_ESCAPE_TIMER) 800 cmd->bf_escape_timer = cpu_to_le32(dbgfs_bf->bf_escape_timer); 801 if (dbgfs_bf->mask & MVM_DEBUGFS_BA_ESCAPE_TIMER) 802 cmd->ba_escape_timer = cpu_to_le32(dbgfs_bf->ba_escape_timer); 803 if (dbgfs_bf->mask & MVM_DEBUGFS_BA_ENABLE_BEACON_ABORT) 804 cmd->ba_enable_beacon_abort = 805 cpu_to_le32(dbgfs_bf->ba_enable_beacon_abort); 806} 807#endif 808 809static int _iwl_mvm_enable_beacon_filter(struct iwl_mvm *mvm, 810 struct ieee80211_vif *vif, 811 struct iwl_beacon_filter_cmd *cmd, 812 u32 cmd_flags) 813{ 814 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 815 int ret; 816 817 if (mvmvif != mvm->bf_allowed_vif || !vif->bss_conf.dtim_period || 818 vif->type != NL80211_IFTYPE_STATION || vif->p2p) 819 return 0; 820 821 iwl_mvm_beacon_filter_set_cqm_params(mvm, vif, cmd); 822 iwl_mvm_beacon_filter_debugfs_parameters(vif, cmd); 823 ret = iwl_mvm_beacon_filter_send_cmd(mvm, cmd, cmd_flags); 824 825 if (!ret) 826 mvmvif->bf_data.bf_enabled = true; 827 828 return ret; 829} 830 831int iwl_mvm_enable_beacon_filter(struct iwl_mvm *mvm, 832 struct ieee80211_vif *vif, 833 u32 flags) 834{ 835 struct iwl_beacon_filter_cmd cmd = { 836 IWL_BF_CMD_CONFIG_DEFAULTS, 837 .bf_enable_beacon_filter = cpu_to_le32(1), 838 }; 839 840 return _iwl_mvm_enable_beacon_filter(mvm, vif, &cmd, flags); 841} 842 843static int _iwl_mvm_disable_beacon_filter(struct iwl_mvm *mvm, 844 struct ieee80211_vif *vif, 845 u32 flags) 846{ 847 struct iwl_beacon_filter_cmd cmd = {}; 848 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 849 int ret; 850 851 if (vif->type != NL80211_IFTYPE_STATION || vif->p2p) 852 return 0; 853 854 ret = iwl_mvm_beacon_filter_send_cmd(mvm, &cmd, flags); 855 856 if (!ret) 857 mvmvif->bf_data.bf_enabled = false; 858 859 return ret; 860} 861 862int iwl_mvm_disable_beacon_filter(struct iwl_mvm *mvm, 863 struct ieee80211_vif *vif, 864 u32 flags) 865{ 866 return _iwl_mvm_disable_beacon_filter(mvm, vif, flags); 867} 868 869static int iwl_mvm_power_set_ps(struct iwl_mvm *mvm) 870{ 871 bool disable_ps; 872 int ret; 873 874 /* disable PS if CAM */ 875 disable_ps = (iwlmvm_mod_params.power_scheme == IWL_POWER_SCHEME_CAM); 876 /* ...or if any of the vifs require PS to be off */ 877 ieee80211_iterate_active_interfaces_atomic(mvm->hw, 878 IEEE80211_IFACE_ITER_NORMAL, 879 iwl_mvm_power_ps_disabled_iterator, 880 &disable_ps); 881 882 /* update device power state if it has changed */ 883 if (mvm->ps_disabled != disable_ps) { 884 bool old_ps_disabled = mvm->ps_disabled; 885 886 mvm->ps_disabled = disable_ps; 887 ret = iwl_mvm_power_update_device(mvm); 888 if (ret) { 889 mvm->ps_disabled = old_ps_disabled; 890 return ret; 891 } 892 } 893 894 return 0; 895} 896 897static int iwl_mvm_power_set_ba(struct iwl_mvm *mvm, 898 struct ieee80211_vif *vif) 899{ 900 struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif); 901 struct iwl_beacon_filter_cmd cmd = { 902 IWL_BF_CMD_CONFIG_DEFAULTS, 903 .bf_enable_beacon_filter = cpu_to_le32(1), 904 }; 905 906 if (!mvmvif->bf_data.bf_enabled) 907 return 0; 908 909 if (test_bit(IWL_MVM_STATUS_IN_D3, &mvm->status)) 910 cmd.ba_escape_timer = cpu_to_le32(IWL_BA_ESCAPE_TIMER_D3); 911 912 mvmvif->bf_data.ba_enabled = !(!mvmvif->pm_enabled || 913 mvm->ps_disabled || 914 !vif->cfg.ps || 915 iwl_mvm_vif_low_latency(mvmvif)); 916 917 return _iwl_mvm_enable_beacon_filter(mvm, vif, &cmd, 0); 918} 919 920int iwl_mvm_power_update_ps(struct iwl_mvm *mvm) 921{ 922 struct iwl_power_vifs vifs = { 923 .mvm = mvm, 924 }; 925 int ret; 926 927 lockdep_assert_held(&mvm->mutex); 928 929 /* get vifs info */ 930 ieee80211_iterate_active_interfaces_atomic(mvm->hw, 931 IEEE80211_IFACE_ITER_NORMAL, 932 iwl_mvm_power_get_vifs_iterator, &vifs); 933 934 ret = iwl_mvm_power_set_ps(mvm); 935 if (ret) 936 return ret; 937 938 if (vifs.bss_vif) 939 return iwl_mvm_power_set_ba(mvm, vifs.bss_vif); 940 941 return 0; 942} 943 944int iwl_mvm_power_update_mac(struct iwl_mvm *mvm) 945{ 946 struct iwl_power_vifs vifs = { 947 .mvm = mvm, 948 }; 949 int ret; 950 951 lockdep_assert_held(&mvm->mutex); 952 953 /* get vifs info */ 954 ieee80211_iterate_active_interfaces_atomic(mvm->hw, 955 IEEE80211_IFACE_ITER_NORMAL, 956 iwl_mvm_power_get_vifs_iterator, &vifs); 957 958 iwl_mvm_power_set_pm(mvm, &vifs); 959 960 ret = iwl_mvm_power_set_ps(mvm); 961 if (ret) 962 return ret; 963 964 if (vifs.bss_vif) { 965 ret = iwl_mvm_power_send_cmd(mvm, vifs.bss_vif); 966 if (ret) 967 return ret; 968 } 969 970 if (vifs.p2p_vif) { 971 ret = iwl_mvm_power_send_cmd(mvm, vifs.p2p_vif); 972 if (ret) 973 return ret; 974 } 975 976 if (vifs.bss_vif) 977 return iwl_mvm_power_set_ba(mvm, vifs.bss_vif); 978 979 return 0; 980} 981