/******************************************************************************
 *
 * Copyright(c) 2012 - 2014 Intel Corporation. All rights reserved.
 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH
 * Copyright(c) 2018        Intel Corporation
 * 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 <net/mac80211.h>
#include <net/netlink.h>

#include "iwl-vendor-cmd.h"
#include "mvm.h"

#ifdef CPTCFG_IWLWIFI_LTE_COEX
#include "lte-coex.h"
#endif

#include "iwl-io.h"
#include "iwl-prph.h"

static const struct nla_policy iwl_mvm_vendor_attr_policy[NUM_IWL_MVM_VENDOR_ATTR] = {
    [IWL_MVM_VENDOR_ATTR_LOW_LATENCY] = {.type = NLA_FLAG},
    [IWL_MVM_VENDOR_ATTR_COUNTRY] = {.type = NLA_STRING, .len = 2},
    [IWL_MVM_VENDOR_ATTR_FILTER_ARP_NA] = {.type = NLA_FLAG},
    [IWL_MVM_VENDOR_ATTR_FILTER_GTK] = {.type = NLA_FLAG},
    [IWL_MVM_VENDOR_ATTR_ADDR] = {.len = ETH_ALEN},
    [IWL_MVM_VENDOR_ATTR_TXP_LIMIT_24] = {.type = NLA_U32},
    [IWL_MVM_VENDOR_ATTR_TXP_LIMIT_52L] = {.type = NLA_U32},
    [IWL_MVM_VENDOR_ATTR_TXP_LIMIT_52H] = {.type = NLA_U32},
    [IWL_MVM_VENDOR_ATTR_OPPPS_WA] = {.type = NLA_FLAG},
    [IWL_MVM_VENDOR_ATTR_GSCAN_MAC_ADDR] = {.len = ETH_ALEN},
    [IWL_MVM_VENDOR_ATTR_GSCAN_MAC_ADDR_MASK] = {.len = ETH_ALEN},
    [IWL_MVM_VENDOR_ATTR_GSCAN_MAX_AP_PER_SCAN] = {.type = NLA_U32},
    [IWL_MVM_VENDOR_ATTR_GSCAN_REPORT_THRESHOLD] = {.type = NLA_U32},
    [IWL_MVM_VENDOR_ATTR_GSCAN_BUCKET_SPECS] = {.type = NLA_NESTED},
    [IWL_MVM_VENDOR_ATTR_GSCAN_LOST_AP_SAMPLE_SIZE] = {.type = NLA_U8},
    [IWL_MVM_VENDOR_ATTR_GSCAN_AP_LIST] = {.type = NLA_NESTED},
    [IWL_MVM_VENDOR_ATTR_GSCAN_RSSI_SAMPLE_SIZE] = {.type = NLA_U8},
    [IWL_MVM_VENDOR_ATTR_GSCAN_MIN_BREACHING] = {.type = NLA_U8},
    [IWL_MVM_VENDOR_ATTR_RXFILTER] = {.type = NLA_U32},
    [IWL_MVM_VENDOR_ATTR_RXFILTER_OP] = {.type = NLA_U32},
    [IWL_MVM_VENDOR_ATTR_DBG_COLLECT_TRIGGER] = {.type = NLA_STRING},
    [IWL_MVM_VENDOR_ATTR_NAN_FAW_FREQ] = {.type = NLA_U32},
    [IWL_MVM_VENDOR_ATTR_NAN_FAW_SLOTS] = {.type = NLA_U8},
    [IWL_MVM_VENDOR_ATTR_GSCAN_REPORT_THRESHOLD_NUM] = {.type = NLA_U32},
    [IWL_MVM_VENDOR_ATTR_SAR_CHAIN_A_PROFILE] = {.type = NLA_U8},
    [IWL_MVM_VENDOR_ATTR_SAR_CHAIN_B_PROFILE] = {.type = NLA_U8},
    [IWL_MVM_VENDOR_ATTR_FIPS_TEST_VECTOR_HW_CCM] = {.type = NLA_NESTED},
    [IWL_MVM_VENDOR_ATTR_FIPS_TEST_VECTOR_HW_GCM] = {.type = NLA_NESTED},
    [IWL_MVM_VENDOR_ATTR_FIPS_TEST_VECTOR_HW_AES] = {.type = NLA_NESTED},
};

static int iwl_mvm_parse_vendor_data(struct nlattr** tb, const void* data, int data_len) {
  if (!data) {
    return -EINVAL;
  }

  return nla_parse(tb, MAX_IWL_MVM_VENDOR_ATTR, data, data_len, iwl_mvm_vendor_attr_policy, NULL);
}

static int iwl_mvm_set_low_latency(struct wiphy* wiphy, struct wireless_dev* wdev, const void* data,
                                   int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  int err;
  struct ieee80211_vif* vif = wdev_to_ieee80211_vif(wdev);
  bool low_latency;

  if (!vif) {
    return -ENODEV;
  }

  if (data) {
    err = iwl_mvm_parse_vendor_data(tb, data, data_len);
    if (err) {
      return err;
    }
    low_latency = tb[IWL_MVM_VENDOR_ATTR_LOW_LATENCY];
  } else {
    low_latency = false;
  }

  mutex_lock(&mvm->mutex);
  err = iwl_mvm_update_low_latency(mvm, vif, low_latency, LOW_LATENCY_VCMD);
  mutex_unlock(&mvm->mutex);

  return err;
}

static int iwl_mvm_get_low_latency(struct wiphy* wiphy, struct wireless_dev* wdev, const void* data,
                                   int data_len) {
  struct ieee80211_vif* vif = wdev_to_ieee80211_vif(wdev);
  struct iwl_mvm_vif* mvmvif;
  struct sk_buff* skb;

  if (!vif) {
    return -ENODEV;
  }
  mvmvif = iwl_mvm_vif_from_mac80211(vif);

  skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 100);
  if (!skb) {
    return -ENOMEM;
  }
  if (iwl_mvm_vif_low_latency(mvmvif) && nla_put_flag(skb, IWL_MVM_VENDOR_ATTR_LOW_LATENCY)) {
    kfree_skb(skb);
    return -ENOBUFS;
  }

  return cfg80211_vendor_cmd_reply(skb);
}

static int iwl_mvm_set_country(struct wiphy* wiphy, struct wireless_dev* wdev, const void* data,
                               int data_len) {
  struct ieee80211_regdomain* regd;
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  int retval;

  if (!iwl_mvm_is_lar_supported(mvm)) {
    return -EOPNOTSUPP;
  }

  retval = iwl_mvm_parse_vendor_data(tb, data, data_len);
  if (retval) {
    return retval;
  }

  if (!tb[IWL_MVM_VENDOR_ATTR_COUNTRY]) {
    return -EINVAL;
  }

  mutex_lock(&mvm->mutex);

  /* set regdomain information to FW */
  regd = iwl_mvm_get_regdomain(
      wiphy, nla_data(tb[IWL_MVM_VENDOR_ATTR_COUNTRY]),
      iwl_mvm_is_wifi_mcc_supported(mvm) ? MCC_SOURCE_3G_LTE_HOST : MCC_SOURCE_OLD_FW, NULL);
  if (IS_ERR_OR_NULL(regd)) {
    retval = -EIO;
    goto unlock;
  }

  retval = regulatory_set_wiphy_regd(wiphy, regd);
  kfree(regd);
unlock:
  mutex_unlock(&mvm->mutex);
  return retval;
}

#ifdef CPTCFG_IWLWIFI_LTE_COEX
static int iwl_vendor_lte_coex_state_cmd(struct wiphy* wiphy, struct wireless_dev* wdev,
                                         const void* data, int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  const struct lte_coex_state_cmd* cmd = data;
  struct sk_buff* skb;
  int err = LTE_OK;

  skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 100);
  if (!skb) {
    return -ENOMEM;
  }

  if (data_len != sizeof(*cmd)) {
    err = LTE_INVALID_DATA;
    goto out;
  }

  IWL_DEBUG_COEX(mvm, "LTE-COEX: state cmd:\n\tstate: %d\n", cmd->lte_state);

  switch (cmd->lte_state) {
    case LTE_OFF:
      if (mvm->lte_state.has_config && mvm->lte_state.state != LTE_CONNECTED) {
        err = LTE_STATE_ERR;
        goto out;
      }
      mvm->lte_state.state = LTE_OFF;
      mvm->lte_state.has_config = 0;
      mvm->lte_state.has_rprtd_chan = 0;
      mvm->lte_state.has_sps = 0;
      mvm->lte_state.has_ft = 0;
      break;
    case LTE_IDLE:
      if (!mvm->lte_state.has_static ||
          (mvm->lte_state.has_config && mvm->lte_state.state != LTE_CONNECTED)) {
        err = LTE_STATE_ERR;
        goto out;
      }
      mvm->lte_state.has_config = 0;
      mvm->lte_state.has_sps = 0;
      mvm->lte_state.state = LTE_IDLE;
      break;
    case LTE_CONNECTED:
      if (!(mvm->lte_state.has_config)) {
        err = LTE_STATE_ERR;
        goto out;
      }
      mvm->lte_state.state = LTE_CONNECTED;
      break;
    default:
      err = LTE_ILLEGAL_PARAMS;
      goto out;
  }

  mvm->lte_state.config.lte_state = cpu_to_le32(mvm->lte_state.state);

  mutex_lock(&mvm->mutex);
  if (iwl_mvm_send_lte_coex_config_cmd(mvm)) {
    err = LTE_OTHER_ERR;
  }
  mutex_unlock(&mvm->mutex);

out:
  if (err) {
    iwl_mvm_reset_lte_state(mvm);
  }

  if (nla_put_u8(skb, NLA_BINARY, err)) {
    kfree_skb(skb);
    return -ENOBUFS;
  }

  return cfg80211_vendor_cmd_reply(skb);
}

static int iwl_vendor_lte_coex_config_cmd(struct wiphy* wiphy, struct wireless_dev* wdev,
                                          const void* data, int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  const struct lte_coex_config_info_cmd* cmd = data;
  struct iwl_lte_coex_static_params_cmd* stat = &mvm->lte_state.stat;
  struct sk_buff* skb;
  int err = LTE_OK;
  int i, j;

  skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 100);
  if (!skb) {
    return -ENOMEM;
  }

  if (data_len != sizeof(*cmd)) {
    err = LTE_INVALID_DATA;
    goto out;
  }

  IWL_DEBUG_COEX(mvm, "LTE-COEX: config cmd:\n");

  /* send static config only once in the FW life */
  if (mvm->lte_state.has_static) {
    goto out;
  }

  for (i = 0; i < LTE_MWS_CONF_LENGTH; i++) {
    IWL_DEBUG_COEX(mvm, "\tmws config data[%d]: %d\n", i, cmd->mws_conf_data[i]);
    stat->mfu_config[i] = cpu_to_le32(cmd->mws_conf_data[i]);
  }

  if (cmd->safe_power_table[0] != LTE_SAFE_PT_FIRST ||
      cmd->safe_power_table[LTE_SAFE_PT_LENGTH - 1] != LTE_SAFE_PT_LAST) {
    err = LTE_ILLEGAL_PARAMS;
    goto out;
  }

  /* power table must be ascending ordered */
  j = LTE_SAFE_PT_FIRST;
  for (i = 0; i < LTE_SAFE_PT_LENGTH; i++) {
    IWL_DEBUG_COEX(mvm, "\tsafe power table[%d]: %d\n", i, cmd->safe_power_table[i]);
    if (cmd->safe_power_table[i] < j) {
      err = LTE_ILLEGAL_PARAMS;
      goto out;
    }
    j = cmd->safe_power_table[i];
    stat->tx_power_in_dbm[i] = cmd->safe_power_table[i];
  }

  mutex_lock(&mvm->mutex);
  if (iwl_mvm_send_lte_coex_static_params_cmd(mvm)) {
    err = LTE_OTHER_ERR;
  } else {
    mvm->lte_state.has_static = 1;
  }
  mutex_unlock(&mvm->mutex);

out:
  if (err) {
    iwl_mvm_reset_lte_state(mvm);
  }

  if (nla_put_u8(skb, NLA_BINARY, err)) {
    kfree_skb(skb);
    return -ENOBUFS;
  }

  return cfg80211_vendor_cmd_reply(skb);
}

static int in_range(int val, int min, int max) { return (val >= min) && (val <= max); }

static bool is_valid_lte_range(uint16_t min, uint16_t max) {
  return (min == 0 && max == 0) || (max >= min && in_range(min, LTE_FRQ_MIN, LTE_FRQ_MAX) &&
                                    in_range(max, LTE_FRQ_MIN, LTE_FRQ_MAX));
}

static int iwl_vendor_lte_coex_dynamic_info_cmd(struct wiphy* wiphy, struct wireless_dev* wdev,
                                                const void* data, int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  const struct lte_coex_dynamic_info_cmd* cmd = data;
  struct iwl_lte_coex_config_cmd* config = &mvm->lte_state.config;
  struct sk_buff* skb;
  int err = LTE_OK;
  int i;

  skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 100);
  if (!skb) {
    return -ENOMEM;
  }

  if (data_len != sizeof(*cmd)) {
    err = LTE_INVALID_DATA;
    goto out;
  }

  if (!mvm->lte_state.has_static ||
      (mvm->lte_state.has_config && mvm->lte_state.state != LTE_CONNECTED)) {
    err = LTE_STATE_ERR;
    goto out;
  }

  IWL_DEBUG_COEX(mvm,
                 "LTE-COEX: dynamic cmd:\n"
                 "\tlte band[0]: %d, chan[0]: %d\n\ttx range: %d - %d\n"
                 "\trx range: %d - %d\n",
                 cmd->lte_connected_bands[0], cmd->lte_connected_bands[1],
                 cmd->wifi_tx_safe_freq_min, cmd->wifi_tx_safe_freq_max, cmd->wifi_rx_safe_freq_min,
                 cmd->wifi_rx_safe_freq_max);

  /* TODO: validate lte connected bands and channel, and frame struct */
  config->lte_band = cpu_to_le32(cmd->lte_connected_bands[0]);
  config->lte_chan = cpu_to_le32(cmd->lte_connected_bands[1]);
  for (i = 0; i < LTE_FRAME_STRUCT_LENGTH; i++) {
    IWL_DEBUG_COEX(mvm, "\tframe structure[%d]: %d\n", i, cmd->lte_frame_structure[i]);
    config->lte_frame_structure[i] = cpu_to_le32(cmd->lte_frame_structure[i]);
  }
  if (!is_valid_lte_range(cmd->wifi_tx_safe_freq_min, cmd->wifi_tx_safe_freq_max) ||
      !is_valid_lte_range(cmd->wifi_rx_safe_freq_min, cmd->wifi_rx_safe_freq_max)) {
    err = LTE_ILLEGAL_PARAMS;
    goto out;
  }
  config->tx_safe_freq_min = cpu_to_le32(cmd->wifi_tx_safe_freq_min);
  config->tx_safe_freq_max = cpu_to_le32(cmd->wifi_tx_safe_freq_max);
  config->rx_safe_freq_min = cpu_to_le32(cmd->wifi_rx_safe_freq_min);
  config->rx_safe_freq_max = cpu_to_le32(cmd->wifi_rx_safe_freq_max);
  for (i = 0; i < LTE_TX_POWER_LENGTH; i++) {
    IWL_DEBUG_COEX(mvm, "\twifi max tx power[%d]: %d\n", i, cmd->wifi_max_tx_power[i]);
    if (!in_range(cmd->wifi_max_tx_power[i], LTE_MAX_TX_MIN, LTE_MAX_TX_MAX)) {
      err = LTE_ILLEGAL_PARAMS;
      goto out;
    }
    config->max_tx_power[i] = cmd->wifi_max_tx_power[i];
  }

  mvm->lte_state.has_config = 1;

  if (mvm->lte_state.state == LTE_CONNECTED) {
    mutex_lock(&mvm->mutex);
    if (iwl_mvm_send_lte_coex_config_cmd(mvm)) {
      err = LTE_OTHER_ERR;
    }
    mutex_unlock(&mvm->mutex);
  }
out:
  if (err) {
    iwl_mvm_reset_lte_state(mvm);
  }

  if (nla_put_u8(skb, NLA_BINARY, err)) {
    kfree_skb(skb);
    return -ENOBUFS;
  }

  return cfg80211_vendor_cmd_reply(skb);
}

static int iwl_vendor_lte_sps_cmd(struct wiphy* wiphy, struct wireless_dev* wdev, const void* data,
                                  int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  const struct lte_coex_sps_info_cmd* cmd = data;
  struct iwl_lte_coex_sps_cmd* sps = &mvm->lte_state.sps;
  struct sk_buff* skb;
  int err = LTE_OK;

  skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 100);
  if (!skb) {
    return -ENOMEM;
  }

  if (data_len != sizeof(*cmd)) {
    err = LTE_INVALID_DATA;
    goto out;
  }

  IWL_DEBUG_COEX(mvm, "LTE-COEX: sps cmd:\n\tsps info: %d\n", cmd->sps_info);

  if (mvm->lte_state.state != LTE_CONNECTED) {
    err = LTE_STATE_ERR;
    goto out;
  }

  /* TODO: validate SPS */
  sps->lte_semi_persistent_info = cpu_to_le32(cmd->sps_info);

  mutex_lock(&mvm->mutex);
  if (iwl_mvm_send_lte_sps_cmd(mvm)) {
    err = LTE_OTHER_ERR;
  } else {
    mvm->lte_state.has_sps = 1;
  }
  mutex_unlock(&mvm->mutex);

out:
  if (err) {
    iwl_mvm_reset_lte_state(mvm);
  }

  if (nla_put_u8(skb, NLA_BINARY, err)) {
    kfree_skb(skb);
    return -ENOBUFS;
  }

  return cfg80211_vendor_cmd_reply(skb);
}

static int iwl_vendor_lte_coex_wifi_reported_channel_cmd(struct wiphy* wiphy,
                                                         struct wireless_dev* wdev,
                                                         const void* data, int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  const struct lte_coex_wifi_reported_chan_cmd* cmd = data;
  struct iwl_lte_coex_wifi_reported_channel_cmd* rprtd_chan = &mvm->lte_state.rprtd_chan;
  struct sk_buff* skb;
  int err = LTE_OK;

  skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 100);
  if (!skb) {
    return -ENOMEM;
  }

  if (data_len != sizeof(*cmd)) {
    err = LTE_INVALID_DATA;
    goto out;
  }

  IWL_DEBUG_COEX(mvm,
                 "LTE-COEX: wifi reported channel cmd:\n"
                 "\tchannel: %d, bandwidth: %d\n",
                 cmd->chan, cmd->bandwidth);

  if (!in_range(cmd->chan, LTE_RC_CHAN_MIN, LTE_RC_CHAN_MAX) ||
      !in_range(cmd->bandwidth, LTE_RC_BW_MIN, LTE_RC_BW_MAX)) {
    err = LTE_ILLEGAL_PARAMS;
    goto out;
  }

  rprtd_chan->channel = cpu_to_le32(cmd->chan);
  rprtd_chan->bandwidth = cpu_to_le32(cmd->bandwidth);

  mutex_lock(&mvm->mutex);
  if (iwl_mvm_send_lte_coex_wifi_reported_channel_cmd(mvm)) {
    err = LTE_OTHER_ERR;
  } else {
    mvm->lte_state.has_rprtd_chan = 1;
  }
  mutex_unlock(&mvm->mutex);

out:
  if (err) {
    iwl_mvm_reset_lte_state(mvm);
  }

  if (nla_put_u8(skb, NLA_BINARY, err)) {
    kfree_skb(skb);
    return -ENOBUFS;
  }

  return cfg80211_vendor_cmd_reply(skb);
}
#endif /* CPTCFG_IWLWIFI_LTE_COEX */

static int iwl_vendor_frame_filter_cmd(struct wiphy* wiphy, struct wireless_dev* wdev,
                                       const void* data, int data_len) {
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  struct ieee80211_vif* vif = wdev_to_ieee80211_vif(wdev);
  int err = iwl_mvm_parse_vendor_data(tb, data, data_len);

  if (err) {
    return err;
  }
  if (!vif) {
    return -EINVAL;
  }
  vif->filter_grat_arp_unsol_na = tb[IWL_MVM_VENDOR_ATTR_FILTER_ARP_NA];
  vif->filter_gtk = tb[IWL_MVM_VENDOR_ATTR_FILTER_GTK];

  return 0;
}

#ifdef CPTCFG_IWLMVM_TDLS_PEER_CACHE
static int iwl_vendor_tdls_peer_cache_add(struct wiphy* wiphy, struct wireless_dev* wdev,
                                          const void* data, int data_len) {
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct iwl_mvm_tdls_peer_counter* cnt;
  uint8_t* addr;
  struct ieee80211_vif* vif = wdev_to_ieee80211_vif(wdev);
  int err = iwl_mvm_parse_vendor_data(tb, data, data_len);

  if (err) {
    return err;
  }

  if (!vif) {
    return -ENODEV;
  }

  if (vif->type != NL80211_IFTYPE_STATION || !tb[IWL_MVM_VENDOR_ATTR_ADDR]) {
    return -EINVAL;
  }

  mutex_lock(&mvm->mutex);
  if (mvm->tdls_peer_cache_cnt >= IWL_MVM_TDLS_CNT_MAX_PEERS) {
    err = -ENOSPC;
    goto out_unlock;
  }

  addr = nla_data(tb[IWL_MVM_VENDOR_ATTR_ADDR]);

  rcu_read_lock();
  cnt = iwl_mvm_tdls_peer_cache_find(mvm, addr);
  rcu_read_unlock();
  if (cnt) {
    err = -EEXIST;
    goto out_unlock;
  }

  cnt = kzalloc(sizeof(*cnt) + sizeof(cnt->rx[0]) * mvm->trans->num_rx_queues, GFP_KERNEL);
  if (!cnt) {
    err = -ENOMEM;
    goto out_unlock;
  }

  IWL_DEBUG_TDLS(mvm, "Adding %pM to TDLS peer cache\n", addr);
  ether_addr_copy(cnt->mac.addr, addr);
  cnt->vif = vif;
  list_add_tail_rcu(&cnt->list, &mvm->tdls_peer_cache_list);
  mvm->tdls_peer_cache_cnt++;

out_unlock:
  mutex_unlock(&mvm->mutex);
  return err;
}

static int iwl_vendor_tdls_peer_cache_del(struct wiphy* wiphy, struct wireless_dev* wdev,
                                          const void* data, int data_len) {
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct iwl_mvm_tdls_peer_counter* cnt;
  uint8_t* addr;
  int err = iwl_mvm_parse_vendor_data(tb, data, data_len);

  if (err) {
    return err;
  }

  if (!tb[IWL_MVM_VENDOR_ATTR_ADDR]) {
    return -EINVAL;
  }

  addr = nla_data(tb[IWL_MVM_VENDOR_ATTR_ADDR]);

  mutex_lock(&mvm->mutex);
  rcu_read_lock();
  cnt = iwl_mvm_tdls_peer_cache_find(mvm, addr);
  if (!cnt) {
    IWL_DEBUG_TDLS(mvm, "%pM not found in TDLS peer cache\n", addr);
    err = -ENOENT;
    goto out_unlock;
  }

  IWL_DEBUG_TDLS(mvm, "Removing %pM from TDLS peer cache\n", addr);
  mvm->tdls_peer_cache_cnt--;
  list_del_rcu(&cnt->list);
  kfree_rcu(cnt, rcu_head);

out_unlock:
  rcu_read_unlock();
  mutex_unlock(&mvm->mutex);
  return err;
}

static int iwl_vendor_tdls_peer_cache_query(struct wiphy* wiphy, struct wireless_dev* wdev,
                                            const void* data, int data_len) {
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct iwl_mvm_tdls_peer_counter* cnt;
  struct sk_buff* skb;
  uint32_t rx_bytes, tx_bytes;
  uint8_t* addr;
  int err = iwl_mvm_parse_vendor_data(tb, data, data_len);

  if (err) {
    return err;
  }

  if (!tb[IWL_MVM_VENDOR_ATTR_ADDR]) {
    return -EINVAL;
  }

  addr = nla_data(tb[IWL_MVM_VENDOR_ATTR_ADDR]);

  rcu_read_lock();
  cnt = iwl_mvm_tdls_peer_cache_find(mvm, addr);
  if (!cnt) {
    IWL_DEBUG_TDLS(mvm, "%pM not found in TDLS peer cache\n", addr);
    err = -ENOENT;
  } else {
    int q;

    tx_bytes = cnt->tx_bytes;
    rx_bytes = 0;
    for (q = 0; q < mvm->trans->num_rx_queues; q++) {
      rx_bytes += cnt->rx[q].bytes;
    }
  }
  rcu_read_unlock();
  if (err) {
    return err;
  }

  skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 100);
  if (!skb) {
    return -ENOMEM;
  }
  if (nla_put_u32(skb, IWL_MVM_VENDOR_ATTR_TX_BYTES, tx_bytes) ||
      nla_put_u32(skb, IWL_MVM_VENDOR_ATTR_RX_BYTES, rx_bytes)) {
    kfree_skb(skb);
    return -ENOBUFS;
  }

  return cfg80211_vendor_cmd_reply(skb);
}
#endif /* CPTCFG_IWLMVM_TDLS_PEER_CACHE */

static int iwl_vendor_set_nic_txpower_limit(struct wiphy* wiphy, struct wireless_dev* wdev,
                                            const void* data, int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  union {
    struct iwl_dev_tx_power_cmd_v4 v4;
    struct iwl_dev_tx_power_cmd v5;
  } cmd = {
      .v5.v3.set_mode = cpu_to_le32(IWL_TX_POWER_MODE_SET_DEVICE),
      .v5.v3.dev_24 = cpu_to_le16(IWL_DEV_MAX_TX_POWER),
      .v5.v3.dev_52_low = cpu_to_le16(IWL_DEV_MAX_TX_POWER),
      .v5.v3.dev_52_high = cpu_to_le16(IWL_DEV_MAX_TX_POWER),
  };
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  int len = sizeof(cmd);
  int err;

  err = iwl_mvm_parse_vendor_data(tb, data, data_len);
  if (err) {
    return err;
  }

  if (tb[IWL_MVM_VENDOR_ATTR_TXP_LIMIT_24]) {
    int32_t txp = nla_get_u32(tb[IWL_MVM_VENDOR_ATTR_TXP_LIMIT_24]);

    if (txp < 0 || txp > IWL_DEV_MAX_TX_POWER) {
      return -EINVAL;
    }
    cmd.v5.v3.dev_24 = cpu_to_le16(txp);
  }

  if (tb[IWL_MVM_VENDOR_ATTR_TXP_LIMIT_52L]) {
    int32_t txp = nla_get_u32(tb[IWL_MVM_VENDOR_ATTR_TXP_LIMIT_52L]);

    if (txp < 0 || txp > IWL_DEV_MAX_TX_POWER) {
      return -EINVAL;
    }
    cmd.v5.v3.dev_52_low = cpu_to_le16(txp);
  }

  if (tb[IWL_MVM_VENDOR_ATTR_TXP_LIMIT_52H]) {
    int32_t txp = nla_get_u32(tb[IWL_MVM_VENDOR_ATTR_TXP_LIMIT_52H]);

    if (txp < 0 || txp > IWL_DEV_MAX_TX_POWER) {
      return -EINVAL;
    }
    cmd.v5.v3.dev_52_high = cpu_to_le16(txp);
  }

  mvm->txp_cmd.v5 = cmd.v5;

  if (fw_has_api(&mvm->fw->ucode_capa, IWL_UCODE_TLV_API_REDUCE_TX_POWER)) {
    len = sizeof(mvm->txp_cmd.v5);
  } else if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_TX_POWER_ACK)) {
    len = sizeof(mvm->txp_cmd.v4);
  } else {
    len = sizeof(mvm->txp_cmd.v4.v3);
  }

  mutex_lock(&mvm->mutex);
  err = iwl_mvm_send_cmd_pdu(mvm, REDUCE_TX_POWER_CMD, 0, len, &cmd);
  mutex_unlock(&mvm->mutex);

  if (err) {
    IWL_ERR(mvm, "failed to update device TX power: %d\n", err);
  }
  return 0;
}

#ifdef CPTCFG_IWLMVM_P2P_OPPPS_TEST_WA
static int iwl_mvm_oppps_wa_update_quota(struct iwl_mvm* mvm, struct ieee80211_vif* vif,
                                         bool enable) {
  struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);
  struct ieee80211_p2p_noa_attr* noa = &vif->bss_conf.p2p_noa_attr;
  bool force_update = true;

  if (enable && noa->oppps_ctwindow & IEEE80211_P2P_OPPPS_ENABLE_BIT) {
    mvm->p2p_opps_test_wa_vif = mvmvif;
  } else {
    mvm->p2p_opps_test_wa_vif = NULL;
  }

  if (fw_has_capa(&mvm->fw->ucode_capa, IWL_UCODE_TLV_CAPA_DYNAMIC_QUOTA)) {
#ifdef CPTCFG_IWLWIFI_DEBUG_HOST_CMD_ENABLED
    return iwl_mvm_dhc_quota_enforce(mvm, mvm->p2p_opps_test_wa_vif, 0);
#else
    return -EOPNOTSUPP;
#endif
  }

  return iwl_mvm_update_quotas(mvm, force_update, NULL);
}

static int iwl_mvm_oppps_wa(struct wiphy* wiphy, struct wireless_dev* wdev, const void* data,
                            int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  int err = iwl_mvm_parse_vendor_data(tb, data, data_len);
  struct ieee80211_vif* vif = wdev_to_ieee80211_vif(wdev);

  if (err) {
    return err;
  }

  if (!vif) {
    return -ENODEV;
  }

  mutex_lock(&mvm->mutex);
  if (vif->type == NL80211_IFTYPE_STATION && vif->p2p) {
    bool enable = !!tb[IWL_MVM_VENDOR_ATTR_OPPPS_WA];

    err = iwl_mvm_oppps_wa_update_quota(mvm, vif, enable);
  }
  mutex_unlock(&mvm->mutex);

  return err;
}
#endif

void iwl_mvm_active_rx_filters(struct iwl_mvm* mvm) {
  int i, len, total = 0;
  struct iwl_mcast_filter_cmd* cmd;
  static const uint8_t ipv4mc[] = {0x01, 0x00, 0x5e};
  static const uint8_t ipv6mc[] = {0x33, 0x33};
  static const uint8_t ipv4_mdns[] = {0x01, 0x00, 0x5e, 0x00, 0x00, 0xfb};
  static const uint8_t ipv6_mdns[] = {0x33, 0x33, 0x00, 0x00, 0x00, 0xfb};

  lockdep_assert_held(&mvm->mutex);

  if (mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_EINVAL) {
    return;
  }

  for (i = 0; i < mvm->mcast_filter_cmd->count; i++) {
    if (mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_MCAST4 &&
        memcmp(&mvm->mcast_filter_cmd->addr_list[i * ETH_ALEN], ipv4mc, sizeof(ipv4mc)) == 0) {
      total++;
    } else if (memcmp(&mvm->mcast_filter_cmd->addr_list[i * ETH_ALEN], ipv4_mdns,
                      sizeof(ipv4_mdns)) == 0) {
      total++;
    } else if (mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_MCAST6 &&
               memcmp(&mvm->mcast_filter_cmd->addr_list[i * ETH_ALEN], ipv6mc, sizeof(ipv6mc)) ==
                   0) {
      total++;
    } else if (memcmp(&mvm->mcast_filter_cmd->addr_list[i * ETH_ALEN], ipv6_mdns,
                      sizeof(ipv6_mdns)) == 0) {
      total++;
    }
  }

  /* FW expects full words */
  len = roundup(sizeof(*cmd) + total * ETH_ALEN, 4);
  cmd = kzalloc(len, GFP_KERNEL);
  if (!cmd) {
    return;
  }

  memcpy(cmd, mvm->mcast_filter_cmd, sizeof(*cmd));
  cmd->count = 0;

  for (i = 0; i < mvm->mcast_filter_cmd->count; i++) {
    bool copy_filter = false;

    if (mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_MCAST4 &&
        memcmp(&mvm->mcast_filter_cmd->addr_list[i * ETH_ALEN], ipv4mc, sizeof(ipv4mc)) == 0) {
      copy_filter = true;
    } else if (memcmp(&mvm->mcast_filter_cmd->addr_list[i * ETH_ALEN], ipv4_mdns,
                      sizeof(ipv4_mdns)) == 0) {
      copy_filter = true;
    } else if (mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_MCAST6 &&
               memcmp(&mvm->mcast_filter_cmd->addr_list[i * ETH_ALEN], ipv6mc, sizeof(ipv6mc)) ==
                   0) {
      copy_filter = true;
    } else if (memcmp(&mvm->mcast_filter_cmd->addr_list[i * ETH_ALEN], ipv6_mdns,
                      sizeof(ipv6_mdns)) == 0) {
      copy_filter = true;
    }

    if (!copy_filter) {
      continue;
    }

    ether_addr_copy(&cmd->addr_list[cmd->count * ETH_ALEN],
                    &mvm->mcast_filter_cmd->addr_list[i * ETH_ALEN]);
    cmd->count++;
  }

  kfree(mvm->mcast_active_filter_cmd);
  mvm->mcast_active_filter_cmd = cmd;
}

static int iwl_mvm_vendor_rxfilter(struct wiphy* wiphy, struct wireless_dev* wdev, const void* data,
                                   int data_len) {
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  enum iwl_mvm_vendor_rxfilter_flags filter, rx_filters, old_rx_filters;
  enum iwl_mvm_vendor_rxfilter_op op;
  bool first_set;
  uint32_t mask;
  int retval;

  retval = iwl_mvm_parse_vendor_data(tb, data, data_len);
  if (retval) {
    return retval;
  }

  if (!tb[IWL_MVM_VENDOR_ATTR_RXFILTER]) {
    return -EINVAL;
  }

  if (!tb[IWL_MVM_VENDOR_ATTR_RXFILTER_OP]) {
    return -EINVAL;
  }

  filter = nla_get_u32(tb[IWL_MVM_VENDOR_ATTR_RXFILTER]);
  op = nla_get_u32(tb[IWL_MVM_VENDOR_ATTR_RXFILTER_OP]);

  if (filter != IWL_MVM_VENDOR_RXFILTER_UNICAST && filter != IWL_MVM_VENDOR_RXFILTER_BCAST &&
      filter != IWL_MVM_VENDOR_RXFILTER_MCAST4 && filter != IWL_MVM_VENDOR_RXFILTER_MCAST6) {
    return -EINVAL;
  }

  rx_filters = mvm->rx_filters & ~IWL_MVM_VENDOR_RXFILTER_EINVAL;
  switch (op) {
    case IWL_MVM_VENDOR_RXFILTER_OP_DROP:
      rx_filters &= ~filter;
      break;
    case IWL_MVM_VENDOR_RXFILTER_OP_PASS:
      rx_filters |= filter;
      break;
    default:
      return -EINVAL;
  }

  first_set = mvm->rx_filters & IWL_MVM_VENDOR_RXFILTER_EINVAL;

  /* If first time set - clear EINVAL value */
  mvm->rx_filters &= ~IWL_MVM_VENDOR_RXFILTER_EINVAL;

  if (rx_filters == mvm->rx_filters && !first_set) {
    return 0;
  }

  mutex_lock(&mvm->mutex);

  old_rx_filters = mvm->rx_filters;
  mvm->rx_filters = rx_filters;

  mask = IWL_MVM_VENDOR_RXFILTER_MCAST4 | IWL_MVM_VENDOR_RXFILTER_MCAST6;
  if ((old_rx_filters & mask) != (rx_filters & mask) || first_set) {
    iwl_mvm_active_rx_filters(mvm);
    iwl_mvm_recalc_multicast(mvm);
  }

  mask = IWL_MVM_VENDOR_RXFILTER_BCAST;
  if ((old_rx_filters & mask) != (rx_filters & mask) || first_set) {
    iwl_mvm_configure_bcast_filter(mvm);
  }

  mutex_unlock(&mvm->mutex);

  return 0;
}

static int iwl_mvm_vendor_dbg_collect(struct wiphy* wiphy, struct wireless_dev* wdev,
                                      const void* data, int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  int err, len = 0;
  const char* trigger_desc;

  err = iwl_mvm_parse_vendor_data(tb, data, data_len);
  if (err) {
    return err;
  }

  if (!tb[IWL_MVM_VENDOR_ATTR_DBG_COLLECT_TRIGGER]) {
    return -EINVAL;
  }

  trigger_desc = nla_data(tb[IWL_MVM_VENDOR_ATTR_DBG_COLLECT_TRIGGER]);
  len = nla_len(tb[IWL_MVM_VENDOR_ATTR_DBG_COLLECT_TRIGGER]);

  iwl_fw_dbg_collect(&mvm->fwrt, FW_DBG_TRIGGER_USER_EXTENDED, trigger_desc, len);

  return 0;
}

static int iwl_mvm_vendor_nan_faw_conf(struct wiphy* wiphy, struct wireless_dev* wdev,
                                       const void* data, int data_len) {
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct cfg80211_chan_def def = {};
  struct ieee80211_channel* chan;
  uint32_t freq;
  uint8_t slots;
  int retval;

  retval = iwl_mvm_parse_vendor_data(tb, data, data_len);
  if (retval) {
    return retval;
  }

  if (!tb[IWL_MVM_VENDOR_ATTR_NAN_FAW_SLOTS]) {
    return -EINVAL;
  }

  if (!tb[IWL_MVM_VENDOR_ATTR_NAN_FAW_FREQ]) {
    return -EINVAL;
  }

  freq = nla_get_u32(tb[IWL_MVM_VENDOR_ATTR_NAN_FAW_FREQ]);
  slots = nla_get_u8(tb[IWL_MVM_VENDOR_ATTR_NAN_FAW_SLOTS]);

  chan = ieee80211_get_channel(wiphy, freq);
  if (!chan) {
    return -EINVAL;
  }

  cfg80211_chandef_create(&def, chan, NL80211_CHAN_NO_HT);

  if (!cfg80211_chandef_usable(wiphy, &def, IEEE80211_CHAN_DISABLED)) {
    return -EINVAL;
  }

  return iwl_mvm_nan_config_nan_faw_cmd(mvm, &def, slots);
}

#ifdef CONFIG_ACPI
static int iwl_mvm_vendor_set_dynamic_txp_profile(struct wiphy* wiphy, struct wireless_dev* wdev,
                                                  const void* data, int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  int ret;
  uint8_t chain_a, chain_b;

  ret = iwl_mvm_parse_vendor_data(tb, data, data_len);
  if (ret) {
    return ret;
  }

  if (!tb[IWL_MVM_VENDOR_ATTR_SAR_CHAIN_A_PROFILE] ||
      !tb[IWL_MVM_VENDOR_ATTR_SAR_CHAIN_B_PROFILE]) {
    return -EINVAL;
  }

  chain_a = nla_get_u8(tb[IWL_MVM_VENDOR_ATTR_SAR_CHAIN_A_PROFILE]);
  chain_b = nla_get_u8(tb[IWL_MVM_VENDOR_ATTR_SAR_CHAIN_B_PROFILE]);

  if (mvm->sar_chain_a_profile == chain_a && mvm->sar_chain_b_profile == chain_b) {
    return 0;
  }

  mvm->sar_chain_a_profile = chain_a;
  mvm->sar_chain_b_profile = chain_b;

  return iwl_mvm_sar_select_profile(mvm, chain_a, chain_b);
}

static int iwl_mvm_vendor_get_sar_profile_info(struct wiphy* wiphy, struct wireless_dev* wdev,
                                               const void* data, int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct sk_buff* skb;
  int i;
  uint32_t n_profiles = 0;

  for (i = 0; i < ACPI_SAR_PROFILE_NUM; i++) {
    if (mvm->sar_profiles[i].enabled) {
      n_profiles++;
    }
  }

  skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 100);
  if (!skb) {
    return -ENOMEM;
  }
  if (nla_put_u8(skb, IWL_MVM_VENDOR_ATTR_SAR_ENABLED_PROFILE_NUM, n_profiles) ||
      nla_put_u8(skb, IWL_MVM_VENDOR_ATTR_SAR_CHAIN_A_PROFILE, mvm->sar_chain_a_profile) ||
      nla_put_u8(skb, IWL_MVM_VENDOR_ATTR_SAR_CHAIN_B_PROFILE, mvm->sar_chain_b_profile)) {
    kfree_skb(skb);
    return -ENOBUFS;
  }

  return cfg80211_vendor_cmd_reply(skb);
}

#define IWL_MVM_SAR_GEO_NUM_BANDS 2

static int iwl_mvm_vendor_get_geo_profile_info(struct wiphy* wiphy, struct wireless_dev* wdev,
                                               const void* data, int data_len) {
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct sk_buff* skb;
  struct nlattr* nl_profile;
  int i, tbl_idx;

  tbl_idx = iwl_mvm_get_sar_geo_profile(mvm);
  if (tbl_idx < 0) {
    return tbl_idx;
  }

  skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, 100);
  if (!skb) {
    return -ENOMEM;
  }

  nl_profile = nla_nest_start(skb, IWL_MVM_VENDOR_ATTR_SAR_GEO_PROFILE);
  if (!nl_profile) {
    kfree_skb(skb);
    return -ENOBUFS;
  }
  if (!tbl_idx) {
    goto out;
  }

  for (i = 0; i < IWL_MVM_SAR_GEO_NUM_BANDS; i++) {
    uint8_t* value;
    struct nlattr* nl_chain = nla_nest_start(skb, i + 1);
    int idx = i * ACPI_GEO_PER_CHAIN_SIZE;

    if (!nl_chain) {
      kfree_skb(skb);
      return -ENOBUFS;
    }

    value = &mvm->geo_profiles[tbl_idx - 1].values[idx];

    nla_put_u8(skb, IWL_VENDOR_SAR_GEO_MAX_TXP, value[0]);
    nla_put_u8(skb, IWL_VENDOR_SAR_GEO_CHAIN_A_OFFSET, value[1]);
    nla_put_u8(skb, IWL_VENDOR_SAR_GEO_CHAIN_B_OFFSET, value[2]);
    nla_nest_end(skb, nl_chain);
  }
out:
  nla_nest_end(skb, nl_profile);

  return cfg80211_vendor_cmd_reply(skb);
}
#endif

static const struct nla_policy iwl_mvm_vendor_fips_hw_policy[NUM_IWL_VENDOR_FIPS_TEST_VECTOR_HW] = {
    [IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY] = {.type = NLA_BINARY},
    [IWL_VENDOR_FIPS_TEST_VECTOR_HW_NONCE] = {.type = NLA_BINARY},
    [IWL_VENDOR_FIPS_TEST_VECTOR_HW_AAD] = {.type = NLA_BINARY},
    [IWL_VENDOR_FIPS_TEST_VECTOR_HW_PAYLOAD] = {.type = NLA_BINARY},
    [IWL_VENDOR_FIPS_TEST_VECTOR_HW_FLAGS] = {.type = NLA_U8},
};

static int iwl_mvm_vendor_validate_ccm_vector(struct nlattr** tb) {
  if (!tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY] || !tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_NONCE] ||
      !tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_AAD] ||
      nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY]) != FIPS_KEY_LEN_128 ||
      nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_NONCE]) != FIPS_CCM_NONCE_LEN) {
    return -EINVAL;
  }

  return 0;
}

static int iwl_mvm_vendor_validate_gcm_vector(struct nlattr** tb) {
  if (!tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY] || !tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_NONCE] ||
      !tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_AAD] ||
      (nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY]) != FIPS_KEY_LEN_128 &&
       nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY]) != FIPS_KEY_LEN_256) ||
      nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_NONCE]) != FIPS_GCM_NONCE_LEN) {
    return -EINVAL;
  }

  return 0;
}

static int iwl_mvm_vendor_validate_aes_vector(struct nlattr** tb) {
  if (!tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY] ||
      (nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY]) != FIPS_KEY_LEN_128 &&
       nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY]) != FIPS_KEY_LEN_256)) {
    return -EINVAL;
  }

  return 0;
}

/**
 * iwl_mvm_vendor_build_vector - build FIPS test vector for AES/CCM/GCM tests
 *
 * @cmd_buf: the command buffer is returned by this pointer in case of success.
 * @vector: test vector attributes.
 * @flags: specifies which encryption algorithm to use. One of
 *  &IWL_FIPS_TEST_VECTOR_FLAGS_CCM, &IWL_FIPS_TEST_VECTOR_FLAGS_GCM and
 *  &IWL_FIPS_TEST_VECTOR_FLAGS_AES.
 *
 * This function returns the length of the command buffer (in bytes) in case of
 * success, or a negative error code on failure.
 */
static int iwl_mvm_vendor_build_vector(uint8_t** cmd_buf, struct nlattr* vector, uint8_t flags) {
  struct nlattr* tb[NUM_IWL_VENDOR_FIPS_TEST_VECTOR_HW];
  struct iwl_fips_test_cmd* cmd;
  int err;
  int payload_len = 0;
  uint8_t* buf;

  err = nla_parse_nested(tb, MAX_IWL_VENDOR_FIPS_TEST_VECTOR_HW, vector,
                         iwl_mvm_vendor_fips_hw_policy, NULL);
  if (err) {
    return err;
  }

  switch (flags) {
    case IWL_FIPS_TEST_VECTOR_FLAGS_CCM:
      err = iwl_mvm_vendor_validate_ccm_vector(tb);
      break;
    case IWL_FIPS_TEST_VECTOR_FLAGS_GCM:
      err = iwl_mvm_vendor_validate_gcm_vector(tb);
      break;
    case IWL_FIPS_TEST_VECTOR_FLAGS_AES:
      err = iwl_mvm_vendor_validate_aes_vector(tb);
      break;
    default:
      return -EINVAL;
  }

  if (err) {
    return err;
  }

  if (tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_AAD] &&
      nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_AAD]) > FIPS_MAX_AAD_LEN) {
    return -EINVAL;
  }

  if (tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_PAYLOAD]) {
    payload_len = nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_PAYLOAD]);
  }

  buf = kzalloc(sizeof(*cmd) + payload_len, GFP_KERNEL);
  if (!buf) {
    return -ENOMEM;
  }

  cmd = (void*)buf;

  cmd->flags = cpu_to_le32(flags);

  memcpy(cmd->key, nla_data(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY]),
         nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY]));

  if (nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_KEY]) == FIPS_KEY_LEN_256) {
    cmd->flags |= cpu_to_le32(IWL_FIPS_TEST_VECTOR_FLAGS_KEY_256);
  }

  if (tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_NONCE])
    memcpy(cmd->nonce, nla_data(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_NONCE]),
           nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_NONCE]));

  if (tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_AAD]) {
    memcpy(cmd->aad, nla_data(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_AAD]),
           nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_AAD]));
    cmd->aad_len = cpu_to_le32(nla_len(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_AAD]));
  }

  if (payload_len) {
    memcpy(cmd->payload, nla_data(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_PAYLOAD]), payload_len);
    cmd->payload_len = cpu_to_le32(payload_len);
  }

  if (tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_FLAGS]) {
    uint8_t hw_flags = nla_get_u8(tb[IWL_VENDOR_FIPS_TEST_VECTOR_HW_FLAGS]);

    if (hw_flags & IWL_VENDOR_FIPS_TEST_VECTOR_FLAGS_ENCRYPT) {
      cmd->flags |= cpu_to_le32(IWL_FIPS_TEST_VECTOR_FLAGS_ENC);
    }
  }

  *cmd_buf = buf;
  return sizeof(*cmd) + payload_len;
}

static int iwl_mvm_vendor_test_fips_send_resp(struct wiphy* wiphy,
                                              struct iwl_fips_test_resp* resp) {
  struct sk_buff* skb;
  uint32_t resp_len = le32_to_cpu(resp->len);
  uint32_t* status = (void*)(resp->payload + resp_len);

  skb = cfg80211_vendor_cmd_alloc_reply_skb(wiphy, sizeof(*resp));
  if (!skb) {
    return -ENOMEM;
  }

  if ((*status) == IWL_FIPS_TEST_STATUS_SUCCESS &&
      nla_put(skb, IWL_MVM_VENDOR_ATTR_FIPS_TEST_RESULT, resp_len, resp->payload)) {
    kfree_skb(skb);
    return -ENOBUFS;
  }

  return cfg80211_vendor_cmd_reply(skb);
}

static int iwl_mvm_vendor_test_fips(struct wiphy* wiphy, struct wireless_dev* wdev,
                                    const void* data, int data_len) {
  struct nlattr* tb[NUM_IWL_MVM_VENDOR_ATTR];
  struct ieee80211_hw* hw = wiphy_to_ieee80211_hw(wiphy);
  struct iwl_mvm* mvm = IWL_MAC80211_GET_MVM(hw);
  struct iwl_host_cmd hcmd = {
      .id = iwl_cmd_id(FIPS_TEST_VECTOR_CMD, LEGACY_GROUP, 0),
      .flags = CMD_WANT_SKB,
      .dataflags = {IWL_HCMD_DFL_NOCOPY},
  };
  struct iwl_rx_packet* pkt;
  struct iwl_fips_test_resp* resp;
  struct nlattr* vector;
  uint8_t flags;
  uint8_t* buf = NULL;
  int ret;

  ret = iwl_mvm_parse_vendor_data(tb, data, data_len);
  if (ret) {
    return ret;
  }

  if (tb[IWL_MVM_VENDOR_ATTR_FIPS_TEST_VECTOR_HW_CCM]) {
    vector = tb[IWL_MVM_VENDOR_ATTR_FIPS_TEST_VECTOR_HW_CCM];
    flags = IWL_FIPS_TEST_VECTOR_FLAGS_CCM;
  } else if (tb[IWL_MVM_VENDOR_ATTR_FIPS_TEST_VECTOR_HW_GCM]) {
    vector = tb[IWL_MVM_VENDOR_ATTR_FIPS_TEST_VECTOR_HW_GCM];
    flags = IWL_FIPS_TEST_VECTOR_FLAGS_GCM;
  } else if (tb[IWL_MVM_VENDOR_ATTR_FIPS_TEST_VECTOR_HW_AES]) {
    vector = tb[IWL_MVM_VENDOR_ATTR_FIPS_TEST_VECTOR_HW_AES];
    flags = IWL_FIPS_TEST_VECTOR_FLAGS_AES;
  } else {
    return -EINVAL;
  }

  ret = iwl_mvm_vendor_build_vector(&buf, vector, flags);
  if (ret <= 0) {
    return ret;
  }

  hcmd.data[0] = buf;
  hcmd.len[0] = ret;

  mutex_lock(&mvm->mutex);
  ret = iwl_mvm_send_cmd(mvm, &hcmd);
  mutex_unlock(&mvm->mutex);

  if (ret) {
    return ret;
  }

  pkt = hcmd.resp_pkt;
  resp = (void*)pkt->data;

  iwl_mvm_vendor_test_fips_send_resp(wiphy, resp);
  iwl_free_resp(&hcmd);

  kfree(buf);
  return 0;
}

static const struct wiphy_vendor_command iwl_mvm_vendor_commands[] = {
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_SET_LOW_LATENCY,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_mvm_set_low_latency,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_GET_LOW_LATENCY,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_mvm_get_low_latency,
    },
#ifdef CPTCFG_IWLWIFI_LTE_COEX
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_LTE_STATE,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_vendor_lte_coex_state_cmd,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_LTE_COEX_CONFIG_INFO,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_vendor_lte_coex_config_cmd,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_LTE_COEX_DYNAMIC_INFO,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_vendor_lte_coex_dynamic_info_cmd,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_LTE_COEX_SPS_INFO,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_vendor_lte_sps_cmd,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_LTE_COEX_WIFI_RPRTD_CHAN,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_vendor_lte_coex_wifi_reported_channel_cmd,
    },
#endif /* CPTCFG_IWLWIFI_LTE_COEX */
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_SET_COUNTRY,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_mvm_set_country,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_PROXY_FRAME_FILTERING,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_vendor_frame_filter_cmd,
    },
#ifdef CPTCFG_IWLMVM_TDLS_PEER_CACHE
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_TDLS_PEER_CACHE_ADD,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_vendor_tdls_peer_cache_add,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_TDLS_PEER_CACHE_DEL,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_vendor_tdls_peer_cache_del,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_TDLS_PEER_CACHE_QUERY,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_vendor_tdls_peer_cache_query,
    },
#endif /* CPTCFG_IWLMVM_TDLS_PEER_CACHE */
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_SET_NIC_TXPOWER_LIMIT,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_vendor_set_nic_txpower_limit,
    },
#ifdef CPTCFG_IWLMVM_P2P_OPPPS_TEST_WA
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_OPPPS_WA,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_mvm_oppps_wa,
    },
#endif
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_RXFILTER,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_NETDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_mvm_vendor_rxfilter,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_DBG_COLLECT,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_mvm_vendor_dbg_collect,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,

                .subcmd = IWL_MVM_VENDOR_CMD_NAN_FAW_CONF,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_mvm_vendor_nan_faw_conf,
    },
#ifdef CONFIG_ACPI
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_SET_SAR_PROFILE,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_WDEV,
        .doit = iwl_mvm_vendor_set_dynamic_txp_profile,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_GET_SAR_PROFILE_INFO,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_WDEV,
        .doit = iwl_mvm_vendor_get_sar_profile_info,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_GET_SAR_GEO_PROFILE,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_mvm_vendor_get_geo_profile_info,
    },
    {
        .info =
            {
                .vendor_id = INTEL_OUI,
                .subcmd = IWL_MVM_VENDOR_CMD_TEST_FIPS,
            },
        .flags = WIPHY_VENDOR_CMD_NEED_WDEV | WIPHY_VENDOR_CMD_NEED_RUNNING,
        .doit = iwl_mvm_vendor_test_fips,
    },
#endif
};

enum iwl_mvm_vendor_events_idx { IWL_MVM_VENDOR_EVENT_IDX_TCM, NUM_IWL_MVM_VENDOR_EVENT_IDX };

static const struct nl80211_vendor_cmd_info iwl_mvm_vendor_events[NUM_IWL_MVM_VENDOR_EVENT_IDX] = {
    [IWL_MVM_VENDOR_EVENT_IDX_TCM] =
        {
            .vendor_id = INTEL_OUI,
            .subcmd = IWL_MVM_VENDOR_CMD_TCM_EVENT,
        },
};

void iwl_mvm_set_wiphy_vendor_commands(struct wiphy* wiphy) {
  wiphy->vendor_commands = iwl_mvm_vendor_commands;
  wiphy->n_vendor_commands = ARRAY_SIZE(iwl_mvm_vendor_commands);
  wiphy->vendor_events = iwl_mvm_vendor_events;
  wiphy->n_vendor_events = ARRAY_SIZE(iwl_mvm_vendor_events);
}

static enum iwl_mvm_vendor_load iwl_mvm_get_vendor_load(enum iwl_mvm_traffic_load load) {
  switch (load) {
    case IWL_MVM_TRAFFIC_HIGH:
      return IWL_MVM_VENDOR_LOAD_HIGH;
    case IWL_MVM_TRAFFIC_MEDIUM:
      return IWL_MVM_VENDOR_LOAD_MEDIUM;
    case IWL_MVM_TRAFFIC_LOW:
      return IWL_MVM_VENDOR_LOAD_LOW;
    default:
      break;
  }

  return IWL_MVM_VENDOR_LOAD_LOW;
}

void iwl_mvm_send_tcm_event(struct iwl_mvm* mvm, struct ieee80211_vif* vif) {
  struct sk_buff* msg = cfg80211_vendor_event_alloc(mvm->hw->wiphy, ieee80211_vif_to_wdev(vif), 200,
                                                    IWL_MVM_VENDOR_EVENT_IDX_TCM, GFP_ATOMIC);

  if (!msg) {
    return;
  }

  if (vif) {
    struct iwl_mvm_vif* mvmvif = iwl_mvm_vif_from_mac80211(vif);

    if (nla_put(msg, IWL_MVM_VENDOR_ATTR_VIF_ADDR, ETH_ALEN, vif->addr) ||
        nla_put_u8(msg, IWL_MVM_VENDOR_ATTR_VIF_LL, iwl_mvm_vif_low_latency(mvmvif)) ||
        nla_put_u8(msg, IWL_MVM_VENDOR_ATTR_VIF_LOAD, mvm->tcm.result.load[mvmvif->id])) {
      goto nla_put_failure;
    }
  }

  if (nla_put_u8(msg, IWL_MVM_VENDOR_ATTR_LL, iwl_mvm_low_latency(mvm)) ||
      nla_put_u8(msg, IWL_MVM_VENDOR_ATTR_LOAD,
                 iwl_mvm_get_vendor_load(mvm->tcm.result.global_load))) {
    goto nla_put_failure;
  }

  cfg80211_vendor_event(msg, GFP_ATOMIC);
  return;

nla_put_failure:
  kfree_skb(msg);
}