drivers/net/wireless/intel/iwlwifi/mvm/utils.c

   1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
   2 /*
   3  * Copyright (C) 2012-2014, 2018-2023 Intel Corporation
   4  * Copyright (C) 2013-2014 Intel Mobile Communications GmbH
   5  * Copyright (C) 2015-2017 Intel Deutschland GmbH
   6  */
   7 #include <net/mac80211.h>
   8
   9 #include "iwl-debug.h"
  10 #include "iwl-io.h"
  11 #include "iwl-prph.h"
  12 #include "iwl-csr.h"
  13 #include "mvm.h"
  14 #include "fw/api/rs.h"
  15 #include "fw/img.h"
  16
  17 /*
  18  * Will return 0 even if the cmd failed when RFKILL is asserted unless
  19  * CMD_WANT_SKB is set in cmd->flags.
  20  */
  21 int iwl_mvm_send_cmd(struct iwl_mvm *mvm, struct iwl_host_cmd *cmd)
  22 {
  23         int ret;
  24
  25 #if defined(CONFIG_IWLWIFI_DEBUGFS) && defined(CONFIG_PM_SLEEP)
  26         if (WARN_ON(mvm->d3_test_active))
  27                 return -EIO;
  28 #endif
  29
  30         /*
  31          * Synchronous commands from this op-mode must hold
  32          * the mutex, this ensures we don't try to send two
  33          * (or more) synchronous commands at a time.
  34          */
  35         if (!(cmd->flags & CMD_ASYNC))
  36                 lockdep_assert_held(&mvm->mutex);
  37
  38         ret = iwl_trans_send_cmd(mvm->trans, cmd);
  39
  40         /*
  41          * If the caller wants the SKB, then don't hide any problems, the
  42          * caller might access the response buffer which will be NULL if
  43          * the command failed.
  44          */
  45         if (cmd->flags & CMD_WANT_SKB)
  46                 return ret;
  47
  48         /*
  49          * Silently ignore failures if RFKILL is asserted or
  50          * we are in suspend\resume process
  51          */
  52         if (!ret || ret == -ERFKILL || ret == -EHOSTDOWN)
  53                 return 0;
  54         return ret;
  55 }
  56
  57 int iwl_mvm_send_cmd_pdu(struct iwl_mvm *mvm, u32 id,
  58                          u32 flags, u16 len, const void *data)
  59 {
  60         struct iwl_host_cmd cmd = {
  61                 .id = id,
  62                 .len = { len, },
  63                 .data = { data, },
  64                 .flags = flags,
  65         };
  66
  67         return iwl_mvm_send_cmd(mvm, &cmd);
  68 }
  69
  70 /*
  71  * We assume that the caller set the status to the success value
  72  */
  73 int iwl_mvm_send_cmd_status(struct iwl_mvm *mvm, struct iwl_host_cmd *cmd,
  74                             u32 *status)
  75 {
  76         struct iwl_rx_packet *pkt;
  77         struct iwl_cmd_response *resp;
  78         int ret, resp_len;
  79
  80         lockdep_assert_held(&mvm->mutex);
  81
  82 #if defined(CONFIG_IWLWIFI_DEBUGFS) && defined(CONFIG_PM_SLEEP)
  83         if (WARN_ON(mvm->d3_test_active))
  84                 return -EIO;
  85 #endif
  86
  87         /*
  88          * Only synchronous commands can wait for status,
  89          * we use WANT_SKB so the caller can't.
  90          */
  91         if (WARN_ONCE(cmd->flags & (CMD_ASYNC | CMD_WANT_SKB),
  92                       "cmd flags %x", cmd->flags))
  93                 return -EINVAL;
  94
  95         cmd->flags |= CMD_WANT_SKB;
  96
  97         ret = iwl_trans_send_cmd(mvm->trans, cmd);
  98         if (ret == -ERFKILL) {
  99                 /*
 100                  * The command failed because of RFKILL, don't update
 101                  * the status, leave it as success and return 0.
 102                  */
 103                 return 0;
 104         } else if (ret) {
 105                 return ret;
 106         }
 107
 108         pkt = cmd->resp_pkt;
 109
 110         resp_len = iwl_rx_packet_payload_len(pkt);
 111         if (WARN_ON_ONCE(resp_len != sizeof(*resp))) {
 112                 ret = -EIO;
 113                 goto out_free_resp;
 114         }
 115
 116         resp = (void *)pkt->data;
 117         *status = le32_to_cpu(resp->status);
 118  out_free_resp:
 119         iwl_free_resp(cmd);
 120         return ret;
 121 }
 122
 123 /*
 124  * We assume that the caller set the status to the sucess value
 125  */
 126 int iwl_mvm_send_cmd_pdu_status(struct iwl_mvm *mvm, u32 id, u16 len,
 127                                 const void *data, u32 *status)
 128 {
 129         struct iwl_host_cmd cmd = {
 130                 .id = id,
 131                 .len = { len, },
 132                 .data = { data, },
 133         };
 134
 135         return iwl_mvm_send_cmd_status(mvm, &cmd, status);
 136 }
 137
 138 int iwl_mvm_legacy_hw_idx_to_mac80211_idx(u32 rate_n_flags,
 139                                           enum nl80211_band band)
 140 {
 141         int format = rate_n_flags & RATE_MCS_MOD_TYPE_MSK;
 142         int rate = rate_n_flags & RATE_LEGACY_RATE_MSK;
 143         bool is_LB = band == NL80211_BAND_2GHZ;
 144
 145         if (format == RATE_MCS_LEGACY_OFDM_MSK)
 146                 return is_LB ? rate + IWL_FIRST_OFDM_RATE :
 147                         rate;
 148
 149         /* CCK is not allowed in HB */
 150         return is_LB ? rate : -1;
 151 }
 152
 153 int iwl_mvm_legacy_rate_to_mac80211_idx(u32 rate_n_flags,
 154                                         enum nl80211_band band)
 155 {
 156         int rate = rate_n_flags & RATE_LEGACY_RATE_MSK_V1;
 157         int idx;
 158         int band_offset = 0;
 159
 160         /* Legacy rate format, search for match in table */
 161         if (band != NL80211_BAND_2GHZ)
 162                 band_offset = IWL_FIRST_OFDM_RATE;
 163         for (idx = band_offset; idx < IWL_RATE_COUNT_LEGACY; idx++)
 164                 if (iwl_fw_rate_idx_to_plcp(idx) == rate)
 165                         return idx - band_offset;
 166
 167         return -1;
 168 }
 169
 170 u8 iwl_mvm_mac80211_idx_to_hwrate(const struct iwl_fw *fw, int rate_idx)
 171 {
 172         if (iwl_fw_lookup_cmd_ver(fw, TX_CMD, 0) > 8)
 173                 /* In the new rate legacy rates are indexed:
 174                  * 0 - 3 for CCK and 0 - 7 for OFDM.
 175                  */
 176                 return (rate_idx >= IWL_FIRST_OFDM_RATE ?
 177                         rate_idx - IWL_FIRST_OFDM_RATE :
 178                         rate_idx);
 179
 180         return iwl_fw_rate_idx_to_plcp(rate_idx);
 181 }
 182
 183 u8 iwl_mvm_mac80211_ac_to_ucode_ac(enum ieee80211_ac_numbers ac)
 184 {
 185         static const u8 mac80211_ac_to_ucode_ac[] = {
 186                 AC_VO,
 187                 AC_VI,
 188                 AC_BE,
 189                 AC_BK
 190         };
 191
 192         return mac80211_ac_to_ucode_ac[ac];
 193 }
 194
 195 void iwl_mvm_rx_fw_error(struct iwl_mvm *mvm, struct iwl_rx_cmd_buffer *rxb)
 196 {
 197         struct iwl_rx_packet *pkt = rxb_addr(rxb);
 198         struct iwl_error_resp *err_resp = (void *)pkt->data;
 199
 200         IWL_ERR(mvm, "FW Error notification: type 0x%08X cmd_id 0x%02X\n",
 201                 le32_to_cpu(err_resp->error_type), err_resp->cmd_id);
 202         IWL_ERR(mvm, "FW Error notification: seq 0x%04X service 0x%08X\n",
 203                 le16_to_cpu(err_resp->bad_cmd_seq_num),
 204                 le32_to_cpu(err_resp->error_service));
 205         IWL_ERR(mvm, "FW Error notification: timestamp 0x%016llX\n",
 206                 le64_to_cpu(err_resp->timestamp));
 207 }
 208
 209 /*
 210  * Returns the first antenna as ANT_[ABC], as defined in iwl-config.h.
 211  * The parameter should also be a combination of ANT_[ABC].
 212  */
 213 u8 first_antenna(u8 mask)
 214 {
 215         BUILD_BUG_ON(ANT_A != BIT(0)); /* using ffs is wrong if not */
 216         if (WARN_ON_ONCE(!mask)) /* ffs will return 0 if mask is zeroed */
 217                 return BIT(0);
 218         return BIT(ffs(mask) - 1);
 219 }
 220
 221 #define MAX_ANT_NUM 2
 222 /*
 223  * Toggles between TX antennas to send the probe request on.
 224  * Receives the bitmask of valid TX antennas and the *index* used
 225  * for the last TX, and returns the next valid *index* to use.
 226  * In order to set it in the tx_cmd, must do BIT(idx).
 227  */
 228 u8 iwl_mvm_next_antenna(struct iwl_mvm *mvm, u8 valid, u8 last_idx)
 229 {
 230         u8 ind = last_idx;
 231         int i;
 232
 233         for (i = 0; i < MAX_ANT_NUM; i++) {
 234                 ind = (ind + 1) % MAX_ANT_NUM;
 235                 if (valid & BIT(ind))
 236                         return ind;
 237         }
 238
 239         WARN_ONCE(1, "Failed to toggle between antennas 0x%x", valid);
 240         return last_idx;
 241 }
 242
 243 /**
 244  * iwl_mvm_send_lq_cmd() - Send link quality command
 245  * @mvm: Driver data.
 246  * @lq: Link quality command to send.
 247  *
 248  * The link quality command is sent as the last step of station creation.
 249  * This is the special case in which init is set and we call a callback in
 250  * this case to clear the state indicating that station creation is in
 251  * progress.
 252  */
 253 int iwl_mvm_send_lq_cmd(struct iwl_mvm *mvm, struct iwl_lq_cmd *lq)
 254 {
 255         struct iwl_host_cmd cmd = {
 256                 .id = LQ_CMD,
 257                 .len = { sizeof(struct iwl_lq_cmd), },
 258                 .flags = CMD_ASYNC,
 259                 .data = { lq, },
 260         };
 261
 262         if (WARN_ON(lq->sta_id == IWL_MVM_INVALID_STA ||
 263                     iwl_mvm_has_tlc_offload(mvm)))
 264                 return -EINVAL;
 265
 266         return iwl_mvm_send_cmd(mvm, &cmd);
 267 }
 268
 269 /**
 270  * iwl_mvm_update_smps - Get a request to change the SMPS mode
 271  * @mvm: Driver data.
 272  * @vif: Pointer to the ieee80211_vif structure
 273  * @req_type: The part of the driver who call for a change.
 274  * @smps_request: The request to change the SMPS mode.
 275  * @link_id: for MLO link_id, otherwise 0 (deflink)
 276  *
 277  * Get a requst to change the SMPS mode,
 278  * and change it according to all other requests in the driver.
 279  */
 280 void iwl_mvm_update_smps(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 281                          enum iwl_mvm_smps_type_request req_type,
 282                          enum ieee80211_smps_mode smps_request,
 283                          unsigned int link_id)
 284 {
 285         struct iwl_mvm_vif *mvmvif;
 286         enum ieee80211_smps_mode smps_mode = IEEE80211_SMPS_AUTOMATIC;
 287         int i;
 288
 289         lockdep_assert_held(&mvm->mutex);
 290
 291         /* SMPS is irrelevant for NICs that don't have at least 2 RX antenna */
 292         if (num_of_ant(iwl_mvm_get_valid_rx_ant(mvm)) == 1)
 293                 return;
 294
 295         if (vif->type != NL80211_IFTYPE_STATION)
 296                 return;
 297
 298         mvmvif = iwl_mvm_vif_from_mac80211(vif);
 299
 300         if (WARN_ON_ONCE(!mvmvif->link[link_id]))
 301                 return;
 302
 303         mvmvif->link[link_id]->smps_requests[req_type] = smps_request;
 304         for (i = 0; i < NUM_IWL_MVM_SMPS_REQ; i++) {
 305                 if (mvmvif->link[link_id]->smps_requests[i] ==
 306                     IEEE80211_SMPS_STATIC) {
 307                         smps_mode = IEEE80211_SMPS_STATIC;
 308                         break;
 309                 }
 310                 if (mvmvif->link[link_id]->smps_requests[i] ==
 311                     IEEE80211_SMPS_DYNAMIC)
 312                         smps_mode = IEEE80211_SMPS_DYNAMIC;
 313         }
 314
 315         /* SMPS is disabled in eSR */
 316         if (mvmvif->esr_active)
 317                 smps_mode = IEEE80211_SMPS_OFF;
 318
 319         ieee80211_request_smps(vif, link_id, smps_mode);
 320 }
 321
 322 void iwl_mvm_update_smps_on_active_links(struct iwl_mvm *mvm,
 323                                          struct ieee80211_vif *vif,
 324                                          enum iwl_mvm_smps_type_request req_type,
 325                                          enum ieee80211_smps_mode smps_request)
 326 {
 327         struct ieee80211_bss_conf *link_conf;
 328         unsigned int link_id;
 329
 330         rcu_read_lock();
 331         for_each_vif_active_link(vif, link_conf, link_id)
 332                 iwl_mvm_update_smps(mvm, vif, req_type, smps_request,
 333                                     link_id);
 334         rcu_read_unlock();
 335 }
 336
 337 static bool iwl_wait_stats_complete(struct iwl_notif_wait_data *notif_wait,
 338                                     struct iwl_rx_packet *pkt, void *data)
 339 {
 340         WARN_ON(pkt->hdr.cmd != STATISTICS_NOTIFICATION);
 341
 342         return true;
 343 }
 344
 345 static int iwl_mvm_request_system_statistics(struct iwl_mvm *mvm, bool clear,
 346                                              u8 cmd_ver)
 347 {
 348         struct iwl_system_statistics_cmd system_cmd = {
 349                 .cfg_mask = clear ?
 350                             cpu_to_le32(IWL_STATS_CFG_FLG_ON_DEMAND_NTFY_MSK) :
 351                             cpu_to_le32(IWL_STATS_CFG_FLG_RESET_MSK |
 352                                         IWL_STATS_CFG_FLG_ON_DEMAND_NTFY_MSK),
 353                 .type_id_mask = cpu_to_le32(IWL_STATS_NTFY_TYPE_ID_OPER |
 354                                             IWL_STATS_NTFY_TYPE_ID_OPER_PART1),
 355         };
 356         struct iwl_host_cmd cmd = {
 357                 .id = WIDE_ID(SYSTEM_GROUP, SYSTEM_STATISTICS_CMD),
 358                 .len[0] = sizeof(system_cmd),
 359                 .data[0] = &system_cmd,
 360         };
 361         struct iwl_notification_wait stats_wait;
 362         static const u16 stats_complete[] = {
 363                 WIDE_ID(SYSTEM_GROUP, SYSTEM_STATISTICS_END_NOTIF),
 364         };
 365         int ret;
 366
 367         if (cmd_ver != 1) {
 368                 IWL_FW_CHECK_FAILED(mvm,
 369                                     "Invalid system statistics command version:%d\n",
 370                                     cmd_ver);
 371                 return -EOPNOTSUPP;
 372         }
 373
 374         iwl_init_notification_wait(&mvm->notif_wait, &stats_wait,
 375                                    stats_complete, ARRAY_SIZE(stats_complete),
 376                                    NULL, NULL);
 377
 378         mvm->statistics_clear = clear;
 379         ret = iwl_mvm_send_cmd(mvm, &cmd);
 380         if (ret) {
 381                 iwl_remove_notification(&mvm->notif_wait, &stats_wait);
 382                 return ret;
 383         }
 384
 385         /* 500ms for OPERATIONAL, PART1 and END notification should be enough
 386          * for FW to collect data from all LMACs and send
 387          * STATISTICS_NOTIFICATION to host
 388          */
 389         ret = iwl_wait_notification(&mvm->notif_wait, &stats_wait, HZ / 2);
 390         if (ret)
 391                 return ret;
 392
 393         if (clear)
 394                 iwl_mvm_accu_radio_stats(mvm);
 395
 396         return ret;
 397 }
 398
 399 int iwl_mvm_request_statistics(struct iwl_mvm *mvm, bool clear)
 400 {
 401         struct iwl_statistics_cmd scmd = {
 402                 .flags = clear ? cpu_to_le32(IWL_STATISTICS_FLG_CLEAR) : 0,
 403         };
 404
 405         struct iwl_host_cmd cmd = {
 406                 .id = STATISTICS_CMD,
 407                 .len[0] = sizeof(scmd),
 408                 .data[0] = &scmd,
 409         };
 410         u8 cmd_ver = iwl_fw_lookup_cmd_ver(mvm->fw,
 411                                            WIDE_ID(SYSTEM_GROUP,
 412                                                    SYSTEM_STATISTICS_CMD),
 413                                            IWL_FW_CMD_VER_UNKNOWN);
 414         int ret;
 415
 416         if (cmd_ver != IWL_FW_CMD_VER_UNKNOWN)
 417                 return iwl_mvm_request_system_statistics(mvm, clear, cmd_ver);
 418
 419         /* From version 15 - STATISTICS_NOTIFICATION, the reply for
 420          * STATISTICS_CMD is empty, and the response is with
 421          * STATISTICS_NOTIFICATION notification
 422          */
 423         if (iwl_fw_lookup_notif_ver(mvm->fw, LEGACY_GROUP,
 424                                     STATISTICS_NOTIFICATION, 0) < 15) {
 425                 cmd.flags = CMD_WANT_SKB;
 426
 427                 ret = iwl_mvm_send_cmd(mvm, &cmd);
 428                 if (ret)
 429                         return ret;
 430
 431                 iwl_mvm_handle_rx_statistics(mvm, cmd.resp_pkt);
 432                 iwl_free_resp(&cmd);
 433         } else {
 434                 struct iwl_notification_wait stats_wait;
 435                 static const u16 stats_complete[] = {
 436                         STATISTICS_NOTIFICATION,
 437                 };
 438
 439                 iwl_init_notification_wait(&mvm->notif_wait, &stats_wait,
 440                                            stats_complete, ARRAY_SIZE(stats_complete),
 441                                            iwl_wait_stats_complete, NULL);
 442
 443                 ret = iwl_mvm_send_cmd(mvm, &cmd);
 444                 if (ret) {
 445                         iwl_remove_notification(&mvm->notif_wait, &stats_wait);
 446                         return ret;
 447                 }
 448
 449                 /* 200ms should be enough for FW to collect data from all
 450                  * LMACs and send STATISTICS_NOTIFICATION to host
 451                  */
 452                 ret = iwl_wait_notification(&mvm->notif_wait, &stats_wait, HZ / 5);
 453                 if (ret)
 454                         return ret;
 455         }
 456
 457         if (clear)
 458                 iwl_mvm_accu_radio_stats(mvm);
 459
 460         return 0;
 461 }
 462
 463 void iwl_mvm_accu_radio_stats(struct iwl_mvm *mvm)
 464 {
 465         mvm->accu_radio_stats.rx_time += mvm->radio_stats.rx_time;
 466         mvm->accu_radio_stats.tx_time += mvm->radio_stats.tx_time;
 467         mvm->accu_radio_stats.on_time_rf += mvm->radio_stats.on_time_rf;
 468         mvm->accu_radio_stats.on_time_scan += mvm->radio_stats.on_time_scan;
 469 }
 470
 471 struct iwl_mvm_diversity_iter_data {
 472         struct iwl_mvm_phy_ctxt *ctxt;
 473         bool result;
 474 };
 475
 476 static void iwl_mvm_diversity_iter(void *_data, u8 *mac,
 477                                    struct ieee80211_vif *vif)
 478 {
 479         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 480         struct iwl_mvm_diversity_iter_data *data = _data;
 481         int i, link_id;
 482
 483         for_each_mvm_vif_valid_link(mvmvif, link_id) {
 484                 struct iwl_mvm_vif_link_info *link_info = mvmvif->link[link_id];
 485
 486                 if (link_info->phy_ctxt != data->ctxt)
 487                         continue;
 488
 489                 for (i = 0; i < NUM_IWL_MVM_SMPS_REQ; i++) {
 490                         if (link_info->smps_requests[i] == IEEE80211_SMPS_STATIC ||
 491                             link_info->smps_requests[i] == IEEE80211_SMPS_DYNAMIC) {
 492                                 data->result = false;
 493                                 break;
 494                         }
 495                 }
 496         }
 497 }
 498
 499 bool iwl_mvm_rx_diversity_allowed(struct iwl_mvm *mvm,
 500                                   struct iwl_mvm_phy_ctxt *ctxt)
 501 {
 502         struct iwl_mvm_diversity_iter_data data = {
 503                 .ctxt = ctxt,
 504                 .result = true,
 505         };
 506
 507         lockdep_assert_held(&mvm->mutex);
 508
 509         if (iwlmvm_mod_params.power_scheme != IWL_POWER_SCHEME_CAM)
 510                 return false;
 511
 512         if (num_of_ant(iwl_mvm_get_valid_rx_ant(mvm)) == 1)
 513                 return false;
 514
 515         if (mvm->cfg->rx_with_siso_diversity)
 516                 return false;
 517
 518         ieee80211_iterate_active_interfaces_atomic(
 519                         mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 520                         iwl_mvm_diversity_iter, &data);
 521
 522         return data.result;
 523 }
 524
 525 void iwl_mvm_send_low_latency_cmd(struct iwl_mvm *mvm,
 526                                   bool low_latency, u16 mac_id)
 527 {
 528         struct iwl_mac_low_latency_cmd cmd = {
 529                 .mac_id = cpu_to_le32(mac_id)
 530         };
 531
 532         if (!fw_has_capa(&mvm->fw->ucode_capa,
 533                          IWL_UCODE_TLV_CAPA_DYNAMIC_QUOTA))
 534                 return;
 535
 536         if (low_latency) {
 537                 /* currently we don't care about the direction */
 538                 cmd.low_latency_rx = 1;
 539                 cmd.low_latency_tx = 1;
 540         }
 541
 542         if (iwl_mvm_send_cmd_pdu(mvm, WIDE_ID(MAC_CONF_GROUP, LOW_LATENCY_CMD),
 543                                  0, sizeof(cmd), &cmd))
 544                 IWL_ERR(mvm, "Failed to send low latency command\n");
 545 }
 546
 547 int iwl_mvm_update_low_latency(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 548                                bool low_latency,
 549                                enum iwl_mvm_low_latency_cause cause)
 550 {
 551         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 552         int res;
 553         bool prev;
 554
 555         lockdep_assert_held(&mvm->mutex);
 556
 557         prev = iwl_mvm_vif_low_latency(mvmvif);
 558         iwl_mvm_vif_set_low_latency(mvmvif, low_latency, cause);
 559
 560         low_latency = iwl_mvm_vif_low_latency(mvmvif);
 561
 562         if (low_latency == prev)
 563                 return 0;
 564
 565         iwl_mvm_send_low_latency_cmd(mvm, low_latency, mvmvif->id);
 566
 567         res = iwl_mvm_update_quotas(mvm, false, NULL);
 568         if (res)
 569                 return res;
 570
 571         iwl_mvm_bt_coex_vif_change(mvm);
 572
 573         return iwl_mvm_power_update_mac(mvm);
 574 }
 575
 576 struct iwl_mvm_low_latency_iter {
 577         bool result;
 578         bool result_per_band[NUM_NL80211_BANDS];
 579 };
 580
 581 static void iwl_mvm_ll_iter(void *_data, u8 *mac, struct ieee80211_vif *vif)
 582 {
 583         struct iwl_mvm_low_latency_iter *result = _data;
 584         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 585         enum nl80211_band band;
 586
 587         if (iwl_mvm_vif_low_latency(mvmvif)) {
 588                 result->result = true;
 589
 590                 if (!mvmvif->deflink.phy_ctxt)
 591                         return;
 592
 593                 band = mvmvif->deflink.phy_ctxt->channel->band;
 594                 result->result_per_band[band] = true;
 595         }
 596 }
 597
 598 bool iwl_mvm_low_latency(struct iwl_mvm *mvm)
 599 {
 600         struct iwl_mvm_low_latency_iter data = {};
 601
 602         ieee80211_iterate_active_interfaces_atomic(
 603                         mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 604                         iwl_mvm_ll_iter, &data);
 605
 606         return data.result;
 607 }
 608
 609 bool iwl_mvm_low_latency_band(struct iwl_mvm *mvm, enum nl80211_band band)
 610 {
 611         struct iwl_mvm_low_latency_iter data = {};
 612
 613         ieee80211_iterate_active_interfaces_atomic(
 614                         mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 615                         iwl_mvm_ll_iter, &data);
 616
 617         return data.result_per_band[band];
 618 }
 619
 620 struct iwl_bss_iter_data {
 621         struct ieee80211_vif *vif;
 622         bool error;
 623 };
 624
 625 static void iwl_mvm_bss_iface_iterator(void *_data, u8 *mac,
 626                                        struct ieee80211_vif *vif)
 627 {
 628         struct iwl_bss_iter_data *data = _data;
 629
 630         if (vif->type != NL80211_IFTYPE_STATION || vif->p2p)
 631                 return;
 632
 633         if (data->vif) {
 634                 data->error = true;
 635                 return;
 636         }
 637
 638         data->vif = vif;
 639 }
 640
 641 struct ieee80211_vif *iwl_mvm_get_bss_vif(struct iwl_mvm *mvm)
 642 {
 643         struct iwl_bss_iter_data bss_iter_data = {};
 644
 645         ieee80211_iterate_active_interfaces_atomic(
 646                 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 647                 iwl_mvm_bss_iface_iterator, &bss_iter_data);
 648
 649         if (bss_iter_data.error) {
 650                 IWL_ERR(mvm, "More than one managed interface active!\n");
 651                 return ERR_PTR(-EINVAL);
 652         }
 653
 654         return bss_iter_data.vif;
 655 }
 656
 657 struct iwl_bss_find_iter_data {
 658         struct ieee80211_vif *vif;
 659         u32 macid;
 660 };
 661
 662 static void iwl_mvm_bss_find_iface_iterator(void *_data, u8 *mac,
 663                                             struct ieee80211_vif *vif)
 664 {
 665         struct iwl_bss_find_iter_data *data = _data;
 666         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 667
 668         if (mvmvif->id == data->macid)
 669                 data->vif = vif;
 670 }
 671
 672 struct ieee80211_vif *iwl_mvm_get_vif_by_macid(struct iwl_mvm *mvm, u32 macid)
 673 {
 674         struct iwl_bss_find_iter_data data = {
 675                 .macid = macid,
 676         };
 677
 678         lockdep_assert_held(&mvm->mutex);
 679
 680         ieee80211_iterate_active_interfaces_atomic(
 681                 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 682                 iwl_mvm_bss_find_iface_iterator, &data);
 683
 684         return data.vif;
 685 }
 686
 687 struct iwl_sta_iter_data {
 688         bool assoc;
 689 };
 690
 691 static void iwl_mvm_sta_iface_iterator(void *_data, u8 *mac,
 692                                        struct ieee80211_vif *vif)
 693 {
 694         struct iwl_sta_iter_data *data = _data;
 695
 696         if (vif->type != NL80211_IFTYPE_STATION)
 697                 return;
 698
 699         if (vif->cfg.assoc)
 700                 data->assoc = true;
 701 }
 702
 703 bool iwl_mvm_is_vif_assoc(struct iwl_mvm *mvm)
 704 {
 705         struct iwl_sta_iter_data data = {
 706                 .assoc = false,
 707         };
 708
 709         ieee80211_iterate_active_interfaces_atomic(mvm->hw,
 710                                                    IEEE80211_IFACE_ITER_NORMAL,
 711                                                    iwl_mvm_sta_iface_iterator,
 712                                                    &data);
 713         return data.assoc;
 714 }
 715
 716 unsigned int iwl_mvm_get_wd_timeout(struct iwl_mvm *mvm,
 717                                     struct ieee80211_vif *vif,
 718                                     bool tdls, bool cmd_q)
 719 {
 720         struct iwl_fw_dbg_trigger_tlv *trigger;
 721         struct iwl_fw_dbg_trigger_txq_timer *txq_timer;
 722         unsigned int default_timeout = cmd_q ?
 723                 IWL_DEF_WD_TIMEOUT :
 724                 mvm->trans->trans_cfg->base_params->wd_timeout;
 725
 726         if (!iwl_fw_dbg_trigger_enabled(mvm->fw, FW_DBG_TRIGGER_TXQ_TIMERS)) {
 727                 /*
 728                  * We can't know when the station is asleep or awake, so we
 729                  * must disable the queue hang detection.
 730                  */
 731                 if (fw_has_capa(&mvm->fw->ucode_capa,
 732                                 IWL_UCODE_TLV_CAPA_STA_PM_NOTIF) &&
 733                     vif && vif->type == NL80211_IFTYPE_AP)
 734                         return IWL_WATCHDOG_DISABLED;
 735                 return default_timeout;
 736         }
 737
 738         trigger = iwl_fw_dbg_get_trigger(mvm->fw, FW_DBG_TRIGGER_TXQ_TIMERS);
 739         txq_timer = (void *)trigger->data;
 740
 741         if (tdls)
 742                 return le32_to_cpu(txq_timer->tdls);
 743
 744         if (cmd_q)
 745                 return le32_to_cpu(txq_timer->command_queue);
 746
 747         if (WARN_ON(!vif))
 748                 return default_timeout;
 749
 750         switch (ieee80211_vif_type_p2p(vif)) {
 751         case NL80211_IFTYPE_ADHOC:
 752                 return le32_to_cpu(txq_timer->ibss);
 753         case NL80211_IFTYPE_STATION:
 754                 return le32_to_cpu(txq_timer->bss);
 755         case NL80211_IFTYPE_AP:
 756                 return le32_to_cpu(txq_timer->softap);
 757         case NL80211_IFTYPE_P2P_CLIENT:
 758                 return le32_to_cpu(txq_timer->p2p_client);
 759         case NL80211_IFTYPE_P2P_GO:
 760                 return le32_to_cpu(txq_timer->p2p_go);
 761         case NL80211_IFTYPE_P2P_DEVICE:
 762                 return le32_to_cpu(txq_timer->p2p_device);
 763         case NL80211_IFTYPE_MONITOR:
 764                 return default_timeout;
 765         default:
 766                 WARN_ON(1);
 767                 return mvm->trans->trans_cfg->base_params->wd_timeout;
 768         }
 769 }
 770
 771 void iwl_mvm_connection_loss(struct iwl_mvm *mvm, struct ieee80211_vif *vif,
 772                              const char *errmsg)
 773 {
 774         struct iwl_fw_dbg_trigger_tlv *trig;
 775         struct iwl_fw_dbg_trigger_mlme *trig_mlme;
 776
 777         trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif),
 778                                      FW_DBG_TRIGGER_MLME);
 779         if (!trig)
 780                 goto out;
 781
 782         trig_mlme = (void *)trig->data;
 783
 784         if (trig_mlme->stop_connection_loss &&
 785             --trig_mlme->stop_connection_loss)
 786                 goto out;
 787
 788         iwl_fw_dbg_collect_trig(&mvm->fwrt, trig, "%s", errmsg);
 789
 790 out:
 791         ieee80211_connection_loss(vif);
 792 }
 793
 794 void iwl_mvm_event_frame_timeout_callback(struct iwl_mvm *mvm,
 795                                           struct ieee80211_vif *vif,
 796                                           const struct ieee80211_sta *sta,
 797                                           u16 tid)
 798 {
 799         struct iwl_fw_dbg_trigger_tlv *trig;
 800         struct iwl_fw_dbg_trigger_ba *ba_trig;
 801
 802         trig = iwl_fw_dbg_trigger_on(&mvm->fwrt, ieee80211_vif_to_wdev(vif),
 803                                      FW_DBG_TRIGGER_BA);
 804         if (!trig)
 805                 return;
 806
 807         ba_trig = (void *)trig->data;
 808
 809         if (!(le16_to_cpu(ba_trig->frame_timeout) & BIT(tid)))
 810                 return;
 811
 812         iwl_fw_dbg_collect_trig(&mvm->fwrt, trig,
 813                                 "Frame from %pM timed out, tid %d",
 814                                 sta->addr, tid);
 815 }
 816
 817 u8 iwl_mvm_tcm_load_percentage(u32 airtime, u32 elapsed)
 818 {
 819         if (!elapsed)
 820                 return 0;
 821
 822         return (100 * airtime / elapsed) / USEC_PER_MSEC;
 823 }
 824
 825 static enum iwl_mvm_traffic_load
 826 iwl_mvm_tcm_load(struct iwl_mvm *mvm, u32 airtime, unsigned long elapsed)
 827 {
 828         u8 load = iwl_mvm_tcm_load_percentage(airtime, elapsed);
 829
 830         if (load > IWL_MVM_TCM_LOAD_HIGH_THRESH)
 831                 return IWL_MVM_TRAFFIC_HIGH;
 832         if (load > IWL_MVM_TCM_LOAD_MEDIUM_THRESH)
 833                 return IWL_MVM_TRAFFIC_MEDIUM;
 834
 835         return IWL_MVM_TRAFFIC_LOW;
 836 }
 837
 838 static void iwl_mvm_tcm_iter(void *_data, u8 *mac, struct ieee80211_vif *vif)
 839 {
 840         struct iwl_mvm *mvm = _data;
 841         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 842         bool low_latency, prev = mvmvif->low_latency & LOW_LATENCY_TRAFFIC;
 843
 844         if (mvmvif->id >= NUM_MAC_INDEX_DRIVER)
 845                 return;
 846
 847         low_latency = mvm->tcm.result.low_latency[mvmvif->id];
 848
 849         if (!mvm->tcm.result.change[mvmvif->id] &&
 850             prev == low_latency) {
 851                 iwl_mvm_update_quotas(mvm, false, NULL);
 852                 return;
 853         }
 854
 855         if (prev != low_latency) {
 856                 /* this sends traffic load and updates quota as well */
 857                 iwl_mvm_update_low_latency(mvm, vif, low_latency,
 858                                            LOW_LATENCY_TRAFFIC);
 859         } else {
 860                 iwl_mvm_update_quotas(mvm, false, NULL);
 861         }
 862 }
 863
 864 static void iwl_mvm_tcm_results(struct iwl_mvm *mvm)
 865 {
 866         mutex_lock(&mvm->mutex);
 867
 868         ieee80211_iterate_active_interfaces(
 869                 mvm->hw, IEEE80211_IFACE_ITER_NORMAL,
 870                 iwl_mvm_tcm_iter, mvm);
 871
 872         if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_UMAC_SCAN))
 873                 iwl_mvm_config_scan(mvm);
 874
 875         mutex_unlock(&mvm->mutex);
 876 }
 877
 878 static void iwl_mvm_tcm_uapsd_nonagg_detected_wk(struct work_struct *wk)
 879 {
 880         struct iwl_mvm *mvm;
 881         struct iwl_mvm_vif *mvmvif;
 882         struct ieee80211_vif *vif;
 883
 884         mvmvif = container_of(wk, struct iwl_mvm_vif,
 885                               uapsd_nonagg_detected_wk.work);
 886         vif = container_of((void *)mvmvif, struct ieee80211_vif, drv_priv);
 887         mvm = mvmvif->mvm;
 888
 889         if (mvm->tcm.data[mvmvif->id].opened_rx_ba_sessions)
 890                 return;
 891
 892         /* remember that this AP is broken */
 893         memcpy(mvm->uapsd_noagg_bssids[mvm->uapsd_noagg_bssid_write_idx].addr,
 894                vif->bss_conf.bssid, ETH_ALEN);
 895         mvm->uapsd_noagg_bssid_write_idx++;
 896         if (mvm->uapsd_noagg_bssid_write_idx >= IWL_MVM_UAPSD_NOAGG_LIST_LEN)
 897                 mvm->uapsd_noagg_bssid_write_idx = 0;
 898
 899         iwl_mvm_connection_loss(mvm, vif,
 900                                 "AP isn't using AMPDU with uAPSD enabled");
 901 }
 902
 903 static void iwl_mvm_uapsd_agg_disconnect(struct iwl_mvm *mvm,
 904                                          struct ieee80211_vif *vif)
 905 {
 906         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 907
 908         if (vif->type != NL80211_IFTYPE_STATION)
 909                 return;
 910
 911         if (!vif->cfg.assoc)
 912                 return;
 913
 914         if (!mvmvif->deflink.queue_params[IEEE80211_AC_VO].uapsd &&
 915             !mvmvif->deflink.queue_params[IEEE80211_AC_VI].uapsd &&
 916             !mvmvif->deflink.queue_params[IEEE80211_AC_BE].uapsd &&
 917             !mvmvif->deflink.queue_params[IEEE80211_AC_BK].uapsd)
 918                 return;
 919
 920         if (mvm->tcm.data[mvmvif->id].uapsd_nonagg_detect.detected)
 921                 return;
 922
 923         mvm->tcm.data[mvmvif->id].uapsd_nonagg_detect.detected = true;
 924         IWL_INFO(mvm,
 925                  "detected AP should do aggregation but isn't, likely due to U-APSD\n");
 926         schedule_delayed_work(&mvmvif->uapsd_nonagg_detected_wk,
 927                               15 * HZ);
 928 }
 929
 930 static void iwl_mvm_check_uapsd_agg_expected_tpt(struct iwl_mvm *mvm,
 931                                                  unsigned int elapsed,
 932                                                  int mac)
 933 {
 934         u64 bytes = mvm->tcm.data[mac].uapsd_nonagg_detect.rx_bytes;
 935         u64 tpt;
 936         unsigned long rate;
 937         struct ieee80211_vif *vif;
 938
 939         rate = ewma_rate_read(&mvm->tcm.data[mac].uapsd_nonagg_detect.rate);
 940
 941         if (!rate || mvm->tcm.data[mac].opened_rx_ba_sessions ||
 942             mvm->tcm.data[mac].uapsd_nonagg_detect.detected)
 943                 return;
 944
 945         if (iwl_mvm_has_new_rx_api(mvm)) {
 946                 tpt = 8 * bytes; /* kbps */
 947                 do_div(tpt, elapsed);
 948                 rate *= 1000; /* kbps */
 949                 if (tpt < 22 * rate / 100)
 950                         return;
 951         } else {
 952                 /*
 953                  * the rate here is actually the threshold, in 100Kbps units,
 954                  * so do the needed conversion from bytes to 100Kbps:
 955                  * 100kb = bits / (100 * 1000),
 956                  * 100kbps = 100kb / (msecs / 1000) ==
 957                  *           (bits / (100 * 1000)) / (msecs / 1000) ==
 958                  *           bits / (100 * msecs)
 959                  */
 960                 tpt = (8 * bytes);
 961                 do_div(tpt, elapsed * 100);
 962                 if (tpt < rate)
 963                         return;
 964         }
 965
 966         rcu_read_lock();
 967         vif = rcu_dereference(mvm->vif_id_to_mac[mac]);
 968         if (vif)
 969                 iwl_mvm_uapsd_agg_disconnect(mvm, vif);
 970         rcu_read_unlock();
 971 }
 972
 973 static void iwl_mvm_tcm_iterator(void *_data, u8 *mac,
 974                                  struct ieee80211_vif *vif)
 975 {
 976         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
 977         u32 *band = _data;
 978
 979         if (!mvmvif->deflink.phy_ctxt)
 980                 return;
 981
 982         band[mvmvif->id] = mvmvif->deflink.phy_ctxt->channel->band;
 983 }
 984
 985 static unsigned long iwl_mvm_calc_tcm_stats(struct iwl_mvm *mvm,
 986                                             unsigned long ts,
 987                                             bool handle_uapsd)
 988 {
 989         unsigned int elapsed = jiffies_to_msecs(ts - mvm->tcm.ts);
 990         unsigned int uapsd_elapsed =
 991                 jiffies_to_msecs(ts - mvm->tcm.uapsd_nonagg_ts);
 992         u32 total_airtime = 0;
 993         u32 band_airtime[NUM_NL80211_BANDS] = {0};
 994         u32 band[NUM_MAC_INDEX_DRIVER] = {0};
 995         int ac, mac, i;
 996         bool low_latency = false;
 997         enum iwl_mvm_traffic_load load, band_load;
 998         bool handle_ll = time_after(ts, mvm->tcm.ll_ts + MVM_LL_PERIOD);
 999
1000         if (handle_ll)
1001                 mvm->tcm.ll_ts = ts;
1002         if (handle_uapsd)
1003                 mvm->tcm.uapsd_nonagg_ts = ts;
1004
1005         mvm->tcm.result.elapsed = elapsed;
1006
1007         ieee80211_iterate_active_interfaces_atomic(mvm->hw,
1008                                                    IEEE80211_IFACE_ITER_NORMAL,
1009                                                    iwl_mvm_tcm_iterator,
1010                                                    &band);
1011
1012         for (mac = 0; mac < NUM_MAC_INDEX_DRIVER; mac++) {
1013                 struct iwl_mvm_tcm_mac *mdata = &mvm->tcm.data[mac];
1014                 u32 vo_vi_pkts = 0;
1015                 u32 airtime = mdata->rx.airtime + mdata->tx.airtime;
1016
1017                 total_airtime += airtime;
1018                 band_airtime[band[mac]] += airtime;
1019
1020                 load = iwl_mvm_tcm_load(mvm, airtime, elapsed);
1021                 mvm->tcm.result.change[mac] = load != mvm->tcm.result.load[mac];
1022                 mvm->tcm.result.load[mac] = load;
1023                 mvm->tcm.result.airtime[mac] = airtime;
1024
1025                 for (ac = IEEE80211_AC_VO; ac <= IEEE80211_AC_VI; ac++)
1026                         vo_vi_pkts += mdata->rx.pkts[ac] +
1027                                       mdata->tx.pkts[ac];
1028
1029                 /* enable immediately with enough packets but defer disabling */
1030                 if (vo_vi_pkts > IWL_MVM_TCM_LOWLAT_ENABLE_THRESH)
1031                         mvm->tcm.result.low_latency[mac] = true;
1032                 else if (handle_ll)
1033                         mvm->tcm.result.low_latency[mac] = false;
1034
1035                 if (handle_ll) {
1036                         /* clear old data */
1037                         memset(&mdata->rx.pkts, 0, sizeof(mdata->rx.pkts));
1038                         memset(&mdata->tx.pkts, 0, sizeof(mdata->tx.pkts));
1039                 }
1040                 low_latency |= mvm->tcm.result.low_latency[mac];
1041
1042                 if (!mvm->tcm.result.low_latency[mac] && handle_uapsd)
1043                         iwl_mvm_check_uapsd_agg_expected_tpt(mvm, uapsd_elapsed,
1044                                                              mac);
1045                 /* clear old data */
1046                 if (handle_uapsd)
1047                         mdata->uapsd_nonagg_detect.rx_bytes = 0;
1048                 memset(&mdata->rx.airtime, 0, sizeof(mdata->rx.airtime));
1049                 memset(&mdata->tx.airtime, 0, sizeof(mdata->tx.airtime));
1050         }
1051
1052         load = iwl_mvm_tcm_load(mvm, total_airtime, elapsed);
1053         mvm->tcm.result.global_load = load;
1054
1055         for (i = 0; i < NUM_NL80211_BANDS; i++) {
1056                 band_load = iwl_mvm_tcm_load(mvm, band_airtime[i], elapsed);
1057                 mvm->tcm.result.band_load[i] = band_load;
1058         }
1059
1060         /*
1061          * If the current load isn't low we need to force re-evaluation
1062          * in the TCM period, so that we can return to low load if there
1063          * was no traffic at all (and thus iwl_mvm_recalc_tcm didn't get
1064          * triggered by traffic).
1065          */
1066         if (load != IWL_MVM_TRAFFIC_LOW)
1067                 return MVM_TCM_PERIOD;
1068         /*
1069          * If low-latency is active we need to force re-evaluation after
1070          * (the longer) MVM_LL_PERIOD, so that we can disable low-latency
1071          * when there's no traffic at all.
1072          */
1073         if (low_latency)
1074                 return MVM_LL_PERIOD;
1075         /*
1076          * Otherwise, we don't need to run the work struct because we're
1077          * in the default "idle" state - traffic indication is low (which
1078          * also covers the "no traffic" case) and low-latency is disabled
1079          * so there's no state that may need to be disabled when there's
1080          * no traffic at all.
1081          *
1082          * Note that this has no impact on the regular scheduling of the
1083          * updates triggered by traffic - those happen whenever one of the
1084          * two timeouts expire (if there's traffic at all.)
1085          */
1086         return 0;
1087 }
1088
1089 void iwl_mvm_recalc_tcm(struct iwl_mvm *mvm)
1090 {
1091         unsigned long ts = jiffies;
1092         bool handle_uapsd =
1093                 time_after(ts, mvm->tcm.uapsd_nonagg_ts +
1094                                msecs_to_jiffies(IWL_MVM_UAPSD_NONAGG_PERIOD));
1095
1096         spin_lock(&mvm->tcm.lock);
1097         if (mvm->tcm.paused || !time_after(ts, mvm->tcm.ts + MVM_TCM_PERIOD)) {
1098                 spin_unlock(&mvm->tcm.lock);
1099                 return;
1100         }
1101         spin_unlock(&mvm->tcm.lock);
1102
1103         if (handle_uapsd && iwl_mvm_has_new_rx_api(mvm)) {
1104                 mutex_lock(&mvm->mutex);
1105                 if (iwl_mvm_request_statistics(mvm, true))
1106                         handle_uapsd = false;
1107                 mutex_unlock(&mvm->mutex);
1108         }
1109
1110         spin_lock(&mvm->tcm.lock);
1111         /* re-check if somebody else won the recheck race */
1112         if (!mvm->tcm.paused && time_after(ts, mvm->tcm.ts + MVM_TCM_PERIOD)) {
1113                 /* calculate statistics */
1114                 unsigned long work_delay = iwl_mvm_calc_tcm_stats(mvm, ts,
1115                                                                   handle_uapsd);
1116
1117                 /* the memset needs to be visible before the timestamp */
1118                 smp_mb();
1119                 mvm->tcm.ts = ts;
1120                 if (work_delay)
1121                         schedule_delayed_work(&mvm->tcm.work, work_delay);
1122         }
1123         spin_unlock(&mvm->tcm.lock);
1124
1125         iwl_mvm_tcm_results(mvm);
1126 }
1127
1128 void iwl_mvm_tcm_work(struct work_struct *work)
1129 {
1130         struct delayed_work *delayed_work = to_delayed_work(work);
1131         struct iwl_mvm *mvm = container_of(delayed_work, struct iwl_mvm,
1132                                            tcm.work);
1133
1134         iwl_mvm_recalc_tcm(mvm);
1135 }
1136
1137 void iwl_mvm_pause_tcm(struct iwl_mvm *mvm, bool with_cancel)
1138 {
1139         spin_lock_bh(&mvm->tcm.lock);
1140         mvm->tcm.paused = true;
1141         spin_unlock_bh(&mvm->tcm.lock);
1142         if (with_cancel)
1143                 cancel_delayed_work_sync(&mvm->tcm.work);
1144 }
1145
1146 void iwl_mvm_resume_tcm(struct iwl_mvm *mvm)
1147 {
1148         int mac;
1149         bool low_latency = false;
1150
1151         spin_lock_bh(&mvm->tcm.lock);
1152         mvm->tcm.ts = jiffies;
1153         mvm->tcm.ll_ts = jiffies;
1154         for (mac = 0; mac < NUM_MAC_INDEX_DRIVER; mac++) {
1155                 struct iwl_mvm_tcm_mac *mdata = &mvm->tcm.data[mac];
1156
1157                 memset(&mdata->rx.pkts, 0, sizeof(mdata->rx.pkts));
1158                 memset(&mdata->tx.pkts, 0, sizeof(mdata->tx.pkts));
1159                 memset(&mdata->rx.airtime, 0, sizeof(mdata->rx.airtime));
1160                 memset(&mdata->tx.airtime, 0, sizeof(mdata->tx.airtime));
1161
1162                 if (mvm->tcm.result.low_latency[mac])
1163                         low_latency = true;
1164         }
1165         /* The TCM data needs to be reset before "paused" flag changes */
1166         smp_mb();
1167         mvm->tcm.paused = false;
1168
1169         /*
1170          * if the current load is not low or low latency is active, force
1171          * re-evaluation to cover the case of no traffic.
1172          */
1173         if (mvm->tcm.result.global_load > IWL_MVM_TRAFFIC_LOW)
1174                 schedule_delayed_work(&mvm->tcm.work, MVM_TCM_PERIOD);
1175         else if (low_latency)
1176                 schedule_delayed_work(&mvm->tcm.work, MVM_LL_PERIOD);
1177
1178         spin_unlock_bh(&mvm->tcm.lock);
1179 }
1180
1181 void iwl_mvm_tcm_add_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1182 {
1183         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1184
1185         INIT_DELAYED_WORK(&mvmvif->uapsd_nonagg_detected_wk,
1186                           iwl_mvm_tcm_uapsd_nonagg_detected_wk);
1187 }
1188
1189 void iwl_mvm_tcm_rm_vif(struct iwl_mvm *mvm, struct ieee80211_vif *vif)
1190 {
1191         struct iwl_mvm_vif *mvmvif = iwl_mvm_vif_from_mac80211(vif);
1192
1193         cancel_delayed_work_sync(&mvmvif->uapsd_nonagg_detected_wk);
1194 }
1195
1196 u32 iwl_mvm_get_systime(struct iwl_mvm *mvm)
1197 {
1198         u32 reg_addr = DEVICE_SYSTEM_TIME_REG;
1199
1200         if (mvm->trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_22000 &&
1201             mvm->trans->cfg->gp2_reg_addr)
1202                 reg_addr = mvm->trans->cfg->gp2_reg_addr;
1203
1204         return iwl_read_prph(mvm->trans, reg_addr);
1205 }
1206
1207 void iwl_mvm_get_sync_time(struct iwl_mvm *mvm, int clock_type,
1208                            u32 *gp2, u64 *boottime, ktime_t *realtime)
1209 {
1210         bool ps_disabled;
1211
1212         lockdep_assert_held(&mvm->mutex);
1213
1214         /* Disable power save when reading GP2 */
1215         ps_disabled = mvm->ps_disabled;
1216         if (!ps_disabled) {
1217                 mvm->ps_disabled = true;
1218                 iwl_mvm_power_update_device(mvm);
1219         }
1220
1221         *gp2 = iwl_mvm_get_systime(mvm);
1222
1223         if (clock_type == CLOCK_BOOTTIME && boottime)
1224                 *boottime = ktime_get_boottime_ns();
1225         else if (clock_type == CLOCK_REALTIME && realtime)
1226                 *realtime = ktime_get_real();
1227
1228         if (!ps_disabled) {
1229                 mvm->ps_disabled = ps_disabled;
1230                 iwl_mvm_power_update_device(mvm);
1231         }
1232 }
1233
1234 /* Find if at least two links from different vifs use same channel
1235  * FIXME: consider having a refcount array in struct iwl_mvm_vif for
1236  * used phy_ctxt ids.
1237  */
1238 bool iwl_mvm_have_links_same_channel(struct iwl_mvm_vif *vif1,
1239                                      struct iwl_mvm_vif *vif2)
1240 {
1241         unsigned int i, j;
1242
1243         for_each_mvm_vif_valid_link(vif1, i) {
1244                 for_each_mvm_vif_valid_link(vif2, j) {
1245                         if (vif1->link[i]->phy_ctxt == vif2->link[j]->phy_ctxt)
1246                                 return true;
1247                 }
1248         }
1249
1250         return false;
1251 }
1252
1253 bool iwl_mvm_vif_is_active(struct iwl_mvm_vif *mvmvif)
1254 {
1255         unsigned int i;
1256
1257         /* FIXME: can it fail when phy_ctxt is assigned? */
1258         for_each_mvm_vif_valid_link(mvmvif, i) {
1259                 if (mvmvif->link[i]->phy_ctxt &&
1260                     mvmvif->link[i]->phy_ctxt->id < NUM_PHY_CTX)
1261                         return true;
1262         }
1263
1264         return false;
1265 }