/******************************************************************************
 *
 * Copyright(c) 2014 Intel Mobile Communications GmbH
 * Copyright(c) 2017 Intel Deutschland GmbH
 * Copyright(C) 2018 Intel Corporation
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name Intel Corporation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *****************************************************************************/

#include <linux/etherdevice.h>

#include "iwl-io.h"
#include "iwl-prph.h"
#include "mvm.h"
#include "time-event.h"

#define TU_TO_US(x) (x * 1024)
#define TU_TO_MS(x) (TU_TO_US(x) / 1000)

void iwl_mvm_teardown_tdls_peers(struct iwl_mvm* mvm) {
  struct ieee80211_sta* sta;
  struct iwl_mvm_sta* mvmsta;
  int i;

  lockdep_assert_held(&mvm->mutex);

  for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
    sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i], lockdep_is_held(&mvm->mutex));
    if (!sta || IS_ERR(sta) || !sta->tdls) {
      continue;
    }

    mvmsta = iwl_mvm_sta_from_mac80211(sta);
    ieee80211_tdls_oper_request(mvmsta->vif, sta->addr, NL80211_TDLS_TEARDOWN,
                                WLAN_REASON_TDLS_TEARDOWN_UNSPECIFIED, GFP_KERNEL);
  }
}

int iwl_mvm_tdls_sta_count(struct iwl_mvm* mvm, struct ieee80211_vif* vif) {
  struct ieee80211_sta* sta;
  struct iwl_mvm_sta* mvmsta;
  int count = 0;
  int i;

  lockdep_assert_held(&mvm->mutex);

  for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
    sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i], lockdep_is_held(&mvm->mutex));
    if (!sta || IS_ERR(sta) || !sta->tdls) {
      continue;
    }

    if (vif) {
      mvmsta = iwl_mvm_sta_from_mac80211(sta);
      if (mvmsta->vif != vif) {
        continue;
      }
    }

    count++;
  }

  return count;
}

static void iwl_mvm_tdls_config(struct iwl_mvm* mvm, struct ieee80211_vif* vif) {
  struct iwl_rx_packet* pkt;
  struct iwl_tdls_config_res* resp;
  struct iwl_tdls_config_cmd tdls_cfg_cmd = {};
  struct iwl_host_cmd cmd = {
      .id = TDLS_CONFIG_CMD,
      .flags = CMD_WANT_SKB,
      .data =
          {
              &tdls_cfg_cmd,
          },
      .len =
          {
              sizeof(struct iwl_tdls_config_cmd),
          },
  };
  struct ieee80211_sta* sta;
  int ret, i, cnt;
  struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);

  lockdep_assert_held(&mvm->mutex);

  tdls_cfg_cmd.id_and_color = cpu_to_le32(FW_CMD_ID_AND_COLOR(mvmvif->id, mvmvif->color));
  tdls_cfg_cmd.tx_to_ap_tid = IWL_MVM_TDLS_FW_TID;
  tdls_cfg_cmd.tx_to_ap_ssn = cpu_to_le16(0); /* not used for now */

  /* for now the Tx cmd is empty and unused */

  /* populate TDLS peer data */
  cnt = 0;
  for (i = 0; i < ARRAY_SIZE(mvm->fw_id_to_mac_id); i++) {
    sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[i], lockdep_is_held(&mvm->mutex));
    if (IS_ERR_OR_NULL(sta) || !sta->tdls) {
      continue;
    }

    tdls_cfg_cmd.sta_info[cnt].sta_id = i;
    tdls_cfg_cmd.sta_info[cnt].tx_to_peer_tid = IWL_MVM_TDLS_FW_TID;
    tdls_cfg_cmd.sta_info[cnt].tx_to_peer_ssn = cpu_to_le16(0);
    tdls_cfg_cmd.sta_info[cnt].is_initiator = cpu_to_le32(sta->tdls_initiator ? 1 : 0);

    cnt++;
  }

  tdls_cfg_cmd.tdls_peer_count = cnt;
  IWL_DEBUG_TDLS(mvm, "send TDLS config to FW for %d peers\n", cnt);

  ret = iwl_mvm_send_cmd(mvm, &cmd);
  if (WARN_ON_ONCE(ret)) {
    return;
  }

  pkt = cmd.resp_pkt;

  WARN_ON_ONCE(iwl_rx_packet_payload_len(pkt) != sizeof(*resp));

  /* we don't really care about the response at this point */

  iwl_free_resp(&cmd);
}

void iwl_mvm_recalc_tdls_state(struct iwl_mvm* mvm, struct ieee80211_vif* vif, bool sta_added) {
  int tdls_sta_cnt = iwl_mvm_tdls_sta_count(mvm, vif);

  /* when the first peer joins, send a power update first */
  if (tdls_sta_cnt == 1 && sta_added) {
    iwl_mvm_power_update_mac(mvm);
  }

  /* Configure the FW with TDLS peer info only if TDLS channel switch
   * capability is set.
   * TDLS config data is used currently only in TDLS channel switch code.
   * Supposed to serve also TDLS buffer station which is not implemneted
   * yet in FW*/
  if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TDLS_CHANNEL_SWITCH)) {
    iwl_mvm_tdls_config(mvm, vif);
  }

  /* when the last peer leaves, send a power update last */
  if (tdls_sta_cnt == 0 && !sta_added) {
    iwl_mvm_power_update_mac(mvm);
  }
}

void iwl_mvm_mac_mgd_protect_tdls_discover(struct ieee80211_hw* hw, struct ieee80211_vif* vif) {
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  uint32_t duration = 2 * vif->bss_conf.dtim_period * vif->bss_conf.beacon_int;

  /*
   * iwl_mvm_protect_session() reads directly from the device
   * (the system time), so make sure it is available.
   */
  if (iwl_mvm_ref_sync(mvm, IWL_MVM_REF_PROTECT_TDLS)) {
    return;
  }

  mutex_lock(&mvm->mutex);
  /* Protect the session to hear the TDLS setup response on the channel */
  iwl_mvm_protect_session(mvm, vif, duration, duration, 100, true);
  mutex_unlock(&mvm->mutex);

  iwl_mvm_unref(mvm, IWL_MVM_REF_PROTECT_TDLS);
}

static const char* iwl_mvm_tdls_cs_state_str(enum iwl_mvm_tdls_cs_state state) {
  switch (state) {
    case IWL_MVM_TDLS_SW_IDLE:
      return "IDLE";
    case IWL_MVM_TDLS_SW_REQ_SENT:
      return "REQ SENT";
    case IWL_MVM_TDLS_SW_RESP_RCVD:
      return "RESP RECEIVED";
    case IWL_MVM_TDLS_SW_REQ_RCVD:
      return "REQ RECEIVED";
    case IWL_MVM_TDLS_SW_ACTIVE:
      return "ACTIVE";
  }

  return NULL;
}

static void iwl_mvm_tdls_update_cs_state(struct iwl_mvm* mvm, enum iwl_mvm_tdls_cs_state state) {
  if (mvm->tdls_cs.state == state) {
    return;
  }

  IWL_DEBUG_TDLS(mvm, "TDLS channel switch state: %s -> %s\n",
                 iwl_mvm_tdls_cs_state_str(mvm->tdls_cs.state), iwl_mvm_tdls_cs_state_str(state));
  mvm->tdls_cs.state = state;

  /* we only send requests to our switching peer - update sent time */
  if (state == IWL_MVM_TDLS_SW_REQ_SENT) {
    mvm->tdls_cs.peer.sent_timestamp = iwl_read_prph(mvm->trans, DEVICE_SYSTEM_TIME_REG);
  }

  if (state == IWL_MVM_TDLS_SW_IDLE) {
    mvm->tdls_cs.cur_sta_id = IWL_MVM_INVALID_STA;
  }
}

void iwl_mvm_rx_tdls_notif(struct iwl_mvm* mvm, struct iwl_rx_cmd_buffer* rxb) {
  struct iwl_rx_packet* pkt = rxb_addr(rxb);
  struct iwl_tdls_channel_switch_notif* notif = (void*)pkt->data;
  struct ieee80211_sta* sta;
  unsigned int delay;
  struct iwl_mvm_sta* mvmsta;
  struct ieee80211_vif* vif;
  uint32_t sta_id = le32_to_cpu(notif->sta_id);

  lockdep_assert_held(&mvm->mutex);

  /* can fail sometimes */
  if (!le32_to_cpu(notif->status)) {
    iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);
    return;
  }

  if (WARN_ON(sta_id >= IWL_MVM_STATION_COUNT)) {
    return;
  }

  sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[sta_id], lockdep_is_held(&mvm->mutex));
  /* the station may not be here, but if it is, it must be a TDLS peer */
  if (IS_ERR_OR_NULL(sta) || WARN_ON(!sta->tdls)) {
    return;
  }

  mvmsta = iwl_mvm_sta_from_mac80211(sta);
  vif = mvmsta->vif;

  /*
   * Update state and possibly switch again after this is over (DTIM).
   * Also convert TU to msec.
   */
  delay = TU_TO_MS(vif->bss_conf.dtim_period * vif->bss_conf.beacon_int);
  mod_delayed_work(system_wq, &mvm->tdls_cs.dwork, msecs_to_jiffies(delay));

  iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_ACTIVE);
}

static int iwl_mvm_tdls_check_action(struct iwl_mvm* mvm, enum iwl_tdls_channel_switch_type type,
                                     const uint8_t* peer, bool peer_initiator, uint32_t timestamp) {
  bool same_peer = false;
  int ret = 0;

  /* get the existing peer if it's there */
  if (mvm->tdls_cs.state != IWL_MVM_TDLS_SW_IDLE &&
      mvm->tdls_cs.cur_sta_id != IWL_MVM_INVALID_STA) {
    struct ieee80211_sta* sta = rcu_dereference_protected(
        mvm->fw_id_to_mac_id[mvm->tdls_cs.cur_sta_id], lockdep_is_held(&mvm->mutex));
    if (!IS_ERR_OR_NULL(sta)) {
      same_peer = ether_addr_equal(peer, sta->addr);
    }
  }

  switch (mvm->tdls_cs.state) {
    case IWL_MVM_TDLS_SW_IDLE:
      /*
       * might be spurious packet from the peer after the switch is
       * already done
       */
      if (type == TDLS_MOVE_CH) {
        ret = -EINVAL;
      }
      break;
    case IWL_MVM_TDLS_SW_REQ_SENT:
      /* only allow requests from the same peer */
      if (!same_peer) {
        ret = -EBUSY;
      } else if (type == TDLS_SEND_CHAN_SW_RESP_AND_MOVE_CH && !peer_initiator)
      /*
       * We received a ch-switch request while an outgoing
       * one is pending. Allow it if the peer is the link
       * initiator.
       */
      {
        ret = -EBUSY;
      } else if (type == TDLS_SEND_CHAN_SW_REQ)
      /* wait for idle before sending another request */
      {
        ret = -EBUSY;
      } else if (timestamp <= mvm->tdls_cs.peer.sent_timestamp)
      /* we got a stale response - ignore it */
      {
        ret = -EINVAL;
      }
      break;
    case IWL_MVM_TDLS_SW_RESP_RCVD:
      /*
       * we are waiting for the FW to give an "active" notification,
       * so ignore requests in the meantime
       */
      ret = -EBUSY;
      break;
    case IWL_MVM_TDLS_SW_REQ_RCVD:
      /* as above, allow the link initiator to proceed */
      if (type == TDLS_SEND_CHAN_SW_REQ) {
        if (!same_peer) {
          ret = -EBUSY;
        } else if (peer_initiator) { /* they are the initiator */
          ret = -EBUSY;
        }
      } else if (type == TDLS_MOVE_CH) {
        ret = -EINVAL;
      }
      break;
    case IWL_MVM_TDLS_SW_ACTIVE:
      /*
       * the only valid request when active is a request to return
       * to the base channel by the current off-channel peer
       */
      if (type != TDLS_MOVE_CH || !same_peer) {
        ret = -EBUSY;
      }
      break;
  }

  if (ret)
    IWL_DEBUG_TDLS(mvm, "Invalid TDLS action %d state %d peer %pM same_peer %d initiator %d\n",
                   type, mvm->tdls_cs.state, peer, same_peer, peer_initiator);

  return ret;
}

static int iwl_mvm_tdls_config_channel_switch(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                              enum iwl_tdls_channel_switch_type type,
                                              const uint8_t* peer, bool peer_initiator,
                                              uint8_t oper_class, struct cfg80211_chan_def* chandef,
                                              uint32_t timestamp, uint16_t switch_time,
                                              uint16_t switch_timeout, struct sk_buff* skb,
                                              uint32_t ch_sw_tm_ie) {
  struct ieee80211_sta* sta;
  struct iwl_mvm_sta* mvmsta;
  struct ieee80211_tx_info* info;
  struct ieee80211_hdr* hdr;
  struct iwl_tdls_channel_switch_cmd cmd = {0};
  int ret;

  lockdep_assert_held(&mvm->mutex);

  ret = iwl_mvm_tdls_check_action(mvm, type, peer, peer_initiator, timestamp);
  if (ret) {
    return ret;
  }

  if (!skb || WARN_ON(skb->len > IWL_TDLS_CH_SW_FRAME_MAX_SIZE)) {
    ret = -EINVAL;
    goto out;
  }

  cmd.switch_type = type;
  cmd.timing.frame_timestamp = cpu_to_le32(timestamp);
  cmd.timing.switch_time = cpu_to_le32(switch_time);
  cmd.timing.switch_timeout = cpu_to_le32(switch_timeout);

  rcu_read_lock();
  sta = ieee80211_find_sta(vif, peer);
  if (!sta) {
    rcu_read_unlock();
    ret = -ENOENT;
    goto out;
  }
  mvmsta = iwl_mvm_sta_from_mac80211(sta);
  cmd.peer_sta_id = cpu_to_le32(mvmsta->sta_id);

  if (!chandef) {
    if (mvm->tdls_cs.state == IWL_MVM_TDLS_SW_REQ_SENT && mvm->tdls_cs.peer.chandef.chan) {
      /* actually moving to the channel */
      chandef = &mvm->tdls_cs.peer.chandef;
    } else if (mvm->tdls_cs.state == IWL_MVM_TDLS_SW_ACTIVE && type == TDLS_MOVE_CH) {
      /* we need to return to base channel */
      struct ieee80211_chanctx_conf* chanctx = rcu_dereference(vif->chanctx_conf);

      if (WARN_ON_ONCE(!chanctx)) {
        rcu_read_unlock();
        goto out;
      }

      chandef = &chanctx->def;
    }
  }

  if (chandef) {
    cmd.ci.band = (chandef->chan->band == NL80211_BAND_2GHZ ? PHY_BAND_24 : PHY_BAND_5);
    cmd.ci.channel = chandef->chan->hw_value;
    cmd.ci.width = iwl_mvm_get_channel_width(chandef);
    cmd.ci.ctrl_pos = iwl_mvm_get_ctrl_pos(chandef);
  }

  /* keep quota calculation simple for now - 50% of DTIM for TDLS */
  cmd.timing.max_offchan_duration =
      cpu_to_le32(TU_TO_US(vif->bss_conf.dtim_period * vif->bss_conf.beacon_int) / 2);

  /* Switch time is the first element in the switch-timing IE. */
  cmd.frame.switch_time_offset = cpu_to_le32(ch_sw_tm_ie + 2);

  info = IEEE80211_SKB_CB(skb);
  hdr = (void*)skb->data;
  if (info->control.hw_key) {
    if (info->control.hw_key->cipher != WLAN_CIPHER_SUITE_CCMP) {
      rcu_read_unlock();
      ret = -EINVAL;
      goto out;
    }
    iwl_mvm_set_tx_cmd_ccmp(info, &cmd.frame.tx_cmd);
  }

  iwl_mvm_set_tx_cmd(mvm, skb, &cmd.frame.tx_cmd, info, mvmsta->sta_id);

  iwl_mvm_set_tx_cmd_rate(mvm, &cmd.frame.tx_cmd, info, sta, hdr->frame_control);
  rcu_read_unlock();

  memcpy(cmd.frame.data, skb->data, skb->len);

  ret = iwl_mvm_send_cmd_pdu(mvm, TDLS_CHANNEL_SWITCH_CMD, 0, sizeof(cmd), &cmd);
  if (ret) {
    IWL_ERR(mvm, "Failed to send TDLS_CHANNEL_SWITCH cmd: %d\n", ret);
    goto out;
  }

  /* channel switch has started, update state */
  if (type != TDLS_MOVE_CH) {
    mvm->tdls_cs.cur_sta_id = mvmsta->sta_id;
    iwl_mvm_tdls_update_cs_state(
        mvm, type == TDLS_SEND_CHAN_SW_REQ ? IWL_MVM_TDLS_SW_REQ_SENT : IWL_MVM_TDLS_SW_REQ_RCVD);
  } else {
    iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_RESP_RCVD);
  }

out:

  /* channel switch failed - we are idle */
  if (ret) {
    iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);
  }

  return ret;
}

void iwl_mvm_tdls_ch_switch_work(struct work_struct* work) {
  struct iwl_mvm* mvm;
  struct ieee80211_sta* sta;
  struct iwl_mvm_sta* mvmsta;
  struct ieee80211_vif* vif;
  unsigned int delay;
  int ret;

  mvm = container_of(work, struct iwl_mvm, tdls_cs.dwork.work);
  mutex_lock(&mvm->mutex);

  /* called after an active channel switch has finished or timed-out */
  iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);

  /* station might be gone, in that case do nothing */
  if (mvm->tdls_cs.peer.sta_id == IWL_MVM_INVALID_STA) {
    goto out;
  }

  sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[mvm->tdls_cs.peer.sta_id],
                                  lockdep_is_held(&mvm->mutex));
  /* the station may not be here, but if it is, it must be a TDLS peer */
  if (!sta || IS_ERR(sta) || WARN_ON(!sta->tdls)) {
    goto out;
  }

  mvmsta = iwl_mvm_sta_from_mac80211(sta);
  vif = mvmsta->vif;
  ret = iwl_mvm_tdls_config_channel_switch(mvm, vif, TDLS_SEND_CHAN_SW_REQ, sta->addr,
                                           mvm->tdls_cs.peer.initiator, mvm->tdls_cs.peer.op_class,
                                           &mvm->tdls_cs.peer.chandef, 0, 0, 0,
                                           mvm->tdls_cs.peer.skb, mvm->tdls_cs.peer.ch_sw_tm_ie);
  if (ret) {
    IWL_ERR(mvm, "Not sending TDLS channel switch: %d\n", ret);
  }

  /* retry after a DTIM if we failed sending now */
  delay = TU_TO_MS(vif->bss_conf.dtim_period * vif->bss_conf.beacon_int);
  schedule_delayed_work(&mvm->tdls_cs.dwork, msecs_to_jiffies(delay));
out:
  mutex_unlock(&mvm->mutex);
}

int iwl_mvm_tdls_channel_switch(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                struct ieee80211_sta* sta, uint8_t oper_class,
                                struct cfg80211_chan_def* chandef, struct sk_buff* tmpl_skb,
                                uint32_t ch_sw_tm_ie) {
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct iwl_mvm_sta* mvmsta;
  unsigned int delay;
  int ret;

  mutex_lock(&mvm->mutex);

  IWL_DEBUG_TDLS(mvm, "TDLS channel switch with %pM ch %d width %d\n", sta->addr,
                 chandef->chan->center_freq, chandef->width);

  /* we only support a single peer for channel switching */
  if (mvm->tdls_cs.peer.sta_id != IWL_MVM_INVALID_STA) {
    IWL_DEBUG_TDLS(mvm, "Existing peer. Can't start switch with %pM\n", sta->addr);
    ret = -EBUSY;
    goto out;
  }

  ret = iwl_mvm_tdls_config_channel_switch(mvm, vif, TDLS_SEND_CHAN_SW_REQ, sta->addr,
                                           sta->tdls_initiator, oper_class, chandef, 0, 0, 0,
                                           tmpl_skb, ch_sw_tm_ie);
  if (ret) {
    goto out;
  }

  /*
   * Mark the peer as "in tdls switch" for this vif. We only allow a
   * single such peer per vif.
   */
  mvm->tdls_cs.peer.skb = skb_copy(tmpl_skb, GFP_KERNEL);
  if (!mvm->tdls_cs.peer.skb) {
    ret = -ENOMEM;
    goto out;
  }

  mvmsta = iwl_mvm_sta_from_mac80211(sta);
  mvm->tdls_cs.peer.sta_id = mvmsta->sta_id;
  mvm->tdls_cs.peer.chandef = *chandef;
  mvm->tdls_cs.peer.initiator = sta->tdls_initiator;
  mvm->tdls_cs.peer.op_class = oper_class;
  mvm->tdls_cs.peer.ch_sw_tm_ie = ch_sw_tm_ie;

  /*
   * Wait for 2 DTIM periods before attempting the next switch. The next
   * switch will be made sooner if the current one completes before that.
   */
  delay = 2 * TU_TO_MS(vif->bss_conf.dtim_period * vif->bss_conf.beacon_int);
  mod_delayed_work(system_wq, &mvm->tdls_cs.dwork, msecs_to_jiffies(delay));

out:
  mutex_unlock(&mvm->mutex);
  return ret;
}

void iwl_mvm_tdls_cancel_channel_switch(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                        struct ieee80211_sta* sta) {
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct ieee80211_sta* cur_sta;
  bool wait_for_phy = false;

  mutex_lock(&mvm->mutex);

  IWL_DEBUG_TDLS(mvm, "TDLS cancel channel switch with %pM\n", sta->addr);

  /* we only support a single peer for channel switching */
  if (mvm->tdls_cs.peer.sta_id == IWL_MVM_INVALID_STA) {
    IWL_DEBUG_TDLS(mvm, "No ch switch peer - %pM\n", sta->addr);
    goto out;
  }

  cur_sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[mvm->tdls_cs.peer.sta_id],
                                      lockdep_is_held(&mvm->mutex));
  /* make sure it's the same peer */
  if (cur_sta != sta) {
    goto out;
  }

  /*
   * If we're currently in a switch because of the now canceled peer,
   * wait a DTIM here to make sure the phy is back on the base channel.
   * We can't otherwise force it.
   */
  if (mvm->tdls_cs.cur_sta_id == mvm->tdls_cs.peer.sta_id &&
      mvm->tdls_cs.state != IWL_MVM_TDLS_SW_IDLE) {
    wait_for_phy = true;
  }

  mvm->tdls_cs.peer.sta_id = IWL_MVM_INVALID_STA;
  dev_kfree_skb(mvm->tdls_cs.peer.skb);
  mvm->tdls_cs.peer.skb = NULL;

out:
  mutex_unlock(&mvm->mutex);

  /* make sure the phy is on the base channel */
  if (wait_for_phy) {
    msleep(TU_TO_MS(vif->bss_conf.dtim_period * vif->bss_conf.beacon_int));
  }

  /* flush the channel switch state */
  flush_delayed_work(&mvm->tdls_cs.dwork);

  IWL_DEBUG_TDLS(mvm, "TDLS ending channel switch with %pM\n", sta->addr);
}

void iwl_mvm_tdls_recv_channel_switch(struct ieee80211_hw* hw, struct ieee80211_vif* vif,
                                      struct ieee80211_tdls_ch_sw_params* params) {
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  enum iwl_tdls_channel_switch_type type;
  unsigned int delay;
  const char* action_str = params->action_code == WLAN_TDLS_CHANNEL_SWITCH_REQUEST ? "REQ" : "RESP";

  mutex_lock(&mvm->mutex);

  IWL_DEBUG_TDLS(mvm, "Received TDLS ch switch action %s from %pM status %d\n", action_str,
                 params->sta->addr, params->status);

  /*
   * we got a non-zero status from a peer we were switching to - move to
   * the idle state and retry again later
   */
  if (params->action_code == WLAN_TDLS_CHANNEL_SWITCH_RESPONSE && params->status != 0 &&
      mvm->tdls_cs.state == IWL_MVM_TDLS_SW_REQ_SENT &&
      mvm->tdls_cs.cur_sta_id != IWL_MVM_INVALID_STA) {
    struct ieee80211_sta* cur_sta;

    /* make sure it's the same peer */
    cur_sta = rcu_dereference_protected(mvm->fw_id_to_mac_id[mvm->tdls_cs.cur_sta_id],
                                        lockdep_is_held(&mvm->mutex));
    if (cur_sta == params->sta) {
      iwl_mvm_tdls_update_cs_state(mvm, IWL_MVM_TDLS_SW_IDLE);
      goto retry;
    }
  }

  type = (params->action_code == WLAN_TDLS_CHANNEL_SWITCH_REQUEST)
             ? TDLS_SEND_CHAN_SW_RESP_AND_MOVE_CH
             : TDLS_MOVE_CH;

  iwl_mvm_tdls_config_channel_switch(mvm, vif, type, params->sta->addr, params->sta->tdls_initiator,
                                     0, params->chandef, params->timestamp, params->switch_time,
                                     params->switch_timeout, params->tmpl_skb, params->ch_sw_tm_ie);

retry:
  /* register a timeout in case we don't succeed in switching */
  delay = vif->bss_conf.dtim_period * vif->bss_conf.beacon_int * 1024 / 1000;
  mod_delayed_work(system_wq, &mvm->tdls_cs.dwork, msecs_to_jiffies(delay));
  mutex_unlock(&mvm->mutex);
}

#ifdef CPTCFG_IWLMVM_TDLS_PEER_CACHE
void iwl_mvm_tdls_peer_cache_pkt(struct iwl_mvm* mvm, struct ieee80211_hdr* hdr, uint32_t len,
                                 int rxq) {
  struct iwl_mvm_tdls_peer_counter* cnt;
  uint8_t* addr;

  /*
   * To reduce code runtime and complexity, we don't check the packet
   * arrived on the correct vif, or even if the current vif is a station.
   * While it is theoretically possible for a TDLS peer to also be
   * connected to us in the capacity of a AP/GO, this will not happen
   * in practice.
   */

  if (list_empty(&mvm->tdls_peer_cache_list)) {
    return;
  }

  if (len < sizeof(*hdr) || !ieee80211_is_data(hdr->frame_control)) {
    return;
  }

  addr = rxq < 0 ? ieee80211_get_DA(hdr) : ieee80211_get_SA(hdr);

  /* we rely on the Rx and Tx path mutual atomicity for the counters */
  rcu_read_lock();
  list_for_each_entry_rcu(cnt, &mvm->tdls_peer_cache_list,
                          list) if (ether_addr_equal(cnt->mac.addr, addr)) {
    if (rxq < 0) {
      cnt->tx_bytes += len;
    } else {
      cnt->rx[rxq].bytes += len;
    }

    break;
  }
  rcu_read_unlock();
}

void iwl_mvm_tdls_peer_cache_clear(struct iwl_mvm* mvm, struct ieee80211_vif* vif) {
  struct iwl_mvm_tdls_peer_counter *cnt, *tmp;

  /*
   * mvm->mutex is held or the HW is already unregistered, barring
   * vendor commands that can change the list.
   */
  list_for_each_entry_safe(cnt, tmp, &mvm->tdls_peer_cache_list, list) {
    if (vif && cnt->vif != vif) {
      continue;
    }

    mvm->tdls_peer_cache_cnt--;
    list_del_rcu(&cnt->list);
    kfree_rcu(cnt, rcu_head);
  }
}

/* requires RCU read side lock taken */
struct iwl_mvm_tdls_peer_counter* iwl_mvm_tdls_peer_cache_find(struct iwl_mvm* mvm,
                                                               const uint8_t* addr) {
  struct iwl_mvm_tdls_peer_counter* cnt;

  list_for_each_entry_rcu(cnt, &mvm->tdls_peer_cache_list,
                          list) if (memcmp(addr, cnt->mac.addr, ETH_ALEN) == 0) {
    break;
  }

  if (&cnt->list == &mvm->tdls_peer_cache_list) {
    return NULL;
  }

  return cnt;
}
#endif /* CPTCFG_IWLMVM_TDLS_PEER_CACHE */