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