drivers/net/wireless/ath/ath11k/wmi.c

   1 // SPDX-License-Identifier: BSD-3-Clause-Clear
   2 /*
   3  * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved.
   4  * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
   5  */
   6 #include <linux/skbuff.h>
   7 #include <linux/ctype.h>
   8 #include <net/mac80211.h>
   9 #include <net/cfg80211.h>
  10 #include <linux/completion.h>
  11 #include <linux/if_ether.h>
  12 #include <linux/types.h>
  13 #include <linux/pci.h>
  14 #include <linux/uuid.h>
  15 #include <linux/time.h>
  16 #include <linux/of.h>
  17 #include "core.h"
  18 #include "debug.h"
  19 #include "mac.h"
  20 #include "hw.h"
  21 #include "peer.h"
  22 #include "testmode.h"
  23 #include "p2p.h"
  24
  25 struct wmi_tlv_policy {
  26         size_t min_len;
  27 };
  28
  29 struct wmi_tlv_svc_ready_parse {
  30         bool wmi_svc_bitmap_done;
  31 };
  32
  33 struct wmi_tlv_dma_ring_caps_parse {
  34         struct wmi_dma_ring_capabilities *dma_ring_caps;
  35         u32 n_dma_ring_caps;
  36 };
  37
  38 struct wmi_tlv_svc_rdy_ext_parse {
  39         struct ath11k_service_ext_param param;
  40         struct wmi_soc_mac_phy_hw_mode_caps *hw_caps;
  41         struct wmi_hw_mode_capabilities *hw_mode_caps;
  42         u32 n_hw_mode_caps;
  43         u32 tot_phy_id;
  44         struct wmi_hw_mode_capabilities pref_hw_mode_caps;
  45         struct wmi_mac_phy_capabilities *mac_phy_caps;
  46         u32 n_mac_phy_caps;
  47         struct wmi_soc_hal_reg_capabilities *soc_hal_reg_caps;
  48         struct wmi_hal_reg_capabilities_ext *ext_hal_reg_caps;
  49         u32 n_ext_hal_reg_caps;
  50         struct wmi_tlv_dma_ring_caps_parse dma_caps_parse;
  51         bool hw_mode_done;
  52         bool mac_phy_done;
  53         bool ext_hal_reg_done;
  54         bool mac_phy_chainmask_combo_done;
  55         bool mac_phy_chainmask_cap_done;
  56         bool oem_dma_ring_cap_done;
  57         bool dma_ring_cap_done;
  58 };
  59
  60 struct wmi_tlv_svc_rdy_ext2_parse {
  61         struct wmi_tlv_dma_ring_caps_parse dma_caps_parse;
  62         bool dma_ring_cap_done;
  63 };
  64
  65 struct wmi_tlv_rdy_parse {
  66         u32 num_extra_mac_addr;
  67 };
  68
  69 struct wmi_tlv_dma_buf_release_parse {
  70         struct ath11k_wmi_dma_buf_release_fixed_param fixed;
  71         struct wmi_dma_buf_release_entry *buf_entry;
  72         struct wmi_dma_buf_release_meta_data *meta_data;
  73         u32 num_buf_entry;
  74         u32 num_meta;
  75         bool buf_entry_done;
  76         bool meta_data_done;
  77 };
  78
  79 struct wmi_tlv_fw_stats_parse {
  80         const struct wmi_stats_event *ev;
  81         const struct wmi_per_chain_rssi_stats *rssi;
  82         struct ath11k_fw_stats *stats;
  83         int rssi_num;
  84         bool chain_rssi_done;
  85 };
  86
  87 struct wmi_tlv_mgmt_rx_parse {
  88         const struct wmi_mgmt_rx_hdr *fixed;
  89         const u8 *frame_buf;
  90         bool frame_buf_done;
  91 };
  92
  93 static const struct wmi_tlv_policy wmi_tlv_policies[] = {
  94         [WMI_TAG_ARRAY_BYTE]
  95                 = { .min_len = 0 },
  96         [WMI_TAG_ARRAY_UINT32]
  97                 = { .min_len = 0 },
  98         [WMI_TAG_SERVICE_READY_EVENT]
  99                 = { .min_len = sizeof(struct wmi_service_ready_event) },
 100         [WMI_TAG_SERVICE_READY_EXT_EVENT]
 101                 = { .min_len =  sizeof(struct wmi_service_ready_ext_event) },
 102         [WMI_TAG_SOC_MAC_PHY_HW_MODE_CAPS]
 103                 = { .min_len = sizeof(struct wmi_soc_mac_phy_hw_mode_caps) },
 104         [WMI_TAG_SOC_HAL_REG_CAPABILITIES]
 105                 = { .min_len = sizeof(struct wmi_soc_hal_reg_capabilities) },
 106         [WMI_TAG_VDEV_START_RESPONSE_EVENT]
 107                 = { .min_len = sizeof(struct wmi_vdev_start_resp_event) },
 108         [WMI_TAG_PEER_DELETE_RESP_EVENT]
 109                 = { .min_len = sizeof(struct wmi_peer_delete_resp_event) },
 110         [WMI_TAG_OFFLOAD_BCN_TX_STATUS_EVENT]
 111                 = { .min_len = sizeof(struct wmi_bcn_tx_status_event) },
 112         [WMI_TAG_VDEV_STOPPED_EVENT]
 113                 = { .min_len = sizeof(struct wmi_vdev_stopped_event) },
 114         [WMI_TAG_REG_CHAN_LIST_CC_EVENT]
 115                 = { .min_len = sizeof(struct wmi_reg_chan_list_cc_event) },
 116         [WMI_TAG_REG_CHAN_LIST_CC_EXT_EVENT]
 117                 = { .min_len = sizeof(struct wmi_reg_chan_list_cc_ext_event) },
 118         [WMI_TAG_MGMT_RX_HDR]
 119                 = { .min_len = sizeof(struct wmi_mgmt_rx_hdr) },
 120         [WMI_TAG_MGMT_TX_COMPL_EVENT]
 121                 = { .min_len = sizeof(struct wmi_mgmt_tx_compl_event) },
 122         [WMI_TAG_SCAN_EVENT]
 123                 = { .min_len = sizeof(struct wmi_scan_event) },
 124         [WMI_TAG_PEER_STA_KICKOUT_EVENT]
 125                 = { .min_len = sizeof(struct wmi_peer_sta_kickout_event) },
 126         [WMI_TAG_ROAM_EVENT]
 127                 = { .min_len = sizeof(struct wmi_roam_event) },
 128         [WMI_TAG_CHAN_INFO_EVENT]
 129                 = { .min_len = sizeof(struct wmi_chan_info_event) },
 130         [WMI_TAG_PDEV_BSS_CHAN_INFO_EVENT]
 131                 = { .min_len = sizeof(struct wmi_pdev_bss_chan_info_event) },
 132         [WMI_TAG_VDEV_INSTALL_KEY_COMPLETE_EVENT]
 133                 = { .min_len = sizeof(struct wmi_vdev_install_key_compl_event) },
 134         [WMI_TAG_READY_EVENT] = {
 135                 .min_len = sizeof(struct wmi_ready_event_min) },
 136         [WMI_TAG_SERVICE_AVAILABLE_EVENT]
 137                 = {.min_len = sizeof(struct wmi_service_available_event) },
 138         [WMI_TAG_PEER_ASSOC_CONF_EVENT]
 139                 = { .min_len = sizeof(struct wmi_peer_assoc_conf_event) },
 140         [WMI_TAG_STATS_EVENT]
 141                 = { .min_len = sizeof(struct wmi_stats_event) },
 142         [WMI_TAG_PDEV_CTL_FAILSAFE_CHECK_EVENT]
 143                 = { .min_len = sizeof(struct wmi_pdev_ctl_failsafe_chk_event) },
 144         [WMI_TAG_HOST_SWFDA_EVENT] = {
 145                 .min_len = sizeof(struct wmi_fils_discovery_event) },
 146         [WMI_TAG_OFFLOAD_PRB_RSP_TX_STATUS_EVENT] = {
 147                 .min_len = sizeof(struct wmi_probe_resp_tx_status_event) },
 148         [WMI_TAG_VDEV_DELETE_RESP_EVENT] = {
 149                 .min_len = sizeof(struct wmi_vdev_delete_resp_event) },
 150         [WMI_TAG_OBSS_COLOR_COLLISION_EVT] = {
 151                 .min_len = sizeof(struct wmi_obss_color_collision_event) },
 152         [WMI_TAG_11D_NEW_COUNTRY_EVENT] = {
 153                 .min_len = sizeof(struct wmi_11d_new_cc_ev) },
 154         [WMI_TAG_PER_CHAIN_RSSI_STATS] = {
 155                 .min_len = sizeof(struct wmi_per_chain_rssi_stats) },
 156         [WMI_TAG_TWT_ADD_DIALOG_COMPLETE_EVENT] = {
 157                 .min_len = sizeof(struct wmi_twt_add_dialog_event) },
 158         [WMI_TAG_P2P_NOA_INFO] = {
 159                 .min_len = sizeof(struct ath11k_wmi_p2p_noa_info) },
 160         [WMI_TAG_P2P_NOA_EVENT] = {
 161                 .min_len = sizeof(struct wmi_p2p_noa_event) },
 162 };
 163
 164 #define PRIMAP(_hw_mode_) \
 165         [_hw_mode_] = _hw_mode_##_PRI
 166
 167 static const int ath11k_hw_mode_pri_map[] = {
 168         PRIMAP(WMI_HOST_HW_MODE_SINGLE),
 169         PRIMAP(WMI_HOST_HW_MODE_DBS),
 170         PRIMAP(WMI_HOST_HW_MODE_SBS_PASSIVE),
 171         PRIMAP(WMI_HOST_HW_MODE_SBS),
 172         PRIMAP(WMI_HOST_HW_MODE_DBS_SBS),
 173         PRIMAP(WMI_HOST_HW_MODE_DBS_OR_SBS),
 174         /* keep last */
 175         PRIMAP(WMI_HOST_HW_MODE_MAX),
 176 };
 177
 178 static int
 179 ath11k_wmi_tlv_iter(struct ath11k_base *ab, const void *ptr, size_t len,
 180                     int (*iter)(struct ath11k_base *ab, u16 tag, u16 len,
 181                                 const void *ptr, void *data),
 182                     void *data)
 183 {
 184         const void *begin = ptr;
 185         const struct wmi_tlv *tlv;
 186         u16 tlv_tag, tlv_len;
 187         int ret;
 188
 189         while (len > 0) {
 190                 if (len < sizeof(*tlv)) {
 191                         ath11k_err(ab, "wmi tlv parse failure at byte %zd (%zu bytes left, %zu expected)\n",
 192                                    ptr - begin, len, sizeof(*tlv));
 193                         return -EINVAL;
 194                 }
 195
 196                 tlv = ptr;
 197                 tlv_tag = FIELD_GET(WMI_TLV_TAG, tlv->header);
 198                 tlv_len = FIELD_GET(WMI_TLV_LEN, tlv->header);
 199                 ptr += sizeof(*tlv);
 200                 len -= sizeof(*tlv);
 201
 202                 if (tlv_len > len) {
 203                         ath11k_err(ab, "wmi tlv parse failure of tag %u at byte %zd (%zu bytes left, %u expected)\n",
 204                                    tlv_tag, ptr - begin, len, tlv_len);
 205                         return -EINVAL;
 206                 }
 207
 208                 if (tlv_tag < ARRAY_SIZE(wmi_tlv_policies) &&
 209                     wmi_tlv_policies[tlv_tag].min_len &&
 210                     wmi_tlv_policies[tlv_tag].min_len > tlv_len) {
 211                         ath11k_err(ab, "wmi tlv parse failure of tag %u at byte %zd (%u bytes is less than min length %zu)\n",
 212                                    tlv_tag, ptr - begin, tlv_len,
 213                                    wmi_tlv_policies[tlv_tag].min_len);
 214                         return -EINVAL;
 215                 }
 216
 217                 ret = iter(ab, tlv_tag, tlv_len, ptr, data);
 218                 if (ret)
 219                         return ret;
 220
 221                 ptr += tlv_len;
 222                 len -= tlv_len;
 223         }
 224
 225         return 0;
 226 }
 227
 228 static int ath11k_wmi_tlv_iter_parse(struct ath11k_base *ab, u16 tag, u16 len,
 229                                      const void *ptr, void *data)
 230 {
 231         const void **tb = data;
 232
 233         if (tag < WMI_TAG_MAX)
 234                 tb[tag] = ptr;
 235
 236         return 0;
 237 }
 238
 239 static int ath11k_wmi_tlv_parse(struct ath11k_base *ar, const void **tb,
 240                                 const void *ptr, size_t len)
 241 {
 242         return ath11k_wmi_tlv_iter(ar, ptr, len, ath11k_wmi_tlv_iter_parse,
 243                                    (void *)tb);
 244 }
 245
 246 const void **ath11k_wmi_tlv_parse_alloc(struct ath11k_base *ab,
 247                                         struct sk_buff *skb, gfp_t gfp)
 248 {
 249         const void **tb;
 250         int ret;
 251
 252         tb = kcalloc(WMI_TAG_MAX, sizeof(*tb), gfp);
 253         if (!tb)
 254                 return ERR_PTR(-ENOMEM);
 255
 256         ret = ath11k_wmi_tlv_parse(ab, tb, skb->data, skb->len);
 257         if (ret) {
 258                 kfree(tb);
 259                 return ERR_PTR(ret);
 260         }
 261
 262         return tb;
 263 }
 264
 265 static int ath11k_wmi_cmd_send_nowait(struct ath11k_pdev_wmi *wmi, struct sk_buff *skb,
 266                                       u32 cmd_id)
 267 {
 268         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
 269         struct ath11k_base *ab = wmi->wmi_ab->ab;
 270         struct wmi_cmd_hdr *cmd_hdr;
 271         int ret;
 272         u32 cmd = 0;
 273
 274         if (skb_push(skb, sizeof(struct wmi_cmd_hdr)) == NULL)
 275                 return -ENOMEM;
 276
 277         cmd |= FIELD_PREP(WMI_CMD_HDR_CMD_ID, cmd_id);
 278
 279         cmd_hdr = (struct wmi_cmd_hdr *)skb->data;
 280         cmd_hdr->cmd_id = cmd;
 281
 282         trace_ath11k_wmi_cmd(ab, cmd_id, skb->data, skb->len);
 283
 284         memset(skb_cb, 0, sizeof(*skb_cb));
 285         ret = ath11k_htc_send(&ab->htc, wmi->eid, skb);
 286
 287         if (ret)
 288                 goto err_pull;
 289
 290         return 0;
 291
 292 err_pull:
 293         skb_pull(skb, sizeof(struct wmi_cmd_hdr));
 294         return ret;
 295 }
 296
 297 int ath11k_wmi_cmd_send(struct ath11k_pdev_wmi *wmi, struct sk_buff *skb,
 298                         u32 cmd_id)
 299 {
 300         struct ath11k_wmi_base *wmi_ab = wmi->wmi_ab;
 301         int ret = -EOPNOTSUPP;
 302         struct ath11k_base *ab = wmi_ab->ab;
 303
 304         might_sleep();
 305
 306         if (ab->hw_params.credit_flow) {
 307                 wait_event_timeout(wmi_ab->tx_credits_wq, ({
 308                         ret = ath11k_wmi_cmd_send_nowait(wmi, skb, cmd_id);
 309
 310                         if (ret && test_bit(ATH11K_FLAG_CRASH_FLUSH,
 311                                             &wmi_ab->ab->dev_flags))
 312                                 ret = -ESHUTDOWN;
 313
 314                         (ret != -EAGAIN);
 315                         }), WMI_SEND_TIMEOUT_HZ);
 316         } else {
 317                 wait_event_timeout(wmi->tx_ce_desc_wq, ({
 318                         ret = ath11k_wmi_cmd_send_nowait(wmi, skb, cmd_id);
 319
 320                         if (ret && test_bit(ATH11K_FLAG_CRASH_FLUSH,
 321                                             &wmi_ab->ab->dev_flags))
 322                                 ret = -ESHUTDOWN;
 323
 324                         (ret != -ENOBUFS);
 325                         }), WMI_SEND_TIMEOUT_HZ);
 326         }
 327
 328         if (ret == -EAGAIN)
 329                 ath11k_warn(wmi_ab->ab, "wmi command %d timeout\n", cmd_id);
 330
 331         if (ret == -ENOBUFS)
 332                 ath11k_warn(wmi_ab->ab, "ce desc not available for wmi command %d\n",
 333                             cmd_id);
 334
 335         return ret;
 336 }
 337
 338 static int ath11k_pull_svc_ready_ext(struct ath11k_pdev_wmi *wmi_handle,
 339                                      const void *ptr,
 340                                      struct ath11k_service_ext_param *param)
 341 {
 342         const struct wmi_service_ready_ext_event *ev = ptr;
 343
 344         if (!ev)
 345                 return -EINVAL;
 346
 347         /* Move this to host based bitmap */
 348         param->default_conc_scan_config_bits = ev->default_conc_scan_config_bits;
 349         param->default_fw_config_bits = ev->default_fw_config_bits;
 350         param->he_cap_info = ev->he_cap_info;
 351         param->mpdu_density = ev->mpdu_density;
 352         param->max_bssid_rx_filters = ev->max_bssid_rx_filters;
 353         memcpy(&param->ppet, &ev->ppet, sizeof(param->ppet));
 354
 355         return 0;
 356 }
 357
 358 static int
 359 ath11k_pull_mac_phy_cap_svc_ready_ext(struct ath11k_pdev_wmi *wmi_handle,
 360                                       struct wmi_soc_mac_phy_hw_mode_caps *hw_caps,
 361                                       struct wmi_hw_mode_capabilities *wmi_hw_mode_caps,
 362                                       struct wmi_soc_hal_reg_capabilities *hal_reg_caps,
 363                                       struct wmi_mac_phy_capabilities *wmi_mac_phy_caps,
 364                                       u8 hw_mode_id, u8 phy_id,
 365                                       struct ath11k_pdev *pdev)
 366 {
 367         struct wmi_mac_phy_capabilities *mac_phy_caps;
 368         struct ath11k_base *ab = wmi_handle->wmi_ab->ab;
 369         struct ath11k_band_cap *cap_band;
 370         struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
 371         u32 phy_map;
 372         u32 hw_idx, phy_idx = 0;
 373
 374         if (!hw_caps || !wmi_hw_mode_caps || !hal_reg_caps)
 375                 return -EINVAL;
 376
 377         for (hw_idx = 0; hw_idx < hw_caps->num_hw_modes; hw_idx++) {
 378                 if (hw_mode_id == wmi_hw_mode_caps[hw_idx].hw_mode_id)
 379                         break;
 380
 381                 phy_map = wmi_hw_mode_caps[hw_idx].phy_id_map;
 382                 while (phy_map) {
 383                         phy_map >>= 1;
 384                         phy_idx++;
 385                 }
 386         }
 387
 388         if (hw_idx == hw_caps->num_hw_modes)
 389                 return -EINVAL;
 390
 391         phy_idx += phy_id;
 392         if (phy_id >= hal_reg_caps->num_phy)
 393                 return -EINVAL;
 394
 395         mac_phy_caps = wmi_mac_phy_caps + phy_idx;
 396
 397         pdev->pdev_id = mac_phy_caps->pdev_id;
 398         pdev_cap->supported_bands |= mac_phy_caps->supported_bands;
 399         pdev_cap->ampdu_density = mac_phy_caps->ampdu_density;
 400         ab->target_pdev_ids[ab->target_pdev_count].supported_bands =
 401                 mac_phy_caps->supported_bands;
 402         ab->target_pdev_ids[ab->target_pdev_count].pdev_id = mac_phy_caps->pdev_id;
 403         ab->target_pdev_count++;
 404
 405         if (!(mac_phy_caps->supported_bands & WMI_HOST_WLAN_2G_CAP) &&
 406             !(mac_phy_caps->supported_bands & WMI_HOST_WLAN_5G_CAP))
 407                 return -EINVAL;
 408
 409         /* Take non-zero tx/rx chainmask. If tx/rx chainmask differs from
 410          * band to band for a single radio, need to see how this should be
 411          * handled.
 412          */
 413         if (mac_phy_caps->supported_bands & WMI_HOST_WLAN_2G_CAP) {
 414                 pdev_cap->tx_chain_mask = mac_phy_caps->tx_chain_mask_2g;
 415                 pdev_cap->rx_chain_mask = mac_phy_caps->rx_chain_mask_2g;
 416         }
 417
 418         if (mac_phy_caps->supported_bands & WMI_HOST_WLAN_5G_CAP) {
 419                 pdev_cap->vht_cap = mac_phy_caps->vht_cap_info_5g;
 420                 pdev_cap->vht_mcs = mac_phy_caps->vht_supp_mcs_5g;
 421                 pdev_cap->he_mcs = mac_phy_caps->he_supp_mcs_5g;
 422                 pdev_cap->tx_chain_mask = mac_phy_caps->tx_chain_mask_5g;
 423                 pdev_cap->rx_chain_mask = mac_phy_caps->rx_chain_mask_5g;
 424                 pdev_cap->nss_ratio_enabled =
 425                         WMI_NSS_RATIO_ENABLE_DISABLE_GET(mac_phy_caps->nss_ratio);
 426                 pdev_cap->nss_ratio_info =
 427                         WMI_NSS_RATIO_INFO_GET(mac_phy_caps->nss_ratio);
 428         }
 429
 430         /* tx/rx chainmask reported from fw depends on the actual hw chains used,
 431          * For example, for 4x4 capable macphys, first 4 chains can be used for first
 432          * mac and the remaining 4 chains can be used for the second mac or vice-versa.
 433          * In this case, tx/rx chainmask 0xf will be advertised for first mac and 0xf0
 434          * will be advertised for second mac or vice-versa. Compute the shift value
 435          * for tx/rx chainmask which will be used to advertise supported ht/vht rates to
 436          * mac80211.
 437          */
 438         pdev_cap->tx_chain_mask_shift =
 439                         find_first_bit((unsigned long *)&pdev_cap->tx_chain_mask, 32);
 440         pdev_cap->rx_chain_mask_shift =
 441                         find_first_bit((unsigned long *)&pdev_cap->rx_chain_mask, 32);
 442
 443         if (mac_phy_caps->supported_bands & WMI_HOST_WLAN_2G_CAP) {
 444                 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ];
 445                 cap_band->phy_id = mac_phy_caps->phy_id;
 446                 cap_band->max_bw_supported = mac_phy_caps->max_bw_supported_2g;
 447                 cap_band->ht_cap_info = mac_phy_caps->ht_cap_info_2g;
 448                 cap_band->he_cap_info[0] = mac_phy_caps->he_cap_info_2g;
 449                 cap_band->he_cap_info[1] = mac_phy_caps->he_cap_info_2g_ext;
 450                 cap_band->he_mcs = mac_phy_caps->he_supp_mcs_2g;
 451                 memcpy(cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_2g,
 452                        sizeof(u32) * PSOC_HOST_MAX_PHY_SIZE);
 453                 memcpy(&cap_band->he_ppet, &mac_phy_caps->he_ppet2g,
 454                        sizeof(struct ath11k_ppe_threshold));
 455         }
 456
 457         if (mac_phy_caps->supported_bands & WMI_HOST_WLAN_5G_CAP) {
 458                 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ];
 459                 cap_band->phy_id = mac_phy_caps->phy_id;
 460                 cap_band->max_bw_supported = mac_phy_caps->max_bw_supported_5g;
 461                 cap_band->ht_cap_info = mac_phy_caps->ht_cap_info_5g;
 462                 cap_band->he_cap_info[0] = mac_phy_caps->he_cap_info_5g;
 463                 cap_band->he_cap_info[1] = mac_phy_caps->he_cap_info_5g_ext;
 464                 cap_band->he_mcs = mac_phy_caps->he_supp_mcs_5g;
 465                 memcpy(cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_5g,
 466                        sizeof(u32) * PSOC_HOST_MAX_PHY_SIZE);
 467                 memcpy(&cap_band->he_ppet, &mac_phy_caps->he_ppet5g,
 468                        sizeof(struct ath11k_ppe_threshold));
 469
 470                 cap_band = &pdev_cap->band[NL80211_BAND_6GHZ];
 471                 cap_band->max_bw_supported = mac_phy_caps->max_bw_supported_5g;
 472                 cap_band->ht_cap_info = mac_phy_caps->ht_cap_info_5g;
 473                 cap_band->he_cap_info[0] = mac_phy_caps->he_cap_info_5g;
 474                 cap_band->he_cap_info[1] = mac_phy_caps->he_cap_info_5g_ext;
 475                 cap_band->he_mcs = mac_phy_caps->he_supp_mcs_5g;
 476                 memcpy(cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_5g,
 477                        sizeof(u32) * PSOC_HOST_MAX_PHY_SIZE);
 478                 memcpy(&cap_band->he_ppet, &mac_phy_caps->he_ppet5g,
 479                        sizeof(struct ath11k_ppe_threshold));
 480         }
 481
 482         return 0;
 483 }
 484
 485 static int
 486 ath11k_pull_reg_cap_svc_rdy_ext(struct ath11k_pdev_wmi *wmi_handle,
 487                                 struct wmi_soc_hal_reg_capabilities *reg_caps,
 488                                 struct wmi_hal_reg_capabilities_ext *wmi_ext_reg_cap,
 489                                 u8 phy_idx,
 490                                 struct ath11k_hal_reg_capabilities_ext *param)
 491 {
 492         struct wmi_hal_reg_capabilities_ext *ext_reg_cap;
 493
 494         if (!reg_caps || !wmi_ext_reg_cap)
 495                 return -EINVAL;
 496
 497         if (phy_idx >= reg_caps->num_phy)
 498                 return -EINVAL;
 499
 500         ext_reg_cap = &wmi_ext_reg_cap[phy_idx];
 501
 502         param->phy_id = ext_reg_cap->phy_id;
 503         param->eeprom_reg_domain = ext_reg_cap->eeprom_reg_domain;
 504         param->eeprom_reg_domain_ext =
 505                               ext_reg_cap->eeprom_reg_domain_ext;
 506         param->regcap1 = ext_reg_cap->regcap1;
 507         param->regcap2 = ext_reg_cap->regcap2;
 508         /* check if param->wireless_mode is needed */
 509         param->low_2ghz_chan = ext_reg_cap->low_2ghz_chan;
 510         param->high_2ghz_chan = ext_reg_cap->high_2ghz_chan;
 511         param->low_5ghz_chan = ext_reg_cap->low_5ghz_chan;
 512         param->high_5ghz_chan = ext_reg_cap->high_5ghz_chan;
 513
 514         return 0;
 515 }
 516
 517 static int ath11k_pull_service_ready_tlv(struct ath11k_base *ab,
 518                                          const void *evt_buf,
 519                                          struct ath11k_targ_cap *cap)
 520 {
 521         const struct wmi_service_ready_event *ev = evt_buf;
 522
 523         if (!ev) {
 524                 ath11k_err(ab, "%s: failed by NULL param\n",
 525                            __func__);
 526                 return -EINVAL;
 527         }
 528
 529         cap->phy_capability = ev->phy_capability;
 530         cap->max_frag_entry = ev->max_frag_entry;
 531         cap->num_rf_chains = ev->num_rf_chains;
 532         cap->ht_cap_info = ev->ht_cap_info;
 533         cap->vht_cap_info = ev->vht_cap_info;
 534         cap->vht_supp_mcs = ev->vht_supp_mcs;
 535         cap->hw_min_tx_power = ev->hw_min_tx_power;
 536         cap->hw_max_tx_power = ev->hw_max_tx_power;
 537         cap->sys_cap_info = ev->sys_cap_info;
 538         cap->min_pkt_size_enable = ev->min_pkt_size_enable;
 539         cap->max_bcn_ie_size = ev->max_bcn_ie_size;
 540         cap->max_num_scan_channels = ev->max_num_scan_channels;
 541         cap->max_supported_macs = ev->max_supported_macs;
 542         cap->wmi_fw_sub_feat_caps = ev->wmi_fw_sub_feat_caps;
 543         cap->txrx_chainmask = ev->txrx_chainmask;
 544         cap->default_dbs_hw_mode_index = ev->default_dbs_hw_mode_index;
 545         cap->num_msdu_desc = ev->num_msdu_desc;
 546
 547         return 0;
 548 }
 549
 550 /* Save the wmi_service_bitmap into a linear bitmap. The wmi_services in
 551  * wmi_service ready event are advertised in b0-b3 (LSB 4-bits) of each
 552  * 4-byte word.
 553  */
 554 static void ath11k_wmi_service_bitmap_copy(struct ath11k_pdev_wmi *wmi,
 555                                            const u32 *wmi_svc_bm)
 556 {
 557         int i, j;
 558
 559         for (i = 0, j = 0; i < WMI_SERVICE_BM_SIZE && j < WMI_MAX_SERVICE; i++) {
 560                 do {
 561                         if (wmi_svc_bm[i] & BIT(j % WMI_SERVICE_BITS_IN_SIZE32))
 562                                 set_bit(j, wmi->wmi_ab->svc_map);
 563                 } while (++j % WMI_SERVICE_BITS_IN_SIZE32);
 564         }
 565 }
 566
 567 static int ath11k_wmi_tlv_svc_rdy_parse(struct ath11k_base *ab, u16 tag, u16 len,
 568                                         const void *ptr, void *data)
 569 {
 570         struct wmi_tlv_svc_ready_parse *svc_ready = data;
 571         struct ath11k_pdev_wmi *wmi_handle = &ab->wmi_ab.wmi[0];
 572         u16 expect_len;
 573
 574         switch (tag) {
 575         case WMI_TAG_SERVICE_READY_EVENT:
 576                 if (ath11k_pull_service_ready_tlv(ab, ptr, &ab->target_caps))
 577                         return -EINVAL;
 578                 break;
 579
 580         case WMI_TAG_ARRAY_UINT32:
 581                 if (!svc_ready->wmi_svc_bitmap_done) {
 582                         expect_len = WMI_SERVICE_BM_SIZE * sizeof(u32);
 583                         if (len < expect_len) {
 584                                 ath11k_warn(ab, "invalid len %d for the tag 0x%x\n",
 585                                             len, tag);
 586                                 return -EINVAL;
 587                         }
 588
 589                         ath11k_wmi_service_bitmap_copy(wmi_handle, ptr);
 590
 591                         svc_ready->wmi_svc_bitmap_done = true;
 592                 }
 593                 break;
 594         default:
 595                 break;
 596         }
 597
 598         return 0;
 599 }
 600
 601 static int ath11k_service_ready_event(struct ath11k_base *ab, struct sk_buff *skb)
 602 {
 603         struct wmi_tlv_svc_ready_parse svc_ready = { };
 604         int ret;
 605
 606         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
 607                                   ath11k_wmi_tlv_svc_rdy_parse,
 608                                   &svc_ready);
 609         if (ret) {
 610                 ath11k_warn(ab, "failed to parse tlv %d\n", ret);
 611                 return ret;
 612         }
 613
 614         ath11k_dbg(ab, ATH11K_DBG_WMI, "event service ready");
 615
 616         return 0;
 617 }
 618
 619 struct sk_buff *ath11k_wmi_alloc_skb(struct ath11k_wmi_base *wmi_ab, u32 len)
 620 {
 621         struct sk_buff *skb;
 622         struct ath11k_base *ab = wmi_ab->ab;
 623         u32 round_len = roundup(len, 4);
 624
 625         skb = ath11k_htc_alloc_skb(ab, WMI_SKB_HEADROOM + round_len);
 626         if (!skb)
 627                 return NULL;
 628
 629         skb_reserve(skb, WMI_SKB_HEADROOM);
 630         if (!IS_ALIGNED((unsigned long)skb->data, 4))
 631                 ath11k_warn(ab, "unaligned WMI skb data\n");
 632
 633         skb_put(skb, round_len);
 634         memset(skb->data, 0, round_len);
 635
 636         return skb;
 637 }
 638
 639 static u32 ath11k_wmi_mgmt_get_freq(struct ath11k *ar,
 640                                     struct ieee80211_tx_info *info)
 641 {
 642         struct ath11k_base *ab = ar->ab;
 643         u32 freq = 0;
 644
 645         if (ab->hw_params.support_off_channel_tx &&
 646             ar->scan.is_roc &&
 647             (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN))
 648                 freq = ar->scan.roc_freq;
 649
 650         return freq;
 651 }
 652
 653 int ath11k_wmi_mgmt_send(struct ath11k *ar, u32 vdev_id, u32 buf_id,
 654                          struct sk_buff *frame)
 655 {
 656         struct ath11k_pdev_wmi *wmi = ar->wmi;
 657         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(frame);
 658         struct wmi_mgmt_send_cmd *cmd;
 659         struct wmi_tlv *frame_tlv;
 660         struct sk_buff *skb;
 661         u32 buf_len;
 662         int ret, len;
 663
 664         buf_len = frame->len < WMI_MGMT_SEND_DOWNLD_LEN ?
 665                   frame->len : WMI_MGMT_SEND_DOWNLD_LEN;
 666
 667         len = sizeof(*cmd) + sizeof(*frame_tlv) + roundup(buf_len, 4);
 668
 669         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
 670         if (!skb)
 671                 return -ENOMEM;
 672
 673         cmd = (struct wmi_mgmt_send_cmd *)skb->data;
 674         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_MGMT_TX_SEND_CMD) |
 675                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 676         cmd->vdev_id = vdev_id;
 677         cmd->desc_id = buf_id;
 678         cmd->chanfreq = ath11k_wmi_mgmt_get_freq(ar, info);
 679         cmd->paddr_lo = lower_32_bits(ATH11K_SKB_CB(frame)->paddr);
 680         cmd->paddr_hi = upper_32_bits(ATH11K_SKB_CB(frame)->paddr);
 681         cmd->frame_len = frame->len;
 682         cmd->buf_len = buf_len;
 683         cmd->tx_params_valid = 0;
 684
 685         frame_tlv = (struct wmi_tlv *)(skb->data + sizeof(*cmd));
 686         frame_tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
 687                             FIELD_PREP(WMI_TLV_LEN, buf_len);
 688
 689         memcpy(frame_tlv->value, frame->data, buf_len);
 690
 691         ath11k_ce_byte_swap(frame_tlv->value, buf_len);
 692
 693         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_MGMT_TX_SEND_CMDID);
 694         if (ret) {
 695                 ath11k_warn(ar->ab,
 696                             "failed to submit WMI_MGMT_TX_SEND_CMDID cmd\n");
 697                 dev_kfree_skb(skb);
 698         }
 699
 700         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd mgmt tx send");
 701
 702         return ret;
 703 }
 704
 705 int ath11k_wmi_vdev_create(struct ath11k *ar, u8 *macaddr,
 706                            struct vdev_create_params *param)
 707 {
 708         struct ath11k_pdev_wmi *wmi = ar->wmi;
 709         struct wmi_vdev_create_cmd *cmd;
 710         struct sk_buff *skb;
 711         struct wmi_vdev_txrx_streams *txrx_streams;
 712         struct wmi_tlv *tlv;
 713         int ret, len;
 714         void *ptr;
 715
 716         /* It can be optimized my sending tx/rx chain configuration
 717          * only for supported bands instead of always sending it for
 718          * both the bands.
 719          */
 720         len = sizeof(*cmd) + TLV_HDR_SIZE +
 721                 (WMI_NUM_SUPPORTED_BAND_MAX * sizeof(*txrx_streams));
 722
 723         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
 724         if (!skb)
 725                 return -ENOMEM;
 726
 727         cmd = (struct wmi_vdev_create_cmd *)skb->data;
 728         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_CREATE_CMD) |
 729                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 730
 731         cmd->vdev_id = param->if_id;
 732         cmd->vdev_type = param->type;
 733         cmd->vdev_subtype = param->subtype;
 734         cmd->num_cfg_txrx_streams = WMI_NUM_SUPPORTED_BAND_MAX;
 735         cmd->pdev_id = param->pdev_id;
 736         cmd->mbssid_flags = param->mbssid_flags;
 737         cmd->mbssid_tx_vdev_id = param->mbssid_tx_vdev_id;
 738
 739         ether_addr_copy(cmd->vdev_macaddr.addr, macaddr);
 740
 741         ptr = skb->data + sizeof(*cmd);
 742         len = WMI_NUM_SUPPORTED_BAND_MAX * sizeof(*txrx_streams);
 743
 744         tlv = ptr;
 745         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
 746                       FIELD_PREP(WMI_TLV_LEN, len);
 747
 748         ptr += TLV_HDR_SIZE;
 749         txrx_streams = ptr;
 750         len = sizeof(*txrx_streams);
 751         txrx_streams->tlv_header =
 752                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_TXRX_STREAMS) |
 753                 FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
 754         txrx_streams->band = WMI_TPC_CHAINMASK_CONFIG_BAND_2G;
 755         txrx_streams->supported_tx_streams =
 756                                  param->chains[NL80211_BAND_2GHZ].tx;
 757         txrx_streams->supported_rx_streams =
 758                                  param->chains[NL80211_BAND_2GHZ].rx;
 759
 760         txrx_streams++;
 761         txrx_streams->tlv_header =
 762                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_TXRX_STREAMS) |
 763                 FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
 764         txrx_streams->band = WMI_TPC_CHAINMASK_CONFIG_BAND_5G;
 765         txrx_streams->supported_tx_streams =
 766                                  param->chains[NL80211_BAND_5GHZ].tx;
 767         txrx_streams->supported_rx_streams =
 768                                  param->chains[NL80211_BAND_5GHZ].rx;
 769
 770         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_CREATE_CMDID);
 771         if (ret) {
 772                 ath11k_warn(ar->ab,
 773                             "failed to submit WMI_VDEV_CREATE_CMDID\n");
 774                 dev_kfree_skb(skb);
 775         }
 776
 777         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
 778                    "cmd vdev create id %d type %d subtype %d macaddr %pM pdevid %d\n",
 779                    param->if_id, param->type, param->subtype,
 780                    macaddr, param->pdev_id);
 781
 782         return ret;
 783 }
 784
 785 int ath11k_wmi_vdev_delete(struct ath11k *ar, u8 vdev_id)
 786 {
 787         struct ath11k_pdev_wmi *wmi = ar->wmi;
 788         struct wmi_vdev_delete_cmd *cmd;
 789         struct sk_buff *skb;
 790         int ret;
 791
 792         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
 793         if (!skb)
 794                 return -ENOMEM;
 795
 796         cmd = (struct wmi_vdev_delete_cmd *)skb->data;
 797         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_DELETE_CMD) |
 798                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 799         cmd->vdev_id = vdev_id;
 800
 801         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_DELETE_CMDID);
 802         if (ret) {
 803                 ath11k_warn(ar->ab, "failed to submit WMI_VDEV_DELETE_CMDID\n");
 804                 dev_kfree_skb(skb);
 805         }
 806
 807         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd vdev delete id %d\n", vdev_id);
 808
 809         return ret;
 810 }
 811
 812 int ath11k_wmi_vdev_stop(struct ath11k *ar, u8 vdev_id)
 813 {
 814         struct ath11k_pdev_wmi *wmi = ar->wmi;
 815         struct wmi_vdev_stop_cmd *cmd;
 816         struct sk_buff *skb;
 817         int ret;
 818
 819         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
 820         if (!skb)
 821                 return -ENOMEM;
 822
 823         cmd = (struct wmi_vdev_stop_cmd *)skb->data;
 824
 825         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_STOP_CMD) |
 826                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 827         cmd->vdev_id = vdev_id;
 828
 829         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_STOP_CMDID);
 830         if (ret) {
 831                 ath11k_warn(ar->ab, "failed to submit WMI_VDEV_STOP cmd\n");
 832                 dev_kfree_skb(skb);
 833         }
 834
 835         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd vdev stop id 0x%x\n", vdev_id);
 836
 837         return ret;
 838 }
 839
 840 int ath11k_wmi_vdev_down(struct ath11k *ar, u8 vdev_id)
 841 {
 842         struct ath11k_pdev_wmi *wmi = ar->wmi;
 843         struct wmi_vdev_down_cmd *cmd;
 844         struct sk_buff *skb;
 845         int ret;
 846
 847         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
 848         if (!skb)
 849                 return -ENOMEM;
 850
 851         cmd = (struct wmi_vdev_down_cmd *)skb->data;
 852
 853         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_DOWN_CMD) |
 854                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 855         cmd->vdev_id = vdev_id;
 856
 857         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_DOWN_CMDID);
 858         if (ret) {
 859                 ath11k_warn(ar->ab, "failed to submit WMI_VDEV_DOWN cmd\n");
 860                 dev_kfree_skb(skb);
 861         }
 862
 863         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd vdev down id 0x%x\n", vdev_id);
 864
 865         return ret;
 866 }
 867
 868 static void ath11k_wmi_put_wmi_channel(struct wmi_channel *chan,
 869                                        struct wmi_vdev_start_req_arg *arg)
 870 {
 871         u32 center_freq1 = arg->channel.band_center_freq1;
 872
 873         memset(chan, 0, sizeof(*chan));
 874
 875         chan->mhz = arg->channel.freq;
 876         chan->band_center_freq1 = arg->channel.band_center_freq1;
 877
 878         if (arg->channel.mode == MODE_11AX_HE160) {
 879                 if (arg->channel.freq > arg->channel.band_center_freq1)
 880                         chan->band_center_freq1 = center_freq1 + 40;
 881                 else
 882                         chan->band_center_freq1 = center_freq1 - 40;
 883
 884                 chan->band_center_freq2 = arg->channel.band_center_freq1;
 885
 886         } else if ((arg->channel.mode == MODE_11AC_VHT80_80) ||
 887                    (arg->channel.mode == MODE_11AX_HE80_80)) {
 888                 chan->band_center_freq2 = arg->channel.band_center_freq2;
 889         } else {
 890                 chan->band_center_freq2 = 0;
 891         }
 892
 893         chan->info |= FIELD_PREP(WMI_CHAN_INFO_MODE, arg->channel.mode);
 894         if (arg->channel.passive)
 895                 chan->info |= WMI_CHAN_INFO_PASSIVE;
 896         if (arg->channel.allow_ibss)
 897                 chan->info |= WMI_CHAN_INFO_ADHOC_ALLOWED;
 898         if (arg->channel.allow_ht)
 899                 chan->info |= WMI_CHAN_INFO_ALLOW_HT;
 900         if (arg->channel.allow_vht)
 901                 chan->info |= WMI_CHAN_INFO_ALLOW_VHT;
 902         if (arg->channel.allow_he)
 903                 chan->info |= WMI_CHAN_INFO_ALLOW_HE;
 904         if (arg->channel.ht40plus)
 905                 chan->info |= WMI_CHAN_INFO_HT40_PLUS;
 906         if (arg->channel.chan_radar)
 907                 chan->info |= WMI_CHAN_INFO_DFS;
 908         if (arg->channel.freq2_radar)
 909                 chan->info |= WMI_CHAN_INFO_DFS_FREQ2;
 910
 911         chan->reg_info_1 = FIELD_PREP(WMI_CHAN_REG_INFO1_MAX_PWR,
 912                                       arg->channel.max_power) |
 913                 FIELD_PREP(WMI_CHAN_REG_INFO1_MAX_REG_PWR,
 914                            arg->channel.max_reg_power);
 915
 916         chan->reg_info_2 = FIELD_PREP(WMI_CHAN_REG_INFO2_ANT_MAX,
 917                                       arg->channel.max_antenna_gain) |
 918                 FIELD_PREP(WMI_CHAN_REG_INFO2_MAX_TX_PWR,
 919                            arg->channel.max_power);
 920 }
 921
 922 int ath11k_wmi_vdev_start(struct ath11k *ar, struct wmi_vdev_start_req_arg *arg,
 923                           bool restart)
 924 {
 925         struct ath11k_pdev_wmi *wmi = ar->wmi;
 926         struct wmi_vdev_start_request_cmd *cmd;
 927         struct sk_buff *skb;
 928         struct wmi_channel *chan;
 929         struct wmi_tlv *tlv;
 930         void *ptr;
 931         int ret, len;
 932
 933         if (WARN_ON(arg->ssid_len > sizeof(cmd->ssid.ssid)))
 934                 return -EINVAL;
 935
 936         len = sizeof(*cmd) + sizeof(*chan) + TLV_HDR_SIZE;
 937
 938         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
 939         if (!skb)
 940                 return -ENOMEM;
 941
 942         cmd = (struct wmi_vdev_start_request_cmd *)skb->data;
 943         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
 944                                      WMI_TAG_VDEV_START_REQUEST_CMD) |
 945                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 946         cmd->vdev_id = arg->vdev_id;
 947         cmd->beacon_interval = arg->bcn_intval;
 948         cmd->bcn_tx_rate = arg->bcn_tx_rate;
 949         cmd->dtim_period = arg->dtim_period;
 950         cmd->num_noa_descriptors = arg->num_noa_descriptors;
 951         cmd->preferred_rx_streams = arg->pref_rx_streams;
 952         cmd->preferred_tx_streams = arg->pref_tx_streams;
 953         cmd->cac_duration_ms = arg->cac_duration_ms;
 954         cmd->regdomain = arg->regdomain;
 955         cmd->he_ops = arg->he_ops;
 956         cmd->mbssid_flags = arg->mbssid_flags;
 957         cmd->mbssid_tx_vdev_id = arg->mbssid_tx_vdev_id;
 958
 959         if (!restart) {
 960                 if (arg->ssid) {
 961                         cmd->ssid.ssid_len = arg->ssid_len;
 962                         memcpy(cmd->ssid.ssid, arg->ssid, arg->ssid_len);
 963                 }
 964                 if (arg->hidden_ssid)
 965                         cmd->flags |= WMI_VDEV_START_HIDDEN_SSID;
 966                 if (arg->pmf_enabled)
 967                         cmd->flags |= WMI_VDEV_START_PMF_ENABLED;
 968         }
 969
 970         cmd->flags |= WMI_VDEV_START_LDPC_RX_ENABLED;
 971         if (test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED, &ar->ab->dev_flags))
 972                 cmd->flags |= WMI_VDEV_START_HW_ENCRYPTION_DISABLED;
 973
 974         ptr = skb->data + sizeof(*cmd);
 975         chan = ptr;
 976
 977         ath11k_wmi_put_wmi_channel(chan, arg);
 978
 979         chan->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_CHANNEL) |
 980                            FIELD_PREP(WMI_TLV_LEN,
 981                                       sizeof(*chan) - TLV_HDR_SIZE);
 982         ptr += sizeof(*chan);
 983
 984         tlv = ptr;
 985         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
 986                       FIELD_PREP(WMI_TLV_LEN, 0);
 987
 988         /* Note: This is a nested TLV containing:
 989          * [wmi_tlv][ath11k_wmi_p2p_noa_descriptor][wmi_tlv]..
 990          */
 991
 992         ptr += sizeof(*tlv);
 993
 994         if (restart)
 995                 ret = ath11k_wmi_cmd_send(wmi, skb,
 996                                           WMI_VDEV_RESTART_REQUEST_CMDID);
 997         else
 998                 ret = ath11k_wmi_cmd_send(wmi, skb,
 999                                           WMI_VDEV_START_REQUEST_CMDID);
1000         if (ret) {
1001                 ath11k_warn(ar->ab, "failed to submit vdev_%s cmd\n",
1002                             restart ? "restart" : "start");
1003                 dev_kfree_skb(skb);
1004         }
1005
1006         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd vdev %s id 0x%x freq 0x%x mode 0x%x\n",
1007                    restart ? "restart" : "start", arg->vdev_id,
1008                    arg->channel.freq, arg->channel.mode);
1009
1010         return ret;
1011 }
1012
1013 int ath11k_wmi_vdev_up(struct ath11k *ar, u32 vdev_id, u32 aid, const u8 *bssid,
1014                        u8 *tx_bssid, u32 nontx_profile_idx, u32 nontx_profile_cnt)
1015 {
1016         struct ath11k_pdev_wmi *wmi = ar->wmi;
1017         struct wmi_vdev_up_cmd *cmd;
1018         struct ieee80211_bss_conf *bss_conf;
1019         struct ath11k_vif *arvif;
1020         struct sk_buff *skb;
1021         int ret;
1022
1023         arvif = ath11k_mac_get_arvif(ar, vdev_id);
1024
1025         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1026         if (!skb)
1027                 return -ENOMEM;
1028
1029         cmd = (struct wmi_vdev_up_cmd *)skb->data;
1030
1031         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_UP_CMD) |
1032                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1033         cmd->vdev_id = vdev_id;
1034         cmd->vdev_assoc_id = aid;
1035
1036         ether_addr_copy(cmd->vdev_bssid.addr, bssid);
1037
1038         cmd->nontx_profile_idx = nontx_profile_idx;
1039         cmd->nontx_profile_cnt = nontx_profile_cnt;
1040         if (tx_bssid)
1041                 ether_addr_copy(cmd->tx_vdev_bssid.addr, tx_bssid);
1042
1043         if (arvif && arvif->vif->type == NL80211_IFTYPE_STATION) {
1044                 bss_conf = &arvif->vif->bss_conf;
1045
1046                 if (bss_conf->nontransmitted) {
1047                         ether_addr_copy(cmd->tx_vdev_bssid.addr,
1048                                         bss_conf->transmitter_bssid);
1049                         cmd->nontx_profile_idx = bss_conf->bssid_index;
1050                         cmd->nontx_profile_cnt = bss_conf->bssid_indicator;
1051                 }
1052         }
1053
1054         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_UP_CMDID);
1055         if (ret) {
1056                 ath11k_warn(ar->ab, "failed to submit WMI_VDEV_UP cmd\n");
1057                 dev_kfree_skb(skb);
1058         }
1059
1060         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1061                    "cmd vdev up id 0x%x assoc id %d bssid %pM\n",
1062                    vdev_id, aid, bssid);
1063
1064         return ret;
1065 }
1066
1067 int ath11k_wmi_send_peer_create_cmd(struct ath11k *ar,
1068                                     struct peer_create_params *param)
1069 {
1070         struct ath11k_pdev_wmi *wmi = ar->wmi;
1071         struct wmi_peer_create_cmd *cmd;
1072         struct sk_buff *skb;
1073         int ret;
1074
1075         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1076         if (!skb)
1077                 return -ENOMEM;
1078
1079         cmd = (struct wmi_peer_create_cmd *)skb->data;
1080         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PEER_CREATE_CMD) |
1081                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1082
1083         ether_addr_copy(cmd->peer_macaddr.addr, param->peer_addr);
1084         cmd->peer_type = param->peer_type;
1085         cmd->vdev_id = param->vdev_id;
1086
1087         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PEER_CREATE_CMDID);
1088         if (ret) {
1089                 ath11k_warn(ar->ab, "failed to submit WMI_PEER_CREATE cmd\n");
1090                 dev_kfree_skb(skb);
1091         }
1092
1093         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1094                    "cmd peer create vdev_id %d peer_addr %pM\n",
1095                    param->vdev_id, param->peer_addr);
1096
1097         return ret;
1098 }
1099
1100 int ath11k_wmi_send_peer_delete_cmd(struct ath11k *ar,
1101                                     const u8 *peer_addr, u8 vdev_id)
1102 {
1103         struct ath11k_pdev_wmi *wmi = ar->wmi;
1104         struct wmi_peer_delete_cmd *cmd;
1105         struct sk_buff *skb;
1106         int ret;
1107
1108         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1109         if (!skb)
1110                 return -ENOMEM;
1111
1112         cmd = (struct wmi_peer_delete_cmd *)skb->data;
1113         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PEER_DELETE_CMD) |
1114                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1115
1116         ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
1117         cmd->vdev_id = vdev_id;
1118
1119         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PEER_DELETE_CMDID);
1120         if (ret) {
1121                 ath11k_warn(ar->ab, "failed to send WMI_PEER_DELETE cmd\n");
1122                 dev_kfree_skb(skb);
1123         }
1124
1125         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1126                    "cmd peer delete vdev_id %d peer_addr %pM\n",
1127                    vdev_id,  peer_addr);
1128
1129         return ret;
1130 }
1131
1132 int ath11k_wmi_send_pdev_set_regdomain(struct ath11k *ar,
1133                                        struct pdev_set_regdomain_params *param)
1134 {
1135         struct ath11k_pdev_wmi *wmi = ar->wmi;
1136         struct wmi_pdev_set_regdomain_cmd *cmd;
1137         struct sk_buff *skb;
1138         int ret;
1139
1140         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1141         if (!skb)
1142                 return -ENOMEM;
1143
1144         cmd = (struct wmi_pdev_set_regdomain_cmd *)skb->data;
1145         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1146                                      WMI_TAG_PDEV_SET_REGDOMAIN_CMD) |
1147                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1148
1149         cmd->reg_domain = param->current_rd_in_use;
1150         cmd->reg_domain_2g = param->current_rd_2g;
1151         cmd->reg_domain_5g = param->current_rd_5g;
1152         cmd->conformance_test_limit_2g = param->ctl_2g;
1153         cmd->conformance_test_limit_5g = param->ctl_5g;
1154         cmd->dfs_domain = param->dfs_domain;
1155         cmd->pdev_id = param->pdev_id;
1156
1157         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_SET_REGDOMAIN_CMDID);
1158         if (ret) {
1159                 ath11k_warn(ar->ab,
1160                             "failed to send WMI_PDEV_SET_REGDOMAIN cmd\n");
1161                 dev_kfree_skb(skb);
1162         }
1163
1164         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1165                    "cmd pdev regd rd %d rd2g %d rd5g %d domain %d pdev id %d\n",
1166                    param->current_rd_in_use, param->current_rd_2g,
1167                    param->current_rd_5g, param->dfs_domain, param->pdev_id);
1168
1169         return ret;
1170 }
1171
1172 int ath11k_wmi_set_peer_param(struct ath11k *ar, const u8 *peer_addr,
1173                               u32 vdev_id, u32 param_id, u32 param_val)
1174 {
1175         struct ath11k_pdev_wmi *wmi = ar->wmi;
1176         struct wmi_peer_set_param_cmd *cmd;
1177         struct sk_buff *skb;
1178         int ret;
1179
1180         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1181         if (!skb)
1182                 return -ENOMEM;
1183
1184         cmd = (struct wmi_peer_set_param_cmd *)skb->data;
1185         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PEER_SET_PARAM_CMD) |
1186                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1187         ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
1188         cmd->vdev_id = vdev_id;
1189         cmd->param_id = param_id;
1190         cmd->param_value = param_val;
1191
1192         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PEER_SET_PARAM_CMDID);
1193         if (ret) {
1194                 ath11k_warn(ar->ab, "failed to send WMI_PEER_SET_PARAM cmd\n");
1195                 dev_kfree_skb(skb);
1196         }
1197
1198         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1199                    "cmd peer set param vdev %d peer 0x%pM set param %d value %d\n",
1200                    vdev_id, peer_addr, param_id, param_val);
1201
1202         return ret;
1203 }
1204
1205 int ath11k_wmi_send_peer_flush_tids_cmd(struct ath11k *ar,
1206                                         u8 peer_addr[ETH_ALEN],
1207                                         struct peer_flush_params *param)
1208 {
1209         struct ath11k_pdev_wmi *wmi = ar->wmi;
1210         struct wmi_peer_flush_tids_cmd *cmd;
1211         struct sk_buff *skb;
1212         int ret;
1213
1214         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1215         if (!skb)
1216                 return -ENOMEM;
1217
1218         cmd = (struct wmi_peer_flush_tids_cmd *)skb->data;
1219         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PEER_FLUSH_TIDS_CMD) |
1220                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1221
1222         ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
1223         cmd->peer_tid_bitmap = param->peer_tid_bitmap;
1224         cmd->vdev_id = param->vdev_id;
1225
1226         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PEER_FLUSH_TIDS_CMDID);
1227         if (ret) {
1228                 ath11k_warn(ar->ab,
1229                             "failed to send WMI_PEER_FLUSH_TIDS cmd\n");
1230                 dev_kfree_skb(skb);
1231         }
1232
1233         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1234                    "cmd peer flush tids vdev_id %d peer_addr %pM tids %08x\n",
1235                    param->vdev_id, peer_addr, param->peer_tid_bitmap);
1236
1237         return ret;
1238 }
1239
1240 int ath11k_wmi_peer_rx_reorder_queue_setup(struct ath11k *ar,
1241                                            int vdev_id, const u8 *addr,
1242                                            dma_addr_t paddr, u8 tid,
1243                                            u8 ba_window_size_valid,
1244                                            u32 ba_window_size)
1245 {
1246         struct wmi_peer_reorder_queue_setup_cmd *cmd;
1247         struct sk_buff *skb;
1248         int ret;
1249
1250         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
1251         if (!skb)
1252                 return -ENOMEM;
1253
1254         cmd = (struct wmi_peer_reorder_queue_setup_cmd *)skb->data;
1255         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1256                                      WMI_TAG_REORDER_QUEUE_SETUP_CMD) |
1257                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1258
1259         ether_addr_copy(cmd->peer_macaddr.addr, addr);
1260         cmd->vdev_id = vdev_id;
1261         cmd->tid = tid;
1262         cmd->queue_ptr_lo = lower_32_bits(paddr);
1263         cmd->queue_ptr_hi = upper_32_bits(paddr);
1264         cmd->queue_no = tid;
1265         cmd->ba_window_size_valid = ba_window_size_valid;
1266         cmd->ba_window_size = ba_window_size;
1267
1268         ret = ath11k_wmi_cmd_send(ar->wmi, skb,
1269                                   WMI_PEER_REORDER_QUEUE_SETUP_CMDID);
1270         if (ret) {
1271                 ath11k_warn(ar->ab,
1272                             "failed to send WMI_PEER_REORDER_QUEUE_SETUP\n");
1273                 dev_kfree_skb(skb);
1274         }
1275
1276         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1277                    "cmd peer reorder queue setup addr %pM vdev_id %d tid %d\n",
1278                    addr, vdev_id, tid);
1279
1280         return ret;
1281 }
1282
1283 int
1284 ath11k_wmi_rx_reord_queue_remove(struct ath11k *ar,
1285                                  struct rx_reorder_queue_remove_params *param)
1286 {
1287         struct ath11k_pdev_wmi *wmi = ar->wmi;
1288         struct wmi_peer_reorder_queue_remove_cmd *cmd;
1289         struct sk_buff *skb;
1290         int ret;
1291
1292         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1293         if (!skb)
1294                 return -ENOMEM;
1295
1296         cmd = (struct wmi_peer_reorder_queue_remove_cmd *)skb->data;
1297         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1298                                      WMI_TAG_REORDER_QUEUE_REMOVE_CMD) |
1299                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1300
1301         ether_addr_copy(cmd->peer_macaddr.addr, param->peer_macaddr);
1302         cmd->vdev_id = param->vdev_id;
1303         cmd->tid_mask = param->peer_tid_bitmap;
1304
1305         ret = ath11k_wmi_cmd_send(wmi, skb,
1306                                   WMI_PEER_REORDER_QUEUE_REMOVE_CMDID);
1307         if (ret) {
1308                 ath11k_warn(ar->ab,
1309                             "failed to send WMI_PEER_REORDER_QUEUE_REMOVE_CMDID");
1310                 dev_kfree_skb(skb);
1311         }
1312
1313         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1314                    "cmd peer reorder queue remove peer_macaddr %pM vdev_id %d tid_map %d",
1315                    param->peer_macaddr, param->vdev_id, param->peer_tid_bitmap);
1316
1317         return ret;
1318 }
1319
1320 int ath11k_wmi_pdev_set_param(struct ath11k *ar, u32 param_id,
1321                               u32 param_value, u8 pdev_id)
1322 {
1323         struct ath11k_pdev_wmi *wmi = ar->wmi;
1324         struct wmi_pdev_set_param_cmd *cmd;
1325         struct sk_buff *skb;
1326         int ret;
1327
1328         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1329         if (!skb)
1330                 return -ENOMEM;
1331
1332         cmd = (struct wmi_pdev_set_param_cmd *)skb->data;
1333         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_SET_PARAM_CMD) |
1334                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1335         cmd->pdev_id = pdev_id;
1336         cmd->param_id = param_id;
1337         cmd->param_value = param_value;
1338
1339         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_SET_PARAM_CMDID);
1340         if (ret) {
1341                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_SET_PARAM cmd\n");
1342                 dev_kfree_skb(skb);
1343         }
1344
1345         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1346                    "cmd pdev set param %d pdev id %d value %d\n",
1347                    param_id, pdev_id, param_value);
1348
1349         return ret;
1350 }
1351
1352 int ath11k_wmi_pdev_set_ps_mode(struct ath11k *ar, int vdev_id,
1353                                 enum wmi_sta_ps_mode psmode)
1354 {
1355         struct ath11k_pdev_wmi *wmi = ar->wmi;
1356         struct wmi_pdev_set_ps_mode_cmd *cmd;
1357         struct sk_buff *skb;
1358         int ret;
1359
1360         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1361         if (!skb)
1362                 return -ENOMEM;
1363
1364         cmd = (struct wmi_pdev_set_ps_mode_cmd *)skb->data;
1365         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_STA_POWERSAVE_MODE_CMD) |
1366                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1367         cmd->vdev_id = vdev_id;
1368         cmd->sta_ps_mode = psmode;
1369
1370         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_STA_POWERSAVE_MODE_CMDID);
1371         if (ret) {
1372                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_SET_PARAM cmd\n");
1373                 dev_kfree_skb(skb);
1374         }
1375
1376         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1377                    "cmd sta powersave mode psmode %d vdev id %d\n",
1378                    psmode, vdev_id);
1379
1380         return ret;
1381 }
1382
1383 int ath11k_wmi_pdev_suspend(struct ath11k *ar, u32 suspend_opt,
1384                             u32 pdev_id)
1385 {
1386         struct ath11k_pdev_wmi *wmi = ar->wmi;
1387         struct wmi_pdev_suspend_cmd *cmd;
1388         struct sk_buff *skb;
1389         int ret;
1390
1391         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1392         if (!skb)
1393                 return -ENOMEM;
1394
1395         cmd = (struct wmi_pdev_suspend_cmd *)skb->data;
1396
1397         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_SUSPEND_CMD) |
1398                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1399
1400         cmd->suspend_opt = suspend_opt;
1401         cmd->pdev_id = pdev_id;
1402
1403         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_SUSPEND_CMDID);
1404         if (ret) {
1405                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_SUSPEND cmd\n");
1406                 dev_kfree_skb(skb);
1407         }
1408
1409         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1410                    "cmd pdev suspend pdev_id %d\n", pdev_id);
1411
1412         return ret;
1413 }
1414
1415 int ath11k_wmi_pdev_resume(struct ath11k *ar, u32 pdev_id)
1416 {
1417         struct ath11k_pdev_wmi *wmi = ar->wmi;
1418         struct wmi_pdev_resume_cmd *cmd;
1419         struct sk_buff *skb;
1420         int ret;
1421
1422         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1423         if (!skb)
1424                 return -ENOMEM;
1425
1426         cmd = (struct wmi_pdev_resume_cmd *)skb->data;
1427
1428         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_RESUME_CMD) |
1429                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1430         cmd->pdev_id = pdev_id;
1431
1432         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_RESUME_CMDID);
1433         if (ret) {
1434                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_RESUME cmd\n");
1435                 dev_kfree_skb(skb);
1436         }
1437
1438         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1439                    "cmd pdev resume pdev id %d\n", pdev_id);
1440
1441         return ret;
1442 }
1443
1444 /* TODO FW Support for the cmd is not available yet.
1445  * Can be tested once the command and corresponding
1446  * event is implemented in FW
1447  */
1448 int ath11k_wmi_pdev_bss_chan_info_request(struct ath11k *ar,
1449                                           enum wmi_bss_chan_info_req_type type)
1450 {
1451         struct ath11k_pdev_wmi *wmi = ar->wmi;
1452         struct wmi_pdev_bss_chan_info_req_cmd *cmd;
1453         struct sk_buff *skb;
1454         int ret;
1455
1456         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1457         if (!skb)
1458                 return -ENOMEM;
1459
1460         cmd = (struct wmi_pdev_bss_chan_info_req_cmd *)skb->data;
1461
1462         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1463                                      WMI_TAG_PDEV_BSS_CHAN_INFO_REQUEST) |
1464                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1465         cmd->req_type = type;
1466         cmd->pdev_id = ar->pdev->pdev_id;
1467
1468         ret = ath11k_wmi_cmd_send(wmi, skb,
1469                                   WMI_PDEV_BSS_CHAN_INFO_REQUEST_CMDID);
1470         if (ret) {
1471                 ath11k_warn(ar->ab,
1472                             "failed to send WMI_PDEV_BSS_CHAN_INFO_REQUEST cmd\n");
1473                 dev_kfree_skb(skb);
1474         }
1475
1476         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1477                    "cmd pdev bss chan info request type %d\n", type);
1478
1479         return ret;
1480 }
1481
1482 int ath11k_wmi_send_set_ap_ps_param_cmd(struct ath11k *ar, u8 *peer_addr,
1483                                         struct ap_ps_params *param)
1484 {
1485         struct ath11k_pdev_wmi *wmi = ar->wmi;
1486         struct wmi_ap_ps_peer_cmd *cmd;
1487         struct sk_buff *skb;
1488         int ret;
1489
1490         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1491         if (!skb)
1492                 return -ENOMEM;
1493
1494         cmd = (struct wmi_ap_ps_peer_cmd *)skb->data;
1495         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_AP_PS_PEER_CMD) |
1496                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1497
1498         cmd->vdev_id = param->vdev_id;
1499         ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
1500         cmd->param = param->param;
1501         cmd->value = param->value;
1502
1503         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_AP_PS_PEER_PARAM_CMDID);
1504         if (ret) {
1505                 ath11k_warn(ar->ab,
1506                             "failed to send WMI_AP_PS_PEER_PARAM_CMDID\n");
1507                 dev_kfree_skb(skb);
1508         }
1509
1510         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1511                    "cmd ap ps peer param vdev id %d peer %pM param %d value %d\n",
1512                    param->vdev_id, peer_addr, param->param, param->value);
1513
1514         return ret;
1515 }
1516
1517 int ath11k_wmi_set_sta_ps_param(struct ath11k *ar, u32 vdev_id,
1518                                 u32 param, u32 param_value)
1519 {
1520         struct ath11k_pdev_wmi *wmi = ar->wmi;
1521         struct wmi_sta_powersave_param_cmd *cmd;
1522         struct sk_buff *skb;
1523         int ret;
1524
1525         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1526         if (!skb)
1527                 return -ENOMEM;
1528
1529         cmd = (struct wmi_sta_powersave_param_cmd *)skb->data;
1530         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1531                                      WMI_TAG_STA_POWERSAVE_PARAM_CMD) |
1532                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1533
1534         cmd->vdev_id = vdev_id;
1535         cmd->param = param;
1536         cmd->value = param_value;
1537
1538         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_STA_POWERSAVE_PARAM_CMDID);
1539         if (ret) {
1540                 ath11k_warn(ar->ab, "failed to send WMI_STA_POWERSAVE_PARAM_CMDID");
1541                 dev_kfree_skb(skb);
1542         }
1543
1544         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1545                    "cmd set powersave param vdev_id %d param %d value %d\n",
1546                    vdev_id, param, param_value);
1547
1548         return ret;
1549 }
1550
1551 int ath11k_wmi_force_fw_hang_cmd(struct ath11k *ar, u32 type, u32 delay_time_ms)
1552 {
1553         struct ath11k_pdev_wmi *wmi = ar->wmi;
1554         struct wmi_force_fw_hang_cmd *cmd;
1555         struct sk_buff *skb;
1556         int ret, len;
1557
1558         len = sizeof(*cmd);
1559
1560         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
1561         if (!skb)
1562                 return -ENOMEM;
1563
1564         cmd = (struct wmi_force_fw_hang_cmd *)skb->data;
1565         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_FORCE_FW_HANG_CMD) |
1566                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
1567
1568         cmd->type = type;
1569         cmd->delay_time_ms = delay_time_ms;
1570
1571         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_FORCE_FW_HANG_CMDID);
1572
1573         if (ret) {
1574                 ath11k_warn(ar->ab, "Failed to send WMI_FORCE_FW_HANG_CMDID");
1575                 dev_kfree_skb(skb);
1576         }
1577
1578         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd force fw hang");
1579
1580         return ret;
1581 }
1582
1583 int ath11k_wmi_vdev_set_param_cmd(struct ath11k *ar, u32 vdev_id,
1584                                   u32 param_id, u32 param_value)
1585 {
1586         struct ath11k_pdev_wmi *wmi = ar->wmi;
1587         struct wmi_vdev_set_param_cmd *cmd;
1588         struct sk_buff *skb;
1589         int ret;
1590
1591         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1592         if (!skb)
1593                 return -ENOMEM;
1594
1595         cmd = (struct wmi_vdev_set_param_cmd *)skb->data;
1596         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_SET_PARAM_CMD) |
1597                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1598
1599         cmd->vdev_id = vdev_id;
1600         cmd->param_id = param_id;
1601         cmd->param_value = param_value;
1602
1603         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_SET_PARAM_CMDID);
1604         if (ret) {
1605                 ath11k_warn(ar->ab,
1606                             "failed to send WMI_VDEV_SET_PARAM_CMDID\n");
1607                 dev_kfree_skb(skb);
1608         }
1609
1610         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1611                    "cmd vdev set param vdev 0x%x param %d value %d\n",
1612                    vdev_id, param_id, param_value);
1613
1614         return ret;
1615 }
1616
1617 int ath11k_wmi_send_stats_request_cmd(struct ath11k *ar,
1618                                       struct stats_request_params *param)
1619 {
1620         struct ath11k_pdev_wmi *wmi = ar->wmi;
1621         struct wmi_request_stats_cmd *cmd;
1622         struct sk_buff *skb;
1623         int ret;
1624
1625         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1626         if (!skb)
1627                 return -ENOMEM;
1628
1629         cmd = (struct wmi_request_stats_cmd *)skb->data;
1630         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_REQUEST_STATS_CMD) |
1631                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1632
1633         cmd->stats_id = param->stats_id;
1634         cmd->vdev_id = param->vdev_id;
1635         cmd->pdev_id = param->pdev_id;
1636
1637         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_REQUEST_STATS_CMDID);
1638         if (ret) {
1639                 ath11k_warn(ar->ab, "failed to send WMI_REQUEST_STATS cmd\n");
1640                 dev_kfree_skb(skb);
1641         }
1642
1643         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1644                    "cmd request stats 0x%x vdev id %d pdev id %d\n",
1645                    param->stats_id, param->vdev_id, param->pdev_id);
1646
1647         return ret;
1648 }
1649
1650 int ath11k_wmi_send_pdev_temperature_cmd(struct ath11k *ar)
1651 {
1652         struct ath11k_pdev_wmi *wmi = ar->wmi;
1653         struct wmi_get_pdev_temperature_cmd *cmd;
1654         struct sk_buff *skb;
1655         int ret;
1656
1657         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1658         if (!skb)
1659                 return -ENOMEM;
1660
1661         cmd = (struct wmi_get_pdev_temperature_cmd *)skb->data;
1662         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_GET_TEMPERATURE_CMD) |
1663                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1664         cmd->pdev_id = ar->pdev->pdev_id;
1665
1666         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_GET_TEMPERATURE_CMDID);
1667         if (ret) {
1668                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_GET_TEMPERATURE cmd\n");
1669                 dev_kfree_skb(skb);
1670         }
1671
1672         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1673                    "cmd pdev get temperature for pdev_id %d\n", ar->pdev->pdev_id);
1674
1675         return ret;
1676 }
1677
1678 int ath11k_wmi_send_bcn_offload_control_cmd(struct ath11k *ar,
1679                                             u32 vdev_id, u32 bcn_ctrl_op)
1680 {
1681         struct ath11k_pdev_wmi *wmi = ar->wmi;
1682         struct wmi_bcn_offload_ctrl_cmd *cmd;
1683         struct sk_buff *skb;
1684         int ret;
1685
1686         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1687         if (!skb)
1688                 return -ENOMEM;
1689
1690         cmd = (struct wmi_bcn_offload_ctrl_cmd *)skb->data;
1691         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1692                                      WMI_TAG_BCN_OFFLOAD_CTRL_CMD) |
1693                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1694
1695         cmd->vdev_id = vdev_id;
1696         cmd->bcn_ctrl_op = bcn_ctrl_op;
1697
1698         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_BCN_OFFLOAD_CTRL_CMDID);
1699         if (ret) {
1700                 ath11k_warn(ar->ab,
1701                             "failed to send WMI_BCN_OFFLOAD_CTRL_CMDID\n");
1702                 dev_kfree_skb(skb);
1703         }
1704
1705         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1706                    "cmd bcn offload ctrl vdev id %d ctrl_op %d\n",
1707                    vdev_id, bcn_ctrl_op);
1708
1709         return ret;
1710 }
1711
1712 int ath11k_wmi_p2p_go_bcn_ie(struct ath11k *ar, u32 vdev_id,
1713                              const u8 *p2p_ie)
1714 {
1715         struct ath11k_pdev_wmi *wmi = ar->wmi;
1716         struct wmi_p2p_go_set_beacon_ie_cmd *cmd;
1717         size_t p2p_ie_len, aligned_len;
1718         struct wmi_tlv *tlv;
1719         struct sk_buff *skb;
1720         int ret, len;
1721
1722         p2p_ie_len = p2p_ie[1] + 2;
1723         aligned_len = roundup(p2p_ie_len, 4);
1724
1725         len = sizeof(*cmd) + TLV_HDR_SIZE + aligned_len;
1726
1727         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
1728         if (!skb)
1729                 return -ENOMEM;
1730
1731         cmd = (struct wmi_p2p_go_set_beacon_ie_cmd *)skb->data;
1732         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_P2P_GO_SET_BEACON_IE) |
1733                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1734         cmd->vdev_id = vdev_id;
1735         cmd->ie_buf_len = p2p_ie_len;
1736
1737         tlv = (struct wmi_tlv *)cmd->tlv;
1738         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
1739                       FIELD_PREP(WMI_TLV_LEN, aligned_len);
1740         memcpy(tlv->value, p2p_ie, p2p_ie_len);
1741
1742         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_P2P_GO_SET_BEACON_IE);
1743         if (ret) {
1744                 ath11k_warn(ar->ab, "failed to send WMI_P2P_GO_SET_BEACON_IE\n");
1745                 dev_kfree_skb(skb);
1746         }
1747
1748         return ret;
1749 }
1750
1751 int ath11k_wmi_bcn_tmpl(struct ath11k *ar, u32 vdev_id,
1752                         struct ieee80211_mutable_offsets *offs,
1753                         struct sk_buff *bcn, u32 ema_params)
1754 {
1755         struct ath11k_pdev_wmi *wmi = ar->wmi;
1756         struct wmi_bcn_tmpl_cmd *cmd;
1757         struct wmi_bcn_prb_info *bcn_prb_info;
1758         struct wmi_tlv *tlv;
1759         struct sk_buff *skb;
1760         void *ptr;
1761         int ret, len;
1762         size_t aligned_len = roundup(bcn->len, 4);
1763         struct ieee80211_vif *vif;
1764         struct ath11k_vif *arvif = ath11k_mac_get_arvif(ar, vdev_id);
1765
1766         if (!arvif) {
1767                 ath11k_warn(ar->ab, "failed to find arvif with vdev id %d\n", vdev_id);
1768                 return -EINVAL;
1769         }
1770
1771         vif = arvif->vif;
1772
1773         len = sizeof(*cmd) + sizeof(*bcn_prb_info) + TLV_HDR_SIZE + aligned_len;
1774
1775         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
1776         if (!skb)
1777                 return -ENOMEM;
1778
1779         cmd = (struct wmi_bcn_tmpl_cmd *)skb->data;
1780         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_BCN_TMPL_CMD) |
1781                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1782         cmd->vdev_id = vdev_id;
1783         cmd->tim_ie_offset = offs->tim_offset;
1784
1785         if (vif->bss_conf.csa_active) {
1786                 cmd->csa_switch_count_offset = offs->cntdwn_counter_offs[0];
1787                 cmd->ext_csa_switch_count_offset = offs->cntdwn_counter_offs[1];
1788         }
1789
1790         cmd->buf_len = bcn->len;
1791         cmd->mbssid_ie_offset = offs->mbssid_off;
1792         cmd->ema_params = ema_params;
1793
1794         ptr = skb->data + sizeof(*cmd);
1795
1796         bcn_prb_info = ptr;
1797         len = sizeof(*bcn_prb_info);
1798         bcn_prb_info->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1799                                               WMI_TAG_BCN_PRB_INFO) |
1800                                    FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
1801         bcn_prb_info->caps = 0;
1802         bcn_prb_info->erp = 0;
1803
1804         ptr += sizeof(*bcn_prb_info);
1805
1806         tlv = ptr;
1807         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
1808                       FIELD_PREP(WMI_TLV_LEN, aligned_len);
1809         memcpy(tlv->value, bcn->data, bcn->len);
1810
1811         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_BCN_TMPL_CMDID);
1812         if (ret) {
1813                 ath11k_warn(ar->ab, "failed to send WMI_BCN_TMPL_CMDID\n");
1814                 dev_kfree_skb(skb);
1815         }
1816
1817         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd bcn tmpl");
1818
1819         return ret;
1820 }
1821
1822 int ath11k_wmi_vdev_install_key(struct ath11k *ar,
1823                                 struct wmi_vdev_install_key_arg *arg)
1824 {
1825         struct ath11k_pdev_wmi *wmi = ar->wmi;
1826         struct wmi_vdev_install_key_cmd *cmd;
1827         struct wmi_tlv *tlv;
1828         struct sk_buff *skb;
1829         int ret, len;
1830         int key_len_aligned = roundup(arg->key_len, sizeof(uint32_t));
1831
1832         len = sizeof(*cmd) + TLV_HDR_SIZE + key_len_aligned;
1833
1834         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
1835         if (!skb)
1836                 return -ENOMEM;
1837
1838         cmd = (struct wmi_vdev_install_key_cmd *)skb->data;
1839         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_INSTALL_KEY_CMD) |
1840                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1841         cmd->vdev_id = arg->vdev_id;
1842         ether_addr_copy(cmd->peer_macaddr.addr, arg->macaddr);
1843         cmd->key_idx = arg->key_idx;
1844         cmd->key_flags = arg->key_flags;
1845         cmd->key_cipher = arg->key_cipher;
1846         cmd->key_len = arg->key_len;
1847         cmd->key_txmic_len = arg->key_txmic_len;
1848         cmd->key_rxmic_len = arg->key_rxmic_len;
1849
1850         if (arg->key_rsc_counter)
1851                 memcpy(&cmd->key_rsc_counter, &arg->key_rsc_counter,
1852                        sizeof(struct wmi_key_seq_counter));
1853
1854         tlv = (struct wmi_tlv *)(skb->data + sizeof(*cmd));
1855         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
1856                       FIELD_PREP(WMI_TLV_LEN, key_len_aligned);
1857         if (arg->key_data)
1858                 memcpy(tlv->value, (u8 *)arg->key_data, key_len_aligned);
1859
1860         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_INSTALL_KEY_CMDID);
1861         if (ret) {
1862                 ath11k_warn(ar->ab,
1863                             "failed to send WMI_VDEV_INSTALL_KEY cmd\n");
1864                 dev_kfree_skb(skb);
1865         }
1866
1867         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1868                    "cmd vdev install key idx %d cipher %d len %d\n",
1869                    arg->key_idx, arg->key_cipher, arg->key_len);
1870
1871         return ret;
1872 }
1873
1874 static inline void
1875 ath11k_wmi_copy_peer_flags(struct wmi_peer_assoc_complete_cmd *cmd,
1876                            struct peer_assoc_params *param,
1877                            bool hw_crypto_disabled)
1878 {
1879         cmd->peer_flags = 0;
1880
1881         if (param->is_wme_set) {
1882                 if (param->qos_flag)
1883                         cmd->peer_flags |= WMI_PEER_QOS;
1884                 if (param->apsd_flag)
1885                         cmd->peer_flags |= WMI_PEER_APSD;
1886                 if (param->ht_flag)
1887                         cmd->peer_flags |= WMI_PEER_HT;
1888                 if (param->bw_40)
1889                         cmd->peer_flags |= WMI_PEER_40MHZ;
1890                 if (param->bw_80)
1891                         cmd->peer_flags |= WMI_PEER_80MHZ;
1892                 if (param->bw_160)
1893                         cmd->peer_flags |= WMI_PEER_160MHZ;
1894
1895                 /* Typically if STBC is enabled for VHT it should be enabled
1896                  * for HT as well
1897                  **/
1898                 if (param->stbc_flag)
1899                         cmd->peer_flags |= WMI_PEER_STBC;
1900
1901                 /* Typically if LDPC is enabled for VHT it should be enabled
1902                  * for HT as well
1903                  **/
1904                 if (param->ldpc_flag)
1905                         cmd->peer_flags |= WMI_PEER_LDPC;
1906
1907                 if (param->static_mimops_flag)
1908                         cmd->peer_flags |= WMI_PEER_STATIC_MIMOPS;
1909                 if (param->dynamic_mimops_flag)
1910                         cmd->peer_flags |= WMI_PEER_DYN_MIMOPS;
1911                 if (param->spatial_mux_flag)
1912                         cmd->peer_flags |= WMI_PEER_SPATIAL_MUX;
1913                 if (param->vht_flag)
1914                         cmd->peer_flags |= WMI_PEER_VHT;
1915                 if (param->he_flag)
1916                         cmd->peer_flags |= WMI_PEER_HE;
1917                 if (param->twt_requester)
1918                         cmd->peer_flags |= WMI_PEER_TWT_REQ;
1919                 if (param->twt_responder)
1920                         cmd->peer_flags |= WMI_PEER_TWT_RESP;
1921         }
1922
1923         /* Suppress authorization for all AUTH modes that need 4-way handshake
1924          * (during re-association).
1925          * Authorization will be done for these modes on key installation.
1926          */
1927         if (param->auth_flag)
1928                 cmd->peer_flags |= WMI_PEER_AUTH;
1929         if (param->need_ptk_4_way) {
1930                 cmd->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1931                 if (!hw_crypto_disabled && param->is_assoc)
1932                         cmd->peer_flags &= ~WMI_PEER_AUTH;
1933         }
1934         if (param->need_gtk_2_way)
1935                 cmd->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1936         /* safe mode bypass the 4-way handshake */
1937         if (param->safe_mode_enabled)
1938                 cmd->peer_flags &= ~(WMI_PEER_NEED_PTK_4_WAY |
1939                                      WMI_PEER_NEED_GTK_2_WAY);
1940
1941         if (param->is_pmf_enabled)
1942                 cmd->peer_flags |= WMI_PEER_PMF;
1943
1944         /* Disable AMSDU for station transmit, if user configures it */
1945         /* Disable AMSDU for AP transmit to 11n Stations, if user configures
1946          * it
1947          * if (param->amsdu_disable) Add after FW support
1948          **/
1949
1950         /* Target asserts if node is marked HT and all MCS is set to 0.
1951          * Mark the node as non-HT if all the mcs rates are disabled through
1952          * iwpriv
1953          **/
1954         if (param->peer_ht_rates.num_rates == 0)
1955                 cmd->peer_flags &= ~WMI_PEER_HT;
1956 }
1957
1958 int ath11k_wmi_send_peer_assoc_cmd(struct ath11k *ar,
1959                                    struct peer_assoc_params *param)
1960 {
1961         struct ath11k_pdev_wmi *wmi = ar->wmi;
1962         struct wmi_peer_assoc_complete_cmd *cmd;
1963         struct wmi_vht_rate_set *mcs;
1964         struct wmi_he_rate_set *he_mcs;
1965         struct sk_buff *skb;
1966         struct wmi_tlv *tlv;
1967         void *ptr;
1968         u32 peer_legacy_rates_align;
1969         u32 peer_ht_rates_align;
1970         int i, ret, len;
1971
1972         peer_legacy_rates_align = roundup(param->peer_legacy_rates.num_rates,
1973                                           sizeof(u32));
1974         peer_ht_rates_align = roundup(param->peer_ht_rates.num_rates,
1975                                       sizeof(u32));
1976
1977         len = sizeof(*cmd) +
1978               TLV_HDR_SIZE + (peer_legacy_rates_align * sizeof(u8)) +
1979               TLV_HDR_SIZE + (peer_ht_rates_align * sizeof(u8)) +
1980               sizeof(*mcs) + TLV_HDR_SIZE +
1981               (sizeof(*he_mcs) * param->peer_he_mcs_count);
1982
1983         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
1984         if (!skb)
1985                 return -ENOMEM;
1986
1987         ptr = skb->data;
1988
1989         cmd = ptr;
1990         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1991                                      WMI_TAG_PEER_ASSOC_COMPLETE_CMD) |
1992                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1993
1994         cmd->vdev_id = param->vdev_id;
1995
1996         cmd->peer_new_assoc = param->peer_new_assoc;
1997         cmd->peer_associd = param->peer_associd;
1998
1999         ath11k_wmi_copy_peer_flags(cmd, param,
2000                                    test_bit(ATH11K_FLAG_HW_CRYPTO_DISABLED,
2001                                             &ar->ab->dev_flags));
2002
2003         ether_addr_copy(cmd->peer_macaddr.addr, param->peer_mac);
2004
2005         cmd->peer_rate_caps = param->peer_rate_caps;
2006         cmd->peer_caps = param->peer_caps;
2007         cmd->peer_listen_intval = param->peer_listen_intval;
2008         cmd->peer_ht_caps = param->peer_ht_caps;
2009         cmd->peer_max_mpdu = param->peer_max_mpdu;
2010         cmd->peer_mpdu_density = param->peer_mpdu_density;
2011         cmd->peer_vht_caps = param->peer_vht_caps;
2012         cmd->peer_phymode = param->peer_phymode;
2013
2014         /* Update 11ax capabilities */
2015         cmd->peer_he_cap_info = param->peer_he_cap_macinfo[0];
2016         cmd->peer_he_cap_info_ext = param->peer_he_cap_macinfo[1];
2017         cmd->peer_he_cap_info_internal = param->peer_he_cap_macinfo_internal;
2018         cmd->peer_he_caps_6ghz = param->peer_he_caps_6ghz;
2019         cmd->peer_he_ops = param->peer_he_ops;
2020         memcpy(&cmd->peer_he_cap_phy, &param->peer_he_cap_phyinfo,
2021                sizeof(param->peer_he_cap_phyinfo));
2022         memcpy(&cmd->peer_ppet, &param->peer_ppet,
2023                sizeof(param->peer_ppet));
2024
2025         /* Update peer legacy rate information */
2026         ptr += sizeof(*cmd);
2027
2028         tlv = ptr;
2029         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
2030                       FIELD_PREP(WMI_TLV_LEN, peer_legacy_rates_align);
2031
2032         ptr += TLV_HDR_SIZE;
2033
2034         cmd->num_peer_legacy_rates = param->peer_legacy_rates.num_rates;
2035         memcpy(ptr, param->peer_legacy_rates.rates,
2036                param->peer_legacy_rates.num_rates);
2037
2038         /* Update peer HT rate information */
2039         ptr += peer_legacy_rates_align;
2040
2041         tlv = ptr;
2042         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
2043                       FIELD_PREP(WMI_TLV_LEN, peer_ht_rates_align);
2044         ptr += TLV_HDR_SIZE;
2045         cmd->num_peer_ht_rates = param->peer_ht_rates.num_rates;
2046         memcpy(ptr, param->peer_ht_rates.rates,
2047                param->peer_ht_rates.num_rates);
2048
2049         /* VHT Rates */
2050         ptr += peer_ht_rates_align;
2051
2052         mcs = ptr;
2053
2054         mcs->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VHT_RATE_SET) |
2055                           FIELD_PREP(WMI_TLV_LEN, sizeof(*mcs) - TLV_HDR_SIZE);
2056
2057         cmd->peer_nss = param->peer_nss;
2058
2059         /* Update bandwidth-NSS mapping */
2060         cmd->peer_bw_rxnss_override = 0;
2061         cmd->peer_bw_rxnss_override |= param->peer_bw_rxnss_override;
2062
2063         if (param->vht_capable) {
2064                 mcs->rx_max_rate = param->rx_max_rate;
2065                 mcs->rx_mcs_set = param->rx_mcs_set;
2066                 mcs->tx_max_rate = param->tx_max_rate;
2067                 mcs->tx_mcs_set = param->tx_mcs_set;
2068         }
2069
2070         /* HE Rates */
2071         cmd->peer_he_mcs = param->peer_he_mcs_count;
2072         cmd->min_data_rate = param->min_data_rate;
2073
2074         ptr += sizeof(*mcs);
2075
2076         len = param->peer_he_mcs_count * sizeof(*he_mcs);
2077
2078         tlv = ptr;
2079         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
2080                       FIELD_PREP(WMI_TLV_LEN, len);
2081         ptr += TLV_HDR_SIZE;
2082
2083         /* Loop through the HE rate set */
2084         for (i = 0; i < param->peer_he_mcs_count; i++) {
2085                 he_mcs = ptr;
2086                 he_mcs->tlv_header = FIELD_PREP(WMI_TLV_TAG,
2087                                                 WMI_TAG_HE_RATE_SET) |
2088                                      FIELD_PREP(WMI_TLV_LEN,
2089                                                 sizeof(*he_mcs) - TLV_HDR_SIZE);
2090
2091                 he_mcs->rx_mcs_set = param->peer_he_tx_mcs_set[i];
2092                 he_mcs->tx_mcs_set = param->peer_he_rx_mcs_set[i];
2093                 ptr += sizeof(*he_mcs);
2094         }
2095
2096         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PEER_ASSOC_CMDID);
2097         if (ret) {
2098                 ath11k_warn(ar->ab,
2099                             "failed to send WMI_PEER_ASSOC_CMDID\n");
2100                 dev_kfree_skb(skb);
2101         }
2102
2103         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2104                    "cmd peer assoc vdev id %d assoc id %d peer mac %pM peer_flags %x rate_caps %x peer_caps %x listen_intval %d ht_caps %x max_mpdu %d nss %d phymode %d peer_mpdu_density %d vht_caps %x he cap_info %x he ops %x he cap_info_ext %x he phy %x %x %x peer_bw_rxnss_override %x\n",
2105                    cmd->vdev_id, cmd->peer_associd, param->peer_mac,
2106                    cmd->peer_flags, cmd->peer_rate_caps, cmd->peer_caps,
2107                    cmd->peer_listen_intval, cmd->peer_ht_caps,
2108                    cmd->peer_max_mpdu, cmd->peer_nss, cmd->peer_phymode,
2109                    cmd->peer_mpdu_density,
2110                    cmd->peer_vht_caps, cmd->peer_he_cap_info,
2111                    cmd->peer_he_ops, cmd->peer_he_cap_info_ext,
2112                    cmd->peer_he_cap_phy[0], cmd->peer_he_cap_phy[1],
2113                    cmd->peer_he_cap_phy[2],
2114                    cmd->peer_bw_rxnss_override);
2115
2116         return ret;
2117 }
2118
2119 void ath11k_wmi_start_scan_init(struct ath11k *ar,
2120                                 struct scan_req_params *arg)
2121 {
2122         /* setup commonly used values */
2123         arg->scan_req_id = 1;
2124         if (ar->state_11d == ATH11K_11D_PREPARING)
2125                 arg->scan_priority = WMI_SCAN_PRIORITY_MEDIUM;
2126         else
2127                 arg->scan_priority = WMI_SCAN_PRIORITY_LOW;
2128         arg->dwell_time_active = 50;
2129         arg->dwell_time_active_2g = 0;
2130         arg->dwell_time_passive = 150;
2131         arg->dwell_time_active_6g = 40;
2132         arg->dwell_time_passive_6g = 30;
2133         arg->min_rest_time = 50;
2134         arg->max_rest_time = 500;
2135         arg->repeat_probe_time = 0;
2136         arg->probe_spacing_time = 0;
2137         arg->idle_time = 0;
2138         arg->max_scan_time = 20000;
2139         arg->probe_delay = 5;
2140         arg->notify_scan_events = WMI_SCAN_EVENT_STARTED |
2141                                   WMI_SCAN_EVENT_COMPLETED |
2142                                   WMI_SCAN_EVENT_BSS_CHANNEL |
2143                                   WMI_SCAN_EVENT_FOREIGN_CHAN |
2144                                   WMI_SCAN_EVENT_DEQUEUED;
2145         arg->scan_f_chan_stat_evnt = 1;
2146
2147         if (test_bit(WMI_TLV_SERVICE_PASSIVE_SCAN_START_TIME_ENHANCE,
2148                      ar->ab->wmi_ab.svc_map))
2149                 arg->scan_ctrl_flags_ext |=
2150                         WMI_SCAN_FLAG_EXT_PASSIVE_SCAN_START_TIME_ENHANCE;
2151
2152         arg->num_bssid = 1;
2153
2154         /* fill bssid_list[0] with 0xff, otherwise bssid and RA will be
2155          * ZEROs in probe request
2156          */
2157         eth_broadcast_addr(arg->bssid_list[0].addr);
2158 }
2159
2160 static inline void
2161 ath11k_wmi_copy_scan_event_cntrl_flags(struct wmi_start_scan_cmd *cmd,
2162                                        struct scan_req_params *param)
2163 {
2164         /* Scan events subscription */
2165         if (param->scan_ev_started)
2166                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_STARTED;
2167         if (param->scan_ev_completed)
2168                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_COMPLETED;
2169         if (param->scan_ev_bss_chan)
2170                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_BSS_CHANNEL;
2171         if (param->scan_ev_foreign_chan)
2172                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_FOREIGN_CHAN;
2173         if (param->scan_ev_dequeued)
2174                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_DEQUEUED;
2175         if (param->scan_ev_preempted)
2176                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_PREEMPTED;
2177         if (param->scan_ev_start_failed)
2178                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_START_FAILED;
2179         if (param->scan_ev_restarted)
2180                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_RESTARTED;
2181         if (param->scan_ev_foreign_chn_exit)
2182                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_FOREIGN_CHAN_EXIT;
2183         if (param->scan_ev_suspended)
2184                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_SUSPENDED;
2185         if (param->scan_ev_resumed)
2186                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_RESUMED;
2187
2188         /** Set scan control flags */
2189         cmd->scan_ctrl_flags = 0;
2190         if (param->scan_f_passive)
2191                 cmd->scan_ctrl_flags |=  WMI_SCAN_FLAG_PASSIVE;
2192         if (param->scan_f_strict_passive_pch)
2193                 cmd->scan_ctrl_flags |=  WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN;
2194         if (param->scan_f_promisc_mode)
2195                 cmd->scan_ctrl_flags |=  WMI_SCAN_FILTER_PROMISCUOS;
2196         if (param->scan_f_capture_phy_err)
2197                 cmd->scan_ctrl_flags |=  WMI_SCAN_CAPTURE_PHY_ERROR;
2198         if (param->scan_f_half_rate)
2199                 cmd->scan_ctrl_flags |=  WMI_SCAN_FLAG_HALF_RATE_SUPPORT;
2200         if (param->scan_f_quarter_rate)
2201                 cmd->scan_ctrl_flags |=  WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT;
2202         if (param->scan_f_cck_rates)
2203                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_CCK_RATES;
2204         if (param->scan_f_ofdm_rates)
2205                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_OFDM_RATES;
2206         if (param->scan_f_chan_stat_evnt)
2207                 cmd->scan_ctrl_flags |=  WMI_SCAN_CHAN_STAT_EVENT;
2208         if (param->scan_f_filter_prb_req)
2209                 cmd->scan_ctrl_flags |=  WMI_SCAN_FILTER_PROBE_REQ;
2210         if (param->scan_f_bcast_probe)
2211                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_BCAST_PROBE_REQ;
2212         if (param->scan_f_offchan_mgmt_tx)
2213                 cmd->scan_ctrl_flags |=  WMI_SCAN_OFFCHAN_MGMT_TX;
2214         if (param->scan_f_offchan_data_tx)
2215                 cmd->scan_ctrl_flags |=  WMI_SCAN_OFFCHAN_DATA_TX;
2216         if (param->scan_f_force_active_dfs_chn)
2217                 cmd->scan_ctrl_flags |=  WMI_SCAN_FLAG_FORCE_ACTIVE_ON_DFS;
2218         if (param->scan_f_add_tpc_ie_in_probe)
2219                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_TPC_IE_IN_PROBE_REQ;
2220         if (param->scan_f_add_ds_ie_in_probe)
2221                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_DS_IE_IN_PROBE_REQ;
2222         if (param->scan_f_add_spoofed_mac_in_probe)
2223                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_SPOOF_MAC_IN_PROBE_REQ;
2224         if (param->scan_f_add_rand_seq_in_probe)
2225                 cmd->scan_ctrl_flags |=  WMI_SCAN_RANDOM_SEQ_NO_IN_PROBE_REQ;
2226         if (param->scan_f_en_ie_whitelist_in_probe)
2227                 cmd->scan_ctrl_flags |=
2228                          WMI_SCAN_ENABLE_IE_WHTELIST_IN_PROBE_REQ;
2229
2230         /* for adaptive scan mode using 3 bits (21 - 23 bits) */
2231         WMI_SCAN_SET_DWELL_MODE(cmd->scan_ctrl_flags,
2232                                 param->adaptive_dwell_time_mode);
2233
2234         cmd->scan_ctrl_flags_ext = param->scan_ctrl_flags_ext;
2235 }
2236
2237 int ath11k_wmi_send_scan_start_cmd(struct ath11k *ar,
2238                                    struct scan_req_params *params)
2239 {
2240         struct ath11k_pdev_wmi *wmi = ar->wmi;
2241         struct wmi_start_scan_cmd *cmd;
2242         struct wmi_ssid *ssid = NULL;
2243         struct wmi_mac_addr *bssid;
2244         struct sk_buff *skb;
2245         struct wmi_tlv *tlv;
2246         void *ptr;
2247         int i, ret, len;
2248         u32 *tmp_ptr;
2249         u16 extraie_len_with_pad = 0;
2250         struct hint_short_ssid *s_ssid = NULL;
2251         struct hint_bssid *hint_bssid = NULL;
2252
2253         len = sizeof(*cmd);
2254
2255         len += TLV_HDR_SIZE;
2256         if (params->num_chan)
2257                 len += params->num_chan * sizeof(u32);
2258
2259         len += TLV_HDR_SIZE;
2260         if (params->num_ssids)
2261                 len += params->num_ssids * sizeof(*ssid);
2262
2263         len += TLV_HDR_SIZE;
2264         if (params->num_bssid)
2265                 len += sizeof(*bssid) * params->num_bssid;
2266
2267         len += TLV_HDR_SIZE;
2268         if (params->extraie.len && params->extraie.len <= 0xFFFF)
2269                 extraie_len_with_pad =
2270                         roundup(params->extraie.len, sizeof(u32));
2271         len += extraie_len_with_pad;
2272
2273         if (params->num_hint_bssid)
2274                 len += TLV_HDR_SIZE +
2275                        params->num_hint_bssid * sizeof(struct hint_bssid);
2276
2277         if (params->num_hint_s_ssid)
2278                 len += TLV_HDR_SIZE +
2279                        params->num_hint_s_ssid * sizeof(struct hint_short_ssid);
2280
2281         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2282         if (!skb)
2283                 return -ENOMEM;
2284
2285         ptr = skb->data;
2286
2287         cmd = ptr;
2288         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_START_SCAN_CMD) |
2289                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2290
2291         cmd->scan_id = params->scan_id;
2292         cmd->scan_req_id = params->scan_req_id;
2293         cmd->vdev_id = params->vdev_id;
2294         cmd->scan_priority = params->scan_priority;
2295         cmd->notify_scan_events = params->notify_scan_events;
2296
2297         ath11k_wmi_copy_scan_event_cntrl_flags(cmd, params);
2298
2299         cmd->dwell_time_active = params->dwell_time_active;
2300         cmd->dwell_time_active_2g = params->dwell_time_active_2g;
2301         cmd->dwell_time_passive = params->dwell_time_passive;
2302         cmd->dwell_time_active_6g = params->dwell_time_active_6g;
2303         cmd->dwell_time_passive_6g = params->dwell_time_passive_6g;
2304         cmd->min_rest_time = params->min_rest_time;
2305         cmd->max_rest_time = params->max_rest_time;
2306         cmd->repeat_probe_time = params->repeat_probe_time;
2307         cmd->probe_spacing_time = params->probe_spacing_time;
2308         cmd->idle_time = params->idle_time;
2309         cmd->max_scan_time = params->max_scan_time;
2310         cmd->probe_delay = params->probe_delay;
2311         cmd->burst_duration = params->burst_duration;
2312         cmd->num_chan = params->num_chan;
2313         cmd->num_bssid = params->num_bssid;
2314         cmd->num_ssids = params->num_ssids;
2315         cmd->ie_len = params->extraie.len;
2316         cmd->n_probes = params->n_probes;
2317         ether_addr_copy(cmd->mac_addr.addr, params->mac_addr.addr);
2318         ether_addr_copy(cmd->mac_mask.addr, params->mac_mask.addr);
2319
2320         ptr += sizeof(*cmd);
2321
2322         len = params->num_chan * sizeof(u32);
2323
2324         tlv = ptr;
2325         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_UINT32) |
2326                       FIELD_PREP(WMI_TLV_LEN, len);
2327         ptr += TLV_HDR_SIZE;
2328         tmp_ptr = ptr;
2329
2330         for (i = 0; i < params->num_chan; ++i)
2331                 tmp_ptr[i] = params->chan_list[i];
2332
2333         ptr += len;
2334
2335         len = params->num_ssids * sizeof(*ssid);
2336         tlv = ptr;
2337         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_FIXED_STRUCT) |
2338                       FIELD_PREP(WMI_TLV_LEN, len);
2339
2340         ptr += TLV_HDR_SIZE;
2341
2342         if (params->num_ssids) {
2343                 ssid = ptr;
2344                 for (i = 0; i < params->num_ssids; ++i) {
2345                         ssid->ssid_len = params->ssid[i].length;
2346                         memcpy(ssid->ssid, params->ssid[i].ssid,
2347                                params->ssid[i].length);
2348                         ssid++;
2349                 }
2350         }
2351
2352         ptr += (params->num_ssids * sizeof(*ssid));
2353         len = params->num_bssid * sizeof(*bssid);
2354         tlv = ptr;
2355         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_FIXED_STRUCT) |
2356                       FIELD_PREP(WMI_TLV_LEN, len);
2357
2358         ptr += TLV_HDR_SIZE;
2359         bssid = ptr;
2360
2361         if (params->num_bssid) {
2362                 for (i = 0; i < params->num_bssid; ++i) {
2363                         ether_addr_copy(bssid->addr,
2364                                         params->bssid_list[i].addr);
2365                         bssid++;
2366                 }
2367         }
2368
2369         ptr += params->num_bssid * sizeof(*bssid);
2370
2371         len = extraie_len_with_pad;
2372         tlv = ptr;
2373         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
2374                       FIELD_PREP(WMI_TLV_LEN, len);
2375         ptr += TLV_HDR_SIZE;
2376
2377         if (extraie_len_with_pad)
2378                 memcpy(ptr, params->extraie.ptr,
2379                        params->extraie.len);
2380
2381         ptr += extraie_len_with_pad;
2382
2383         if (params->num_hint_s_ssid) {
2384                 len = params->num_hint_s_ssid * sizeof(struct hint_short_ssid);
2385                 tlv = ptr;
2386                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_FIXED_STRUCT) |
2387                               FIELD_PREP(WMI_TLV_LEN, len);
2388                 ptr += TLV_HDR_SIZE;
2389                 s_ssid = ptr;
2390                 for (i = 0; i < params->num_hint_s_ssid; ++i) {
2391                         s_ssid->freq_flags = params->hint_s_ssid[i].freq_flags;
2392                         s_ssid->short_ssid = params->hint_s_ssid[i].short_ssid;
2393                         s_ssid++;
2394                 }
2395                 ptr += len;
2396         }
2397
2398         if (params->num_hint_bssid) {
2399                 len = params->num_hint_bssid * sizeof(struct hint_bssid);
2400                 tlv = ptr;
2401                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_FIXED_STRUCT) |
2402                               FIELD_PREP(WMI_TLV_LEN, len);
2403                 ptr += TLV_HDR_SIZE;
2404                 hint_bssid = ptr;
2405                 for (i = 0; i < params->num_hint_bssid; ++i) {
2406                         hint_bssid->freq_flags =
2407                                 params->hint_bssid[i].freq_flags;
2408                         ether_addr_copy(&params->hint_bssid[i].bssid.addr[0],
2409                                         &hint_bssid->bssid.addr[0]);
2410                         hint_bssid++;
2411                 }
2412         }
2413
2414         ret = ath11k_wmi_cmd_send(wmi, skb,
2415                                   WMI_START_SCAN_CMDID);
2416         if (ret) {
2417                 ath11k_warn(ar->ab, "failed to send WMI_START_SCAN_CMDID\n");
2418                 dev_kfree_skb(skb);
2419         }
2420
2421         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd start scan");
2422
2423         return ret;
2424 }
2425
2426 int ath11k_wmi_send_vdev_set_tpc_power(struct ath11k *ar,
2427                                        u32 vdev_id,
2428                                        struct ath11k_reg_tpc_power_info *param)
2429 {
2430         struct ath11k_pdev_wmi *wmi = ar->wmi;
2431         struct wmi_vdev_set_tpc_power_cmd *cmd;
2432         struct wmi_vdev_ch_power_info *ch;
2433         struct sk_buff *skb;
2434         struct wmi_tlv *tlv;
2435         u8 *ptr;
2436         int i, ret, len, array_len;
2437
2438         array_len = sizeof(*ch) * param->num_pwr_levels;
2439         len = sizeof(*cmd) + TLV_HDR_SIZE + array_len;
2440
2441         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2442         if (!skb)
2443                 return -ENOMEM;
2444
2445         ptr = skb->data;
2446
2447         cmd = (struct wmi_vdev_set_tpc_power_cmd *)ptr;
2448         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_SET_TPC_POWER_CMD) |
2449                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2450         cmd->vdev_id = vdev_id;
2451         cmd->psd_power = param->is_psd_power;
2452         cmd->eirp_power = param->eirp_power;
2453         cmd->power_type_6ghz = param->ap_power_type;
2454
2455         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2456                    "tpc vdev id %d is psd power %d eirp power %d 6 ghz power type %d\n",
2457                    vdev_id, param->is_psd_power, param->eirp_power, param->ap_power_type);
2458
2459         ptr += sizeof(*cmd);
2460         tlv = (struct wmi_tlv *)ptr;
2461         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
2462                       FIELD_PREP(WMI_TLV_LEN, array_len);
2463
2464         ptr += TLV_HDR_SIZE;
2465         ch = (struct wmi_vdev_ch_power_info *)ptr;
2466
2467         for (i = 0; i < param->num_pwr_levels; i++, ch++) {
2468                 ch->tlv_header = FIELD_PREP(WMI_TLV_TAG,
2469                                             WMI_TAG_VDEV_CH_POWER_INFO) |
2470                                 FIELD_PREP(WMI_TLV_LEN,
2471                                            sizeof(*ch) - TLV_HDR_SIZE);
2472
2473                 ch->chan_cfreq = param->chan_power_info[i].chan_cfreq;
2474                 ch->tx_power = param->chan_power_info[i].tx_power;
2475
2476                 ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "tpc chan freq %d TX power %d\n",
2477                            ch->chan_cfreq, ch->tx_power);
2478         }
2479
2480         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_SET_TPC_POWER_CMDID);
2481         if (ret) {
2482                 ath11k_warn(ar->ab, "failed to send WMI_VDEV_SET_TPC_POWER_CMDID\n");
2483                 dev_kfree_skb(skb);
2484                 return ret;
2485         }
2486
2487         return 0;
2488 }
2489
2490 int ath11k_wmi_send_scan_stop_cmd(struct ath11k *ar,
2491                                   struct scan_cancel_param *param)
2492 {
2493         struct ath11k_pdev_wmi *wmi = ar->wmi;
2494         struct wmi_stop_scan_cmd *cmd;
2495         struct sk_buff *skb;
2496         int ret;
2497
2498         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2499         if (!skb)
2500                 return -ENOMEM;
2501
2502         cmd = (struct wmi_stop_scan_cmd *)skb->data;
2503
2504         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_STOP_SCAN_CMD) |
2505                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2506
2507         cmd->vdev_id = param->vdev_id;
2508         cmd->requestor = param->requester;
2509         cmd->scan_id = param->scan_id;
2510         cmd->pdev_id = param->pdev_id;
2511         /* stop the scan with the corresponding scan_id */
2512         if (param->req_type == WLAN_SCAN_CANCEL_PDEV_ALL) {
2513                 /* Cancelling all scans */
2514                 cmd->req_type =  WMI_SCAN_STOP_ALL;
2515         } else if (param->req_type == WLAN_SCAN_CANCEL_VDEV_ALL) {
2516                 /* Cancelling VAP scans */
2517                 cmd->req_type =  WMI_SCN_STOP_VAP_ALL;
2518         } else if (param->req_type == WLAN_SCAN_CANCEL_SINGLE) {
2519                 /* Cancelling specific scan */
2520                 cmd->req_type =  WMI_SCAN_STOP_ONE;
2521         } else {
2522                 ath11k_warn(ar->ab, "invalid scan cancel param %d",
2523                             param->req_type);
2524                 dev_kfree_skb(skb);
2525                 return -EINVAL;
2526         }
2527
2528         ret = ath11k_wmi_cmd_send(wmi, skb,
2529                                   WMI_STOP_SCAN_CMDID);
2530         if (ret) {
2531                 ath11k_warn(ar->ab, "failed to send WMI_STOP_SCAN_CMDID\n");
2532                 dev_kfree_skb(skb);
2533         }
2534
2535         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd stop scan");
2536
2537         return ret;
2538 }
2539
2540 int ath11k_wmi_send_scan_chan_list_cmd(struct ath11k *ar,
2541                                        struct scan_chan_list_params *chan_list)
2542 {
2543         struct ath11k_pdev_wmi *wmi = ar->wmi;
2544         struct wmi_scan_chan_list_cmd *cmd;
2545         struct sk_buff *skb;
2546         struct wmi_channel *chan_info;
2547         struct channel_param *tchan_info;
2548         struct wmi_tlv *tlv;
2549         void *ptr;
2550         int i, ret, len;
2551         u16 num_send_chans, num_sends = 0, max_chan_limit = 0;
2552         u32 *reg1, *reg2;
2553
2554         tchan_info = chan_list->ch_param;
2555         while (chan_list->nallchans) {
2556                 len = sizeof(*cmd) + TLV_HDR_SIZE;
2557                 max_chan_limit = (wmi->wmi_ab->max_msg_len[ar->pdev_idx] - len) /
2558                         sizeof(*chan_info);
2559
2560                 if (chan_list->nallchans > max_chan_limit)
2561                         num_send_chans = max_chan_limit;
2562                 else
2563                         num_send_chans = chan_list->nallchans;
2564
2565                 chan_list->nallchans -= num_send_chans;
2566                 len += sizeof(*chan_info) * num_send_chans;
2567
2568                 skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2569                 if (!skb)
2570                         return -ENOMEM;
2571
2572                 cmd = (struct wmi_scan_chan_list_cmd *)skb->data;
2573                 cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_SCAN_CHAN_LIST_CMD) |
2574                         FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2575                 cmd->pdev_id = chan_list->pdev_id;
2576                 cmd->num_scan_chans = num_send_chans;
2577                 if (num_sends)
2578                         cmd->flags |= WMI_APPEND_TO_EXISTING_CHAN_LIST_FLAG;
2579
2580                 ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2581                            "no.of chan = %d len = %d pdev_id = %d num_sends = %d\n",
2582                            num_send_chans, len, cmd->pdev_id, num_sends);
2583
2584                 ptr = skb->data + sizeof(*cmd);
2585
2586                 len = sizeof(*chan_info) * num_send_chans;
2587                 tlv = ptr;
2588                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
2589                               FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
2590                 ptr += TLV_HDR_SIZE;
2591
2592                 for (i = 0; i < num_send_chans; ++i) {
2593                         chan_info = ptr;
2594                         memset(chan_info, 0, sizeof(*chan_info));
2595                         len = sizeof(*chan_info);
2596                         chan_info->tlv_header = FIELD_PREP(WMI_TLV_TAG,
2597                                                            WMI_TAG_CHANNEL) |
2598                                                 FIELD_PREP(WMI_TLV_LEN,
2599                                                            len - TLV_HDR_SIZE);
2600
2601                         reg1 = &chan_info->reg_info_1;
2602                         reg2 = &chan_info->reg_info_2;
2603                         chan_info->mhz = tchan_info->mhz;
2604                         chan_info->band_center_freq1 = tchan_info->cfreq1;
2605                         chan_info->band_center_freq2 = tchan_info->cfreq2;
2606
2607                         if (tchan_info->is_chan_passive)
2608                                 chan_info->info |= WMI_CHAN_INFO_PASSIVE;
2609                         if (tchan_info->allow_he)
2610                                 chan_info->info |= WMI_CHAN_INFO_ALLOW_HE;
2611                         else if (tchan_info->allow_vht)
2612                                 chan_info->info |= WMI_CHAN_INFO_ALLOW_VHT;
2613                         else if (tchan_info->allow_ht)
2614                                 chan_info->info |= WMI_CHAN_INFO_ALLOW_HT;
2615                         if (tchan_info->half_rate)
2616                                 chan_info->info |= WMI_CHAN_INFO_HALF_RATE;
2617                         if (tchan_info->quarter_rate)
2618                                 chan_info->info |= WMI_CHAN_INFO_QUARTER_RATE;
2619                         if (tchan_info->psc_channel)
2620                                 chan_info->info |= WMI_CHAN_INFO_PSC;
2621                         if (tchan_info->dfs_set)
2622                                 chan_info->info |= WMI_CHAN_INFO_DFS;
2623
2624                         chan_info->info |= FIELD_PREP(WMI_CHAN_INFO_MODE,
2625                                                       tchan_info->phy_mode);
2626                         *reg1 |= FIELD_PREP(WMI_CHAN_REG_INFO1_MIN_PWR,
2627                                             tchan_info->minpower);
2628                         *reg1 |= FIELD_PREP(WMI_CHAN_REG_INFO1_MAX_PWR,
2629                                             tchan_info->maxpower);
2630                         *reg1 |= FIELD_PREP(WMI_CHAN_REG_INFO1_MAX_REG_PWR,
2631                                             tchan_info->maxregpower);
2632                         *reg1 |= FIELD_PREP(WMI_CHAN_REG_INFO1_REG_CLS,
2633                                             tchan_info->reg_class_id);
2634                         *reg2 |= FIELD_PREP(WMI_CHAN_REG_INFO2_ANT_MAX,
2635                                             tchan_info->antennamax);
2636                         *reg2 |= FIELD_PREP(WMI_CHAN_REG_INFO2_MAX_TX_PWR,
2637                                             tchan_info->maxregpower);
2638
2639                         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2640                                    "chan scan list chan[%d] = %u, chan_info->info %8x\n",
2641                                    i, chan_info->mhz, chan_info->info);
2642
2643                         ptr += sizeof(*chan_info);
2644
2645                         tchan_info++;
2646                 }
2647
2648                 ret = ath11k_wmi_cmd_send(wmi, skb, WMI_SCAN_CHAN_LIST_CMDID);
2649                 if (ret) {
2650                         ath11k_warn(ar->ab, "failed to send WMI_SCAN_CHAN_LIST cmd\n");
2651                         dev_kfree_skb(skb);
2652                         return ret;
2653                 }
2654
2655                 ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd scan chan list channels %d",
2656                            num_send_chans);
2657
2658                 num_sends++;
2659         }
2660
2661         return 0;
2662 }
2663
2664 int ath11k_wmi_send_wmm_update_cmd_tlv(struct ath11k *ar, u32 vdev_id,
2665                                        struct wmi_wmm_params_all_arg *param)
2666 {
2667         struct ath11k_pdev_wmi *wmi = ar->wmi;
2668         struct wmi_vdev_set_wmm_params_cmd *cmd;
2669         struct wmi_wmm_params *wmm_param;
2670         struct wmi_wmm_params_arg *wmi_wmm_arg;
2671         struct sk_buff *skb;
2672         int ret, ac;
2673
2674         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2675         if (!skb)
2676                 return -ENOMEM;
2677
2678         cmd = (struct wmi_vdev_set_wmm_params_cmd *)skb->data;
2679         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
2680                                      WMI_TAG_VDEV_SET_WMM_PARAMS_CMD) |
2681                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2682
2683         cmd->vdev_id = vdev_id;
2684         cmd->wmm_param_type = 0;
2685
2686         for (ac = 0; ac < WME_NUM_AC; ac++) {
2687                 switch (ac) {
2688                 case WME_AC_BE:
2689                         wmi_wmm_arg = &param->ac_be;
2690                         break;
2691                 case WME_AC_BK:
2692                         wmi_wmm_arg = &param->ac_bk;
2693                         break;
2694                 case WME_AC_VI:
2695                         wmi_wmm_arg = &param->ac_vi;
2696                         break;
2697                 case WME_AC_VO:
2698                         wmi_wmm_arg = &param->ac_vo;
2699                         break;
2700                 }
2701
2702                 wmm_param = (struct wmi_wmm_params *)&cmd->wmm_params[ac];
2703                 wmm_param->tlv_header =
2704                                 FIELD_PREP(WMI_TLV_TAG,
2705                                            WMI_TAG_VDEV_SET_WMM_PARAMS_CMD) |
2706                                 FIELD_PREP(WMI_TLV_LEN,
2707                                            sizeof(*wmm_param) - TLV_HDR_SIZE);
2708
2709                 wmm_param->aifs = wmi_wmm_arg->aifs;
2710                 wmm_param->cwmin = wmi_wmm_arg->cwmin;
2711                 wmm_param->cwmax = wmi_wmm_arg->cwmax;
2712                 wmm_param->txoplimit = wmi_wmm_arg->txop;
2713                 wmm_param->acm = wmi_wmm_arg->acm;
2714                 wmm_param->no_ack = wmi_wmm_arg->no_ack;
2715
2716                 ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2717                            "wmm set ac %d aifs %d cwmin %d cwmax %d txop %d acm %d no_ack %d\n",
2718                            ac, wmm_param->aifs, wmm_param->cwmin,
2719                            wmm_param->cwmax, wmm_param->txoplimit,
2720                            wmm_param->acm, wmm_param->no_ack);
2721         }
2722         ret = ath11k_wmi_cmd_send(wmi, skb,
2723                                   WMI_VDEV_SET_WMM_PARAMS_CMDID);
2724         if (ret) {
2725                 ath11k_warn(ar->ab,
2726                             "failed to send WMI_VDEV_SET_WMM_PARAMS_CMDID");
2727                 dev_kfree_skb(skb);
2728         }
2729
2730         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd vdev set wmm params");
2731
2732         return ret;
2733 }
2734
2735 int ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(struct ath11k *ar,
2736                                                   u32 pdev_id)
2737 {
2738         struct ath11k_pdev_wmi *wmi = ar->wmi;
2739         struct wmi_dfs_phyerr_offload_cmd *cmd;
2740         struct sk_buff *skb;
2741         int ret;
2742
2743         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2744         if (!skb)
2745                 return -ENOMEM;
2746
2747         cmd = (struct wmi_dfs_phyerr_offload_cmd *)skb->data;
2748         cmd->tlv_header =
2749                 FIELD_PREP(WMI_TLV_TAG,
2750                            WMI_TAG_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMD) |
2751                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2752
2753         cmd->pdev_id = pdev_id;
2754
2755         ret = ath11k_wmi_cmd_send(wmi, skb,
2756                                   WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMDID);
2757         if (ret) {
2758                 ath11k_warn(ar->ab,
2759                             "failed to send WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE cmd\n");
2760                 dev_kfree_skb(skb);
2761         }
2762
2763         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2764                    "cmd pdev dfs phyerr offload enable pdev id %d\n", pdev_id);
2765
2766         return ret;
2767 }
2768
2769 int ath11k_wmi_delba_send(struct ath11k *ar, u32 vdev_id, const u8 *mac,
2770                           u32 tid, u32 initiator, u32 reason)
2771 {
2772         struct ath11k_pdev_wmi *wmi = ar->wmi;
2773         struct wmi_delba_send_cmd *cmd;
2774         struct sk_buff *skb;
2775         int ret;
2776
2777         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2778         if (!skb)
2779                 return -ENOMEM;
2780
2781         cmd = (struct wmi_delba_send_cmd *)skb->data;
2782         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_DELBA_SEND_CMD) |
2783                         FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2784         cmd->vdev_id = vdev_id;
2785         ether_addr_copy(cmd->peer_macaddr.addr, mac);
2786         cmd->tid = tid;
2787         cmd->initiator = initiator;
2788         cmd->reasoncode = reason;
2789
2790         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_DELBA_SEND_CMDID);
2791
2792         if (ret) {
2793                 ath11k_warn(ar->ab,
2794                             "failed to send WMI_DELBA_SEND_CMDID cmd\n");
2795                 dev_kfree_skb(skb);
2796         }
2797
2798         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2799                    "cmd delba send vdev_id 0x%X mac_addr %pM tid %u initiator %u reason %u\n",
2800                    vdev_id, mac, tid, initiator, reason);
2801
2802         return ret;
2803 }
2804
2805 int ath11k_wmi_addba_set_resp(struct ath11k *ar, u32 vdev_id, const u8 *mac,
2806                               u32 tid, u32 status)
2807 {
2808         struct ath11k_pdev_wmi *wmi = ar->wmi;
2809         struct wmi_addba_setresponse_cmd *cmd;
2810         struct sk_buff *skb;
2811         int ret;
2812
2813         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2814         if (!skb)
2815                 return -ENOMEM;
2816
2817         cmd = (struct wmi_addba_setresponse_cmd *)skb->data;
2818         cmd->tlv_header =
2819                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ADDBA_SETRESPONSE_CMD) |
2820                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2821         cmd->vdev_id = vdev_id;
2822         ether_addr_copy(cmd->peer_macaddr.addr, mac);
2823         cmd->tid = tid;
2824         cmd->statuscode = status;
2825
2826         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_ADDBA_SET_RESP_CMDID);
2827
2828         if (ret) {
2829                 ath11k_warn(ar->ab,
2830                             "failed to send WMI_ADDBA_SET_RESP_CMDID cmd\n");
2831                 dev_kfree_skb(skb);
2832         }
2833
2834         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2835                    "cmd addba set resp vdev_id 0x%X mac_addr %pM tid %u status %u\n",
2836                    vdev_id, mac, tid, status);
2837
2838         return ret;
2839 }
2840
2841 int ath11k_wmi_addba_send(struct ath11k *ar, u32 vdev_id, const u8 *mac,
2842                           u32 tid, u32 buf_size)
2843 {
2844         struct ath11k_pdev_wmi *wmi = ar->wmi;
2845         struct wmi_addba_send_cmd *cmd;
2846         struct sk_buff *skb;
2847         int ret;
2848
2849         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2850         if (!skb)
2851                 return -ENOMEM;
2852
2853         cmd = (struct wmi_addba_send_cmd *)skb->data;
2854         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ADDBA_SEND_CMD) |
2855                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2856         cmd->vdev_id = vdev_id;
2857         ether_addr_copy(cmd->peer_macaddr.addr, mac);
2858         cmd->tid = tid;
2859         cmd->buffersize = buf_size;
2860
2861         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_ADDBA_SEND_CMDID);
2862
2863         if (ret) {
2864                 ath11k_warn(ar->ab,
2865                             "failed to send WMI_ADDBA_SEND_CMDID cmd\n");
2866                 dev_kfree_skb(skb);
2867         }
2868
2869         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2870                    "cmd addba send vdev_id 0x%X mac_addr %pM tid %u bufsize %u\n",
2871                    vdev_id, mac, tid, buf_size);
2872
2873         return ret;
2874 }
2875
2876 int ath11k_wmi_addba_clear_resp(struct ath11k *ar, u32 vdev_id, const u8 *mac)
2877 {
2878         struct ath11k_pdev_wmi *wmi = ar->wmi;
2879         struct wmi_addba_clear_resp_cmd *cmd;
2880         struct sk_buff *skb;
2881         int ret;
2882
2883         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2884         if (!skb)
2885                 return -ENOMEM;
2886
2887         cmd = (struct wmi_addba_clear_resp_cmd *)skb->data;
2888         cmd->tlv_header =
2889                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ADDBA_CLEAR_RESP_CMD) |
2890                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2891         cmd->vdev_id = vdev_id;
2892         ether_addr_copy(cmd->peer_macaddr.addr, mac);
2893
2894         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_ADDBA_CLEAR_RESP_CMDID);
2895
2896         if (ret) {
2897                 ath11k_warn(ar->ab,
2898                             "failed to send WMI_ADDBA_CLEAR_RESP_CMDID cmd\n");
2899                 dev_kfree_skb(skb);
2900         }
2901
2902         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2903                    "cmd addba clear resp vdev_id 0x%X mac_addr %pM\n",
2904                    vdev_id, mac);
2905
2906         return ret;
2907 }
2908
2909 int ath11k_wmi_pdev_peer_pktlog_filter(struct ath11k *ar, u8 *addr, u8 enable)
2910 {
2911         struct ath11k_pdev_wmi *wmi = ar->wmi;
2912         struct wmi_pdev_pktlog_filter_cmd *cmd;
2913         struct wmi_pdev_pktlog_filter_info *info;
2914         struct sk_buff *skb;
2915         struct wmi_tlv *tlv;
2916         void *ptr;
2917         int ret, len;
2918
2919         len = sizeof(*cmd) + sizeof(*info) + TLV_HDR_SIZE;
2920         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2921         if (!skb)
2922                 return -ENOMEM;
2923
2924         cmd = (struct wmi_pdev_pktlog_filter_cmd *)skb->data;
2925
2926         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_PEER_PKTLOG_FILTER_CMD) |
2927                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2928
2929         cmd->pdev_id = DP_HW2SW_MACID(ar->pdev->pdev_id);
2930         cmd->num_mac = 1;
2931         cmd->enable = enable;
2932
2933         ptr = skb->data + sizeof(*cmd);
2934
2935         tlv = ptr;
2936         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
2937                       FIELD_PREP(WMI_TLV_LEN, sizeof(*info));
2938
2939         ptr += TLV_HDR_SIZE;
2940         info = ptr;
2941
2942         ether_addr_copy(info->peer_macaddr.addr, addr);
2943         info->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_PEER_PKTLOG_FILTER_INFO) |
2944                            FIELD_PREP(WMI_TLV_LEN,
2945                                       sizeof(*info) - TLV_HDR_SIZE);
2946
2947         ret = ath11k_wmi_cmd_send(wmi, skb,
2948                                   WMI_PDEV_PKTLOG_FILTER_CMDID);
2949         if (ret) {
2950                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_PKTLOG_ENABLE_CMDID\n");
2951                 dev_kfree_skb(skb);
2952         }
2953
2954         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd pdev pktlog filter");
2955
2956         return ret;
2957 }
2958
2959 int
2960 ath11k_wmi_send_init_country_cmd(struct ath11k *ar,
2961                                  struct wmi_init_country_params init_cc_params)
2962 {
2963         struct ath11k_pdev_wmi *wmi = ar->wmi;
2964         struct wmi_init_country_cmd *cmd;
2965         struct sk_buff *skb;
2966         int ret;
2967
2968         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2969         if (!skb)
2970                 return -ENOMEM;
2971
2972         cmd = (struct wmi_init_country_cmd *)skb->data;
2973         cmd->tlv_header =
2974                 FIELD_PREP(WMI_TLV_TAG,
2975                            WMI_TAG_SET_INIT_COUNTRY_CMD) |
2976                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2977
2978         cmd->pdev_id = ar->pdev->pdev_id;
2979
2980         switch (init_cc_params.flags) {
2981         case ALPHA_IS_SET:
2982                 cmd->init_cc_type = WMI_COUNTRY_INFO_TYPE_ALPHA;
2983                 memcpy((u8 *)&cmd->cc_info.alpha2,
2984                        init_cc_params.cc_info.alpha2, 3);
2985                 break;
2986         case CC_IS_SET:
2987                 cmd->init_cc_type = WMI_COUNTRY_INFO_TYPE_COUNTRY_CODE;
2988                 cmd->cc_info.country_code = init_cc_params.cc_info.country_code;
2989                 break;
2990         case REGDMN_IS_SET:
2991                 cmd->init_cc_type = WMI_COUNTRY_INFO_TYPE_REGDOMAIN;
2992                 cmd->cc_info.regdom_id = init_cc_params.cc_info.regdom_id;
2993                 break;
2994         default:
2995                 ath11k_warn(ar->ab, "unknown cc params flags: 0x%x",
2996                             init_cc_params.flags);
2997                 ret = -EINVAL;
2998                 goto err;
2999         }
3000
3001         ret = ath11k_wmi_cmd_send(wmi, skb,
3002                                   WMI_SET_INIT_COUNTRY_CMDID);
3003         if (ret) {
3004                 ath11k_warn(ar->ab,
3005                             "failed to send WMI_SET_INIT_COUNTRY CMD :%d\n",
3006                             ret);
3007                 goto err;
3008         }
3009
3010         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd set init country");
3011
3012         return 0;
3013
3014 err:
3015         dev_kfree_skb(skb);
3016         return ret;
3017 }
3018
3019 int ath11k_wmi_send_set_current_country_cmd(struct ath11k *ar,
3020                                             struct wmi_set_current_country_params *param)
3021 {
3022         struct ath11k_pdev_wmi *wmi = ar->wmi;
3023         struct wmi_set_current_country_cmd *cmd;
3024         struct sk_buff *skb;
3025         int ret;
3026
3027         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
3028         if (!skb)
3029                 return -ENOMEM;
3030
3031         cmd = (struct wmi_set_current_country_cmd *)skb->data;
3032         cmd->tlv_header =
3033                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_SET_CURRENT_COUNTRY_CMD) |
3034                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3035
3036         cmd->pdev_id = ar->pdev->pdev_id;
3037         memcpy(&cmd->new_alpha2, &param->alpha2, 3);
3038
3039         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_SET_CURRENT_COUNTRY_CMDID);
3040         if (ret) {
3041                 ath11k_warn(ar->ab,
3042                             "failed to send WMI_SET_CURRENT_COUNTRY_CMDID: %d\n", ret);
3043                 dev_kfree_skb(skb);
3044         }
3045
3046         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3047                    "cmd set current country pdev id %d alpha2 %c%c\n",
3048                    ar->pdev->pdev_id,
3049                    param->alpha2[0],
3050                    param->alpha2[1]);
3051
3052         return ret;
3053 }
3054
3055 int
3056 ath11k_wmi_send_thermal_mitigation_param_cmd(struct ath11k *ar,
3057                                              struct thermal_mitigation_params *param)
3058 {
3059         struct ath11k_pdev_wmi *wmi = ar->wmi;
3060         struct wmi_therm_throt_config_request_cmd *cmd;
3061         struct wmi_therm_throt_level_config_info *lvl_conf;
3062         struct wmi_tlv *tlv;
3063         struct sk_buff *skb;
3064         int i, ret, len;
3065
3066         len = sizeof(*cmd) + TLV_HDR_SIZE +
3067               THERMAL_LEVELS * sizeof(struct wmi_therm_throt_level_config_info);
3068
3069         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3070         if (!skb)
3071                 return -ENOMEM;
3072
3073         cmd = (struct wmi_therm_throt_config_request_cmd *)skb->data;
3074
3075         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_THERM_THROT_CONFIG_REQUEST) |
3076                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3077
3078         cmd->pdev_id = ar->pdev->pdev_id;
3079         cmd->enable = param->enable;
3080         cmd->dc = param->dc;
3081         cmd->dc_per_event = param->dc_per_event;
3082         cmd->therm_throt_levels = THERMAL_LEVELS;
3083
3084         tlv = (struct wmi_tlv *)(skb->data + sizeof(*cmd));
3085         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
3086                       FIELD_PREP(WMI_TLV_LEN,
3087                                  (THERMAL_LEVELS *
3088                                   sizeof(struct wmi_therm_throt_level_config_info)));
3089
3090         lvl_conf = (struct wmi_therm_throt_level_config_info *)(skb->data +
3091                                                                 sizeof(*cmd) +
3092                                                                 TLV_HDR_SIZE);
3093         for (i = 0; i < THERMAL_LEVELS; i++) {
3094                 lvl_conf->tlv_header =
3095                         FIELD_PREP(WMI_TLV_TAG, WMI_TAG_THERM_THROT_LEVEL_CONFIG_INFO) |
3096                         FIELD_PREP(WMI_TLV_LEN, sizeof(*lvl_conf) - TLV_HDR_SIZE);
3097
3098                 lvl_conf->temp_lwm = param->levelconf[i].tmplwm;
3099                 lvl_conf->temp_hwm = param->levelconf[i].tmphwm;
3100                 lvl_conf->dc_off_percent = param->levelconf[i].dcoffpercent;
3101                 lvl_conf->prio = param->levelconf[i].priority;
3102                 lvl_conf++;
3103         }
3104
3105         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_THERM_THROT_SET_CONF_CMDID);
3106         if (ret) {
3107                 ath11k_warn(ar->ab, "failed to send THERM_THROT_SET_CONF cmd\n");
3108                 dev_kfree_skb(skb);
3109         }
3110
3111         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3112                    "cmd therm throt set conf pdev_id %d enable %d dc %d dc_per_event %x levels %d\n",
3113                    ar->pdev->pdev_id, param->enable, param->dc,
3114                    param->dc_per_event, THERMAL_LEVELS);
3115
3116         return ret;
3117 }
3118
3119 int ath11k_wmi_send_11d_scan_start_cmd(struct ath11k *ar,
3120                                        struct wmi_11d_scan_start_params *param)
3121 {
3122         struct ath11k_pdev_wmi *wmi = ar->wmi;
3123         struct wmi_11d_scan_start_cmd *cmd;
3124         struct sk_buff *skb;
3125         int ret;
3126
3127         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
3128         if (!skb)
3129                 return -ENOMEM;
3130
3131         cmd = (struct wmi_11d_scan_start_cmd *)skb->data;
3132         cmd->tlv_header =
3133                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_11D_SCAN_START_CMD) |
3134                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3135
3136         cmd->vdev_id = param->vdev_id;
3137         cmd->scan_period_msec = param->scan_period_msec;
3138         cmd->start_interval_msec = param->start_interval_msec;
3139
3140         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_11D_SCAN_START_CMDID);
3141         if (ret) {
3142                 ath11k_warn(ar->ab,
3143                             "failed to send WMI_11D_SCAN_START_CMDID: %d\n", ret);
3144                 dev_kfree_skb(skb);
3145         }
3146
3147         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3148                    "cmd 11d scan start vdev id %d period %d ms internal %d ms\n",
3149                    cmd->vdev_id,
3150                    cmd->scan_period_msec,
3151                    cmd->start_interval_msec);
3152
3153         return ret;
3154 }
3155
3156 int ath11k_wmi_send_11d_scan_stop_cmd(struct ath11k *ar, u32 vdev_id)
3157 {
3158         struct ath11k_pdev_wmi *wmi = ar->wmi;
3159         struct wmi_11d_scan_stop_cmd *cmd;
3160         struct sk_buff *skb;
3161         int ret;
3162
3163         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
3164         if (!skb)
3165                 return -ENOMEM;
3166
3167         cmd = (struct wmi_11d_scan_stop_cmd *)skb->data;
3168         cmd->tlv_header =
3169                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_11D_SCAN_STOP_CMD) |
3170                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3171
3172         cmd->vdev_id = vdev_id;
3173
3174         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_11D_SCAN_STOP_CMDID);
3175         if (ret) {
3176                 ath11k_warn(ar->ab,
3177                             "failed to send WMI_11D_SCAN_STOP_CMDID: %d\n", ret);
3178                 dev_kfree_skb(skb);
3179         }
3180
3181         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3182                    "cmd 11d scan stop vdev id %d\n",
3183                    cmd->vdev_id);
3184
3185         return ret;
3186 }
3187
3188 int ath11k_wmi_pdev_pktlog_enable(struct ath11k *ar, u32 pktlog_filter)
3189 {
3190         struct ath11k_pdev_wmi *wmi = ar->wmi;
3191         struct wmi_pktlog_enable_cmd *cmd;
3192         struct sk_buff *skb;
3193         int ret;
3194
3195         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
3196         if (!skb)
3197                 return -ENOMEM;
3198
3199         cmd = (struct wmi_pktlog_enable_cmd *)skb->data;
3200
3201         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_PKTLOG_ENABLE_CMD) |
3202                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3203
3204         cmd->pdev_id = DP_HW2SW_MACID(ar->pdev->pdev_id);
3205         cmd->evlist = pktlog_filter;
3206         cmd->enable = ATH11K_WMI_PKTLOG_ENABLE_FORCE;
3207
3208         ret = ath11k_wmi_cmd_send(wmi, skb,
3209                                   WMI_PDEV_PKTLOG_ENABLE_CMDID);
3210         if (ret) {
3211                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_PKTLOG_ENABLE_CMDID\n");
3212                 dev_kfree_skb(skb);
3213         }
3214
3215         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd pdev pktlog enable");
3216
3217         return ret;
3218 }
3219
3220 int ath11k_wmi_pdev_pktlog_disable(struct ath11k *ar)
3221 {
3222         struct ath11k_pdev_wmi *wmi = ar->wmi;
3223         struct wmi_pktlog_disable_cmd *cmd;
3224         struct sk_buff *skb;
3225         int ret;
3226
3227         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
3228         if (!skb)
3229                 return -ENOMEM;
3230
3231         cmd = (struct wmi_pktlog_disable_cmd *)skb->data;
3232
3233         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_PKTLOG_DISABLE_CMD) |
3234                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3235
3236         cmd->pdev_id = DP_HW2SW_MACID(ar->pdev->pdev_id);
3237
3238         ret = ath11k_wmi_cmd_send(wmi, skb,
3239                                   WMI_PDEV_PKTLOG_DISABLE_CMDID);
3240         if (ret) {
3241                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_PKTLOG_ENABLE_CMDID\n");
3242                 dev_kfree_skb(skb);
3243         }
3244
3245         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd pdev pktlog disable");
3246
3247         return ret;
3248 }
3249
3250 void ath11k_wmi_fill_default_twt_params(struct wmi_twt_enable_params *twt_params)
3251 {
3252         twt_params->sta_cong_timer_ms = ATH11K_TWT_DEF_STA_CONG_TIMER_MS;
3253         twt_params->default_slot_size = ATH11K_TWT_DEF_DEFAULT_SLOT_SIZE;
3254         twt_params->congestion_thresh_setup = ATH11K_TWT_DEF_CONGESTION_THRESH_SETUP;
3255         twt_params->congestion_thresh_teardown =
3256                 ATH11K_TWT_DEF_CONGESTION_THRESH_TEARDOWN;
3257         twt_params->congestion_thresh_critical =
3258                 ATH11K_TWT_DEF_CONGESTION_THRESH_CRITICAL;
3259         twt_params->interference_thresh_teardown =
3260                 ATH11K_TWT_DEF_INTERFERENCE_THRESH_TEARDOWN;
3261         twt_params->interference_thresh_setup =
3262                 ATH11K_TWT_DEF_INTERFERENCE_THRESH_SETUP;
3263         twt_params->min_no_sta_setup = ATH11K_TWT_DEF_MIN_NO_STA_SETUP;
3264         twt_params->min_no_sta_teardown = ATH11K_TWT_DEF_MIN_NO_STA_TEARDOWN;
3265         twt_params->no_of_bcast_mcast_slots = ATH11K_TWT_DEF_NO_OF_BCAST_MCAST_SLOTS;
3266         twt_params->min_no_twt_slots = ATH11K_TWT_DEF_MIN_NO_TWT_SLOTS;
3267         twt_params->max_no_sta_twt = ATH11K_TWT_DEF_MAX_NO_STA_TWT;
3268         twt_params->mode_check_interval = ATH11K_TWT_DEF_MODE_CHECK_INTERVAL;
3269         twt_params->add_sta_slot_interval = ATH11K_TWT_DEF_ADD_STA_SLOT_INTERVAL;
3270         twt_params->remove_sta_slot_interval =
3271                 ATH11K_TWT_DEF_REMOVE_STA_SLOT_INTERVAL;
3272         /* TODO add MBSSID support */
3273         twt_params->mbss_support = 0;
3274 }
3275
3276 int ath11k_wmi_send_twt_enable_cmd(struct ath11k *ar, u32 pdev_id,
3277                                    struct wmi_twt_enable_params *params)
3278 {
3279         struct ath11k_pdev_wmi *wmi = ar->wmi;
3280         struct ath11k_base *ab = wmi->wmi_ab->ab;
3281         struct wmi_twt_enable_params_cmd *cmd;
3282         struct sk_buff *skb;
3283         int ret, len;
3284
3285         len = sizeof(*cmd);
3286
3287         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3288         if (!skb)
3289                 return -ENOMEM;
3290
3291         cmd = (struct wmi_twt_enable_params_cmd *)skb->data;
3292         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_TWT_ENABLE_CMD) |
3293                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3294         cmd->pdev_id = pdev_id;
3295         cmd->sta_cong_timer_ms = params->sta_cong_timer_ms;
3296         cmd->default_slot_size = params->default_slot_size;
3297         cmd->congestion_thresh_setup = params->congestion_thresh_setup;
3298         cmd->congestion_thresh_teardown = params->congestion_thresh_teardown;
3299         cmd->congestion_thresh_critical = params->congestion_thresh_critical;
3300         cmd->interference_thresh_teardown = params->interference_thresh_teardown;
3301         cmd->interference_thresh_setup = params->interference_thresh_setup;
3302         cmd->min_no_sta_setup = params->min_no_sta_setup;
3303         cmd->min_no_sta_teardown = params->min_no_sta_teardown;
3304         cmd->no_of_bcast_mcast_slots = params->no_of_bcast_mcast_slots;
3305         cmd->min_no_twt_slots = params->min_no_twt_slots;
3306         cmd->max_no_sta_twt = params->max_no_sta_twt;
3307         cmd->mode_check_interval = params->mode_check_interval;
3308         cmd->add_sta_slot_interval = params->add_sta_slot_interval;
3309         cmd->remove_sta_slot_interval = params->remove_sta_slot_interval;
3310         cmd->mbss_support = params->mbss_support;
3311
3312         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_TWT_ENABLE_CMDID);
3313         if (ret) {
3314                 ath11k_warn(ab, "Failed to send WMI_TWT_ENABLE_CMDID");
3315                 dev_kfree_skb(skb);
3316                 return ret;
3317         }
3318
3319         ar->twt_enabled = 1;
3320
3321         ath11k_dbg(ab, ATH11K_DBG_WMI, "cmd twt enable");
3322
3323         return 0;
3324 }
3325
3326 int
3327 ath11k_wmi_send_twt_disable_cmd(struct ath11k *ar, u32 pdev_id)
3328 {
3329         struct ath11k_pdev_wmi *wmi = ar->wmi;
3330         struct ath11k_base *ab = wmi->wmi_ab->ab;
3331         struct wmi_twt_disable_params_cmd *cmd;
3332         struct sk_buff *skb;
3333         int ret, len;
3334
3335         len = sizeof(*cmd);
3336
3337         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3338         if (!skb)
3339                 return -ENOMEM;
3340
3341         cmd = (struct wmi_twt_disable_params_cmd *)skb->data;
3342         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_TWT_DISABLE_CMD) |
3343                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3344         cmd->pdev_id = pdev_id;
3345
3346         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_TWT_DISABLE_CMDID);
3347         if (ret) {
3348                 ath11k_warn(ab, "Failed to send WMI_TWT_DISABLE_CMDID");
3349                 dev_kfree_skb(skb);
3350                 return ret;
3351         }
3352
3353         ath11k_dbg(ab, ATH11K_DBG_WMI, "cmd twt disable");
3354
3355         ar->twt_enabled = 0;
3356
3357         return 0;
3358 }
3359
3360 int ath11k_wmi_send_twt_add_dialog_cmd(struct ath11k *ar,
3361                                        struct wmi_twt_add_dialog_params *params)
3362 {
3363         struct ath11k_pdev_wmi *wmi = ar->wmi;
3364         struct ath11k_base *ab = wmi->wmi_ab->ab;
3365         struct wmi_twt_add_dialog_params_cmd *cmd;
3366         struct sk_buff *skb;
3367         int ret, len;
3368
3369         len = sizeof(*cmd);
3370
3371         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3372         if (!skb)
3373                 return -ENOMEM;
3374
3375         cmd = (struct wmi_twt_add_dialog_params_cmd *)skb->data;
3376         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_TWT_ADD_DIALOG_CMD) |
3377                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3378
3379         cmd->vdev_id = params->vdev_id;
3380         ether_addr_copy(cmd->peer_macaddr.addr, params->peer_macaddr);
3381         cmd->dialog_id = params->dialog_id;
3382         cmd->wake_intvl_us = params->wake_intvl_us;
3383         cmd->wake_intvl_mantis = params->wake_intvl_mantis;
3384         cmd->wake_dura_us = params->wake_dura_us;
3385         cmd->sp_offset_us = params->sp_offset_us;
3386         cmd->flags = params->twt_cmd;
3387         if (params->flag_bcast)
3388                 cmd->flags |= WMI_TWT_ADD_DIALOG_FLAG_BCAST;
3389         if (params->flag_trigger)
3390                 cmd->flags |= WMI_TWT_ADD_DIALOG_FLAG_TRIGGER;
3391         if (params->flag_flow_type)
3392                 cmd->flags |= WMI_TWT_ADD_DIALOG_FLAG_FLOW_TYPE;
3393         if (params->flag_protection)
3394                 cmd->flags |= WMI_TWT_ADD_DIALOG_FLAG_PROTECTION;
3395
3396         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_TWT_ADD_DIALOG_CMDID);
3397         if (ret) {
3398                 ath11k_warn(ab,
3399                             "failed to send wmi command to add twt dialog: %d",
3400                             ret);
3401                 dev_kfree_skb(skb);
3402                 return ret;
3403         }
3404
3405         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3406                    "cmd twt add dialog vdev %u dialog id %u wake interval %u mantissa %u wake duration %u service period offset %u flags 0x%x\n",
3407                    cmd->vdev_id, cmd->dialog_id, cmd->wake_intvl_us,
3408                    cmd->wake_intvl_mantis, cmd->wake_dura_us, cmd->sp_offset_us,
3409                    cmd->flags);
3410
3411         return 0;
3412 }
3413
3414 int ath11k_wmi_send_twt_del_dialog_cmd(struct ath11k *ar,
3415                                        struct wmi_twt_del_dialog_params *params)
3416 {
3417         struct ath11k_pdev_wmi *wmi = ar->wmi;
3418         struct ath11k_base *ab = wmi->wmi_ab->ab;
3419         struct wmi_twt_del_dialog_params_cmd *cmd;
3420         struct sk_buff *skb;
3421         int ret, len;
3422
3423         len = sizeof(*cmd);
3424
3425         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3426         if (!skb)
3427                 return -ENOMEM;
3428
3429         cmd = (struct wmi_twt_del_dialog_params_cmd *)skb->data;
3430         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_TWT_DEL_DIALOG_CMD) |
3431                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3432
3433         cmd->vdev_id = params->vdev_id;
3434         ether_addr_copy(cmd->peer_macaddr.addr, params->peer_macaddr);
3435         cmd->dialog_id = params->dialog_id;
3436
3437         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_TWT_DEL_DIALOG_CMDID);
3438         if (ret) {
3439                 ath11k_warn(ab,
3440                             "failed to send wmi command to delete twt dialog: %d",
3441                             ret);
3442                 dev_kfree_skb(skb);
3443                 return ret;
3444         }
3445
3446         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3447                    "cmd twt del dialog vdev %u dialog id %u\n",
3448                    cmd->vdev_id, cmd->dialog_id);
3449
3450         return 0;
3451 }
3452
3453 int ath11k_wmi_send_twt_pause_dialog_cmd(struct ath11k *ar,
3454                                          struct wmi_twt_pause_dialog_params *params)
3455 {
3456         struct ath11k_pdev_wmi *wmi = ar->wmi;
3457         struct ath11k_base *ab = wmi->wmi_ab->ab;
3458         struct wmi_twt_pause_dialog_params_cmd *cmd;
3459         struct sk_buff *skb;
3460         int ret, len;
3461
3462         len = sizeof(*cmd);
3463
3464         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3465         if (!skb)
3466                 return -ENOMEM;
3467
3468         cmd = (struct wmi_twt_pause_dialog_params_cmd *)skb->data;
3469         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3470                                      WMI_TAG_TWT_PAUSE_DIALOG_CMD) |
3471                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3472
3473         cmd->vdev_id = params->vdev_id;
3474         ether_addr_copy(cmd->peer_macaddr.addr, params->peer_macaddr);
3475         cmd->dialog_id = params->dialog_id;
3476
3477         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_TWT_PAUSE_DIALOG_CMDID);
3478         if (ret) {
3479                 ath11k_warn(ab,
3480                             "failed to send wmi command to pause twt dialog: %d",
3481                             ret);
3482                 dev_kfree_skb(skb);
3483                 return ret;
3484         }
3485
3486         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3487                    "cmd twt pause dialog vdev %u dialog id %u\n",
3488                    cmd->vdev_id, cmd->dialog_id);
3489
3490         return 0;
3491 }
3492
3493 int ath11k_wmi_send_twt_resume_dialog_cmd(struct ath11k *ar,
3494                                           struct wmi_twt_resume_dialog_params *params)
3495 {
3496         struct ath11k_pdev_wmi *wmi = ar->wmi;
3497         struct ath11k_base *ab = wmi->wmi_ab->ab;
3498         struct wmi_twt_resume_dialog_params_cmd *cmd;
3499         struct sk_buff *skb;
3500         int ret, len;
3501
3502         len = sizeof(*cmd);
3503
3504         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3505         if (!skb)
3506                 return -ENOMEM;
3507
3508         cmd = (struct wmi_twt_resume_dialog_params_cmd *)skb->data;
3509         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3510                                      WMI_TAG_TWT_RESUME_DIALOG_CMD) |
3511                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3512
3513         cmd->vdev_id = params->vdev_id;
3514         ether_addr_copy(cmd->peer_macaddr.addr, params->peer_macaddr);
3515         cmd->dialog_id = params->dialog_id;
3516         cmd->sp_offset_us = params->sp_offset_us;
3517         cmd->next_twt_size = params->next_twt_size;
3518
3519         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_TWT_RESUME_DIALOG_CMDID);
3520         if (ret) {
3521                 ath11k_warn(ab,
3522                             "failed to send wmi command to resume twt dialog: %d",
3523                             ret);
3524                 dev_kfree_skb(skb);
3525                 return ret;
3526         }
3527
3528         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3529                    "cmd twt resume dialog vdev %u dialog id %u service period offset %u next twt subfield size %u\n",
3530                    cmd->vdev_id, cmd->dialog_id, cmd->sp_offset_us,
3531                    cmd->next_twt_size);
3532
3533         return 0;
3534 }
3535
3536 int
3537 ath11k_wmi_send_obss_spr_cmd(struct ath11k *ar, u32 vdev_id,
3538                              struct ieee80211_he_obss_pd *he_obss_pd)
3539 {
3540         struct ath11k_pdev_wmi *wmi = ar->wmi;
3541         struct ath11k_base *ab = wmi->wmi_ab->ab;
3542         struct wmi_obss_spatial_reuse_params_cmd *cmd;
3543         struct sk_buff *skb;
3544         int ret, len;
3545
3546         len = sizeof(*cmd);
3547
3548         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3549         if (!skb)
3550                 return -ENOMEM;
3551
3552         cmd = (struct wmi_obss_spatial_reuse_params_cmd *)skb->data;
3553         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3554                                      WMI_TAG_OBSS_SPATIAL_REUSE_SET_CMD) |
3555                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3556         cmd->vdev_id = vdev_id;
3557         cmd->enable = he_obss_pd->enable;
3558         cmd->obss_min = he_obss_pd->min_offset;
3559         cmd->obss_max = he_obss_pd->max_offset;
3560
3561         ret = ath11k_wmi_cmd_send(wmi, skb,
3562                                   WMI_PDEV_OBSS_PD_SPATIAL_REUSE_CMDID);
3563         if (ret) {
3564                 ath11k_warn(ab,
3565                             "Failed to send WMI_PDEV_OBSS_PD_SPATIAL_REUSE_CMDID");
3566                 dev_kfree_skb(skb);
3567                 return ret;
3568         }
3569
3570         ath11k_dbg(ab, ATH11K_DBG_WMI, "cmd pdev obss pd spatial reuse");
3571
3572         return 0;
3573 }
3574
3575 int
3576 ath11k_wmi_pdev_set_srg_bss_color_bitmap(struct ath11k *ar, u32 *bitmap)
3577 {
3578         struct ath11k_pdev_wmi *wmi = ar->wmi;
3579         struct ath11k_base *ab = wmi->wmi_ab->ab;
3580         struct wmi_pdev_obss_pd_bitmap_cmd *cmd;
3581         struct sk_buff *skb;
3582         int ret, len;
3583
3584         len = sizeof(*cmd);
3585
3586         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3587         if (!skb)
3588                 return -ENOMEM;
3589
3590         cmd = (struct wmi_pdev_obss_pd_bitmap_cmd *)skb->data;
3591         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3592                                      WMI_TAG_PDEV_SRG_BSS_COLOR_BITMAP_CMD) |
3593                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3594         cmd->pdev_id = ar->pdev->pdev_id;
3595         memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));
3596
3597         ret = ath11k_wmi_cmd_send(wmi, skb,
3598                                   WMI_PDEV_SET_SRG_BSS_COLOR_BITMAP_CMDID);
3599         if (ret) {
3600                 ath11k_warn(ab,
3601                             "failed to send WMI_PDEV_SET_SRG_BSS_COLOR_BITMAP_CMDID");
3602                 dev_kfree_skb(skb);
3603                 return ret;
3604         }
3605
3606         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3607                    "cmd pdev set srg bss color bitmap pdev_id %d bss color bitmap %08x %08x\n",
3608                    cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);
3609
3610         return 0;
3611 }
3612
3613 int
3614 ath11k_wmi_pdev_set_srg_patial_bssid_bitmap(struct ath11k *ar, u32 *bitmap)
3615 {
3616         struct ath11k_pdev_wmi *wmi = ar->wmi;
3617         struct ath11k_base *ab = wmi->wmi_ab->ab;
3618         struct wmi_pdev_obss_pd_bitmap_cmd *cmd;
3619         struct sk_buff *skb;
3620         int ret, len;
3621
3622         len = sizeof(*cmd);
3623
3624         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3625         if (!skb)
3626                 return -ENOMEM;
3627
3628         cmd = (struct wmi_pdev_obss_pd_bitmap_cmd *)skb->data;
3629         cmd->tlv_header =
3630                 FIELD_PREP(WMI_TLV_TAG,
3631                            WMI_TAG_PDEV_SRG_PARTIAL_BSSID_BITMAP_CMD) |
3632                 FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3633         cmd->pdev_id = ar->pdev->pdev_id;
3634         memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));
3635
3636         ret = ath11k_wmi_cmd_send(wmi, skb,
3637                                   WMI_PDEV_SET_SRG_PARTIAL_BSSID_BITMAP_CMDID);
3638         if (ret) {
3639                 ath11k_warn(ab,
3640                             "failed to send WMI_PDEV_SET_SRG_PARTIAL_BSSID_BITMAP_CMDID");
3641                 dev_kfree_skb(skb);
3642                 return ret;
3643         }
3644
3645         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3646                    "cmd pdev set srg partial bssid bitmap pdev_id %d partial bssid bitmap %08x %08x\n",
3647                    cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);
3648
3649         return 0;
3650 }
3651
3652 int
3653 ath11k_wmi_pdev_srg_obss_color_enable_bitmap(struct ath11k *ar, u32 *bitmap)
3654 {
3655         struct ath11k_pdev_wmi *wmi = ar->wmi;
3656         struct ath11k_base *ab = wmi->wmi_ab->ab;
3657         struct wmi_pdev_obss_pd_bitmap_cmd *cmd;
3658         struct sk_buff *skb;
3659         int ret, len;
3660
3661         len = sizeof(*cmd);
3662
3663         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3664         if (!skb)
3665                 return -ENOMEM;
3666
3667         cmd = (struct wmi_pdev_obss_pd_bitmap_cmd *)skb->data;
3668         cmd->tlv_header =
3669                 FIELD_PREP(WMI_TLV_TAG,
3670                            WMI_TAG_PDEV_SRG_OBSS_COLOR_ENABLE_BITMAP_CMD) |
3671                 FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3672         cmd->pdev_id = ar->pdev->pdev_id;
3673         memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));
3674
3675         ret = ath11k_wmi_cmd_send(wmi, skb,
3676                                   WMI_PDEV_SET_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID);
3677         if (ret) {
3678                 ath11k_warn(ab,
3679                             "failed to send WMI_PDEV_SET_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID");
3680                 dev_kfree_skb(skb);
3681                 return ret;
3682         }
3683
3684         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3685                    "cmd pdev set srg obsscolor enable pdev_id %d bss color enable bitmap %08x %08x\n",
3686                    cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);
3687
3688         return 0;
3689 }
3690
3691 int
3692 ath11k_wmi_pdev_srg_obss_bssid_enable_bitmap(struct ath11k *ar, u32 *bitmap)
3693 {
3694         struct ath11k_pdev_wmi *wmi = ar->wmi;
3695         struct ath11k_base *ab = wmi->wmi_ab->ab;
3696         struct wmi_pdev_obss_pd_bitmap_cmd *cmd;
3697         struct sk_buff *skb;
3698         int ret, len;
3699
3700         len = sizeof(*cmd);
3701
3702         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3703         if (!skb)
3704                 return -ENOMEM;
3705
3706         cmd = (struct wmi_pdev_obss_pd_bitmap_cmd *)skb->data;
3707         cmd->tlv_header =
3708                 FIELD_PREP(WMI_TLV_TAG,
3709                            WMI_TAG_PDEV_SRG_OBSS_BSSID_ENABLE_BITMAP_CMD) |
3710                 FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3711         cmd->pdev_id = ar->pdev->pdev_id;
3712         memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));
3713
3714         ret = ath11k_wmi_cmd_send(wmi, skb,
3715                                   WMI_PDEV_SET_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID);
3716         if (ret) {
3717                 ath11k_warn(ab,
3718                             "failed to send WMI_PDEV_SET_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID");
3719                 dev_kfree_skb(skb);
3720                 return ret;
3721         }
3722
3723         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3724                    "cmd pdev set srg obss bssid enable bitmap pdev_id %d bssid enable bitmap %08x %08x\n",
3725                    cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);
3726
3727         return 0;
3728 }
3729
3730 int
3731 ath11k_wmi_pdev_non_srg_obss_color_enable_bitmap(struct ath11k *ar, u32 *bitmap)
3732 {
3733         struct ath11k_pdev_wmi *wmi = ar->wmi;
3734         struct ath11k_base *ab = wmi->wmi_ab->ab;
3735         struct wmi_pdev_obss_pd_bitmap_cmd *cmd;
3736         struct sk_buff *skb;
3737         int ret, len;
3738
3739         len = sizeof(*cmd);
3740
3741         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3742         if (!skb)
3743                 return -ENOMEM;
3744
3745         cmd = (struct wmi_pdev_obss_pd_bitmap_cmd *)skb->data;
3746         cmd->tlv_header =
3747                 FIELD_PREP(WMI_TLV_TAG,
3748                            WMI_TAG_PDEV_NON_SRG_OBSS_COLOR_ENABLE_BITMAP_CMD) |
3749                 FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3750         cmd->pdev_id = ar->pdev->pdev_id;
3751         memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));
3752
3753         ret = ath11k_wmi_cmd_send(wmi, skb,
3754                                   WMI_PDEV_SET_NON_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID);
3755         if (ret) {
3756                 ath11k_warn(ab,
3757                             "failed to send WMI_PDEV_SET_NON_SRG_OBSS_COLOR_ENABLE_BITMAP_CMDID");
3758                 dev_kfree_skb(skb);
3759                 return ret;
3760         }
3761
3762         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3763                    "cmd pdev set non srg obss color enable bitmap pdev_id %d bss color enable bitmap %08x %08x\n",
3764                    cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);
3765
3766         return 0;
3767 }
3768
3769 int
3770 ath11k_wmi_pdev_non_srg_obss_bssid_enable_bitmap(struct ath11k *ar, u32 *bitmap)
3771 {
3772         struct ath11k_pdev_wmi *wmi = ar->wmi;
3773         struct ath11k_base *ab = wmi->wmi_ab->ab;
3774         struct wmi_pdev_obss_pd_bitmap_cmd *cmd;
3775         struct sk_buff *skb;
3776         int ret, len;
3777
3778         len = sizeof(*cmd);
3779
3780         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3781         if (!skb)
3782                 return -ENOMEM;
3783
3784         cmd = (struct wmi_pdev_obss_pd_bitmap_cmd *)skb->data;
3785         cmd->tlv_header =
3786                 FIELD_PREP(WMI_TLV_TAG,
3787                            WMI_TAG_PDEV_NON_SRG_OBSS_BSSID_ENABLE_BITMAP_CMD) |
3788                 FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3789         cmd->pdev_id = ar->pdev->pdev_id;
3790         memcpy(cmd->bitmap, bitmap, sizeof(cmd->bitmap));
3791
3792         ret = ath11k_wmi_cmd_send(wmi, skb,
3793                                   WMI_PDEV_SET_NON_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID);
3794         if (ret) {
3795                 ath11k_warn(ab,
3796                             "failed to send WMI_PDEV_SET_NON_SRG_OBSS_BSSID_ENABLE_BITMAP_CMDID");
3797                 dev_kfree_skb(skb);
3798                 return ret;
3799         }
3800
3801         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3802                    "cmd pdev set non srg obss bssid enable bitmap pdev_id %d bssid enable bitmap %08x %08x\n",
3803                    cmd->pdev_id, cmd->bitmap[0], cmd->bitmap[1]);
3804
3805         return 0;
3806 }
3807
3808 int
3809 ath11k_wmi_send_obss_color_collision_cfg_cmd(struct ath11k *ar, u32 vdev_id,
3810                                              u8 bss_color, u32 period,
3811                                              bool enable)
3812 {
3813         struct ath11k_pdev_wmi *wmi = ar->wmi;
3814         struct ath11k_base *ab = wmi->wmi_ab->ab;
3815         struct wmi_obss_color_collision_cfg_params_cmd *cmd;
3816         struct sk_buff *skb;
3817         int ret, len;
3818
3819         len = sizeof(*cmd);
3820
3821         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3822         if (!skb)
3823                 return -ENOMEM;
3824
3825         cmd = (struct wmi_obss_color_collision_cfg_params_cmd *)skb->data;
3826         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3827                                      WMI_TAG_OBSS_COLOR_COLLISION_DET_CONFIG) |
3828                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3829         cmd->vdev_id = vdev_id;
3830         cmd->evt_type = enable ? ATH11K_OBSS_COLOR_COLLISION_DETECTION :
3831                                  ATH11K_OBSS_COLOR_COLLISION_DETECTION_DISABLE;
3832         cmd->current_bss_color = bss_color;
3833         cmd->detection_period_ms = period;
3834         cmd->scan_period_ms = ATH11K_BSS_COLOR_COLLISION_SCAN_PERIOD_MS;
3835         cmd->free_slot_expiry_time_ms = 0;
3836         cmd->flags = 0;
3837
3838         ret = ath11k_wmi_cmd_send(wmi, skb,
3839                                   WMI_OBSS_COLOR_COLLISION_DET_CONFIG_CMDID);
3840         if (ret) {
3841                 ath11k_warn(ab, "Failed to send WMI_OBSS_COLOR_COLLISION_DET_CONFIG_CMDID");
3842                 dev_kfree_skb(skb);
3843                 return ret;
3844         }
3845
3846         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3847                    "cmd obss color collision det config id %d type %d bss_color %d detect_period %d scan_period %d\n",
3848                    cmd->vdev_id, cmd->evt_type, cmd->current_bss_color,
3849                    cmd->detection_period_ms, cmd->scan_period_ms);
3850
3851         return 0;
3852 }
3853
3854 int ath11k_wmi_send_bss_color_change_enable_cmd(struct ath11k *ar, u32 vdev_id,
3855                                                 bool enable)
3856 {
3857         struct ath11k_pdev_wmi *wmi = ar->wmi;
3858         struct ath11k_base *ab = wmi->wmi_ab->ab;
3859         struct wmi_bss_color_change_enable_params_cmd *cmd;
3860         struct sk_buff *skb;
3861         int ret, len;
3862
3863         len = sizeof(*cmd);
3864
3865         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3866         if (!skb)
3867                 return -ENOMEM;
3868
3869         cmd = (struct wmi_bss_color_change_enable_params_cmd *)skb->data;
3870         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_BSS_COLOR_CHANGE_ENABLE) |
3871                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3872         cmd->vdev_id = vdev_id;
3873         cmd->enable = enable ? 1 : 0;
3874
3875         ret = ath11k_wmi_cmd_send(wmi, skb,
3876                                   WMI_BSS_COLOR_CHANGE_ENABLE_CMDID);
3877         if (ret) {
3878                 ath11k_warn(ab, "Failed to send WMI_BSS_COLOR_CHANGE_ENABLE_CMDID");
3879                 dev_kfree_skb(skb);
3880                 return ret;
3881         }
3882
3883         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3884                    "cmd bss color change enable id %d enable %d\n",
3885                    cmd->vdev_id, cmd->enable);
3886
3887         return 0;
3888 }
3889
3890 int ath11k_wmi_fils_discovery_tmpl(struct ath11k *ar, u32 vdev_id,
3891                                    struct sk_buff *tmpl)
3892 {
3893         struct wmi_tlv *tlv;
3894         struct sk_buff *skb;
3895         void *ptr;
3896         int ret, len;
3897         size_t aligned_len;
3898         struct wmi_fils_discovery_tmpl_cmd *cmd;
3899
3900         aligned_len = roundup(tmpl->len, 4);
3901         len = sizeof(*cmd) + TLV_HDR_SIZE + aligned_len;
3902
3903         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3904                    "vdev %i set FILS discovery template\n", vdev_id);
3905
3906         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
3907         if (!skb)
3908                 return -ENOMEM;
3909
3910         cmd = (struct wmi_fils_discovery_tmpl_cmd *)skb->data;
3911         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3912                                      WMI_TAG_FILS_DISCOVERY_TMPL_CMD) |
3913                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3914         cmd->vdev_id = vdev_id;
3915         cmd->buf_len = tmpl->len;
3916         ptr = skb->data + sizeof(*cmd);
3917
3918         tlv = ptr;
3919         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
3920                       FIELD_PREP(WMI_TLV_LEN, aligned_len);
3921         memcpy(tlv->value, tmpl->data, tmpl->len);
3922
3923         ret = ath11k_wmi_cmd_send(ar->wmi, skb, WMI_FILS_DISCOVERY_TMPL_CMDID);
3924         if (ret) {
3925                 ath11k_warn(ar->ab,
3926                             "WMI vdev %i failed to send FILS discovery template command\n",
3927                             vdev_id);
3928                 dev_kfree_skb(skb);
3929                 return ret;
3930         }
3931
3932         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd fils discovery tmpl");
3933
3934         return 0;
3935 }
3936
3937 int ath11k_wmi_probe_resp_tmpl(struct ath11k *ar, u32 vdev_id,
3938                                struct sk_buff *tmpl)
3939 {
3940         struct wmi_probe_tmpl_cmd *cmd;
3941         struct wmi_bcn_prb_info *probe_info;
3942         struct wmi_tlv *tlv;
3943         struct sk_buff *skb;
3944         void *ptr;
3945         int ret, len;
3946         size_t aligned_len = roundup(tmpl->len, 4);
3947
3948         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3949                    "vdev %i set probe response template\n", vdev_id);
3950
3951         len = sizeof(*cmd) + sizeof(*probe_info) + TLV_HDR_SIZE + aligned_len;
3952
3953         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
3954         if (!skb)
3955                 return -ENOMEM;
3956
3957         cmd = (struct wmi_probe_tmpl_cmd *)skb->data;
3958         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PRB_TMPL_CMD) |
3959                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3960         cmd->vdev_id = vdev_id;
3961         cmd->buf_len = tmpl->len;
3962
3963         ptr = skb->data + sizeof(*cmd);
3964
3965         probe_info = ptr;
3966         len = sizeof(*probe_info);
3967         probe_info->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3968                                             WMI_TAG_BCN_PRB_INFO) |
3969                                  FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3970         probe_info->caps = 0;
3971         probe_info->erp = 0;
3972
3973         ptr += sizeof(*probe_info);
3974
3975         tlv = ptr;
3976         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
3977                       FIELD_PREP(WMI_TLV_LEN, aligned_len);
3978         memcpy(tlv->value, tmpl->data, tmpl->len);
3979
3980         ret = ath11k_wmi_cmd_send(ar->wmi, skb, WMI_PRB_TMPL_CMDID);
3981         if (ret) {
3982                 ath11k_warn(ar->ab,
3983                             "WMI vdev %i failed to send probe response template command\n",
3984                             vdev_id);
3985                 dev_kfree_skb(skb);
3986                 return ret;
3987         }
3988
3989         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd ");
3990
3991         return 0;
3992 }
3993
3994 int ath11k_wmi_fils_discovery(struct ath11k *ar, u32 vdev_id, u32 interval,
3995                               bool unsol_bcast_probe_resp_enabled)
3996 {
3997         struct sk_buff *skb;
3998         int ret, len;
3999         struct wmi_fils_discovery_cmd *cmd;
4000
4001         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
4002                    "vdev %i set %s interval to %u TU\n",
4003                    vdev_id, unsol_bcast_probe_resp_enabled ?
4004                    "unsolicited broadcast probe response" : "FILS discovery",
4005                    interval);
4006
4007         len = sizeof(*cmd);
4008         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
4009         if (!skb)
4010                 return -ENOMEM;
4011
4012         cmd = (struct wmi_fils_discovery_cmd *)skb->data;
4013         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ENABLE_FILS_CMD) |
4014                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
4015         cmd->vdev_id = vdev_id;
4016         cmd->interval = interval;
4017         cmd->config = unsol_bcast_probe_resp_enabled;
4018
4019         ret = ath11k_wmi_cmd_send(ar->wmi, skb, WMI_ENABLE_FILS_CMDID);
4020         if (ret) {
4021                 ath11k_warn(ar->ab,
4022                             "WMI vdev %i failed to send FILS discovery enable/disable command\n",
4023                             vdev_id);
4024                 dev_kfree_skb(skb);
4025                 return ret;
4026         }
4027
4028         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd enable fils");
4029
4030         return 0;
4031 }
4032
4033 static void
4034 ath11k_wmi_obss_color_collision_event(struct ath11k_base *ab, struct sk_buff *skb)
4035 {
4036         const void **tb;
4037         const struct wmi_obss_color_collision_event *ev;
4038         struct ath11k_vif *arvif;
4039         int ret;
4040
4041         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
4042         if (IS_ERR(tb)) {
4043                 ret = PTR_ERR(tb);
4044                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4045                 return;
4046         }
4047
4048         ath11k_dbg(ab, ATH11K_DBG_WMI, "event obss color collision");
4049
4050         rcu_read_lock();
4051
4052         ev = tb[WMI_TAG_OBSS_COLOR_COLLISION_EVT];
4053         if (!ev) {
4054                 ath11k_warn(ab, "failed to fetch obss color collision ev");
4055                 goto exit;
4056         }
4057
4058         arvif = ath11k_mac_get_arvif_by_vdev_id(ab, ev->vdev_id);
4059         if (!arvif) {
4060                 ath11k_warn(ab, "failed to find arvif with vedv id %d in obss_color_collision_event\n",
4061                             ev->vdev_id);
4062                 goto exit;
4063         }
4064
4065         switch (ev->evt_type) {
4066         case WMI_BSS_COLOR_COLLISION_DETECTION:
4067                 ieee80211_obss_color_collision_notify(arvif->vif, ev->obss_color_bitmap,
4068                                                       0);
4069                 ath11k_dbg(ab, ATH11K_DBG_WMI,
4070                            "OBSS color collision detected vdev:%d, event:%d, bitmap:%08llx\n",
4071                            ev->vdev_id, ev->evt_type, ev->obss_color_bitmap);
4072                 break;
4073         case WMI_BSS_COLOR_COLLISION_DISABLE:
4074         case WMI_BSS_COLOR_FREE_SLOT_TIMER_EXPIRY:
4075         case WMI_BSS_COLOR_FREE_SLOT_AVAILABLE:
4076                 break;
4077         default:
4078                 ath11k_warn(ab, "received unknown obss color collision detection event\n");
4079         }
4080
4081 exit:
4082         kfree(tb);
4083         rcu_read_unlock();
4084 }
4085
4086 static void
4087 ath11k_fill_band_to_mac_param(struct ath11k_base  *soc,
4088                               struct wmi_host_pdev_band_to_mac *band_to_mac)
4089 {
4090         u8 i;
4091         struct ath11k_hal_reg_capabilities_ext *hal_reg_cap;
4092         struct ath11k_pdev *pdev;
4093
4094         for (i = 0; i < soc->num_radios; i++) {
4095                 pdev = &soc->pdevs[i];
4096                 hal_reg_cap = &soc->hal_reg_cap[i];
4097                 band_to_mac[i].pdev_id = pdev->pdev_id;
4098
4099                 switch (pdev->cap.supported_bands) {
4100                 case WMI_HOST_WLAN_2G_5G_CAP:
4101                         band_to_mac[i].start_freq = hal_reg_cap->low_2ghz_chan;
4102                         band_to_mac[i].end_freq = hal_reg_cap->high_5ghz_chan;
4103                         break;
4104                 case WMI_HOST_WLAN_2G_CAP:
4105                         band_to_mac[i].start_freq = hal_reg_cap->low_2ghz_chan;
4106                         band_to_mac[i].end_freq = hal_reg_cap->high_2ghz_chan;
4107                         break;
4108                 case WMI_HOST_WLAN_5G_CAP:
4109                         band_to_mac[i].start_freq = hal_reg_cap->low_5ghz_chan;
4110                         band_to_mac[i].end_freq = hal_reg_cap->high_5ghz_chan;
4111                         break;
4112                 default:
4113                         break;
4114                 }
4115         }
4116 }
4117
4118 static void
4119 ath11k_wmi_copy_resource_config(struct wmi_resource_config *wmi_cfg,
4120                                 struct target_resource_config *tg_cfg)
4121 {
4122         wmi_cfg->num_vdevs = tg_cfg->num_vdevs;
4123         wmi_cfg->num_peers = tg_cfg->num_peers;
4124         wmi_cfg->num_offload_peers = tg_cfg->num_offload_peers;
4125         wmi_cfg->num_offload_reorder_buffs = tg_cfg->num_offload_reorder_buffs;
4126         wmi_cfg->num_peer_keys = tg_cfg->num_peer_keys;
4127         wmi_cfg->num_tids = tg_cfg->num_tids;
4128         wmi_cfg->ast_skid_limit = tg_cfg->ast_skid_limit;
4129         wmi_cfg->tx_chain_mask = tg_cfg->tx_chain_mask;
4130         wmi_cfg->rx_chain_mask = tg_cfg->rx_chain_mask;
4131         wmi_cfg->rx_timeout_pri[0] = tg_cfg->rx_timeout_pri[0];
4132         wmi_cfg->rx_timeout_pri[1] = tg_cfg->rx_timeout_pri[1];
4133         wmi_cfg->rx_timeout_pri[2] = tg_cfg->rx_timeout_pri[2];
4134         wmi_cfg->rx_timeout_pri[3] = tg_cfg->rx_timeout_pri[3];
4135         wmi_cfg->rx_decap_mode = tg_cfg->rx_decap_mode;
4136         wmi_cfg->scan_max_pending_req = tg_cfg->scan_max_pending_req;
4137         wmi_cfg->bmiss_offload_max_vdev = tg_cfg->bmiss_offload_max_vdev;
4138         wmi_cfg->roam_offload_max_vdev = tg_cfg->roam_offload_max_vdev;
4139         wmi_cfg->roam_offload_max_ap_profiles =
4140                 tg_cfg->roam_offload_max_ap_profiles;
4141         wmi_cfg->num_mcast_groups = tg_cfg->num_mcast_groups;
4142         wmi_cfg->num_mcast_table_elems = tg_cfg->num_mcast_table_elems;
4143         wmi_cfg->mcast2ucast_mode = tg_cfg->mcast2ucast_mode;
4144         wmi_cfg->tx_dbg_log_size = tg_cfg->tx_dbg_log_size;
4145         wmi_cfg->num_wds_entries = tg_cfg->num_wds_entries;
4146         wmi_cfg->dma_burst_size = tg_cfg->dma_burst_size;
4147         wmi_cfg->mac_aggr_delim = tg_cfg->mac_aggr_delim;
4148         wmi_cfg->rx_skip_defrag_timeout_dup_detection_check =
4149                 tg_cfg->rx_skip_defrag_timeout_dup_detection_check;
4150         wmi_cfg->vow_config = tg_cfg->vow_config;
4151         wmi_cfg->gtk_offload_max_vdev = tg_cfg->gtk_offload_max_vdev;
4152         wmi_cfg->num_msdu_desc = tg_cfg->num_msdu_desc;
4153         wmi_cfg->max_frag_entries = tg_cfg->max_frag_entries;
4154         wmi_cfg->num_tdls_vdevs = tg_cfg->num_tdls_vdevs;
4155         wmi_cfg->num_tdls_conn_table_entries =
4156                 tg_cfg->num_tdls_conn_table_entries;
4157         wmi_cfg->beacon_tx_offload_max_vdev =
4158                 tg_cfg->beacon_tx_offload_max_vdev;
4159         wmi_cfg->num_multicast_filter_entries =
4160                 tg_cfg->num_multicast_filter_entries;
4161         wmi_cfg->num_wow_filters = tg_cfg->num_wow_filters;
4162         wmi_cfg->num_keep_alive_pattern = tg_cfg->num_keep_alive_pattern;
4163         wmi_cfg->keep_alive_pattern_size = tg_cfg->keep_alive_pattern_size;
4164         wmi_cfg->max_tdls_concurrent_sleep_sta =
4165                 tg_cfg->max_tdls_concurrent_sleep_sta;
4166         wmi_cfg->max_tdls_concurrent_buffer_sta =
4167                 tg_cfg->max_tdls_concurrent_buffer_sta;
4168         wmi_cfg->wmi_send_separate = tg_cfg->wmi_send_separate;
4169         wmi_cfg->num_ocb_vdevs = tg_cfg->num_ocb_vdevs;
4170         wmi_cfg->num_ocb_channels = tg_cfg->num_ocb_channels;
4171         wmi_cfg->num_ocb_schedules = tg_cfg->num_ocb_schedules;
4172         wmi_cfg->bpf_instruction_size = tg_cfg->bpf_instruction_size;
4173         wmi_cfg->max_bssid_rx_filters = tg_cfg->max_bssid_rx_filters;
4174         wmi_cfg->use_pdev_id = tg_cfg->use_pdev_id;
4175         wmi_cfg->flag1 = tg_cfg->flag1;
4176         wmi_cfg->peer_map_unmap_v2_support = tg_cfg->peer_map_unmap_v2_support;
4177         wmi_cfg->sched_params = tg_cfg->sched_params;
4178         wmi_cfg->twt_ap_pdev_count = tg_cfg->twt_ap_pdev_count;
4179         wmi_cfg->twt_ap_sta_count = tg_cfg->twt_ap_sta_count;
4180         wmi_cfg->host_service_flags &=
4181                 ~(1 << WMI_CFG_HOST_SERVICE_FLAG_REG_CC_EXT);
4182         wmi_cfg->host_service_flags |= (tg_cfg->is_reg_cc_ext_event_supported <<
4183                                         WMI_CFG_HOST_SERVICE_FLAG_REG_CC_EXT);
4184         wmi_cfg->flags2 = WMI_RSRC_CFG_FLAG2_CALC_NEXT_DTIM_COUNT_SET;
4185         wmi_cfg->ema_max_vap_cnt = tg_cfg->ema_max_vap_cnt;
4186         wmi_cfg->ema_max_profile_period = tg_cfg->ema_max_profile_period;
4187 }
4188
4189 static int ath11k_init_cmd_send(struct ath11k_pdev_wmi *wmi,
4190                                 struct wmi_init_cmd_param *param)
4191 {
4192         struct ath11k_base *ab = wmi->wmi_ab->ab;
4193         struct sk_buff *skb;
4194         struct wmi_init_cmd *cmd;
4195         struct wmi_resource_config *cfg;
4196         struct wmi_pdev_set_hw_mode_cmd_param *hw_mode;
4197         struct wmi_pdev_band_to_mac *band_to_mac;
4198         struct wlan_host_mem_chunk *host_mem_chunks;
4199         struct wmi_tlv *tlv;
4200         size_t ret, len;
4201         void *ptr;
4202         u32 hw_mode_len = 0;
4203         u16 idx;
4204
4205         if (param->hw_mode_id != WMI_HOST_HW_MODE_MAX)
4206                 hw_mode_len = sizeof(*hw_mode) + TLV_HDR_SIZE +
4207                               (param->num_band_to_mac * sizeof(*band_to_mac));
4208
4209         len = sizeof(*cmd) + TLV_HDR_SIZE + sizeof(*cfg) + hw_mode_len +
4210               (param->num_mem_chunks ? (sizeof(*host_mem_chunks) * WMI_MAX_MEM_REQS) : 0);
4211
4212         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
4213         if (!skb)
4214                 return -ENOMEM;
4215
4216         cmd = (struct wmi_init_cmd *)skb->data;
4217
4218         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_INIT_CMD) |
4219                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
4220
4221         ptr = skb->data + sizeof(*cmd);
4222         cfg = ptr;
4223
4224         ath11k_wmi_copy_resource_config(cfg, param->res_cfg);
4225
4226         cfg->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_RESOURCE_CONFIG) |
4227                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cfg) - TLV_HDR_SIZE);
4228
4229         ptr += sizeof(*cfg);
4230         host_mem_chunks = ptr + TLV_HDR_SIZE;
4231         len = sizeof(struct wlan_host_mem_chunk);
4232
4233         for (idx = 0; idx < param->num_mem_chunks; ++idx) {
4234                 host_mem_chunks[idx].tlv_header =
4235                                 FIELD_PREP(WMI_TLV_TAG,
4236                                            WMI_TAG_WLAN_HOST_MEMORY_CHUNK) |
4237                                 FIELD_PREP(WMI_TLV_LEN, len);
4238
4239                 host_mem_chunks[idx].ptr = param->mem_chunks[idx].paddr;
4240                 host_mem_chunks[idx].size = param->mem_chunks[idx].len;
4241                 host_mem_chunks[idx].req_id = param->mem_chunks[idx].req_id;
4242
4243                 ath11k_dbg(ab, ATH11K_DBG_WMI,
4244                            "host mem chunk req_id %d paddr 0x%llx len %d\n",
4245                            param->mem_chunks[idx].req_id,
4246                            (u64)param->mem_chunks[idx].paddr,
4247                            param->mem_chunks[idx].len);
4248         }
4249         cmd->num_host_mem_chunks = param->num_mem_chunks;
4250         len = sizeof(struct wlan_host_mem_chunk) * param->num_mem_chunks;
4251
4252         /* num_mem_chunks is zero */
4253         tlv = ptr;
4254         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
4255                       FIELD_PREP(WMI_TLV_LEN, len);
4256         ptr += TLV_HDR_SIZE + len;
4257
4258         if (param->hw_mode_id != WMI_HOST_HW_MODE_MAX) {
4259                 hw_mode = ptr;
4260                 hw_mode->tlv_header = FIELD_PREP(WMI_TLV_TAG,
4261                                                  WMI_TAG_PDEV_SET_HW_MODE_CMD) |
4262                                       FIELD_PREP(WMI_TLV_LEN,
4263                                                  sizeof(*hw_mode) - TLV_HDR_SIZE);
4264
4265                 hw_mode->hw_mode_index = param->hw_mode_id;
4266                 hw_mode->num_band_to_mac = param->num_band_to_mac;
4267
4268                 ptr += sizeof(*hw_mode);
4269
4270                 len = param->num_band_to_mac * sizeof(*band_to_mac);
4271                 tlv = ptr;
4272                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
4273                               FIELD_PREP(WMI_TLV_LEN, len);
4274
4275                 ptr += TLV_HDR_SIZE;
4276                 len = sizeof(*band_to_mac);
4277
4278                 for (idx = 0; idx < param->num_band_to_mac; idx++) {
4279                         band_to_mac = ptr;
4280
4281                         band_to_mac->tlv_header = FIELD_PREP(WMI_TLV_TAG,
4282                                                              WMI_TAG_PDEV_BAND_TO_MAC) |
4283                                                   FIELD_PREP(WMI_TLV_LEN,
4284                                                              len - TLV_HDR_SIZE);
4285                         band_to_mac->pdev_id = param->band_to_mac[idx].pdev_id;
4286                         band_to_mac->start_freq =
4287                                 param->band_to_mac[idx].start_freq;
4288                         band_to_mac->end_freq =
4289                                 param->band_to_mac[idx].end_freq;
4290                         ptr += sizeof(*band_to_mac);
4291                 }
4292         }
4293
4294         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_INIT_CMDID);
4295         if (ret) {
4296                 ath11k_warn(ab, "failed to send WMI_INIT_CMDID\n");
4297                 dev_kfree_skb(skb);
4298                 return ret;
4299         }
4300
4301         ath11k_dbg(ab, ATH11K_DBG_WMI, "cmd wmi init");
4302
4303         return 0;
4304 }
4305
4306 int ath11k_wmi_pdev_lro_cfg(struct ath11k *ar,
4307                             int pdev_id)
4308 {
4309         struct ath11k_wmi_pdev_lro_config_cmd *cmd;
4310         struct sk_buff *skb;
4311         int ret;
4312
4313         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
4314         if (!skb)
4315                 return -ENOMEM;
4316
4317         cmd = (struct ath11k_wmi_pdev_lro_config_cmd *)skb->data;
4318         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_LRO_INFO_CMD) |
4319                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
4320
4321         get_random_bytes(cmd->th_4, sizeof(uint32_t) * ATH11K_IPV4_TH_SEED_SIZE);
4322         get_random_bytes(cmd->th_6, sizeof(uint32_t) * ATH11K_IPV6_TH_SEED_SIZE);
4323
4324         cmd->pdev_id = pdev_id;
4325
4326         ret = ath11k_wmi_cmd_send(ar->wmi, skb, WMI_LRO_CONFIG_CMDID);
4327         if (ret) {
4328                 ath11k_warn(ar->ab,
4329                             "failed to send lro cfg req wmi cmd\n");
4330                 goto err;
4331         }
4332
4333         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
4334                    "cmd lro config pdev_id 0x%x\n", pdev_id);
4335         return 0;
4336 err:
4337         dev_kfree_skb(skb);
4338         return ret;
4339 }
4340
4341 int ath11k_wmi_wait_for_service_ready(struct ath11k_base *ab)
4342 {
4343         unsigned long time_left;
4344
4345         time_left = wait_for_completion_timeout(&ab->wmi_ab.service_ready,
4346                                                 WMI_SERVICE_READY_TIMEOUT_HZ);
4347         if (!time_left)
4348                 return -ETIMEDOUT;
4349
4350         return 0;
4351 }
4352
4353 int ath11k_wmi_wait_for_unified_ready(struct ath11k_base *ab)
4354 {
4355         unsigned long time_left;
4356
4357         time_left = wait_for_completion_timeout(&ab->wmi_ab.unified_ready,
4358                                                 WMI_SERVICE_READY_TIMEOUT_HZ);
4359         if (!time_left)
4360                 return -ETIMEDOUT;
4361
4362         return 0;
4363 }
4364
4365 int ath11k_wmi_set_hw_mode(struct ath11k_base *ab,
4366                            enum wmi_host_hw_mode_config_type mode)
4367 {
4368         struct wmi_pdev_set_hw_mode_cmd_param *cmd;
4369         struct sk_buff *skb;
4370         struct ath11k_wmi_base *wmi_ab = &ab->wmi_ab;
4371         int len;
4372         int ret;
4373
4374         len = sizeof(*cmd);
4375
4376         skb = ath11k_wmi_alloc_skb(wmi_ab, len);
4377         if (!skb)
4378                 return -ENOMEM;
4379
4380         cmd = (struct wmi_pdev_set_hw_mode_cmd_param *)skb->data;
4381
4382         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_SET_HW_MODE_CMD) |
4383                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
4384
4385         cmd->pdev_id = WMI_PDEV_ID_SOC;
4386         cmd->hw_mode_index = mode;
4387
4388         ret = ath11k_wmi_cmd_send(&wmi_ab->wmi[0], skb, WMI_PDEV_SET_HW_MODE_CMDID);
4389         if (ret) {
4390                 ath11k_warn(ab, "failed to send WMI_PDEV_SET_HW_MODE_CMDID\n");
4391                 dev_kfree_skb(skb);
4392                 return ret;
4393         }
4394
4395         ath11k_dbg(ab, ATH11K_DBG_WMI, "cmd pdev set hw mode %d", cmd->hw_mode_index);
4396
4397         return 0;
4398 }
4399
4400 int ath11k_wmi_cmd_init(struct ath11k_base *ab)
4401 {
4402         struct ath11k_wmi_base *wmi_ab = &ab->wmi_ab;
4403         struct wmi_init_cmd_param init_param;
4404         struct target_resource_config  config;
4405
4406         memset(&init_param, 0, sizeof(init_param));
4407         memset(&config, 0, sizeof(config));
4408
4409         ab->hw_params.hw_ops->wmi_init_config(ab, &config);
4410
4411         if (test_bit(WMI_TLV_SERVICE_REG_CC_EXT_EVENT_SUPPORT,
4412                      ab->wmi_ab.svc_map))
4413                 config.is_reg_cc_ext_event_supported = 1;
4414
4415         memcpy(&wmi_ab->wlan_resource_config, &config, sizeof(config));
4416
4417         init_param.res_cfg = &wmi_ab->wlan_resource_config;
4418         init_param.num_mem_chunks = wmi_ab->num_mem_chunks;
4419         init_param.hw_mode_id = wmi_ab->preferred_hw_mode;
4420         init_param.mem_chunks = wmi_ab->mem_chunks;
4421
4422         if (ab->hw_params.single_pdev_only)
4423                 init_param.hw_mode_id = WMI_HOST_HW_MODE_MAX;
4424
4425         init_param.num_band_to_mac = ab->num_radios;
4426         ath11k_fill_band_to_mac_param(ab, init_param.band_to_mac);
4427
4428         return ath11k_init_cmd_send(&wmi_ab->wmi[0], &init_param);
4429 }
4430
4431 int ath11k_wmi_vdev_spectral_conf(struct ath11k *ar,
4432                                   struct ath11k_wmi_vdev_spectral_conf_param *param)
4433 {
4434         struct ath11k_wmi_vdev_spectral_conf_cmd *cmd;
4435         struct sk_buff *skb;
4436         int ret;
4437
4438         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
4439         if (!skb)
4440                 return -ENOMEM;
4441
4442         cmd = (struct ath11k_wmi_vdev_spectral_conf_cmd *)skb->data;
4443         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
4444                                      WMI_TAG_VDEV_SPECTRAL_CONFIGURE_CMD) |
4445                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
4446
4447         memcpy(&cmd->param, param, sizeof(*param));
4448
4449         ret = ath11k_wmi_cmd_send(ar->wmi, skb,
4450                                   WMI_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID);
4451         if (ret) {
4452                 ath11k_warn(ar->ab,
4453                             "failed to send spectral scan config wmi cmd\n");
4454                 goto err;
4455         }
4456
4457         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
4458                    "cmd vdev spectral scan configure vdev_id 0x%x\n",
4459                    param->vdev_id);
4460
4461         return 0;
4462 err:
4463         dev_kfree_skb(skb);
4464         return ret;
4465 }
4466
4467 int ath11k_wmi_vdev_spectral_enable(struct ath11k *ar, u32 vdev_id,
4468                                     u32 trigger, u32 enable)
4469 {
4470         struct ath11k_wmi_vdev_spectral_enable_cmd *cmd;
4471         struct sk_buff *skb;
4472         int ret;
4473
4474         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
4475         if (!skb)
4476                 return -ENOMEM;
4477
4478         cmd = (struct ath11k_wmi_vdev_spectral_enable_cmd *)skb->data;
4479         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
4480                                      WMI_TAG_VDEV_SPECTRAL_ENABLE_CMD) |
4481                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
4482
4483         cmd->vdev_id = vdev_id;
4484         cmd->trigger_cmd = trigger;
4485         cmd->enable_cmd = enable;
4486
4487         ret = ath11k_wmi_cmd_send(ar->wmi, skb,
4488                                   WMI_VDEV_SPECTRAL_SCAN_ENABLE_CMDID);
4489         if (ret) {
4490                 ath11k_warn(ar->ab,
4491                             "failed to send spectral enable wmi cmd\n");
4492                 goto err;
4493         }
4494
4495         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
4496                    "cmd vdev spectral scan enable vdev id 0x%x\n",
4497                    vdev_id);
4498
4499         return 0;
4500 err:
4501         dev_kfree_skb(skb);
4502         return ret;
4503 }
4504
4505 int ath11k_wmi_pdev_dma_ring_cfg(struct ath11k *ar,
4506                                  struct ath11k_wmi_pdev_dma_ring_cfg_req_cmd *param)
4507 {
4508         struct ath11k_wmi_pdev_dma_ring_cfg_req_cmd *cmd;
4509         struct sk_buff *skb;
4510         int ret;
4511
4512         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
4513         if (!skb)
4514                 return -ENOMEM;
4515
4516         cmd = (struct ath11k_wmi_pdev_dma_ring_cfg_req_cmd *)skb->data;
4517         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_DMA_RING_CFG_REQ) |
4518                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
4519
4520         cmd->pdev_id            = param->pdev_id;
4521         cmd->module_id          = param->module_id;
4522         cmd->base_paddr_lo      = param->base_paddr_lo;
4523         cmd->base_paddr_hi      = param->base_paddr_hi;
4524         cmd->head_idx_paddr_lo  = param->head_idx_paddr_lo;
4525         cmd->head_idx_paddr_hi  = param->head_idx_paddr_hi;
4526         cmd->tail_idx_paddr_lo  = param->tail_idx_paddr_lo;
4527         cmd->tail_idx_paddr_hi  = param->tail_idx_paddr_hi;
4528         cmd->num_elems          = param->num_elems;
4529         cmd->buf_size           = param->buf_size;
4530         cmd->num_resp_per_event = param->num_resp_per_event;
4531         cmd->event_timeout_ms   = param->event_timeout_ms;
4532
4533         ret = ath11k_wmi_cmd_send(ar->wmi, skb,
4534                                   WMI_PDEV_DMA_RING_CFG_REQ_CMDID);
4535         if (ret) {
4536                 ath11k_warn(ar->ab,
4537                             "failed to send dma ring cfg req wmi cmd\n");
4538                 goto err;
4539         }
4540
4541         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
4542                    "cmd pdev dma ring cfg req pdev_id 0x%x\n",
4543                    param->pdev_id);
4544
4545         return 0;
4546 err:
4547         dev_kfree_skb(skb);
4548         return ret;
4549 }
4550
4551 static int ath11k_wmi_tlv_dma_buf_entry_parse(struct ath11k_base *soc,
4552                                               u16 tag, u16 len,
4553                                               const void *ptr, void *data)
4554 {
4555         struct wmi_tlv_dma_buf_release_parse *parse = data;
4556
4557         if (tag != WMI_TAG_DMA_BUF_RELEASE_ENTRY)
4558                 return -EPROTO;
4559
4560         if (parse->num_buf_entry >= parse->fixed.num_buf_release_entry)
4561                 return -ENOBUFS;
4562
4563         parse->num_buf_entry++;
4564         return 0;
4565 }
4566
4567 static int ath11k_wmi_tlv_dma_buf_meta_parse(struct ath11k_base *soc,
4568                                              u16 tag, u16 len,
4569                                              const void *ptr, void *data)
4570 {
4571         struct wmi_tlv_dma_buf_release_parse *parse = data;
4572
4573         if (tag != WMI_TAG_DMA_BUF_RELEASE_SPECTRAL_META_DATA)
4574                 return -EPROTO;
4575
4576         if (parse->num_meta >= parse->fixed.num_meta_data_entry)
4577                 return -ENOBUFS;
4578
4579         parse->num_meta++;
4580         return 0;
4581 }
4582
4583 static int ath11k_wmi_tlv_dma_buf_parse(struct ath11k_base *ab,
4584                                         u16 tag, u16 len,
4585                                         const void *ptr, void *data)
4586 {
4587         struct wmi_tlv_dma_buf_release_parse *parse = data;
4588         int ret;
4589
4590         switch (tag) {
4591         case WMI_TAG_DMA_BUF_RELEASE:
4592                 memcpy(&parse->fixed, ptr,
4593                        sizeof(struct ath11k_wmi_dma_buf_release_fixed_param));
4594                 parse->fixed.pdev_id = DP_HW2SW_MACID(parse->fixed.pdev_id);
4595                 break;
4596         case WMI_TAG_ARRAY_STRUCT:
4597                 if (!parse->buf_entry_done) {
4598                         parse->num_buf_entry = 0;
4599                         parse->buf_entry = (struct wmi_dma_buf_release_entry *)ptr;
4600
4601                         ret = ath11k_wmi_tlv_iter(ab, ptr, len,
4602                                                   ath11k_wmi_tlv_dma_buf_entry_parse,
4603                                                   parse);
4604                         if (ret) {
4605                                 ath11k_warn(ab, "failed to parse dma buf entry tlv %d\n",
4606                                             ret);
4607                                 return ret;
4608                         }
4609
4610                         parse->buf_entry_done = true;
4611                 } else if (!parse->meta_data_done) {
4612                         parse->num_meta = 0;
4613                         parse->meta_data = (struct wmi_dma_buf_release_meta_data *)ptr;
4614
4615                         ret = ath11k_wmi_tlv_iter(ab, ptr, len,
4616                                                   ath11k_wmi_tlv_dma_buf_meta_parse,
4617                                                   parse);
4618                         if (ret) {
4619                                 ath11k_warn(ab, "failed to parse dma buf meta tlv %d\n",
4620                                             ret);
4621                                 return ret;
4622                         }
4623
4624                         parse->meta_data_done = true;
4625                 }
4626                 break;
4627         default:
4628                 break;
4629         }
4630         return 0;
4631 }
4632
4633 static void ath11k_wmi_pdev_dma_ring_buf_release_event(struct ath11k_base *ab,
4634                                                        struct sk_buff *skb)
4635 {
4636         struct wmi_tlv_dma_buf_release_parse parse = { };
4637         struct ath11k_dbring_buf_release_event param;
4638         int ret;
4639
4640         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
4641                                   ath11k_wmi_tlv_dma_buf_parse,
4642                                   &parse);
4643         if (ret) {
4644                 ath11k_warn(ab, "failed to parse dma buf release tlv %d\n", ret);
4645                 return;
4646         }
4647
4648         ath11k_dbg(ab, ATH11K_DBG_WMI, "event pdev dma ring buf release");
4649
4650         param.fixed             = parse.fixed;
4651         param.buf_entry         = parse.buf_entry;
4652         param.num_buf_entry     = parse.num_buf_entry;
4653         param.meta_data         = parse.meta_data;
4654         param.num_meta          = parse.num_meta;
4655
4656         ret = ath11k_dbring_buffer_release_event(ab, &param);
4657         if (ret) {
4658                 ath11k_warn(ab, "failed to handle dma buf release event %d\n", ret);
4659                 return;
4660         }
4661 }
4662
4663 static int ath11k_wmi_tlv_hw_mode_caps_parse(struct ath11k_base *soc,
4664                                              u16 tag, u16 len,
4665                                              const void *ptr, void *data)
4666 {
4667         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
4668         struct wmi_hw_mode_capabilities *hw_mode_cap;
4669         u32 phy_map = 0;
4670
4671         if (tag != WMI_TAG_HW_MODE_CAPABILITIES)
4672                 return -EPROTO;
4673
4674         if (svc_rdy_ext->n_hw_mode_caps >= svc_rdy_ext->param.num_hw_modes)
4675                 return -ENOBUFS;
4676
4677         hw_mode_cap = container_of(ptr, struct wmi_hw_mode_capabilities,
4678                                    hw_mode_id);
4679         svc_rdy_ext->n_hw_mode_caps++;
4680
4681         phy_map = hw_mode_cap->phy_id_map;
4682         while (phy_map) {
4683                 svc_rdy_ext->tot_phy_id++;
4684                 phy_map = phy_map >> 1;
4685         }
4686
4687         return 0;
4688 }
4689
4690 static int ath11k_wmi_tlv_hw_mode_caps(struct ath11k_base *soc,
4691                                        u16 len, const void *ptr, void *data)
4692 {
4693         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
4694         struct wmi_hw_mode_capabilities *hw_mode_caps;
4695         enum wmi_host_hw_mode_config_type mode, pref;
4696         u32 i;
4697         int ret;
4698
4699         svc_rdy_ext->n_hw_mode_caps = 0;
4700         svc_rdy_ext->hw_mode_caps = (struct wmi_hw_mode_capabilities *)ptr;
4701
4702         ret = ath11k_wmi_tlv_iter(soc, ptr, len,
4703                                   ath11k_wmi_tlv_hw_mode_caps_parse,
4704                                   svc_rdy_ext);
4705         if (ret) {
4706                 ath11k_warn(soc, "failed to parse tlv %d\n", ret);
4707                 return ret;
4708         }
4709
4710         i = 0;
4711         while (i < svc_rdy_ext->n_hw_mode_caps) {
4712                 hw_mode_caps = &svc_rdy_ext->hw_mode_caps[i];
4713                 mode = hw_mode_caps->hw_mode_id;
4714                 pref = soc->wmi_ab.preferred_hw_mode;
4715
4716                 if (ath11k_hw_mode_pri_map[mode] < ath11k_hw_mode_pri_map[pref]) {
4717                         svc_rdy_ext->pref_hw_mode_caps = *hw_mode_caps;
4718                         soc->wmi_ab.preferred_hw_mode = mode;
4719                 }
4720                 i++;
4721         }
4722
4723         ath11k_dbg(soc, ATH11K_DBG_WMI, "preferred_hw_mode:%d\n",
4724                    soc->wmi_ab.preferred_hw_mode);
4725         if (soc->wmi_ab.preferred_hw_mode == WMI_HOST_HW_MODE_MAX)
4726                 return -EINVAL;
4727
4728         return 0;
4729 }
4730
4731 static int ath11k_wmi_tlv_mac_phy_caps_parse(struct ath11k_base *soc,
4732                                              u16 tag, u16 len,
4733                                              const void *ptr, void *data)
4734 {
4735         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
4736
4737         if (tag != WMI_TAG_MAC_PHY_CAPABILITIES)
4738                 return -EPROTO;
4739
4740         if (svc_rdy_ext->n_mac_phy_caps >= svc_rdy_ext->tot_phy_id)
4741                 return -ENOBUFS;
4742
4743         len = min_t(u16, len, sizeof(struct wmi_mac_phy_capabilities));
4744         if (!svc_rdy_ext->n_mac_phy_caps) {
4745                 svc_rdy_ext->mac_phy_caps = kcalloc(svc_rdy_ext->tot_phy_id,
4746                                                     len, GFP_ATOMIC);
4747                 if (!svc_rdy_ext->mac_phy_caps)
4748                         return -ENOMEM;
4749         }
4750
4751         memcpy(svc_rdy_ext->mac_phy_caps + svc_rdy_ext->n_mac_phy_caps, ptr, len);
4752         svc_rdy_ext->n_mac_phy_caps++;
4753         return 0;
4754 }
4755
4756 static int ath11k_wmi_tlv_ext_hal_reg_caps_parse(struct ath11k_base *soc,
4757                                                  u16 tag, u16 len,
4758                                                  const void *ptr, void *data)
4759 {
4760         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
4761
4762         if (tag != WMI_TAG_HAL_REG_CAPABILITIES_EXT)
4763                 return -EPROTO;
4764
4765         if (svc_rdy_ext->n_ext_hal_reg_caps >= svc_rdy_ext->param.num_phy)
4766                 return -ENOBUFS;
4767
4768         svc_rdy_ext->n_ext_hal_reg_caps++;
4769         return 0;
4770 }
4771
4772 static int ath11k_wmi_tlv_ext_hal_reg_caps(struct ath11k_base *soc,
4773                                            u16 len, const void *ptr, void *data)
4774 {
4775         struct ath11k_pdev_wmi *wmi_handle = &soc->wmi_ab.wmi[0];
4776         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
4777         struct ath11k_hal_reg_capabilities_ext reg_cap;
4778         int ret;
4779         u32 i;
4780
4781         svc_rdy_ext->n_ext_hal_reg_caps = 0;
4782         svc_rdy_ext->ext_hal_reg_caps = (struct wmi_hal_reg_capabilities_ext *)ptr;
4783         ret = ath11k_wmi_tlv_iter(soc, ptr, len,
4784                                   ath11k_wmi_tlv_ext_hal_reg_caps_parse,
4785                                   svc_rdy_ext);
4786         if (ret) {
4787                 ath11k_warn(soc, "failed to parse tlv %d\n", ret);
4788                 return ret;
4789         }
4790
4791         for (i = 0; i < svc_rdy_ext->param.num_phy; i++) {
4792                 ret = ath11k_pull_reg_cap_svc_rdy_ext(wmi_handle,
4793                                                       svc_rdy_ext->soc_hal_reg_caps,
4794                                                       svc_rdy_ext->ext_hal_reg_caps, i,
4795                                                       &reg_cap);
4796                 if (ret) {
4797                         ath11k_warn(soc, "failed to extract reg cap %d\n", i);
4798                         return ret;
4799                 }
4800
4801                 memcpy(&soc->hal_reg_cap[reg_cap.phy_id],
4802                        &reg_cap, sizeof(reg_cap));
4803         }
4804         return 0;
4805 }
4806
4807 static int ath11k_wmi_tlv_ext_soc_hal_reg_caps_parse(struct ath11k_base *soc,
4808                                                      u16 len, const void *ptr,
4809                                                      void *data)
4810 {
4811         struct ath11k_pdev_wmi *wmi_handle = &soc->wmi_ab.wmi[0];
4812         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
4813         u8 hw_mode_id = svc_rdy_ext->pref_hw_mode_caps.hw_mode_id;
4814         u32 phy_id_map;
4815         int pdev_index = 0;
4816         int ret;
4817
4818         svc_rdy_ext->soc_hal_reg_caps = (struct wmi_soc_hal_reg_capabilities *)ptr;
4819         svc_rdy_ext->param.num_phy = svc_rdy_ext->soc_hal_reg_caps->num_phy;
4820
4821         soc->num_radios = 0;
4822         soc->target_pdev_count = 0;
4823         phy_id_map = svc_rdy_ext->pref_hw_mode_caps.phy_id_map;
4824
4825         while (phy_id_map && soc->num_radios < MAX_RADIOS) {
4826                 ret = ath11k_pull_mac_phy_cap_svc_ready_ext(wmi_handle,
4827                                                             svc_rdy_ext->hw_caps,
4828                                                             svc_rdy_ext->hw_mode_caps,
4829                                                             svc_rdy_ext->soc_hal_reg_caps,
4830                                                             svc_rdy_ext->mac_phy_caps,
4831                                                             hw_mode_id, soc->num_radios,
4832                                                             &soc->pdevs[pdev_index]);
4833                 if (ret) {
4834                         ath11k_warn(soc, "failed to extract mac caps, idx :%d\n",
4835                                     soc->num_radios);
4836                         return ret;
4837                 }
4838
4839                 soc->num_radios++;
4840
4841                 /* For QCA6390, save mac_phy capability in the same pdev */
4842                 if (soc->hw_params.single_pdev_only)
4843                         pdev_index = 0;
4844                 else
4845                         pdev_index = soc->num_radios;
4846
4847                 /* TODO: mac_phy_cap prints */
4848                 phy_id_map >>= 1;
4849         }
4850
4851         /* For QCA6390, set num_radios to 1 because host manages
4852          * both 2G and 5G radio in one pdev.
4853          * Set pdev_id = 0 and 0 means soc level.
4854          */
4855         if (soc->hw_params.single_pdev_only) {
4856                 soc->num_radios = 1;
4857                 soc->pdevs[0].pdev_id = 0;
4858         }
4859
4860         if (!soc->reg_info_store) {
4861                 soc->reg_info_store = kcalloc(soc->num_radios,
4862                                               sizeof(*soc->reg_info_store),
4863                                               GFP_ATOMIC);
4864                 if (!soc->reg_info_store)
4865                         return -ENOMEM;
4866         }
4867
4868         return 0;
4869 }
4870
4871 static int ath11k_wmi_tlv_dma_ring_caps_parse(struct ath11k_base *soc,
4872                                               u16 tag, u16 len,
4873                                               const void *ptr, void *data)
4874 {
4875         struct wmi_tlv_dma_ring_caps_parse *parse = data;
4876
4877         if (tag != WMI_TAG_DMA_RING_CAPABILITIES)
4878                 return -EPROTO;
4879
4880         parse->n_dma_ring_caps++;
4881         return 0;
4882 }
4883
4884 static int ath11k_wmi_alloc_dbring_caps(struct ath11k_base *ab,
4885                                         u32 num_cap)
4886 {
4887         size_t sz;
4888         void *ptr;
4889
4890         sz = num_cap * sizeof(struct ath11k_dbring_cap);
4891         ptr = kzalloc(sz, GFP_ATOMIC);
4892         if (!ptr)
4893                 return -ENOMEM;
4894
4895         ab->db_caps = ptr;
4896         ab->num_db_cap = num_cap;
4897
4898         return 0;
4899 }
4900
4901 static void ath11k_wmi_free_dbring_caps(struct ath11k_base *ab)
4902 {
4903         kfree(ab->db_caps);
4904         ab->db_caps = NULL;
4905         ab->num_db_cap = 0;
4906 }
4907
4908 static int ath11k_wmi_tlv_dma_ring_caps(struct ath11k_base *ab,
4909                                         u16 len, const void *ptr, void *data)
4910 {
4911         struct wmi_tlv_dma_ring_caps_parse *dma_caps_parse = data;
4912         struct wmi_dma_ring_capabilities *dma_caps;
4913         struct ath11k_dbring_cap *dir_buff_caps;
4914         int ret;
4915         u32 i;
4916
4917         dma_caps_parse->n_dma_ring_caps = 0;
4918         dma_caps = (struct wmi_dma_ring_capabilities *)ptr;
4919         ret = ath11k_wmi_tlv_iter(ab, ptr, len,
4920                                   ath11k_wmi_tlv_dma_ring_caps_parse,
4921                                   dma_caps_parse);
4922         if (ret) {
4923                 ath11k_warn(ab, "failed to parse dma ring caps tlv %d\n", ret);
4924                 return ret;
4925         }
4926
4927         if (!dma_caps_parse->n_dma_ring_caps)
4928                 return 0;
4929
4930         if (ab->num_db_cap) {
4931                 ath11k_warn(ab, "Already processed, so ignoring dma ring caps\n");
4932                 return 0;
4933         }
4934
4935         ret = ath11k_wmi_alloc_dbring_caps(ab, dma_caps_parse->n_dma_ring_caps);
4936         if (ret)
4937                 return ret;
4938
4939         dir_buff_caps = ab->db_caps;
4940         for (i = 0; i < dma_caps_parse->n_dma_ring_caps; i++) {
4941                 if (dma_caps[i].module_id >= WMI_DIRECT_BUF_MAX) {
4942                         ath11k_warn(ab, "Invalid module id %d\n", dma_caps[i].module_id);
4943                         ret = -EINVAL;
4944                         goto free_dir_buff;
4945                 }
4946
4947                 dir_buff_caps[i].id = dma_caps[i].module_id;
4948                 dir_buff_caps[i].pdev_id = DP_HW2SW_MACID(dma_caps[i].pdev_id);
4949                 dir_buff_caps[i].min_elem = dma_caps[i].min_elem;
4950                 dir_buff_caps[i].min_buf_sz = dma_caps[i].min_buf_sz;
4951                 dir_buff_caps[i].min_buf_align = dma_caps[i].min_buf_align;
4952         }
4953
4954         return 0;
4955
4956 free_dir_buff:
4957         ath11k_wmi_free_dbring_caps(ab);
4958         return ret;
4959 }
4960
4961 static int ath11k_wmi_tlv_svc_rdy_ext_parse(struct ath11k_base *ab,
4962                                             u16 tag, u16 len,
4963                                             const void *ptr, void *data)
4964 {
4965         struct ath11k_pdev_wmi *wmi_handle = &ab->wmi_ab.wmi[0];
4966         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
4967         int ret;
4968
4969         switch (tag) {
4970         case WMI_TAG_SERVICE_READY_EXT_EVENT:
4971                 ret = ath11k_pull_svc_ready_ext(wmi_handle, ptr,
4972                                                 &svc_rdy_ext->param);
4973                 if (ret) {
4974                         ath11k_warn(ab, "unable to extract ext params\n");
4975                         return ret;
4976                 }
4977                 break;
4978
4979         case WMI_TAG_SOC_MAC_PHY_HW_MODE_CAPS:
4980                 svc_rdy_ext->hw_caps = (struct wmi_soc_mac_phy_hw_mode_caps *)ptr;
4981                 svc_rdy_ext->param.num_hw_modes = svc_rdy_ext->hw_caps->num_hw_modes;
4982                 break;
4983
4984         case WMI_TAG_SOC_HAL_REG_CAPABILITIES:
4985                 ret = ath11k_wmi_tlv_ext_soc_hal_reg_caps_parse(ab, len, ptr,
4986                                                                 svc_rdy_ext);
4987                 if (ret)
4988                         return ret;
4989                 break;
4990
4991         case WMI_TAG_ARRAY_STRUCT:
4992                 if (!svc_rdy_ext->hw_mode_done) {
4993                         ret = ath11k_wmi_tlv_hw_mode_caps(ab, len, ptr,
4994                                                           svc_rdy_ext);
4995                         if (ret)
4996                                 return ret;
4997
4998                         svc_rdy_ext->hw_mode_done = true;
4999                 } else if (!svc_rdy_ext->mac_phy_done) {
5000                         svc_rdy_ext->n_mac_phy_caps = 0;
5001                         ret = ath11k_wmi_tlv_iter(ab, ptr, len,
5002                                                   ath11k_wmi_tlv_mac_phy_caps_parse,
5003                                                   svc_rdy_ext);
5004                         if (ret) {
5005                                 ath11k_warn(ab, "failed to parse tlv %d\n", ret);
5006                                 return ret;
5007                         }
5008
5009                         svc_rdy_ext->mac_phy_done = true;
5010                 } else if (!svc_rdy_ext->ext_hal_reg_done) {
5011                         ret = ath11k_wmi_tlv_ext_hal_reg_caps(ab, len, ptr,
5012                                                               svc_rdy_ext);
5013                         if (ret)
5014                                 return ret;
5015
5016                         svc_rdy_ext->ext_hal_reg_done = true;
5017                 } else if (!svc_rdy_ext->mac_phy_chainmask_combo_done) {
5018                         svc_rdy_ext->mac_phy_chainmask_combo_done = true;
5019                 } else if (!svc_rdy_ext->mac_phy_chainmask_cap_done) {
5020                         svc_rdy_ext->mac_phy_chainmask_cap_done = true;
5021                 } else if (!svc_rdy_ext->oem_dma_ring_cap_done) {
5022                         svc_rdy_ext->oem_dma_ring_cap_done = true;
5023                 } else if (!svc_rdy_ext->dma_ring_cap_done) {
5024                         ret = ath11k_wmi_tlv_dma_ring_caps(ab, len, ptr,
5025                                                            &svc_rdy_ext->dma_caps_parse);
5026                         if (ret)
5027                                 return ret;
5028
5029                         svc_rdy_ext->dma_ring_cap_done = true;
5030                 }
5031                 break;
5032
5033         default:
5034                 break;
5035         }
5036         return 0;
5037 }
5038
5039 static int ath11k_service_ready_ext_event(struct ath11k_base *ab,
5040                                           struct sk_buff *skb)
5041 {
5042         struct wmi_tlv_svc_rdy_ext_parse svc_rdy_ext = { };
5043         int ret;
5044
5045         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
5046                                   ath11k_wmi_tlv_svc_rdy_ext_parse,
5047                                   &svc_rdy_ext);
5048         if (ret) {
5049                 ath11k_warn(ab, "failed to parse tlv %d\n", ret);
5050                 goto err;
5051         }
5052
5053         ath11k_dbg(ab, ATH11K_DBG_WMI, "event service ready ext");
5054
5055         if (!test_bit(WMI_TLV_SERVICE_EXT2_MSG, ab->wmi_ab.svc_map))
5056                 complete(&ab->wmi_ab.service_ready);
5057
5058         kfree(svc_rdy_ext.mac_phy_caps);
5059         return 0;
5060
5061 err:
5062         ath11k_wmi_free_dbring_caps(ab);
5063         return ret;
5064 }
5065
5066 static int ath11k_wmi_tlv_svc_rdy_ext2_parse(struct ath11k_base *ab,
5067                                              u16 tag, u16 len,
5068                                              const void *ptr, void *data)
5069 {
5070         struct wmi_tlv_svc_rdy_ext2_parse *parse = data;
5071         int ret;
5072
5073         switch (tag) {
5074         case WMI_TAG_ARRAY_STRUCT:
5075                 if (!parse->dma_ring_cap_done) {
5076                         ret = ath11k_wmi_tlv_dma_ring_caps(ab, len, ptr,
5077                                                            &parse->dma_caps_parse);
5078                         if (ret)
5079                                 return ret;
5080
5081                         parse->dma_ring_cap_done = true;
5082                 }
5083                 break;
5084         default:
5085                 break;
5086         }
5087
5088         return 0;
5089 }
5090
5091 static int ath11k_service_ready_ext2_event(struct ath11k_base *ab,
5092                                            struct sk_buff *skb)
5093 {
5094         struct wmi_tlv_svc_rdy_ext2_parse svc_rdy_ext2 = { };
5095         int ret;
5096
5097         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
5098                                   ath11k_wmi_tlv_svc_rdy_ext2_parse,
5099                                   &svc_rdy_ext2);
5100         if (ret) {
5101                 ath11k_warn(ab, "failed to parse ext2 event tlv %d\n", ret);
5102                 goto err;
5103         }
5104
5105         ath11k_dbg(ab, ATH11K_DBG_WMI, "event service ready ext2");
5106
5107         complete(&ab->wmi_ab.service_ready);
5108
5109         return 0;
5110
5111 err:
5112         ath11k_wmi_free_dbring_caps(ab);
5113         return ret;
5114 }
5115
5116 static int ath11k_pull_vdev_start_resp_tlv(struct ath11k_base *ab, struct sk_buff *skb,
5117                                            struct wmi_vdev_start_resp_event *vdev_rsp)
5118 {
5119         const void **tb;
5120         const struct wmi_vdev_start_resp_event *ev;
5121         int ret;
5122
5123         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
5124         if (IS_ERR(tb)) {
5125                 ret = PTR_ERR(tb);
5126                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
5127                 return ret;
5128         }
5129
5130         ev = tb[WMI_TAG_VDEV_START_RESPONSE_EVENT];
5131         if (!ev) {
5132                 ath11k_warn(ab, "failed to fetch vdev start resp ev");
5133                 kfree(tb);
5134                 return -EPROTO;
5135         }
5136
5137         memset(vdev_rsp, 0, sizeof(*vdev_rsp));
5138
5139         vdev_rsp->vdev_id = ev->vdev_id;
5140         vdev_rsp->requestor_id = ev->requestor_id;
5141         vdev_rsp->resp_type = ev->resp_type;
5142         vdev_rsp->status = ev->status;
5143         vdev_rsp->chain_mask = ev->chain_mask;
5144         vdev_rsp->smps_mode = ev->smps_mode;
5145         vdev_rsp->mac_id = ev->mac_id;
5146         vdev_rsp->cfgd_tx_streams = ev->cfgd_tx_streams;
5147         vdev_rsp->cfgd_rx_streams = ev->cfgd_rx_streams;
5148         vdev_rsp->max_allowed_tx_power = ev->max_allowed_tx_power;
5149
5150         kfree(tb);
5151         return 0;
5152 }
5153
5154 static void ath11k_print_reg_rule(struct ath11k_base *ab, const char *band,
5155                                   u32 num_reg_rules,
5156                                   struct cur_reg_rule *reg_rule_ptr)
5157 {
5158         struct cur_reg_rule *reg_rule = reg_rule_ptr;
5159         u32 count;
5160
5161         ath11k_dbg(ab, ATH11K_DBG_WMI, "number of reg rules in %s band: %d\n",
5162                    band, num_reg_rules);
5163
5164         for (count = 0; count < num_reg_rules; count++) {
5165                 ath11k_dbg(ab, ATH11K_DBG_WMI,
5166                            "reg rule %d: (%d - %d @ %d) (%d, %d) (FLAGS %d)\n",
5167                            count + 1, reg_rule->start_freq, reg_rule->end_freq,
5168                            reg_rule->max_bw, reg_rule->ant_gain,
5169                            reg_rule->reg_power, reg_rule->flags);
5170                 reg_rule++;
5171         }
5172 }
5173
5174 static struct cur_reg_rule
5175 *create_reg_rules_from_wmi(u32 num_reg_rules,
5176                            struct wmi_regulatory_rule_struct *wmi_reg_rule)
5177 {
5178         struct cur_reg_rule *reg_rule_ptr;
5179         u32 count;
5180
5181         reg_rule_ptr = kcalloc(num_reg_rules, sizeof(*reg_rule_ptr),
5182                                GFP_ATOMIC);
5183
5184         if (!reg_rule_ptr)
5185                 return NULL;
5186
5187         for (count = 0; count < num_reg_rules; count++) {
5188                 reg_rule_ptr[count].start_freq =
5189                         FIELD_GET(REG_RULE_START_FREQ,
5190                                   wmi_reg_rule[count].freq_info);
5191                 reg_rule_ptr[count].end_freq =
5192                         FIELD_GET(REG_RULE_END_FREQ,
5193                                   wmi_reg_rule[count].freq_info);
5194                 reg_rule_ptr[count].max_bw =
5195                         FIELD_GET(REG_RULE_MAX_BW,
5196                                   wmi_reg_rule[count].bw_pwr_info);
5197                 reg_rule_ptr[count].reg_power =
5198                         FIELD_GET(REG_RULE_REG_PWR,
5199                                   wmi_reg_rule[count].bw_pwr_info);
5200                 reg_rule_ptr[count].ant_gain =
5201                         FIELD_GET(REG_RULE_ANT_GAIN,
5202                                   wmi_reg_rule[count].bw_pwr_info);
5203                 reg_rule_ptr[count].flags =
5204                         FIELD_GET(REG_RULE_FLAGS,
5205                                   wmi_reg_rule[count].flag_info);
5206         }
5207
5208         return reg_rule_ptr;
5209 }
5210
5211 static int ath11k_pull_reg_chan_list_update_ev(struct ath11k_base *ab,
5212                                                struct sk_buff *skb,
5213                                                struct cur_regulatory_info *reg_info)
5214 {
5215         const void **tb;
5216         const struct wmi_reg_chan_list_cc_event *chan_list_event_hdr;
5217         struct wmi_regulatory_rule_struct *wmi_reg_rule;
5218         u32 num_2ghz_reg_rules, num_5ghz_reg_rules;
5219         int ret;
5220
5221         ath11k_dbg(ab, ATH11K_DBG_WMI, "processing regulatory channel list\n");
5222
5223         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
5224         if (IS_ERR(tb)) {
5225                 ret = PTR_ERR(tb);
5226                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
5227                 return ret;
5228         }
5229
5230         chan_list_event_hdr = tb[WMI_TAG_REG_CHAN_LIST_CC_EVENT];
5231         if (!chan_list_event_hdr) {
5232                 ath11k_warn(ab, "failed to fetch reg chan list update ev\n");
5233                 kfree(tb);
5234                 return -EPROTO;
5235         }
5236
5237         reg_info->num_2ghz_reg_rules = chan_list_event_hdr->num_2ghz_reg_rules;
5238         reg_info->num_5ghz_reg_rules = chan_list_event_hdr->num_5ghz_reg_rules;
5239
5240         if (!(reg_info->num_2ghz_reg_rules + reg_info->num_5ghz_reg_rules)) {
5241                 ath11k_warn(ab, "No regulatory rules available in the event info\n");
5242                 kfree(tb);
5243                 return -EINVAL;
5244         }
5245
5246         memcpy(reg_info->alpha2, &chan_list_event_hdr->alpha2,
5247                REG_ALPHA2_LEN);
5248         reg_info->dfs_region = chan_list_event_hdr->dfs_region;
5249         reg_info->phybitmap = chan_list_event_hdr->phybitmap;
5250         reg_info->num_phy = chan_list_event_hdr->num_phy;
5251         reg_info->phy_id = chan_list_event_hdr->phy_id;
5252         reg_info->ctry_code = chan_list_event_hdr->country_id;
5253         reg_info->reg_dmn_pair = chan_list_event_hdr->domain_code;
5254
5255         ath11k_dbg(ab, ATH11K_DBG_WMI,
5256                    "status_code %s",
5257                    ath11k_cc_status_to_str(reg_info->status_code));
5258
5259         reg_info->status_code =
5260                 ath11k_wmi_cc_setting_code_to_reg(chan_list_event_hdr->status_code);
5261
5262         reg_info->is_ext_reg_event = false;
5263
5264         reg_info->min_bw_2ghz = chan_list_event_hdr->min_bw_2ghz;
5265         reg_info->max_bw_2ghz = chan_list_event_hdr->max_bw_2ghz;
5266         reg_info->min_bw_5ghz = chan_list_event_hdr->min_bw_5ghz;
5267         reg_info->max_bw_5ghz = chan_list_event_hdr->max_bw_5ghz;
5268
5269         num_2ghz_reg_rules = reg_info->num_2ghz_reg_rules;
5270         num_5ghz_reg_rules = reg_info->num_5ghz_reg_rules;
5271
5272         ath11k_dbg(ab, ATH11K_DBG_WMI,
5273                    "cc %s dsf %d BW: min_2ghz %d max_2ghz %d min_5ghz %d max_5ghz %d",
5274                    reg_info->alpha2, reg_info->dfs_region,
5275                    reg_info->min_bw_2ghz, reg_info->max_bw_2ghz,
5276                    reg_info->min_bw_5ghz, reg_info->max_bw_5ghz);
5277
5278         ath11k_dbg(ab, ATH11K_DBG_WMI,
5279                    "num_2ghz_reg_rules %d num_5ghz_reg_rules %d",
5280                    num_2ghz_reg_rules, num_5ghz_reg_rules);
5281
5282         wmi_reg_rule =
5283                 (struct wmi_regulatory_rule_struct *)((u8 *)chan_list_event_hdr
5284                                                 + sizeof(*chan_list_event_hdr)
5285                                                 + sizeof(struct wmi_tlv));
5286
5287         if (num_2ghz_reg_rules) {
5288                 reg_info->reg_rules_2ghz_ptr =
5289                                 create_reg_rules_from_wmi(num_2ghz_reg_rules,
5290                                                           wmi_reg_rule);
5291                 if (!reg_info->reg_rules_2ghz_ptr) {
5292                         kfree(tb);
5293                         ath11k_warn(ab, "Unable to Allocate memory for 2 GHz rules\n");
5294                         return -ENOMEM;
5295                 }
5296
5297                 ath11k_print_reg_rule(ab, "2 GHz",
5298                                       num_2ghz_reg_rules,
5299                                       reg_info->reg_rules_2ghz_ptr);
5300         }
5301
5302         if (num_5ghz_reg_rules) {
5303                 wmi_reg_rule += num_2ghz_reg_rules;
5304                 reg_info->reg_rules_5ghz_ptr =
5305                                 create_reg_rules_from_wmi(num_5ghz_reg_rules,
5306                                                           wmi_reg_rule);
5307                 if (!reg_info->reg_rules_5ghz_ptr) {
5308                         kfree(tb);
5309                         ath11k_warn(ab, "Unable to Allocate memory for 5 GHz rules\n");
5310                         return -ENOMEM;
5311                 }
5312
5313                 ath11k_print_reg_rule(ab, "5 GHz",
5314                                       num_5ghz_reg_rules,
5315                                       reg_info->reg_rules_5ghz_ptr);
5316         }
5317
5318         ath11k_dbg(ab, ATH11K_DBG_WMI, "processed regulatory channel list\n");
5319
5320         kfree(tb);
5321         return 0;
5322 }
5323
5324 static struct cur_reg_rule
5325 *create_ext_reg_rules_from_wmi(u32 num_reg_rules,
5326                                struct wmi_regulatory_ext_rule *wmi_reg_rule)
5327 {
5328         struct cur_reg_rule *reg_rule_ptr;
5329         u32 count;
5330
5331         reg_rule_ptr =  kcalloc(num_reg_rules, sizeof(*reg_rule_ptr), GFP_ATOMIC);
5332
5333         if (!reg_rule_ptr)
5334                 return NULL;
5335
5336         for (count = 0; count < num_reg_rules; count++) {
5337                 reg_rule_ptr[count].start_freq =
5338                         u32_get_bits(wmi_reg_rule[count].freq_info,
5339                                      REG_RULE_START_FREQ);
5340                 reg_rule_ptr[count].end_freq =
5341                         u32_get_bits(wmi_reg_rule[count].freq_info,
5342                                      REG_RULE_END_FREQ);
5343                 reg_rule_ptr[count].max_bw =
5344                         u32_get_bits(wmi_reg_rule[count].bw_pwr_info,
5345                                      REG_RULE_MAX_BW);
5346                 reg_rule_ptr[count].reg_power =
5347                         u32_get_bits(wmi_reg_rule[count].bw_pwr_info,
5348                                      REG_RULE_REG_PWR);
5349                 reg_rule_ptr[count].ant_gain =
5350                         u32_get_bits(wmi_reg_rule[count].bw_pwr_info,
5351                                      REG_RULE_ANT_GAIN);
5352                 reg_rule_ptr[count].flags =
5353                         u32_get_bits(wmi_reg_rule[count].flag_info,
5354                                      REG_RULE_FLAGS);
5355                 reg_rule_ptr[count].psd_flag =
5356                         u32_get_bits(wmi_reg_rule[count].psd_power_info,
5357                                      REG_RULE_PSD_INFO);
5358                 reg_rule_ptr[count].psd_eirp =
5359                         u32_get_bits(wmi_reg_rule[count].psd_power_info,
5360                                      REG_RULE_PSD_EIRP);
5361         }
5362
5363         return reg_rule_ptr;
5364 }
5365
5366 static u8
5367 ath11k_invalid_5ghz_reg_ext_rules_from_wmi(u32 num_reg_rules,
5368                                            const struct wmi_regulatory_ext_rule *rule)
5369 {
5370         u8 num_invalid_5ghz_rules = 0;
5371         u32 count, start_freq;
5372
5373         for (count = 0; count < num_reg_rules; count++) {
5374                 start_freq = u32_get_bits(rule[count].freq_info,
5375                                           REG_RULE_START_FREQ);
5376
5377                 if (start_freq >= ATH11K_MIN_6G_FREQ)
5378                         num_invalid_5ghz_rules++;
5379         }
5380
5381         return num_invalid_5ghz_rules;
5382 }
5383
5384 static int ath11k_pull_reg_chan_list_ext_update_ev(struct ath11k_base *ab,
5385                                                    struct sk_buff *skb,
5386                                                    struct cur_regulatory_info *reg_info)
5387 {
5388         const void **tb;
5389         const struct wmi_reg_chan_list_cc_ext_event *ev;
5390         struct wmi_regulatory_ext_rule *ext_wmi_reg_rule;
5391         u32 num_2ghz_reg_rules, num_5ghz_reg_rules;
5392         u32 num_6ghz_reg_rules_ap[WMI_REG_CURRENT_MAX_AP_TYPE];
5393         u32 num_6ghz_client[WMI_REG_CURRENT_MAX_AP_TYPE][WMI_REG_MAX_CLIENT_TYPE];
5394         u32 total_reg_rules = 0;
5395         int ret, i, j, num_invalid_5ghz_ext_rules = 0;
5396
5397         ath11k_dbg(ab, ATH11K_DBG_WMI, "processing regulatory ext channel list\n");
5398
5399         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
5400         if (IS_ERR(tb)) {
5401                 ret = PTR_ERR(tb);
5402                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
5403                 return ret;
5404         }
5405
5406         ev = tb[WMI_TAG_REG_CHAN_LIST_CC_EXT_EVENT];
5407         if (!ev) {
5408                 ath11k_warn(ab, "failed to fetch reg chan list ext update ev\n");
5409                 kfree(tb);
5410                 return -EPROTO;
5411         }
5412
5413         reg_info->num_2ghz_reg_rules = ev->num_2ghz_reg_rules;
5414         reg_info->num_5ghz_reg_rules = ev->num_5ghz_reg_rules;
5415         reg_info->num_6ghz_rules_ap[WMI_REG_INDOOR_AP] =
5416                         ev->num_6ghz_reg_rules_ap_lpi;
5417         reg_info->num_6ghz_rules_ap[WMI_REG_STANDARD_POWER_AP] =
5418                         ev->num_6ghz_reg_rules_ap_sp;
5419         reg_info->num_6ghz_rules_ap[WMI_REG_VERY_LOW_POWER_AP] =
5420                         ev->num_6ghz_reg_rules_ap_vlp;
5421
5422         for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
5423                 reg_info->num_6ghz_rules_client[WMI_REG_INDOOR_AP][i] =
5424                         ev->num_6ghz_reg_rules_client_lpi[i];
5425                 reg_info->num_6ghz_rules_client[WMI_REG_STANDARD_POWER_AP][i] =
5426                         ev->num_6ghz_reg_rules_client_sp[i];
5427                 reg_info->num_6ghz_rules_client[WMI_REG_VERY_LOW_POWER_AP][i] =
5428                         ev->num_6ghz_reg_rules_client_vlp[i];
5429         }
5430
5431         num_2ghz_reg_rules = reg_info->num_2ghz_reg_rules;
5432         num_5ghz_reg_rules = reg_info->num_5ghz_reg_rules;
5433
5434         total_reg_rules += num_2ghz_reg_rules;
5435         total_reg_rules += num_5ghz_reg_rules;
5436
5437         if ((num_2ghz_reg_rules > MAX_REG_RULES) ||
5438             (num_5ghz_reg_rules > MAX_REG_RULES)) {
5439                 ath11k_warn(ab, "Num reg rules for 2.4 GHz/5 GHz exceeds max limit (num_2ghz_reg_rules: %d num_5ghz_reg_rules: %d max_rules: %d)\n",
5440                             num_2ghz_reg_rules, num_5ghz_reg_rules, MAX_REG_RULES);
5441                 kfree(tb);
5442                 return -EINVAL;
5443         }
5444
5445         for (i = 0; i < WMI_REG_CURRENT_MAX_AP_TYPE; i++) {
5446                 num_6ghz_reg_rules_ap[i] = reg_info->num_6ghz_rules_ap[i];
5447
5448                 if (num_6ghz_reg_rules_ap[i] > MAX_6GHZ_REG_RULES) {
5449                         ath11k_warn(ab, "Num 6 GHz reg rules for AP mode(%d) exceeds max limit (num_6ghz_reg_rules_ap: %d, max_rules: %d)\n",
5450                                     i, num_6ghz_reg_rules_ap[i], MAX_6GHZ_REG_RULES);
5451                         kfree(tb);
5452                         return -EINVAL;
5453                 }
5454
5455                 total_reg_rules += num_6ghz_reg_rules_ap[i];
5456         }
5457
5458         for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
5459                 num_6ghz_client[WMI_REG_INDOOR_AP][i] =
5460                         reg_info->num_6ghz_rules_client[WMI_REG_INDOOR_AP][i];
5461                 total_reg_rules += num_6ghz_client[WMI_REG_INDOOR_AP][i];
5462
5463                 num_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] =
5464                         reg_info->num_6ghz_rules_client[WMI_REG_STANDARD_POWER_AP][i];
5465                 total_reg_rules += num_6ghz_client[WMI_REG_STANDARD_POWER_AP][i];
5466
5467                 num_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] =
5468                         reg_info->num_6ghz_rules_client[WMI_REG_VERY_LOW_POWER_AP][i];
5469                 total_reg_rules += num_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i];
5470
5471                 if ((num_6ghz_client[WMI_REG_INDOOR_AP][i] > MAX_6GHZ_REG_RULES) ||
5472                     (num_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] >
5473                                                              MAX_6GHZ_REG_RULES) ||
5474                     (num_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] >
5475                                                              MAX_6GHZ_REG_RULES)) {
5476                         ath11k_warn(ab,
5477                                     "Num 6 GHz client reg rules exceeds max limit, for client(type: %d)\n",
5478                                     i);
5479                         kfree(tb);
5480                         return -EINVAL;
5481                 }
5482         }
5483
5484         if (!total_reg_rules) {
5485                 ath11k_warn(ab, "No reg rules available\n");
5486                 kfree(tb);
5487                 return -EINVAL;
5488         }
5489
5490         memcpy(reg_info->alpha2, &ev->alpha2, REG_ALPHA2_LEN);
5491
5492         reg_info->dfs_region = ev->dfs_region;
5493         reg_info->phybitmap = ev->phybitmap;
5494         reg_info->num_phy = ev->num_phy;
5495         reg_info->phy_id = ev->phy_id;
5496         reg_info->ctry_code = ev->country_id;
5497         reg_info->reg_dmn_pair = ev->domain_code;
5498
5499         ath11k_dbg(ab, ATH11K_DBG_WMI,
5500                    "status_code %s",
5501                    ath11k_cc_status_to_str(reg_info->status_code));
5502
5503         reg_info->status_code =
5504                 ath11k_wmi_cc_setting_code_to_reg(ev->status_code);
5505
5506         reg_info->is_ext_reg_event = true;
5507
5508         reg_info->min_bw_2ghz = ev->min_bw_2ghz;
5509         reg_info->max_bw_2ghz = ev->max_bw_2ghz;
5510         reg_info->min_bw_5ghz = ev->min_bw_5ghz;
5511         reg_info->max_bw_5ghz = ev->max_bw_5ghz;
5512
5513         reg_info->min_bw_6ghz_ap[WMI_REG_INDOOR_AP] =
5514                         ev->min_bw_6ghz_ap_lpi;
5515         reg_info->max_bw_6ghz_ap[WMI_REG_INDOOR_AP] =
5516                         ev->max_bw_6ghz_ap_lpi;
5517         reg_info->min_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP] =
5518                         ev->min_bw_6ghz_ap_sp;
5519         reg_info->max_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP] =
5520                         ev->max_bw_6ghz_ap_sp;
5521         reg_info->min_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP] =
5522                         ev->min_bw_6ghz_ap_vlp;
5523         reg_info->max_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP] =
5524                         ev->max_bw_6ghz_ap_vlp;
5525
5526         ath11k_dbg(ab, ATH11K_DBG_WMI,
5527                    "6 GHz AP BW: LPI (%d - %d), SP (%d - %d), VLP (%d - %d)\n",
5528                    reg_info->min_bw_6ghz_ap[WMI_REG_INDOOR_AP],
5529                    reg_info->max_bw_6ghz_ap[WMI_REG_INDOOR_AP],
5530                    reg_info->min_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP],
5531                    reg_info->max_bw_6ghz_ap[WMI_REG_STANDARD_POWER_AP],
5532                    reg_info->min_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP],
5533                    reg_info->max_bw_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP]);
5534
5535         for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
5536                 reg_info->min_bw_6ghz_client[WMI_REG_INDOOR_AP][i] =
5537                                 ev->min_bw_6ghz_client_lpi[i];
5538                 reg_info->max_bw_6ghz_client[WMI_REG_INDOOR_AP][i] =
5539                                 ev->max_bw_6ghz_client_lpi[i];
5540                 reg_info->min_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] =
5541                                 ev->min_bw_6ghz_client_sp[i];
5542                 reg_info->max_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] =
5543                                 ev->max_bw_6ghz_client_sp[i];
5544                 reg_info->min_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] =
5545                                 ev->min_bw_6ghz_client_vlp[i];
5546                 reg_info->max_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] =
5547                                 ev->max_bw_6ghz_client_vlp[i];
5548
5549                 ath11k_dbg(ab, ATH11K_DBG_WMI,
5550                            "6 GHz %s BW: LPI (%d - %d), SP (%d - %d), VLP (%d - %d)\n",
5551                            ath11k_6ghz_client_type_to_str(i),
5552                            reg_info->min_bw_6ghz_client[WMI_REG_INDOOR_AP][i],
5553                            reg_info->max_bw_6ghz_client[WMI_REG_INDOOR_AP][i],
5554                            reg_info->min_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i],
5555                            reg_info->max_bw_6ghz_client[WMI_REG_STANDARD_POWER_AP][i],
5556                            reg_info->min_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i],
5557                            reg_info->max_bw_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i]);
5558         }
5559
5560         ath11k_dbg(ab, ATH11K_DBG_WMI,
5561                    "cc_ext %s dfs %d BW: min_2ghz %d max_2ghz %d min_5ghz %d max_5ghz %d phy_bitmap 0x%x",
5562                    reg_info->alpha2, reg_info->dfs_region,
5563                    reg_info->min_bw_2ghz, reg_info->max_bw_2ghz,
5564                    reg_info->min_bw_5ghz, reg_info->max_bw_5ghz,
5565                    reg_info->phybitmap);
5566
5567         ath11k_dbg(ab, ATH11K_DBG_WMI,
5568                    "num_2ghz_reg_rules %d num_5ghz_reg_rules %d",
5569                    num_2ghz_reg_rules, num_5ghz_reg_rules);
5570
5571         ath11k_dbg(ab, ATH11K_DBG_WMI,
5572                    "num_6ghz_reg_rules_ap_lpi: %d num_6ghz_reg_rules_ap_sp: %d num_6ghz_reg_rules_ap_vlp: %d",
5573                    num_6ghz_reg_rules_ap[WMI_REG_INDOOR_AP],
5574                    num_6ghz_reg_rules_ap[WMI_REG_STANDARD_POWER_AP],
5575                    num_6ghz_reg_rules_ap[WMI_REG_VERY_LOW_POWER_AP]);
5576
5577         j = WMI_REG_DEFAULT_CLIENT;
5578         ath11k_dbg(ab, ATH11K_DBG_WMI,
5579                    "6 GHz Regular client: num_6ghz_reg_rules_lpi: %d num_6ghz_reg_rules_sp: %d num_6ghz_reg_rules_vlp: %d",
5580                    num_6ghz_client[WMI_REG_INDOOR_AP][j],
5581                    num_6ghz_client[WMI_REG_STANDARD_POWER_AP][j],
5582                    num_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][j]);
5583
5584         j = WMI_REG_SUBORDINATE_CLIENT;
5585         ath11k_dbg(ab, ATH11K_DBG_WMI,
5586                    "6 GHz Subordinate client: num_6ghz_reg_rules_lpi: %d num_6ghz_reg_rules_sp: %d num_6ghz_reg_rules_vlp: %d",
5587                    num_6ghz_client[WMI_REG_INDOOR_AP][j],
5588                    num_6ghz_client[WMI_REG_STANDARD_POWER_AP][j],
5589                    num_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][j]);
5590
5591         ext_wmi_reg_rule =
5592                 (struct wmi_regulatory_ext_rule *)((u8 *)ev + sizeof(*ev) +
5593                                                    sizeof(struct wmi_tlv));
5594         if (num_2ghz_reg_rules) {
5595                 reg_info->reg_rules_2ghz_ptr =
5596                         create_ext_reg_rules_from_wmi(num_2ghz_reg_rules,
5597                                                       ext_wmi_reg_rule);
5598
5599                 if (!reg_info->reg_rules_2ghz_ptr) {
5600                         kfree(tb);
5601                         ath11k_warn(ab, "Unable to Allocate memory for 2 GHz rules\n");
5602                         return -ENOMEM;
5603                 }
5604
5605                 ath11k_print_reg_rule(ab, "2 GHz",
5606                                       num_2ghz_reg_rules,
5607                                       reg_info->reg_rules_2ghz_ptr);
5608         }
5609
5610         ext_wmi_reg_rule += num_2ghz_reg_rules;
5611
5612         /* Firmware might include 6 GHz reg rule in 5 GHz rule list
5613          * for few countries along with separate 6 GHz rule.
5614          * Having same 6 GHz reg rule in 5 GHz and 6 GHz rules list
5615          * causes intersect check to be true, and same rules will be
5616          * shown multiple times in iw cmd.
5617          * Hence, avoid parsing 6 GHz rule from 5 GHz reg rule list
5618          */
5619         num_invalid_5ghz_ext_rules =
5620                 ath11k_invalid_5ghz_reg_ext_rules_from_wmi(num_5ghz_reg_rules,
5621                                                            ext_wmi_reg_rule);
5622
5623         if (num_invalid_5ghz_ext_rules) {
5624                 ath11k_dbg(ab, ATH11K_DBG_WMI,
5625                            "CC: %s 5 GHz reg rules number %d from fw, %d number of invalid 5 GHz rules",
5626                            reg_info->alpha2, reg_info->num_5ghz_reg_rules,
5627                            num_invalid_5ghz_ext_rules);
5628
5629                 num_5ghz_reg_rules = num_5ghz_reg_rules - num_invalid_5ghz_ext_rules;
5630                 reg_info->num_5ghz_reg_rules = num_5ghz_reg_rules;
5631         }
5632
5633         if (num_5ghz_reg_rules) {
5634                 reg_info->reg_rules_5ghz_ptr =
5635                         create_ext_reg_rules_from_wmi(num_5ghz_reg_rules,
5636                                                       ext_wmi_reg_rule);
5637
5638                 if (!reg_info->reg_rules_5ghz_ptr) {
5639                         kfree(tb);
5640                         ath11k_warn(ab, "Unable to Allocate memory for 5 GHz rules\n");
5641                         return -ENOMEM;
5642                 }
5643
5644                 ath11k_print_reg_rule(ab, "5 GHz",
5645                                       num_5ghz_reg_rules,
5646                                       reg_info->reg_rules_5ghz_ptr);
5647         }
5648
5649         /* We have adjusted the number of 5 GHz reg rules above. But still those
5650          * many rules needs to be adjusted in ext_wmi_reg_rule.
5651          *
5652          * NOTE: num_invalid_5ghz_ext_rules will be 0 for rest other cases.
5653          */
5654         ext_wmi_reg_rule += (num_5ghz_reg_rules + num_invalid_5ghz_ext_rules);
5655
5656         for (i = 0; i < WMI_REG_CURRENT_MAX_AP_TYPE; i++) {
5657                 reg_info->reg_rules_6ghz_ap_ptr[i] =
5658                         create_ext_reg_rules_from_wmi(num_6ghz_reg_rules_ap[i],
5659                                                       ext_wmi_reg_rule);
5660
5661                 if (!reg_info->reg_rules_6ghz_ap_ptr[i]) {
5662                         kfree(tb);
5663                         ath11k_warn(ab, "Unable to Allocate memory for 6 GHz AP rules\n");
5664                         return -ENOMEM;
5665                 }
5666
5667                 ath11k_print_reg_rule(ab, ath11k_6ghz_ap_type_to_str(i),
5668                                       num_6ghz_reg_rules_ap[i],
5669                                       reg_info->reg_rules_6ghz_ap_ptr[i]);
5670
5671                 ext_wmi_reg_rule += num_6ghz_reg_rules_ap[i];
5672         }
5673
5674         for (j = 0; j < WMI_REG_CURRENT_MAX_AP_TYPE; j++) {
5675                 ath11k_dbg(ab, ATH11K_DBG_WMI,
5676                            "6 GHz AP type %s", ath11k_6ghz_ap_type_to_str(j));
5677
5678                 for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
5679                         reg_info->reg_rules_6ghz_client_ptr[j][i] =
5680                                 create_ext_reg_rules_from_wmi(num_6ghz_client[j][i],
5681                                                               ext_wmi_reg_rule);
5682
5683                         if (!reg_info->reg_rules_6ghz_client_ptr[j][i]) {
5684                                 kfree(tb);
5685                                 ath11k_warn(ab, "Unable to Allocate memory for 6 GHz client rules\n");
5686                                 return -ENOMEM;
5687                         }
5688
5689                         ath11k_print_reg_rule(ab,
5690                                               ath11k_6ghz_client_type_to_str(i),
5691                                               num_6ghz_client[j][i],
5692                                               reg_info->reg_rules_6ghz_client_ptr[j][i]);
5693
5694                         ext_wmi_reg_rule += num_6ghz_client[j][i];
5695                 }
5696         }
5697
5698         reg_info->client_type = ev->client_type;
5699         reg_info->rnr_tpe_usable = ev->rnr_tpe_usable;
5700         reg_info->unspecified_ap_usable =
5701                         ev->unspecified_ap_usable;
5702         reg_info->domain_code_6ghz_ap[WMI_REG_INDOOR_AP] =
5703                         ev->domain_code_6ghz_ap_lpi;
5704         reg_info->domain_code_6ghz_ap[WMI_REG_STANDARD_POWER_AP] =
5705                         ev->domain_code_6ghz_ap_sp;
5706         reg_info->domain_code_6ghz_ap[WMI_REG_VERY_LOW_POWER_AP] =
5707                         ev->domain_code_6ghz_ap_vlp;
5708
5709         ath11k_dbg(ab, ATH11K_DBG_WMI,
5710                    "6 GHz reg info client type %s rnr_tpe_usable %d unspecified_ap_usable %d AP sub domain: lpi %s, sp %s, vlp %s\n",
5711                    ath11k_6ghz_client_type_to_str(reg_info->client_type),
5712                    reg_info->rnr_tpe_usable,
5713                    reg_info->unspecified_ap_usable,
5714                    ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_ap_lpi),
5715                    ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_ap_sp),
5716                    ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_ap_vlp));
5717
5718         for (i = 0; i < WMI_REG_MAX_CLIENT_TYPE; i++) {
5719                 reg_info->domain_code_6ghz_client[WMI_REG_INDOOR_AP][i] =
5720                                 ev->domain_code_6ghz_client_lpi[i];
5721                 reg_info->domain_code_6ghz_client[WMI_REG_STANDARD_POWER_AP][i] =
5722                                 ev->domain_code_6ghz_client_sp[i];
5723                 reg_info->domain_code_6ghz_client[WMI_REG_VERY_LOW_POWER_AP][i] =
5724                                 ev->domain_code_6ghz_client_vlp[i];
5725
5726                 ath11k_dbg(ab, ATH11K_DBG_WMI,
5727                            "6 GHz client type %s client sub domain: lpi %s, sp %s, vlp %s\n",
5728                            ath11k_6ghz_client_type_to_str(i),
5729                            ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_client_lpi[i]),
5730                            ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_client_sp[i]),
5731                            ath11k_sub_reg_6ghz_to_str(ev->domain_code_6ghz_client_vlp[i])
5732                           );
5733         }
5734
5735         reg_info->domain_code_6ghz_super_id = ev->domain_code_6ghz_super_id;
5736
5737         ath11k_dbg(ab, ATH11K_DBG_WMI,
5738                    "6 GHz client_type %s 6 GHz super domain %s",
5739                    ath11k_6ghz_client_type_to_str(reg_info->client_type),
5740                    ath11k_super_reg_6ghz_to_str(reg_info->domain_code_6ghz_super_id));
5741
5742         ath11k_dbg(ab, ATH11K_DBG_WMI, "processed regulatory ext channel list\n");
5743
5744         kfree(tb);
5745         return 0;
5746 }
5747
5748 static int ath11k_pull_peer_del_resp_ev(struct ath11k_base *ab, struct sk_buff *skb,
5749                                         struct wmi_peer_delete_resp_event *peer_del_resp)
5750 {
5751         const void **tb;
5752         const struct wmi_peer_delete_resp_event *ev;
5753         int ret;
5754
5755         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
5756         if (IS_ERR(tb)) {
5757                 ret = PTR_ERR(tb);
5758                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
5759                 return ret;
5760         }
5761
5762         ev = tb[WMI_TAG_PEER_DELETE_RESP_EVENT];
5763         if (!ev) {
5764                 ath11k_warn(ab, "failed to fetch peer delete resp ev");
5765                 kfree(tb);
5766                 return -EPROTO;
5767         }
5768
5769         memset(peer_del_resp, 0, sizeof(*peer_del_resp));
5770
5771         peer_del_resp->vdev_id = ev->vdev_id;
5772         ether_addr_copy(peer_del_resp->peer_macaddr.addr,
5773                         ev->peer_macaddr.addr);
5774
5775         kfree(tb);
5776         return 0;
5777 }
5778
5779 static int ath11k_pull_vdev_del_resp_ev(struct ath11k_base *ab,
5780                                         struct sk_buff *skb,
5781                                         u32 *vdev_id)
5782 {
5783         const void **tb;
5784         const struct wmi_vdev_delete_resp_event *ev;
5785         int ret;
5786
5787         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
5788         if (IS_ERR(tb)) {
5789                 ret = PTR_ERR(tb);
5790                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
5791                 return ret;
5792         }
5793
5794         ev = tb[WMI_TAG_VDEV_DELETE_RESP_EVENT];
5795         if (!ev) {
5796                 ath11k_warn(ab, "failed to fetch vdev delete resp ev");
5797                 kfree(tb);
5798                 return -EPROTO;
5799         }
5800
5801         *vdev_id = ev->vdev_id;
5802
5803         kfree(tb);
5804         return 0;
5805 }
5806
5807 static int ath11k_pull_bcn_tx_status_ev(struct ath11k_base *ab,
5808                                         struct sk_buff *skb,
5809                                         u32 *vdev_id, u32 *tx_status)
5810 {
5811         const void **tb;
5812         const struct wmi_bcn_tx_status_event *ev;
5813         int ret;
5814
5815         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
5816         if (IS_ERR(tb)) {
5817                 ret = PTR_ERR(tb);
5818                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
5819                 return ret;
5820         }
5821
5822         ev = tb[WMI_TAG_OFFLOAD_BCN_TX_STATUS_EVENT];
5823         if (!ev) {
5824                 ath11k_warn(ab, "failed to fetch bcn tx status ev");
5825                 kfree(tb);
5826                 return -EPROTO;
5827         }
5828
5829         *vdev_id   = ev->vdev_id;
5830         *tx_status = ev->tx_status;
5831
5832         kfree(tb);
5833         return 0;
5834 }
5835
5836 static int ath11k_pull_vdev_stopped_param_tlv(struct ath11k_base *ab, struct sk_buff *skb,
5837                                               u32 *vdev_id)
5838 {
5839         const void **tb;
5840         const struct wmi_vdev_stopped_event *ev;
5841         int ret;
5842
5843         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
5844         if (IS_ERR(tb)) {
5845                 ret = PTR_ERR(tb);
5846                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
5847                 return ret;
5848         }
5849
5850         ev = tb[WMI_TAG_VDEV_STOPPED_EVENT];
5851         if (!ev) {
5852                 ath11k_warn(ab, "failed to fetch vdev stop ev");
5853                 kfree(tb);
5854                 return -EPROTO;
5855         }
5856
5857         *vdev_id =  ev->vdev_id;
5858
5859         kfree(tb);
5860         return 0;
5861 }
5862
5863 static int ath11k_wmi_tlv_mgmt_rx_parse(struct ath11k_base *ab,
5864                                         u16 tag, u16 len,
5865                                         const void *ptr, void *data)
5866 {
5867         struct wmi_tlv_mgmt_rx_parse *parse = data;
5868
5869         switch (tag) {
5870         case WMI_TAG_MGMT_RX_HDR:
5871                 parse->fixed = ptr;
5872                 break;
5873         case WMI_TAG_ARRAY_BYTE:
5874                 if (!parse->frame_buf_done) {
5875                         parse->frame_buf = ptr;
5876                         parse->frame_buf_done = true;
5877                 }
5878                 break;
5879         }
5880         return 0;
5881 }
5882
5883 static int ath11k_pull_mgmt_rx_params_tlv(struct ath11k_base *ab,
5884                                           struct sk_buff *skb,
5885                                           struct mgmt_rx_event_params *hdr)
5886 {
5887         struct wmi_tlv_mgmt_rx_parse parse = { };
5888         const struct wmi_mgmt_rx_hdr *ev;
5889         const u8 *frame;
5890         int ret;
5891
5892         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
5893                                   ath11k_wmi_tlv_mgmt_rx_parse,
5894                                   &parse);
5895         if (ret) {
5896                 ath11k_warn(ab, "failed to parse mgmt rx tlv %d\n",
5897                             ret);
5898                 return ret;
5899         }
5900
5901         ev = parse.fixed;
5902         frame = parse.frame_buf;
5903
5904         if (!ev || !frame) {
5905                 ath11k_warn(ab, "failed to fetch mgmt rx hdr");
5906                 return -EPROTO;
5907         }
5908
5909         hdr->pdev_id =  ev->pdev_id;
5910         hdr->chan_freq = ev->chan_freq;
5911         hdr->channel =  ev->channel;
5912         hdr->snr =  ev->snr;
5913         hdr->rate =  ev->rate;
5914         hdr->phy_mode =  ev->phy_mode;
5915         hdr->buf_len =  ev->buf_len;
5916         hdr->status =  ev->status;
5917         hdr->flags =  ev->flags;
5918         hdr->rssi =  ev->rssi;
5919         hdr->tsf_delta =  ev->tsf_delta;
5920         memcpy(hdr->rssi_ctl, ev->rssi_ctl, sizeof(hdr->rssi_ctl));
5921
5922         if (skb->len < (frame - skb->data) + hdr->buf_len) {
5923                 ath11k_warn(ab, "invalid length in mgmt rx hdr ev");
5924                 return -EPROTO;
5925         }
5926
5927         /* shift the sk_buff to point to `frame` */
5928         skb_trim(skb, 0);
5929         skb_put(skb, frame - skb->data);
5930         skb_pull(skb, frame - skb->data);
5931         skb_put(skb, hdr->buf_len);
5932
5933         ath11k_ce_byte_swap(skb->data, hdr->buf_len);
5934
5935         return 0;
5936 }
5937
5938 static int wmi_process_mgmt_tx_comp(struct ath11k *ar,
5939                                     struct wmi_mgmt_tx_compl_event *tx_compl_param)
5940 {
5941         struct sk_buff *msdu;
5942         struct ieee80211_tx_info *info;
5943         struct ath11k_skb_cb *skb_cb;
5944         int num_mgmt;
5945
5946         spin_lock_bh(&ar->txmgmt_idr_lock);
5947         msdu = idr_find(&ar->txmgmt_idr, tx_compl_param->desc_id);
5948
5949         if (!msdu) {
5950                 ath11k_warn(ar->ab, "received mgmt tx compl for invalid msdu_id: %d\n",
5951                             tx_compl_param->desc_id);
5952                 spin_unlock_bh(&ar->txmgmt_idr_lock);
5953                 return -ENOENT;
5954         }
5955
5956         idr_remove(&ar->txmgmt_idr, tx_compl_param->desc_id);
5957         spin_unlock_bh(&ar->txmgmt_idr_lock);
5958
5959         skb_cb = ATH11K_SKB_CB(msdu);
5960         dma_unmap_single(ar->ab->dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE);
5961
5962         info = IEEE80211_SKB_CB(msdu);
5963         if ((!(info->flags & IEEE80211_TX_CTL_NO_ACK)) &&
5964             !tx_compl_param->status) {
5965                 info->flags |= IEEE80211_TX_STAT_ACK;
5966                 if (test_bit(WMI_TLV_SERVICE_TX_DATA_MGMT_ACK_RSSI,
5967                              ar->ab->wmi_ab.svc_map))
5968                         info->status.ack_signal = tx_compl_param->ack_rssi;
5969         }
5970
5971         ieee80211_tx_status_irqsafe(ar->hw, msdu);
5972
5973         num_mgmt = atomic_dec_if_positive(&ar->num_pending_mgmt_tx);
5974
5975         /* WARN when we received this event without doing any mgmt tx */
5976         if (num_mgmt < 0)
5977                 WARN_ON_ONCE(1);
5978
5979         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
5980                    "mgmt tx comp pending %d desc id %d\n",
5981                    num_mgmt, tx_compl_param->desc_id);
5982
5983         if (!num_mgmt)
5984                 wake_up(&ar->txmgmt_empty_waitq);
5985
5986         return 0;
5987 }
5988
5989 static int ath11k_pull_mgmt_tx_compl_param_tlv(struct ath11k_base *ab,
5990                                                struct sk_buff *skb,
5991                                                struct wmi_mgmt_tx_compl_event *param)
5992 {
5993         const void **tb;
5994         const struct wmi_mgmt_tx_compl_event *ev;
5995         int ret;
5996
5997         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
5998         if (IS_ERR(tb)) {
5999                 ret = PTR_ERR(tb);
6000                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6001                 return ret;
6002         }
6003
6004         ev = tb[WMI_TAG_MGMT_TX_COMPL_EVENT];
6005         if (!ev) {
6006                 ath11k_warn(ab, "failed to fetch mgmt tx compl ev");
6007                 kfree(tb);
6008                 return -EPROTO;
6009         }
6010
6011         param->pdev_id = ev->pdev_id;
6012         param->desc_id = ev->desc_id;
6013         param->status = ev->status;
6014         param->ack_rssi = ev->ack_rssi;
6015
6016         kfree(tb);
6017         return 0;
6018 }
6019
6020 static void ath11k_wmi_event_scan_started(struct ath11k *ar)
6021 {
6022         lockdep_assert_held(&ar->data_lock);
6023
6024         switch (ar->scan.state) {
6025         case ATH11K_SCAN_IDLE:
6026         case ATH11K_SCAN_RUNNING:
6027         case ATH11K_SCAN_ABORTING:
6028                 ath11k_warn(ar->ab, "received scan started event in an invalid scan state: %s (%d)\n",
6029                             ath11k_scan_state_str(ar->scan.state),
6030                             ar->scan.state);
6031                 break;
6032         case ATH11K_SCAN_STARTING:
6033                 ar->scan.state = ATH11K_SCAN_RUNNING;
6034                 if (ar->scan.is_roc)
6035                         ieee80211_ready_on_channel(ar->hw);
6036                 complete(&ar->scan.started);
6037                 break;
6038         }
6039 }
6040
6041 static void ath11k_wmi_event_scan_start_failed(struct ath11k *ar)
6042 {
6043         lockdep_assert_held(&ar->data_lock);
6044
6045         switch (ar->scan.state) {
6046         case ATH11K_SCAN_IDLE:
6047         case ATH11K_SCAN_RUNNING:
6048         case ATH11K_SCAN_ABORTING:
6049                 ath11k_warn(ar->ab, "received scan start failed event in an invalid scan state: %s (%d)\n",
6050                             ath11k_scan_state_str(ar->scan.state),
6051                             ar->scan.state);
6052                 break;
6053         case ATH11K_SCAN_STARTING:
6054                 complete(&ar->scan.started);
6055                 __ath11k_mac_scan_finish(ar);
6056                 break;
6057         }
6058 }
6059
6060 static void ath11k_wmi_event_scan_completed(struct ath11k *ar)
6061 {
6062         lockdep_assert_held(&ar->data_lock);
6063
6064         switch (ar->scan.state) {
6065         case ATH11K_SCAN_IDLE:
6066         case ATH11K_SCAN_STARTING:
6067                 /* One suspected reason scan can be completed while starting is
6068                  * if firmware fails to deliver all scan events to the host,
6069                  * e.g. when transport pipe is full. This has been observed
6070                  * with spectral scan phyerr events starving wmi transport
6071                  * pipe. In such case the "scan completed" event should be (and
6072                  * is) ignored by the host as it may be just firmware's scan
6073                  * state machine recovering.
6074                  */
6075                 ath11k_warn(ar->ab, "received scan completed event in an invalid scan state: %s (%d)\n",
6076                             ath11k_scan_state_str(ar->scan.state),
6077                             ar->scan.state);
6078                 break;
6079         case ATH11K_SCAN_RUNNING:
6080         case ATH11K_SCAN_ABORTING:
6081                 __ath11k_mac_scan_finish(ar);
6082                 break;
6083         }
6084 }
6085
6086 static void ath11k_wmi_event_scan_bss_chan(struct ath11k *ar)
6087 {
6088         lockdep_assert_held(&ar->data_lock);
6089
6090         switch (ar->scan.state) {
6091         case ATH11K_SCAN_IDLE:
6092         case ATH11K_SCAN_STARTING:
6093                 ath11k_warn(ar->ab, "received scan bss chan event in an invalid scan state: %s (%d)\n",
6094                             ath11k_scan_state_str(ar->scan.state),
6095                             ar->scan.state);
6096                 break;
6097         case ATH11K_SCAN_RUNNING:
6098         case ATH11K_SCAN_ABORTING:
6099                 ar->scan_channel = NULL;
6100                 break;
6101         }
6102 }
6103
6104 static void ath11k_wmi_event_scan_foreign_chan(struct ath11k *ar, u32 freq)
6105 {
6106         lockdep_assert_held(&ar->data_lock);
6107
6108         switch (ar->scan.state) {
6109         case ATH11K_SCAN_IDLE:
6110         case ATH11K_SCAN_STARTING:
6111                 ath11k_warn(ar->ab, "received scan foreign chan event in an invalid scan state: %s (%d)\n",
6112                             ath11k_scan_state_str(ar->scan.state),
6113                             ar->scan.state);
6114                 break;
6115         case ATH11K_SCAN_RUNNING:
6116         case ATH11K_SCAN_ABORTING:
6117                 ar->scan_channel = ieee80211_get_channel(ar->hw->wiphy, freq);
6118                 if (ar->scan.is_roc && ar->scan.roc_freq == freq)
6119                         complete(&ar->scan.on_channel);
6120                 break;
6121         }
6122 }
6123
6124 static const char *
6125 ath11k_wmi_event_scan_type_str(enum wmi_scan_event_type type,
6126                                enum wmi_scan_completion_reason reason)
6127 {
6128         switch (type) {
6129         case WMI_SCAN_EVENT_STARTED:
6130                 return "started";
6131         case WMI_SCAN_EVENT_COMPLETED:
6132                 switch (reason) {
6133                 case WMI_SCAN_REASON_COMPLETED:
6134                         return "completed";
6135                 case WMI_SCAN_REASON_CANCELLED:
6136                         return "completed [cancelled]";
6137                 case WMI_SCAN_REASON_PREEMPTED:
6138                         return "completed [preempted]";
6139                 case WMI_SCAN_REASON_TIMEDOUT:
6140                         return "completed [timedout]";
6141                 case WMI_SCAN_REASON_INTERNAL_FAILURE:
6142                         return "completed [internal err]";
6143                 case WMI_SCAN_REASON_MAX:
6144                         break;
6145                 }
6146                 return "completed [unknown]";
6147         case WMI_SCAN_EVENT_BSS_CHANNEL:
6148                 return "bss channel";
6149         case WMI_SCAN_EVENT_FOREIGN_CHAN:
6150                 return "foreign channel";
6151         case WMI_SCAN_EVENT_DEQUEUED:
6152                 return "dequeued";
6153         case WMI_SCAN_EVENT_PREEMPTED:
6154                 return "preempted";
6155         case WMI_SCAN_EVENT_START_FAILED:
6156                 return "start failed";
6157         case WMI_SCAN_EVENT_RESTARTED:
6158                 return "restarted";
6159         case WMI_SCAN_EVENT_FOREIGN_CHAN_EXIT:
6160                 return "foreign channel exit";
6161         default:
6162                 return "unknown";
6163         }
6164 }
6165
6166 static int ath11k_pull_scan_ev(struct ath11k_base *ab, struct sk_buff *skb,
6167                                struct wmi_scan_event *scan_evt_param)
6168 {
6169         const void **tb;
6170         const struct wmi_scan_event *ev;
6171         int ret;
6172
6173         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
6174         if (IS_ERR(tb)) {
6175                 ret = PTR_ERR(tb);
6176                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6177                 return ret;
6178         }
6179
6180         ev = tb[WMI_TAG_SCAN_EVENT];
6181         if (!ev) {
6182                 ath11k_warn(ab, "failed to fetch scan ev");
6183                 kfree(tb);
6184                 return -EPROTO;
6185         }
6186
6187         scan_evt_param->event_type = ev->event_type;
6188         scan_evt_param->reason = ev->reason;
6189         scan_evt_param->channel_freq = ev->channel_freq;
6190         scan_evt_param->scan_req_id = ev->scan_req_id;
6191         scan_evt_param->scan_id = ev->scan_id;
6192         scan_evt_param->vdev_id = ev->vdev_id;
6193         scan_evt_param->tsf_timestamp = ev->tsf_timestamp;
6194
6195         kfree(tb);
6196         return 0;
6197 }
6198
6199 static int ath11k_pull_peer_sta_kickout_ev(struct ath11k_base *ab, struct sk_buff *skb,
6200                                            struct wmi_peer_sta_kickout_arg *arg)
6201 {
6202         const void **tb;
6203         const struct wmi_peer_sta_kickout_event *ev;
6204         int ret;
6205
6206         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
6207         if (IS_ERR(tb)) {
6208                 ret = PTR_ERR(tb);
6209                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6210                 return ret;
6211         }
6212
6213         ev = tb[WMI_TAG_PEER_STA_KICKOUT_EVENT];
6214         if (!ev) {
6215                 ath11k_warn(ab, "failed to fetch peer sta kickout ev");
6216                 kfree(tb);
6217                 return -EPROTO;
6218         }
6219
6220         arg->mac_addr = ev->peer_macaddr.addr;
6221
6222         kfree(tb);
6223         return 0;
6224 }
6225
6226 static int ath11k_pull_roam_ev(struct ath11k_base *ab, struct sk_buff *skb,
6227                                struct wmi_roam_event *roam_ev)
6228 {
6229         const void **tb;
6230         const struct wmi_roam_event *ev;
6231         int ret;
6232
6233         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
6234         if (IS_ERR(tb)) {
6235                 ret = PTR_ERR(tb);
6236                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6237                 return ret;
6238         }
6239
6240         ev = tb[WMI_TAG_ROAM_EVENT];
6241         if (!ev) {
6242                 ath11k_warn(ab, "failed to fetch roam ev");
6243                 kfree(tb);
6244                 return -EPROTO;
6245         }
6246
6247         roam_ev->vdev_id = ev->vdev_id;
6248         roam_ev->reason = ev->reason;
6249         roam_ev->rssi = ev->rssi;
6250
6251         kfree(tb);
6252         return 0;
6253 }
6254
6255 static int freq_to_idx(struct ath11k *ar, int freq)
6256 {
6257         struct ieee80211_supported_band *sband;
6258         int band, ch, idx = 0;
6259
6260         for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
6261                 sband = ar->hw->wiphy->bands[band];
6262                 if (!sband)
6263                         continue;
6264
6265                 for (ch = 0; ch < sband->n_channels; ch++, idx++)
6266                         if (sband->channels[ch].center_freq == freq)
6267                                 goto exit;
6268         }
6269
6270 exit:
6271         return idx;
6272 }
6273
6274 static int ath11k_pull_chan_info_ev(struct ath11k_base *ab, struct sk_buff *skb,
6275                                     struct wmi_chan_info_event *ch_info_ev)
6276 {
6277         const void **tb;
6278         const struct wmi_chan_info_event *ev;
6279         int ret;
6280
6281         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
6282         if (IS_ERR(tb)) {
6283                 ret = PTR_ERR(tb);
6284                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6285                 return ret;
6286         }
6287
6288         ev = tb[WMI_TAG_CHAN_INFO_EVENT];
6289         if (!ev) {
6290                 ath11k_warn(ab, "failed to fetch chan info ev");
6291                 kfree(tb);
6292                 return -EPROTO;
6293         }
6294
6295         ch_info_ev->err_code = ev->err_code;
6296         ch_info_ev->freq = ev->freq;
6297         ch_info_ev->cmd_flags = ev->cmd_flags;
6298         ch_info_ev->noise_floor = ev->noise_floor;
6299         ch_info_ev->rx_clear_count = ev->rx_clear_count;
6300         ch_info_ev->cycle_count = ev->cycle_count;
6301         ch_info_ev->chan_tx_pwr_range = ev->chan_tx_pwr_range;
6302         ch_info_ev->chan_tx_pwr_tp = ev->chan_tx_pwr_tp;
6303         ch_info_ev->rx_frame_count = ev->rx_frame_count;
6304         ch_info_ev->tx_frame_cnt = ev->tx_frame_cnt;
6305         ch_info_ev->mac_clk_mhz = ev->mac_clk_mhz;
6306         ch_info_ev->vdev_id = ev->vdev_id;
6307
6308         kfree(tb);
6309         return 0;
6310 }
6311
6312 static int
6313 ath11k_pull_pdev_bss_chan_info_ev(struct ath11k_base *ab, struct sk_buff *skb,
6314                                   struct wmi_pdev_bss_chan_info_event *bss_ch_info_ev)
6315 {
6316         const void **tb;
6317         const struct wmi_pdev_bss_chan_info_event *ev;
6318         int ret;
6319
6320         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
6321         if (IS_ERR(tb)) {
6322                 ret = PTR_ERR(tb);
6323                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6324                 return ret;
6325         }
6326
6327         ev = tb[WMI_TAG_PDEV_BSS_CHAN_INFO_EVENT];
6328         if (!ev) {
6329                 ath11k_warn(ab, "failed to fetch pdev bss chan info ev");
6330                 kfree(tb);
6331                 return -EPROTO;
6332         }
6333
6334         bss_ch_info_ev->pdev_id = ev->pdev_id;
6335         bss_ch_info_ev->freq = ev->freq;
6336         bss_ch_info_ev->noise_floor = ev->noise_floor;
6337         bss_ch_info_ev->rx_clear_count_low = ev->rx_clear_count_low;
6338         bss_ch_info_ev->rx_clear_count_high = ev->rx_clear_count_high;
6339         bss_ch_info_ev->cycle_count_low = ev->cycle_count_low;
6340         bss_ch_info_ev->cycle_count_high = ev->cycle_count_high;
6341         bss_ch_info_ev->tx_cycle_count_low = ev->tx_cycle_count_low;
6342         bss_ch_info_ev->tx_cycle_count_high = ev->tx_cycle_count_high;
6343         bss_ch_info_ev->rx_cycle_count_low = ev->rx_cycle_count_low;
6344         bss_ch_info_ev->rx_cycle_count_high = ev->rx_cycle_count_high;
6345         bss_ch_info_ev->rx_bss_cycle_count_low = ev->rx_bss_cycle_count_low;
6346         bss_ch_info_ev->rx_bss_cycle_count_high = ev->rx_bss_cycle_count_high;
6347
6348         kfree(tb);
6349         return 0;
6350 }
6351
6352 static int
6353 ath11k_pull_vdev_install_key_compl_ev(struct ath11k_base *ab, struct sk_buff *skb,
6354                                       struct wmi_vdev_install_key_complete_arg *arg)
6355 {
6356         const void **tb;
6357         const struct wmi_vdev_install_key_compl_event *ev;
6358         int ret;
6359
6360         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
6361         if (IS_ERR(tb)) {
6362                 ret = PTR_ERR(tb);
6363                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6364                 return ret;
6365         }
6366
6367         ev = tb[WMI_TAG_VDEV_INSTALL_KEY_COMPLETE_EVENT];
6368         if (!ev) {
6369                 ath11k_warn(ab, "failed to fetch vdev install key compl ev");
6370                 kfree(tb);
6371                 return -EPROTO;
6372         }
6373
6374         arg->vdev_id = ev->vdev_id;
6375         arg->macaddr = ev->peer_macaddr.addr;
6376         arg->key_idx = ev->key_idx;
6377         arg->key_flags = ev->key_flags;
6378         arg->status = ev->status;
6379
6380         kfree(tb);
6381         return 0;
6382 }
6383
6384 static int ath11k_pull_peer_assoc_conf_ev(struct ath11k_base *ab, struct sk_buff *skb,
6385                                           struct wmi_peer_assoc_conf_arg *peer_assoc_conf)
6386 {
6387         const void **tb;
6388         const struct wmi_peer_assoc_conf_event *ev;
6389         int ret;
6390
6391         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
6392         if (IS_ERR(tb)) {
6393                 ret = PTR_ERR(tb);
6394                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6395                 return ret;
6396         }
6397
6398         ev = tb[WMI_TAG_PEER_ASSOC_CONF_EVENT];
6399         if (!ev) {
6400                 ath11k_warn(ab, "failed to fetch peer assoc conf ev");
6401                 kfree(tb);
6402                 return -EPROTO;
6403         }
6404
6405         peer_assoc_conf->vdev_id = ev->vdev_id;
6406         peer_assoc_conf->macaddr = ev->peer_macaddr.addr;
6407
6408         kfree(tb);
6409         return 0;
6410 }
6411
6412 static void ath11k_wmi_pull_pdev_stats_base(const struct wmi_pdev_stats_base *src,
6413                                             struct ath11k_fw_stats_pdev *dst)
6414 {
6415         dst->ch_noise_floor = src->chan_nf;
6416         dst->tx_frame_count = src->tx_frame_count;
6417         dst->rx_frame_count = src->rx_frame_count;
6418         dst->rx_clear_count = src->rx_clear_count;
6419         dst->cycle_count = src->cycle_count;
6420         dst->phy_err_count = src->phy_err_count;
6421         dst->chan_tx_power = src->chan_tx_pwr;
6422 }
6423
6424 static void
6425 ath11k_wmi_pull_pdev_stats_tx(const struct wmi_pdev_stats_tx *src,
6426                               struct ath11k_fw_stats_pdev *dst)
6427 {
6428         dst->comp_queued = src->comp_queued;
6429         dst->comp_delivered = src->comp_delivered;
6430         dst->msdu_enqued = src->msdu_enqued;
6431         dst->mpdu_enqued = src->mpdu_enqued;
6432         dst->wmm_drop = src->wmm_drop;
6433         dst->local_enqued = src->local_enqued;
6434         dst->local_freed = src->local_freed;
6435         dst->hw_queued = src->hw_queued;
6436         dst->hw_reaped = src->hw_reaped;
6437         dst->underrun = src->underrun;
6438         dst->hw_paused = src->hw_paused;
6439         dst->tx_abort = src->tx_abort;
6440         dst->mpdus_requeued = src->mpdus_requeued;
6441         dst->tx_ko = src->tx_ko;
6442         dst->tx_xretry = src->tx_xretry;
6443         dst->data_rc = src->data_rc;
6444         dst->self_triggers = src->self_triggers;
6445         dst->sw_retry_failure = src->sw_retry_failure;
6446         dst->illgl_rate_phy_err = src->illgl_rate_phy_err;
6447         dst->pdev_cont_xretry = src->pdev_cont_xretry;
6448         dst->pdev_tx_timeout = src->pdev_tx_timeout;
6449         dst->pdev_resets = src->pdev_resets;
6450         dst->stateless_tid_alloc_failure = src->stateless_tid_alloc_failure;
6451         dst->phy_underrun = src->phy_underrun;
6452         dst->txop_ovf = src->txop_ovf;
6453         dst->seq_posted = src->seq_posted;
6454         dst->seq_failed_queueing = src->seq_failed_queueing;
6455         dst->seq_completed = src->seq_completed;
6456         dst->seq_restarted = src->seq_restarted;
6457         dst->mu_seq_posted = src->mu_seq_posted;
6458         dst->mpdus_sw_flush = src->mpdus_sw_flush;
6459         dst->mpdus_hw_filter = src->mpdus_hw_filter;
6460         dst->mpdus_truncated = src->mpdus_truncated;
6461         dst->mpdus_ack_failed = src->mpdus_ack_failed;
6462         dst->mpdus_expired = src->mpdus_expired;
6463 }
6464
6465 static void ath11k_wmi_pull_pdev_stats_rx(const struct wmi_pdev_stats_rx *src,
6466                                           struct ath11k_fw_stats_pdev *dst)
6467 {
6468         dst->mid_ppdu_route_change = src->mid_ppdu_route_change;
6469         dst->status_rcvd = src->status_rcvd;
6470         dst->r0_frags = src->r0_frags;
6471         dst->r1_frags = src->r1_frags;
6472         dst->r2_frags = src->r2_frags;
6473         dst->r3_frags = src->r3_frags;
6474         dst->htt_msdus = src->htt_msdus;
6475         dst->htt_mpdus = src->htt_mpdus;
6476         dst->loc_msdus = src->loc_msdus;
6477         dst->loc_mpdus = src->loc_mpdus;
6478         dst->oversize_amsdu = src->oversize_amsdu;
6479         dst->phy_errs = src->phy_errs;
6480         dst->phy_err_drop = src->phy_err_drop;
6481         dst->mpdu_errs = src->mpdu_errs;
6482         dst->rx_ovfl_errs = src->rx_ovfl_errs;
6483 }
6484
6485 static void
6486 ath11k_wmi_pull_vdev_stats(const struct wmi_vdev_stats *src,
6487                            struct ath11k_fw_stats_vdev *dst)
6488 {
6489         int i;
6490
6491         dst->vdev_id = src->vdev_id;
6492         dst->beacon_snr = src->beacon_snr;
6493         dst->data_snr = src->data_snr;
6494         dst->num_rx_frames = src->num_rx_frames;
6495         dst->num_rts_fail = src->num_rts_fail;
6496         dst->num_rts_success = src->num_rts_success;
6497         dst->num_rx_err = src->num_rx_err;
6498         dst->num_rx_discard = src->num_rx_discard;
6499         dst->num_tx_not_acked = src->num_tx_not_acked;
6500
6501         for (i = 0; i < ARRAY_SIZE(src->num_tx_frames); i++)
6502                 dst->num_tx_frames[i] = src->num_tx_frames[i];
6503
6504         for (i = 0; i < ARRAY_SIZE(src->num_tx_frames_retries); i++)
6505                 dst->num_tx_frames_retries[i] = src->num_tx_frames_retries[i];
6506
6507         for (i = 0; i < ARRAY_SIZE(src->num_tx_frames_failures); i++)
6508                 dst->num_tx_frames_failures[i] = src->num_tx_frames_failures[i];
6509
6510         for (i = 0; i < ARRAY_SIZE(src->tx_rate_history); i++)
6511                 dst->tx_rate_history[i] = src->tx_rate_history[i];
6512
6513         for (i = 0; i < ARRAY_SIZE(src->beacon_rssi_history); i++)
6514                 dst->beacon_rssi_history[i] = src->beacon_rssi_history[i];
6515 }
6516
6517 static void
6518 ath11k_wmi_pull_bcn_stats(const struct wmi_bcn_stats *src,
6519                           struct ath11k_fw_stats_bcn *dst)
6520 {
6521         dst->vdev_id = src->vdev_id;
6522         dst->tx_bcn_succ_cnt = src->tx_bcn_succ_cnt;
6523         dst->tx_bcn_outage_cnt = src->tx_bcn_outage_cnt;
6524 }
6525
6526 static int ath11k_wmi_tlv_rssi_chain_parse(struct ath11k_base *ab,
6527                                            u16 tag, u16 len,
6528                                            const void *ptr, void *data)
6529 {
6530         struct wmi_tlv_fw_stats_parse *parse = data;
6531         const struct wmi_stats_event *ev = parse->ev;
6532         struct ath11k_fw_stats *stats = parse->stats;
6533         struct ath11k *ar;
6534         struct ath11k_vif *arvif;
6535         struct ieee80211_sta *sta;
6536         struct ath11k_sta *arsta;
6537         const struct wmi_rssi_stats *stats_rssi = (const struct wmi_rssi_stats *)ptr;
6538         int j, ret = 0;
6539
6540         if (tag != WMI_TAG_RSSI_STATS)
6541                 return -EPROTO;
6542
6543         rcu_read_lock();
6544
6545         ar = ath11k_mac_get_ar_by_pdev_id(ab, ev->pdev_id);
6546         stats->stats_id = WMI_REQUEST_RSSI_PER_CHAIN_STAT;
6547
6548         ath11k_dbg(ab, ATH11K_DBG_WMI,
6549                    "stats vdev id %d mac %pM\n",
6550                    stats_rssi->vdev_id, stats_rssi->peer_macaddr.addr);
6551
6552         arvif = ath11k_mac_get_arvif(ar, stats_rssi->vdev_id);
6553         if (!arvif) {
6554                 ath11k_warn(ab, "not found vif for vdev id %d\n",
6555                             stats_rssi->vdev_id);
6556                 ret = -EPROTO;
6557                 goto exit;
6558         }
6559
6560         ath11k_dbg(ab, ATH11K_DBG_WMI,
6561                    "stats bssid %pM vif %p\n",
6562                    arvif->bssid, arvif->vif);
6563
6564         sta = ieee80211_find_sta_by_ifaddr(ar->hw,
6565                                            arvif->bssid,
6566                                            NULL);
6567         if (!sta) {
6568                 ath11k_dbg(ab, ATH11K_DBG_WMI,
6569                            "not found station of bssid %pM for rssi chain\n",
6570                            arvif->bssid);
6571                 goto exit;
6572         }
6573
6574         arsta = ath11k_sta_to_arsta(sta);
6575
6576         BUILD_BUG_ON(ARRAY_SIZE(arsta->chain_signal) >
6577                      ARRAY_SIZE(stats_rssi->rssi_avg_beacon));
6578
6579         for (j = 0; j < ARRAY_SIZE(arsta->chain_signal); j++) {
6580                 arsta->chain_signal[j] = stats_rssi->rssi_avg_beacon[j];
6581                 ath11k_dbg(ab, ATH11K_DBG_WMI,
6582                            "stats beacon rssi[%d] %d data rssi[%d] %d\n",
6583                            j,
6584                            stats_rssi->rssi_avg_beacon[j],
6585                            j,
6586                            stats_rssi->rssi_avg_data[j]);
6587         }
6588
6589 exit:
6590         rcu_read_unlock();
6591         return ret;
6592 }
6593
6594 static int ath11k_wmi_tlv_fw_stats_data_parse(struct ath11k_base *ab,
6595                                               struct wmi_tlv_fw_stats_parse *parse,
6596                                               const void *ptr,
6597                                               u16 len)
6598 {
6599         struct ath11k_fw_stats *stats = parse->stats;
6600         const struct wmi_stats_event *ev = parse->ev;
6601         struct ath11k *ar;
6602         struct ath11k_vif *arvif;
6603         struct ieee80211_sta *sta;
6604         struct ath11k_sta *arsta;
6605         int i, ret = 0;
6606         const void *data = ptr;
6607
6608         if (!ev) {
6609                 ath11k_warn(ab, "failed to fetch update stats ev");
6610                 return -EPROTO;
6611         }
6612
6613         stats->stats_id = 0;
6614
6615         rcu_read_lock();
6616
6617         ar = ath11k_mac_get_ar_by_pdev_id(ab, ev->pdev_id);
6618
6619         for (i = 0; i < ev->num_pdev_stats; i++) {
6620                 const struct wmi_pdev_stats *src;
6621                 struct ath11k_fw_stats_pdev *dst;
6622
6623                 src = data;
6624                 if (len < sizeof(*src)) {
6625                         ret = -EPROTO;
6626                         goto exit;
6627                 }
6628
6629                 stats->stats_id = WMI_REQUEST_PDEV_STAT;
6630
6631                 data += sizeof(*src);
6632                 len -= sizeof(*src);
6633
6634                 dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
6635                 if (!dst)
6636                         continue;
6637
6638                 ath11k_wmi_pull_pdev_stats_base(&src->base, dst);
6639                 ath11k_wmi_pull_pdev_stats_tx(&src->tx, dst);
6640                 ath11k_wmi_pull_pdev_stats_rx(&src->rx, dst);
6641                 list_add_tail(&dst->list, &stats->pdevs);
6642         }
6643
6644         for (i = 0; i < ev->num_vdev_stats; i++) {
6645                 const struct wmi_vdev_stats *src;
6646                 struct ath11k_fw_stats_vdev *dst;
6647
6648                 src = data;
6649                 if (len < sizeof(*src)) {
6650                         ret = -EPROTO;
6651                         goto exit;
6652                 }
6653
6654                 stats->stats_id = WMI_REQUEST_VDEV_STAT;
6655
6656                 arvif = ath11k_mac_get_arvif(ar, src->vdev_id);
6657                 if (arvif) {
6658                         sta = ieee80211_find_sta_by_ifaddr(ar->hw,
6659                                                            arvif->bssid,
6660                                                            NULL);
6661                         if (sta) {
6662                                 arsta = ath11k_sta_to_arsta(sta);
6663                                 arsta->rssi_beacon = src->beacon_snr;
6664                                 ath11k_dbg(ab, ATH11K_DBG_WMI,
6665                                            "stats vdev id %d snr %d\n",
6666                                            src->vdev_id, src->beacon_snr);
6667                         } else {
6668                                 ath11k_dbg(ab, ATH11K_DBG_WMI,
6669                                            "not found station of bssid %pM for vdev stat\n",
6670                                            arvif->bssid);
6671                         }
6672                 }
6673
6674                 data += sizeof(*src);
6675                 len -= sizeof(*src);
6676
6677                 dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
6678                 if (!dst)
6679                         continue;
6680
6681                 ath11k_wmi_pull_vdev_stats(src, dst);
6682                 list_add_tail(&dst->list, &stats->vdevs);
6683         }
6684
6685         for (i = 0; i < ev->num_bcn_stats; i++) {
6686                 const struct wmi_bcn_stats *src;
6687                 struct ath11k_fw_stats_bcn *dst;
6688
6689                 src = data;
6690                 if (len < sizeof(*src)) {
6691                         ret = -EPROTO;
6692                         goto exit;
6693                 }
6694
6695                 stats->stats_id = WMI_REQUEST_BCN_STAT;
6696
6697                 data += sizeof(*src);
6698                 len -= sizeof(*src);
6699
6700                 dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
6701                 if (!dst)
6702                         continue;
6703
6704                 ath11k_wmi_pull_bcn_stats(src, dst);
6705                 list_add_tail(&dst->list, &stats->bcn);
6706         }
6707
6708 exit:
6709         rcu_read_unlock();
6710         return ret;
6711 }
6712
6713 static int ath11k_wmi_tlv_fw_stats_parse(struct ath11k_base *ab,
6714                                          u16 tag, u16 len,
6715                                          const void *ptr, void *data)
6716 {
6717         struct wmi_tlv_fw_stats_parse *parse = data;
6718         int ret = 0;
6719
6720         switch (tag) {
6721         case WMI_TAG_STATS_EVENT:
6722                 parse->ev = (struct wmi_stats_event *)ptr;
6723                 parse->stats->pdev_id = parse->ev->pdev_id;
6724                 break;
6725         case WMI_TAG_ARRAY_BYTE:
6726                 ret = ath11k_wmi_tlv_fw_stats_data_parse(ab, parse, ptr, len);
6727                 break;
6728         case WMI_TAG_PER_CHAIN_RSSI_STATS:
6729                 parse->rssi = (struct wmi_per_chain_rssi_stats *)ptr;
6730
6731                 if (parse->ev->stats_id & WMI_REQUEST_RSSI_PER_CHAIN_STAT)
6732                         parse->rssi_num = parse->rssi->num_per_chain_rssi_stats;
6733
6734                 ath11k_dbg(ab, ATH11K_DBG_WMI,
6735                            "stats id 0x%x num chain %d\n",
6736                            parse->ev->stats_id,
6737                            parse->rssi_num);
6738                 break;
6739         case WMI_TAG_ARRAY_STRUCT:
6740                 if (parse->rssi_num && !parse->chain_rssi_done) {
6741                         ret = ath11k_wmi_tlv_iter(ab, ptr, len,
6742                                                   ath11k_wmi_tlv_rssi_chain_parse,
6743                                                   parse);
6744                         if (ret) {
6745                                 ath11k_warn(ab, "failed to parse rssi chain %d\n",
6746                                             ret);
6747                                 return ret;
6748                         }
6749                         parse->chain_rssi_done = true;
6750                 }
6751                 break;
6752         default:
6753                 break;
6754         }
6755         return ret;
6756 }
6757
6758 int ath11k_wmi_pull_fw_stats(struct ath11k_base *ab, struct sk_buff *skb,
6759                              struct ath11k_fw_stats *stats)
6760 {
6761         struct wmi_tlv_fw_stats_parse parse = { };
6762
6763         stats->stats_id = 0;
6764         parse.stats = stats;
6765
6766         return ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
6767                                    ath11k_wmi_tlv_fw_stats_parse,
6768                                    &parse);
6769 }
6770
6771 static void
6772 ath11k_wmi_fw_pdev_base_stats_fill(const struct ath11k_fw_stats_pdev *pdev,
6773                                    char *buf, u32 *length)
6774 {
6775         u32 len = *length;
6776         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
6777
6778         len += scnprintf(buf + len, buf_len - len, "\n");
6779         len += scnprintf(buf + len, buf_len - len, "%30s\n",
6780                         "ath11k PDEV stats");
6781         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
6782                         "=================");
6783
6784         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6785                         "Channel noise floor", pdev->ch_noise_floor);
6786         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6787                         "Channel TX power", pdev->chan_tx_power);
6788         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6789                         "TX frame count", pdev->tx_frame_count);
6790         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6791                         "RX frame count", pdev->rx_frame_count);
6792         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6793                         "RX clear count", pdev->rx_clear_count);
6794         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6795                         "Cycle count", pdev->cycle_count);
6796         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6797                         "PHY error count", pdev->phy_err_count);
6798
6799         *length = len;
6800 }
6801
6802 static void
6803 ath11k_wmi_fw_pdev_tx_stats_fill(const struct ath11k_fw_stats_pdev *pdev,
6804                                  char *buf, u32 *length)
6805 {
6806         u32 len = *length;
6807         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
6808
6809         len += scnprintf(buf + len, buf_len - len, "\n%30s\n",
6810                          "ath11k PDEV TX stats");
6811         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
6812                          "====================");
6813
6814         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6815                          "HTT cookies queued", pdev->comp_queued);
6816         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6817                          "HTT cookies disp.", pdev->comp_delivered);
6818         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6819                          "MSDU queued", pdev->msdu_enqued);
6820         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6821                          "MPDU queued", pdev->mpdu_enqued);
6822         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6823                          "MSDUs dropped", pdev->wmm_drop);
6824         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6825                          "Local enqued", pdev->local_enqued);
6826         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6827                          "Local freed", pdev->local_freed);
6828         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6829                          "HW queued", pdev->hw_queued);
6830         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6831                          "PPDUs reaped", pdev->hw_reaped);
6832         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6833                          "Num underruns", pdev->underrun);
6834         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6835                          "Num HW Paused", pdev->hw_paused);
6836         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6837                          "PPDUs cleaned", pdev->tx_abort);
6838         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6839                          "MPDUs requeued", pdev->mpdus_requeued);
6840         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6841                          "PPDU OK", pdev->tx_ko);
6842         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6843                          "Excessive retries", pdev->tx_xretry);
6844         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6845                          "HW rate", pdev->data_rc);
6846         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6847                          "Sched self triggers", pdev->self_triggers);
6848         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6849                          "Dropped due to SW retries",
6850                          pdev->sw_retry_failure);
6851         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6852                          "Illegal rate phy errors",
6853                          pdev->illgl_rate_phy_err);
6854         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6855                          "PDEV continuous xretry", pdev->pdev_cont_xretry);
6856         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6857                          "TX timeout", pdev->pdev_tx_timeout);
6858         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6859                          "PDEV resets", pdev->pdev_resets);
6860         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6861                          "Stateless TIDs alloc failures",
6862                          pdev->stateless_tid_alloc_failure);
6863         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6864                          "PHY underrun", pdev->phy_underrun);
6865         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6866                          "MPDU is more than txop limit", pdev->txop_ovf);
6867         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6868                          "Num sequences posted", pdev->seq_posted);
6869         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6870                          "Num seq failed queueing ", pdev->seq_failed_queueing);
6871         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6872                          "Num sequences completed ", pdev->seq_completed);
6873         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6874                          "Num sequences restarted ", pdev->seq_restarted);
6875         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6876                          "Num of MU sequences posted ", pdev->mu_seq_posted);
6877         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6878                          "Num of MPDUS SW flushed ", pdev->mpdus_sw_flush);
6879         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6880                          "Num of MPDUS HW filtered ", pdev->mpdus_hw_filter);
6881         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6882                          "Num of MPDUS truncated ", pdev->mpdus_truncated);
6883         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6884                          "Num of MPDUS ACK failed ", pdev->mpdus_ack_failed);
6885         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
6886                          "Num of MPDUS expired ", pdev->mpdus_expired);
6887         *length = len;
6888 }
6889
6890 static void
6891 ath11k_wmi_fw_pdev_rx_stats_fill(const struct ath11k_fw_stats_pdev *pdev,
6892                                  char *buf, u32 *length)
6893 {
6894         u32 len = *length;
6895         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
6896
6897         len += scnprintf(buf + len, buf_len - len, "\n%30s\n",
6898                          "ath11k PDEV RX stats");
6899         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
6900                          "====================");
6901
6902         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6903                          "Mid PPDU route change",
6904                          pdev->mid_ppdu_route_change);
6905         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6906                          "Tot. number of statuses", pdev->status_rcvd);
6907         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6908                          "Extra frags on rings 0", pdev->r0_frags);
6909         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6910                          "Extra frags on rings 1", pdev->r1_frags);
6911         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6912                          "Extra frags on rings 2", pdev->r2_frags);
6913         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6914                          "Extra frags on rings 3", pdev->r3_frags);
6915         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6916                          "MSDUs delivered to HTT", pdev->htt_msdus);
6917         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6918                          "MPDUs delivered to HTT", pdev->htt_mpdus);
6919         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6920                          "MSDUs delivered to stack", pdev->loc_msdus);
6921         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6922                          "MPDUs delivered to stack", pdev->loc_mpdus);
6923         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6924                          "Oversized AMSUs", pdev->oversize_amsdu);
6925         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6926                          "PHY errors", pdev->phy_errs);
6927         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6928                          "PHY errors drops", pdev->phy_err_drop);
6929         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6930                          "MPDU errors (FCS, MIC, ENC)", pdev->mpdu_errs);
6931         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
6932                          "Overflow errors", pdev->rx_ovfl_errs);
6933         *length = len;
6934 }
6935
6936 static void
6937 ath11k_wmi_fw_vdev_stats_fill(struct ath11k *ar,
6938                               const struct ath11k_fw_stats_vdev *vdev,
6939                               char *buf, u32 *length)
6940 {
6941         u32 len = *length;
6942         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
6943         struct ath11k_vif *arvif = ath11k_mac_get_arvif(ar, vdev->vdev_id);
6944         u8 *vif_macaddr;
6945         int i;
6946
6947         /* VDEV stats has all the active VDEVs of other PDEVs as well,
6948          * ignoring those not part of requested PDEV
6949          */
6950         if (!arvif)
6951                 return;
6952
6953         vif_macaddr = arvif->vif->addr;
6954
6955         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
6956                          "VDEV ID", vdev->vdev_id);
6957         len += scnprintf(buf + len, buf_len - len, "%30s %pM\n",
6958                          "VDEV MAC address", vif_macaddr);
6959         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
6960                          "beacon snr", vdev->beacon_snr);
6961         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
6962                          "data snr", vdev->data_snr);
6963         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
6964                          "num rx frames", vdev->num_rx_frames);
6965         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
6966                          "num rts fail", vdev->num_rts_fail);
6967         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
6968                          "num rts success", vdev->num_rts_success);
6969         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
6970                          "num rx err", vdev->num_rx_err);
6971         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
6972                          "num rx discard", vdev->num_rx_discard);
6973         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
6974                          "num tx not acked", vdev->num_tx_not_acked);
6975
6976         for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames); i++)
6977                 len += scnprintf(buf + len, buf_len - len,
6978                                 "%25s [%02d] %u\n",
6979                                 "num tx frames", i,
6980                                 vdev->num_tx_frames[i]);
6981
6982         for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames_retries); i++)
6983                 len += scnprintf(buf + len, buf_len - len,
6984                                 "%25s [%02d] %u\n",
6985                                 "num tx frames retries", i,
6986                                 vdev->num_tx_frames_retries[i]);
6987
6988         for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames_failures); i++)
6989                 len += scnprintf(buf + len, buf_len - len,
6990                                 "%25s [%02d] %u\n",
6991                                 "num tx frames failures", i,
6992                                 vdev->num_tx_frames_failures[i]);
6993
6994         for (i = 0 ; i < ARRAY_SIZE(vdev->tx_rate_history); i++)
6995                 len += scnprintf(buf + len, buf_len - len,
6996                                 "%25s [%02d] 0x%08x\n",
6997                                 "tx rate history", i,
6998                                 vdev->tx_rate_history[i]);
6999
7000         for (i = 0 ; i < ARRAY_SIZE(vdev->beacon_rssi_history); i++)
7001                 len += scnprintf(buf + len, buf_len - len,
7002                                 "%25s [%02d] %u\n",
7003                                 "beacon rssi history", i,
7004                                 vdev->beacon_rssi_history[i]);
7005
7006         len += scnprintf(buf + len, buf_len - len, "\n");
7007         *length = len;
7008 }
7009
7010 static void
7011 ath11k_wmi_fw_bcn_stats_fill(struct ath11k *ar,
7012                              const struct ath11k_fw_stats_bcn *bcn,
7013                              char *buf, u32 *length)
7014 {
7015         u32 len = *length;
7016         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
7017         struct ath11k_vif *arvif = ath11k_mac_get_arvif(ar, bcn->vdev_id);
7018         u8 *vdev_macaddr;
7019
7020         if (!arvif) {
7021                 ath11k_warn(ar->ab, "invalid vdev id %d in bcn stats",
7022                             bcn->vdev_id);
7023                 return;
7024         }
7025
7026         vdev_macaddr = arvif->vif->addr;
7027
7028         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
7029                          "VDEV ID", bcn->vdev_id);
7030         len += scnprintf(buf + len, buf_len - len, "%30s %pM\n",
7031                          "VDEV MAC address", vdev_macaddr);
7032         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
7033                          "================");
7034         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
7035                          "Num of beacon tx success", bcn->tx_bcn_succ_cnt);
7036         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
7037                          "Num of beacon tx failures", bcn->tx_bcn_outage_cnt);
7038
7039         len += scnprintf(buf + len, buf_len - len, "\n");
7040         *length = len;
7041 }
7042
7043 void ath11k_wmi_fw_stats_fill(struct ath11k *ar,
7044                               struct ath11k_fw_stats *fw_stats,
7045                               u32 stats_id, char *buf)
7046 {
7047         u32 len = 0;
7048         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
7049         const struct ath11k_fw_stats_pdev *pdev;
7050         const struct ath11k_fw_stats_vdev *vdev;
7051         const struct ath11k_fw_stats_bcn *bcn;
7052         size_t num_bcn;
7053
7054         spin_lock_bh(&ar->data_lock);
7055
7056         if (stats_id == WMI_REQUEST_PDEV_STAT) {
7057                 pdev = list_first_entry_or_null(&fw_stats->pdevs,
7058                                                 struct ath11k_fw_stats_pdev, list);
7059                 if (!pdev) {
7060                         ath11k_warn(ar->ab, "failed to get pdev stats\n");
7061                         goto unlock;
7062                 }
7063
7064                 ath11k_wmi_fw_pdev_base_stats_fill(pdev, buf, &len);
7065                 ath11k_wmi_fw_pdev_tx_stats_fill(pdev, buf, &len);
7066                 ath11k_wmi_fw_pdev_rx_stats_fill(pdev, buf, &len);
7067         }
7068
7069         if (stats_id == WMI_REQUEST_VDEV_STAT) {
7070                 len += scnprintf(buf + len, buf_len - len, "\n");
7071                 len += scnprintf(buf + len, buf_len - len, "%30s\n",
7072                                  "ath11k VDEV stats");
7073                 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
7074                                  "=================");
7075
7076                 list_for_each_entry(vdev, &fw_stats->vdevs, list)
7077                         ath11k_wmi_fw_vdev_stats_fill(ar, vdev, buf, &len);
7078         }
7079
7080         if (stats_id == WMI_REQUEST_BCN_STAT) {
7081                 num_bcn = list_count_nodes(&fw_stats->bcn);
7082
7083                 len += scnprintf(buf + len, buf_len - len, "\n");
7084                 len += scnprintf(buf + len, buf_len - len, "%30s (%zu)\n",
7085                                  "ath11k Beacon stats", num_bcn);
7086                 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
7087                                  "===================");
7088
7089                 list_for_each_entry(bcn, &fw_stats->bcn, list)
7090                         ath11k_wmi_fw_bcn_stats_fill(ar, bcn, buf, &len);
7091         }
7092
7093 unlock:
7094         spin_unlock_bh(&ar->data_lock);
7095
7096         if (len >= buf_len)
7097                 buf[len - 1] = 0;
7098         else
7099                 buf[len] = 0;
7100 }
7101
7102 static void ath11k_wmi_op_ep_tx_credits(struct ath11k_base *ab)
7103 {
7104         /* try to send pending beacons first. they take priority */
7105         wake_up(&ab->wmi_ab.tx_credits_wq);
7106 }
7107
7108 static int ath11k_reg_11d_new_cc_event(struct ath11k_base *ab, struct sk_buff *skb)
7109 {
7110         const struct wmi_11d_new_cc_ev *ev;
7111         struct ath11k *ar;
7112         struct ath11k_pdev *pdev;
7113         const void **tb;
7114         int ret, i;
7115
7116         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
7117         if (IS_ERR(tb)) {
7118                 ret = PTR_ERR(tb);
7119                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
7120                 return ret;
7121         }
7122
7123         ev = tb[WMI_TAG_11D_NEW_COUNTRY_EVENT];
7124         if (!ev) {
7125                 kfree(tb);
7126                 ath11k_warn(ab, "failed to fetch 11d new cc ev");
7127                 return -EPROTO;
7128         }
7129
7130         spin_lock_bh(&ab->base_lock);
7131         memcpy(&ab->new_alpha2, &ev->new_alpha2, 2);
7132         spin_unlock_bh(&ab->base_lock);
7133
7134         ath11k_dbg(ab, ATH11K_DBG_WMI, "event 11d new cc %c%c\n",
7135                    ab->new_alpha2[0],
7136                    ab->new_alpha2[1]);
7137
7138         kfree(tb);
7139
7140         for (i = 0; i < ab->num_radios; i++) {
7141                 pdev = &ab->pdevs[i];
7142                 ar = pdev->ar;
7143                 ar->state_11d = ATH11K_11D_IDLE;
7144                 complete(&ar->completed_11d_scan);
7145         }
7146
7147         queue_work(ab->workqueue, &ab->update_11d_work);
7148
7149         return 0;
7150 }
7151
7152 static void ath11k_wmi_htc_tx_complete(struct ath11k_base *ab,
7153                                        struct sk_buff *skb)
7154 {
7155         struct ath11k_pdev_wmi *wmi = NULL;
7156         u32 i;
7157         u8 wmi_ep_count;
7158         u8 eid;
7159
7160         eid = ATH11K_SKB_CB(skb)->eid;
7161         dev_kfree_skb(skb);
7162
7163         if (eid >= ATH11K_HTC_EP_COUNT)
7164                 return;
7165
7166         wmi_ep_count = ab->htc.wmi_ep_count;
7167         if (wmi_ep_count > ab->hw_params.max_radios)
7168                 return;
7169
7170         for (i = 0; i < ab->htc.wmi_ep_count; i++) {
7171                 if (ab->wmi_ab.wmi[i].eid == eid) {
7172                         wmi = &ab->wmi_ab.wmi[i];
7173                         break;
7174                 }
7175         }
7176
7177         if (wmi)
7178                 wake_up(&wmi->tx_ce_desc_wq);
7179 }
7180
7181 static int ath11k_reg_chan_list_event(struct ath11k_base *ab, struct sk_buff *skb,
7182                                       enum wmi_reg_chan_list_cmd_type id)
7183 {
7184         struct cur_regulatory_info *reg_info;
7185         int ret;
7186
7187         reg_info = kzalloc(sizeof(*reg_info), GFP_ATOMIC);
7188         if (!reg_info)
7189                 return -ENOMEM;
7190
7191         if (id == WMI_REG_CHAN_LIST_CC_ID)
7192                 ret = ath11k_pull_reg_chan_list_update_ev(ab, skb, reg_info);
7193         else
7194                 ret = ath11k_pull_reg_chan_list_ext_update_ev(ab, skb, reg_info);
7195
7196         if (ret) {
7197                 ath11k_warn(ab, "failed to extract regulatory info\n");
7198                 goto mem_free;
7199         }
7200
7201         ret = ath11k_reg_handle_chan_list(ab, reg_info, IEEE80211_REG_UNSET_AP);
7202         if (ret) {
7203                 ath11k_warn(ab, "failed to process regulatory info %d\n", ret);
7204                 goto mem_free;
7205         }
7206
7207         kfree(reg_info);
7208         return 0;
7209
7210 mem_free:
7211         ath11k_reg_reset_info(reg_info);
7212         kfree(reg_info);
7213         return ret;
7214 }
7215
7216 static int ath11k_wmi_tlv_rdy_parse(struct ath11k_base *ab, u16 tag, u16 len,
7217                                     const void *ptr, void *data)
7218 {
7219         struct wmi_tlv_rdy_parse *rdy_parse = data;
7220         struct wmi_ready_event fixed_param;
7221         struct wmi_mac_addr *addr_list;
7222         struct ath11k_pdev *pdev;
7223         u32 num_mac_addr;
7224         int i;
7225
7226         switch (tag) {
7227         case WMI_TAG_READY_EVENT:
7228                 memset(&fixed_param, 0, sizeof(fixed_param));
7229                 memcpy(&fixed_param, (struct wmi_ready_event *)ptr,
7230                        min_t(u16, sizeof(fixed_param), len));
7231                 rdy_parse->num_extra_mac_addr =
7232                         fixed_param.ready_event_min.num_extra_mac_addr;
7233
7234                 ether_addr_copy(ab->mac_addr,
7235                                 fixed_param.ready_event_min.mac_addr.addr);
7236                 ab->pktlog_defs_checksum = fixed_param.pktlog_defs_checksum;
7237                 break;
7238         case WMI_TAG_ARRAY_FIXED_STRUCT:
7239                 addr_list = (struct wmi_mac_addr *)ptr;
7240                 num_mac_addr = rdy_parse->num_extra_mac_addr;
7241
7242                 if (!(ab->num_radios > 1 && num_mac_addr >= ab->num_radios))
7243                         break;
7244
7245                 for (i = 0; i < ab->num_radios; i++) {
7246                         pdev = &ab->pdevs[i];
7247                         ether_addr_copy(pdev->mac_addr, addr_list[i].addr);
7248                 }
7249                 ab->pdevs_macaddr_valid = true;
7250                 break;
7251         default:
7252                 break;
7253         }
7254
7255         return 0;
7256 }
7257
7258 static int ath11k_ready_event(struct ath11k_base *ab, struct sk_buff *skb)
7259 {
7260         struct wmi_tlv_rdy_parse rdy_parse = { };
7261         int ret;
7262
7263         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
7264                                   ath11k_wmi_tlv_rdy_parse, &rdy_parse);
7265         if (ret) {
7266                 ath11k_warn(ab, "failed to parse tlv %d\n", ret);
7267                 return ret;
7268         }
7269
7270         ath11k_dbg(ab, ATH11K_DBG_WMI, "event ready");
7271
7272         complete(&ab->wmi_ab.unified_ready);
7273         return 0;
7274 }
7275
7276 static void ath11k_peer_delete_resp_event(struct ath11k_base *ab, struct sk_buff *skb)
7277 {
7278         struct wmi_peer_delete_resp_event peer_del_resp;
7279         struct ath11k *ar;
7280
7281         if (ath11k_pull_peer_del_resp_ev(ab, skb, &peer_del_resp) != 0) {
7282                 ath11k_warn(ab, "failed to extract peer delete resp");
7283                 return;
7284         }
7285
7286         ath11k_dbg(ab, ATH11K_DBG_WMI, "event peer delete resp");
7287
7288         rcu_read_lock();
7289         ar = ath11k_mac_get_ar_by_vdev_id(ab, peer_del_resp.vdev_id);
7290         if (!ar) {
7291                 ath11k_warn(ab, "invalid vdev id in peer delete resp ev %d",
7292                             peer_del_resp.vdev_id);
7293                 rcu_read_unlock();
7294                 return;
7295         }
7296
7297         complete(&ar->peer_delete_done);
7298         rcu_read_unlock();
7299         ath11k_dbg(ab, ATH11K_DBG_WMI, "peer delete resp for vdev id %d addr %pM\n",
7300                    peer_del_resp.vdev_id, peer_del_resp.peer_macaddr.addr);
7301 }
7302
7303 static void ath11k_vdev_delete_resp_event(struct ath11k_base *ab,
7304                                           struct sk_buff *skb)
7305 {
7306         struct ath11k *ar;
7307         u32 vdev_id = 0;
7308
7309         if (ath11k_pull_vdev_del_resp_ev(ab, skb, &vdev_id) != 0) {
7310                 ath11k_warn(ab, "failed to extract vdev delete resp");
7311                 return;
7312         }
7313
7314         rcu_read_lock();
7315         ar = ath11k_mac_get_ar_by_vdev_id(ab, vdev_id);
7316         if (!ar) {
7317                 ath11k_warn(ab, "invalid vdev id in vdev delete resp ev %d",
7318                             vdev_id);
7319                 rcu_read_unlock();
7320                 return;
7321         }
7322
7323         complete(&ar->vdev_delete_done);
7324
7325         rcu_read_unlock();
7326
7327         ath11k_dbg(ab, ATH11K_DBG_WMI, "event vdev delete resp for vdev id %d\n",
7328                    vdev_id);
7329 }
7330
7331 static inline const char *ath11k_wmi_vdev_resp_print(u32 vdev_resp_status)
7332 {
7333         switch (vdev_resp_status) {
7334         case WMI_VDEV_START_RESPONSE_INVALID_VDEVID:
7335                 return "invalid vdev id";
7336         case WMI_VDEV_START_RESPONSE_NOT_SUPPORTED:
7337                 return "not supported";
7338         case WMI_VDEV_START_RESPONSE_DFS_VIOLATION:
7339                 return "dfs violation";
7340         case WMI_VDEV_START_RESPONSE_INVALID_REGDOMAIN:
7341                 return "invalid regdomain";
7342         default:
7343                 return "unknown";
7344         }
7345 }
7346
7347 static void ath11k_vdev_start_resp_event(struct ath11k_base *ab, struct sk_buff *skb)
7348 {
7349         struct wmi_vdev_start_resp_event vdev_start_resp;
7350         struct ath11k *ar;
7351         u32 status;
7352
7353         if (ath11k_pull_vdev_start_resp_tlv(ab, skb, &vdev_start_resp) != 0) {
7354                 ath11k_warn(ab, "failed to extract vdev start resp");
7355                 return;
7356         }
7357
7358         ath11k_dbg(ab, ATH11K_DBG_WMI, "event start resp event");
7359
7360         rcu_read_lock();
7361         ar = ath11k_mac_get_ar_by_vdev_id(ab, vdev_start_resp.vdev_id);
7362         if (!ar) {
7363                 ath11k_warn(ab, "invalid vdev id in vdev start resp ev %d",
7364                             vdev_start_resp.vdev_id);
7365                 rcu_read_unlock();
7366                 return;
7367         }
7368
7369         ar->last_wmi_vdev_start_status = 0;
7370         ar->max_allowed_tx_power = vdev_start_resp.max_allowed_tx_power;
7371         status = vdev_start_resp.status;
7372
7373         if (WARN_ON_ONCE(status)) {
7374                 ath11k_warn(ab, "vdev start resp error status %d (%s)\n",
7375                             status, ath11k_wmi_vdev_resp_print(status));
7376                 ar->last_wmi_vdev_start_status = status;
7377         }
7378
7379         complete(&ar->vdev_setup_done);
7380
7381         rcu_read_unlock();
7382
7383         ath11k_dbg(ab, ATH11K_DBG_WMI, "vdev start resp for vdev id %d",
7384                    vdev_start_resp.vdev_id);
7385 }
7386
7387 static void ath11k_bcn_tx_status_event(struct ath11k_base *ab, struct sk_buff *skb)
7388 {
7389         struct ath11k_vif *arvif;
7390         u32 vdev_id, tx_status;
7391
7392         if (ath11k_pull_bcn_tx_status_ev(ab, skb, &vdev_id, &tx_status) != 0) {
7393                 ath11k_warn(ab, "failed to extract bcn tx status");
7394                 return;
7395         }
7396
7397         ath11k_dbg(ab, ATH11K_DBG_WMI, "event offload bcn tx status");
7398
7399         rcu_read_lock();
7400         arvif = ath11k_mac_get_arvif_by_vdev_id(ab, vdev_id);
7401         if (!arvif) {
7402                 ath11k_warn(ab, "invalid vdev id %d in bcn_tx_status",
7403                             vdev_id);
7404                 rcu_read_unlock();
7405                 return;
7406         }
7407
7408         queue_work(ab->workqueue, &arvif->bcn_tx_work);
7409
7410         rcu_read_unlock();
7411 }
7412
7413 static void ath11k_wmi_event_peer_sta_ps_state_chg(struct ath11k_base *ab,
7414                                                    struct sk_buff *skb)
7415 {
7416         const struct wmi_peer_sta_ps_state_chg_event *ev;
7417         struct ieee80211_sta *sta;
7418         struct ath11k_peer *peer;
7419         struct ath11k *ar;
7420         struct ath11k_sta *arsta;
7421         const void **tb;
7422         enum ath11k_wmi_peer_ps_state peer_previous_ps_state;
7423         int ret;
7424
7425         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
7426         if (IS_ERR(tb)) {
7427                 ret = PTR_ERR(tb);
7428                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
7429                 return;
7430         }
7431
7432         ev = tb[WMI_TAG_PEER_STA_PS_STATECHANGE_EVENT];
7433         if (!ev) {
7434                 ath11k_warn(ab, "failed to fetch sta ps change ev");
7435                 kfree(tb);
7436                 return;
7437         }
7438
7439         ath11k_dbg(ab, ATH11K_DBG_WMI,
7440                    "event peer sta ps change ev addr %pM state %u sup_bitmap %x ps_valid %u ts %u\n",
7441                    ev->peer_macaddr.addr, ev->peer_ps_state,
7442                    ev->ps_supported_bitmap, ev->peer_ps_valid,
7443                    ev->peer_ps_timestamp);
7444
7445         rcu_read_lock();
7446
7447         spin_lock_bh(&ab->base_lock);
7448
7449         peer = ath11k_peer_find_by_addr(ab, ev->peer_macaddr.addr);
7450
7451         if (!peer) {
7452                 spin_unlock_bh(&ab->base_lock);
7453                 ath11k_warn(ab, "peer not found %pM\n", ev->peer_macaddr.addr);
7454                 goto exit;
7455         }
7456
7457         ar = ath11k_mac_get_ar_by_vdev_id(ab, peer->vdev_id);
7458
7459         if (!ar) {
7460                 spin_unlock_bh(&ab->base_lock);
7461                 ath11k_warn(ab, "invalid vdev id in peer sta ps state change ev %d",
7462                             peer->vdev_id);
7463
7464                 goto exit;
7465         }
7466
7467         sta = peer->sta;
7468
7469         spin_unlock_bh(&ab->base_lock);
7470
7471         if (!sta) {
7472                 ath11k_warn(ab, "failed to find station entry %pM\n",
7473                             ev->peer_macaddr.addr);
7474                 goto exit;
7475         }
7476
7477         arsta = ath11k_sta_to_arsta(sta);
7478
7479         spin_lock_bh(&ar->data_lock);
7480
7481         peer_previous_ps_state = arsta->peer_ps_state;
7482         arsta->peer_ps_state = ev->peer_ps_state;
7483         arsta->peer_current_ps_valid = !!ev->peer_ps_valid;
7484
7485         if (test_bit(WMI_TLV_SERVICE_PEER_POWER_SAVE_DURATION_SUPPORT,
7486                      ar->ab->wmi_ab.svc_map)) {
7487                 if (!(ev->ps_supported_bitmap & WMI_PEER_PS_VALID) ||
7488                     !(ev->ps_supported_bitmap & WMI_PEER_PS_STATE_TIMESTAMP) ||
7489                     !ev->peer_ps_valid)
7490                         goto out;
7491
7492                 if (arsta->peer_ps_state == WMI_PEER_PS_STATE_ON) {
7493                         arsta->ps_start_time = ev->peer_ps_timestamp;
7494                         arsta->ps_start_jiffies = jiffies;
7495                 } else if (arsta->peer_ps_state == WMI_PEER_PS_STATE_OFF &&
7496                            peer_previous_ps_state == WMI_PEER_PS_STATE_ON) {
7497                         arsta->ps_total_duration = arsta->ps_total_duration +
7498                                         (ev->peer_ps_timestamp - arsta->ps_start_time);
7499                 }
7500
7501                 if (ar->ps_timekeeper_enable)
7502                         trace_ath11k_ps_timekeeper(ar, ev->peer_macaddr.addr,
7503                                                    ev->peer_ps_timestamp,
7504                                                    arsta->peer_ps_state);
7505         }
7506
7507 out:
7508         spin_unlock_bh(&ar->data_lock);
7509 exit:
7510         rcu_read_unlock();
7511         kfree(tb);
7512 }
7513
7514 static void ath11k_vdev_stopped_event(struct ath11k_base *ab, struct sk_buff *skb)
7515 {
7516         struct ath11k *ar;
7517         u32 vdev_id = 0;
7518
7519         if (ath11k_pull_vdev_stopped_param_tlv(ab, skb, &vdev_id) != 0) {
7520                 ath11k_warn(ab, "failed to extract vdev stopped event");
7521                 return;
7522         }
7523
7524         ath11k_dbg(ab, ATH11K_DBG_WMI, "event vdev stopped");
7525
7526         rcu_read_lock();
7527         ar = ath11k_mac_get_ar_by_vdev_id(ab, vdev_id);
7528         if (!ar) {
7529                 ath11k_warn(ab, "invalid vdev id in vdev stopped ev %d",
7530                             vdev_id);
7531                 rcu_read_unlock();
7532                 return;
7533         }
7534
7535         complete(&ar->vdev_setup_done);
7536
7537         rcu_read_unlock();
7538
7539         ath11k_dbg(ab, ATH11K_DBG_WMI, "vdev stopped for vdev id %d", vdev_id);
7540 }
7541
7542 static void ath11k_mgmt_rx_event(struct ath11k_base *ab, struct sk_buff *skb)
7543 {
7544         struct mgmt_rx_event_params rx_ev = {0};
7545         struct ath11k *ar;
7546         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
7547         struct ieee80211_hdr *hdr;
7548         u16 fc;
7549         struct ieee80211_supported_band *sband;
7550
7551         if (ath11k_pull_mgmt_rx_params_tlv(ab, skb, &rx_ev) != 0) {
7552                 ath11k_warn(ab, "failed to extract mgmt rx event");
7553                 dev_kfree_skb(skb);
7554                 return;
7555         }
7556
7557         memset(status, 0, sizeof(*status));
7558
7559         ath11k_dbg(ab, ATH11K_DBG_MGMT, "event mgmt rx status %08x\n",
7560                    rx_ev.status);
7561
7562         rcu_read_lock();
7563         ar = ath11k_mac_get_ar_by_pdev_id(ab, rx_ev.pdev_id);
7564
7565         if (!ar) {
7566                 ath11k_warn(ab, "invalid pdev_id %d in mgmt_rx_event\n",
7567                             rx_ev.pdev_id);
7568                 dev_kfree_skb(skb);
7569                 goto exit;
7570         }
7571
7572         if ((test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) ||
7573             (rx_ev.status & (WMI_RX_STATUS_ERR_DECRYPT |
7574             WMI_RX_STATUS_ERR_KEY_CACHE_MISS | WMI_RX_STATUS_ERR_CRC))) {
7575                 dev_kfree_skb(skb);
7576                 goto exit;
7577         }
7578
7579         if (rx_ev.status & WMI_RX_STATUS_ERR_MIC)
7580                 status->flag |= RX_FLAG_MMIC_ERROR;
7581
7582         if (rx_ev.chan_freq >= ATH11K_MIN_6G_FREQ &&
7583             rx_ev.chan_freq <= ATH11K_MAX_6G_FREQ) {
7584                 status->band = NL80211_BAND_6GHZ;
7585                 status->freq = rx_ev.chan_freq;
7586         } else if (rx_ev.channel >= 1 && rx_ev.channel <= 14) {
7587                 status->band = NL80211_BAND_2GHZ;
7588         } else if (rx_ev.channel >= 36 && rx_ev.channel <= ATH11K_MAX_5G_CHAN) {
7589                 status->band = NL80211_BAND_5GHZ;
7590         } else {
7591                 /* Shouldn't happen unless list of advertised channels to
7592                  * mac80211 has been changed.
7593                  */
7594                 WARN_ON_ONCE(1);
7595                 dev_kfree_skb(skb);
7596                 goto exit;
7597         }
7598
7599         if (rx_ev.phy_mode == MODE_11B &&
7600             (status->band == NL80211_BAND_5GHZ || status->band == NL80211_BAND_6GHZ))
7601                 ath11k_dbg(ab, ATH11K_DBG_WMI,
7602                            "mgmt rx 11b (CCK) on 5/6GHz, band = %d\n", status->band);
7603
7604         sband = &ar->mac.sbands[status->band];
7605
7606         if (status->band != NL80211_BAND_6GHZ)
7607                 status->freq = ieee80211_channel_to_frequency(rx_ev.channel,
7608                                                               status->band);
7609
7610         status->signal = rx_ev.snr + ATH11K_DEFAULT_NOISE_FLOOR;
7611         status->rate_idx = ath11k_mac_bitrate_to_idx(sband, rx_ev.rate / 100);
7612
7613         hdr = (struct ieee80211_hdr *)skb->data;
7614         fc = le16_to_cpu(hdr->frame_control);
7615
7616         /* Firmware is guaranteed to report all essential management frames via
7617          * WMI while it can deliver some extra via HTT. Since there can be
7618          * duplicates split the reporting wrt monitor/sniffing.
7619          */
7620         status->flag |= RX_FLAG_SKIP_MONITOR;
7621
7622         /* In case of PMF, FW delivers decrypted frames with Protected Bit set.
7623          * Don't clear that. Also, FW delivers broadcast management frames
7624          * (ex: group privacy action frames in mesh) as encrypted payload.
7625          */
7626         if (ieee80211_has_protected(hdr->frame_control) &&
7627             !is_multicast_ether_addr(ieee80211_get_DA(hdr))) {
7628                 status->flag |= RX_FLAG_DECRYPTED;
7629
7630                 if (!ieee80211_is_robust_mgmt_frame(skb)) {
7631                         status->flag |= RX_FLAG_IV_STRIPPED |
7632                                         RX_FLAG_MMIC_STRIPPED;
7633                         hdr->frame_control = __cpu_to_le16(fc &
7634                                              ~IEEE80211_FCTL_PROTECTED);
7635                 }
7636         }
7637
7638         if (ieee80211_is_beacon(hdr->frame_control))
7639                 ath11k_mac_handle_beacon(ar, skb);
7640
7641         ath11k_dbg(ab, ATH11K_DBG_MGMT,
7642                    "event mgmt rx skb %p len %d ftype %02x stype %02x\n",
7643                    skb, skb->len,
7644                    fc & IEEE80211_FCTL_FTYPE, fc & IEEE80211_FCTL_STYPE);
7645
7646         ath11k_dbg(ab, ATH11K_DBG_MGMT,
7647                    "event mgmt rx freq %d band %d snr %d, rate_idx %d\n",
7648                    status->freq, status->band, status->signal,
7649                    status->rate_idx);
7650
7651         ieee80211_rx_ni(ar->hw, skb);
7652
7653 exit:
7654         rcu_read_unlock();
7655 }
7656
7657 static void ath11k_mgmt_tx_compl_event(struct ath11k_base *ab, struct sk_buff *skb)
7658 {
7659         struct wmi_mgmt_tx_compl_event tx_compl_param = {0};
7660         struct ath11k *ar;
7661
7662         if (ath11k_pull_mgmt_tx_compl_param_tlv(ab, skb, &tx_compl_param) != 0) {
7663                 ath11k_warn(ab, "failed to extract mgmt tx compl event");
7664                 return;
7665         }
7666
7667         rcu_read_lock();
7668         ar = ath11k_mac_get_ar_by_pdev_id(ab, tx_compl_param.pdev_id);
7669         if (!ar) {
7670                 ath11k_warn(ab, "invalid pdev id %d in mgmt_tx_compl_event\n",
7671                             tx_compl_param.pdev_id);
7672                 goto exit;
7673         }
7674
7675         wmi_process_mgmt_tx_comp(ar, &tx_compl_param);
7676
7677         ath11k_dbg(ab, ATH11K_DBG_MGMT,
7678                    "event mgmt tx compl ev pdev_id %d, desc_id %d, status %d ack_rssi %d",
7679                    tx_compl_param.pdev_id, tx_compl_param.desc_id,
7680                    tx_compl_param.status, tx_compl_param.ack_rssi);
7681
7682 exit:
7683         rcu_read_unlock();
7684 }
7685
7686 static struct ath11k *ath11k_get_ar_on_scan_state(struct ath11k_base *ab,
7687                                                   u32 vdev_id,
7688                                                   enum ath11k_scan_state state)
7689 {
7690         int i;
7691         struct ath11k_pdev *pdev;
7692         struct ath11k *ar;
7693
7694         for (i = 0; i < ab->num_radios; i++) {
7695                 pdev = rcu_dereference(ab->pdevs_active[i]);
7696                 if (pdev && pdev->ar) {
7697                         ar = pdev->ar;
7698
7699                         spin_lock_bh(&ar->data_lock);
7700                         if (ar->scan.state == state &&
7701                             ar->scan.vdev_id == vdev_id) {
7702                                 spin_unlock_bh(&ar->data_lock);
7703                                 return ar;
7704                         }
7705                         spin_unlock_bh(&ar->data_lock);
7706                 }
7707         }
7708         return NULL;
7709 }
7710
7711 static void ath11k_scan_event(struct ath11k_base *ab, struct sk_buff *skb)
7712 {
7713         struct ath11k *ar;
7714         struct wmi_scan_event scan_ev = {0};
7715
7716         if (ath11k_pull_scan_ev(ab, skb, &scan_ev) != 0) {
7717                 ath11k_warn(ab, "failed to extract scan event");
7718                 return;
7719         }
7720
7721         rcu_read_lock();
7722
7723         /* In case the scan was cancelled, ex. during interface teardown,
7724          * the interface will not be found in active interfaces.
7725          * Rather, in such scenarios, iterate over the active pdev's to
7726          * search 'ar' if the corresponding 'ar' scan is ABORTING and the
7727          * aborting scan's vdev id matches this event info.
7728          */
7729         if (scan_ev.event_type == WMI_SCAN_EVENT_COMPLETED &&
7730             scan_ev.reason == WMI_SCAN_REASON_CANCELLED) {
7731                 ar = ath11k_get_ar_on_scan_state(ab, scan_ev.vdev_id,
7732                                                  ATH11K_SCAN_ABORTING);
7733                 if (!ar)
7734                         ar = ath11k_get_ar_on_scan_state(ab, scan_ev.vdev_id,
7735                                                          ATH11K_SCAN_RUNNING);
7736         } else {
7737                 ar = ath11k_mac_get_ar_by_vdev_id(ab, scan_ev.vdev_id);
7738         }
7739
7740         if (!ar) {
7741                 ath11k_warn(ab, "Received scan event for unknown vdev");
7742                 rcu_read_unlock();
7743                 return;
7744         }
7745
7746         spin_lock_bh(&ar->data_lock);
7747
7748         ath11k_dbg(ab, ATH11K_DBG_WMI,
7749                    "event scan %s type %d reason %d freq %d req_id %d scan_id %d vdev_id %d state %s (%d)\n",
7750                    ath11k_wmi_event_scan_type_str(scan_ev.event_type, scan_ev.reason),
7751                    scan_ev.event_type, scan_ev.reason, scan_ev.channel_freq,
7752                    scan_ev.scan_req_id, scan_ev.scan_id, scan_ev.vdev_id,
7753                    ath11k_scan_state_str(ar->scan.state), ar->scan.state);
7754
7755         switch (scan_ev.event_type) {
7756         case WMI_SCAN_EVENT_STARTED:
7757                 ath11k_wmi_event_scan_started(ar);
7758                 break;
7759         case WMI_SCAN_EVENT_COMPLETED:
7760                 ath11k_wmi_event_scan_completed(ar);
7761                 break;
7762         case WMI_SCAN_EVENT_BSS_CHANNEL:
7763                 ath11k_wmi_event_scan_bss_chan(ar);
7764                 break;
7765         case WMI_SCAN_EVENT_FOREIGN_CHAN:
7766                 ath11k_wmi_event_scan_foreign_chan(ar, scan_ev.channel_freq);
7767                 break;
7768         case WMI_SCAN_EVENT_START_FAILED:
7769                 ath11k_warn(ab, "received scan start failure event\n");
7770                 ath11k_wmi_event_scan_start_failed(ar);
7771                 break;
7772         case WMI_SCAN_EVENT_DEQUEUED:
7773                 __ath11k_mac_scan_finish(ar);
7774                 break;
7775         case WMI_SCAN_EVENT_PREEMPTED:
7776         case WMI_SCAN_EVENT_RESTARTED:
7777         case WMI_SCAN_EVENT_FOREIGN_CHAN_EXIT:
7778         default:
7779                 break;
7780         }
7781
7782         spin_unlock_bh(&ar->data_lock);
7783
7784         rcu_read_unlock();
7785 }
7786
7787 static void ath11k_peer_sta_kickout_event(struct ath11k_base *ab, struct sk_buff *skb)
7788 {
7789         struct wmi_peer_sta_kickout_arg arg = {};
7790         struct ieee80211_sta *sta;
7791         struct ath11k_peer *peer;
7792         struct ath11k *ar;
7793         u32 vdev_id;
7794
7795         if (ath11k_pull_peer_sta_kickout_ev(ab, skb, &arg) != 0) {
7796                 ath11k_warn(ab, "failed to extract peer sta kickout event");
7797                 return;
7798         }
7799
7800         rcu_read_lock();
7801
7802         spin_lock_bh(&ab->base_lock);
7803
7804         peer = ath11k_peer_find_by_addr(ab, arg.mac_addr);
7805
7806         if (!peer) {
7807                 ath11k_warn(ab, "peer not found %pM\n",
7808                             arg.mac_addr);
7809                 spin_unlock_bh(&ab->base_lock);
7810                 goto exit;
7811         }
7812
7813         vdev_id = peer->vdev_id;
7814
7815         spin_unlock_bh(&ab->base_lock);
7816
7817         ar = ath11k_mac_get_ar_by_vdev_id(ab, vdev_id);
7818         if (!ar) {
7819                 ath11k_warn(ab, "invalid vdev id in peer sta kickout ev %d",
7820                             peer->vdev_id);
7821                 goto exit;
7822         }
7823
7824         sta = ieee80211_find_sta_by_ifaddr(ar->hw,
7825                                            arg.mac_addr, NULL);
7826         if (!sta) {
7827                 ath11k_warn(ab, "Spurious quick kickout for STA %pM\n",
7828                             arg.mac_addr);
7829                 goto exit;
7830         }
7831
7832         ath11k_dbg(ab, ATH11K_DBG_WMI, "event peer sta kickout %pM",
7833                    arg.mac_addr);
7834
7835         ieee80211_report_low_ack(sta, 10);
7836
7837 exit:
7838         rcu_read_unlock();
7839 }
7840
7841 static void ath11k_roam_event(struct ath11k_base *ab, struct sk_buff *skb)
7842 {
7843         struct wmi_roam_event roam_ev = {};
7844         struct ath11k *ar;
7845
7846         if (ath11k_pull_roam_ev(ab, skb, &roam_ev) != 0) {
7847                 ath11k_warn(ab, "failed to extract roam event");
7848                 return;
7849         }
7850
7851         ath11k_dbg(ab, ATH11K_DBG_WMI,
7852                    "event roam vdev %u reason 0x%08x rssi %d\n",
7853                    roam_ev.vdev_id, roam_ev.reason, roam_ev.rssi);
7854
7855         rcu_read_lock();
7856         ar = ath11k_mac_get_ar_by_vdev_id(ab, roam_ev.vdev_id);
7857         if (!ar) {
7858                 ath11k_warn(ab, "invalid vdev id in roam ev %d",
7859                             roam_ev.vdev_id);
7860                 rcu_read_unlock();
7861                 return;
7862         }
7863
7864         if (roam_ev.reason >= WMI_ROAM_REASON_MAX)
7865                 ath11k_warn(ab, "ignoring unknown roam event reason %d on vdev %i\n",
7866                             roam_ev.reason, roam_ev.vdev_id);
7867
7868         switch (roam_ev.reason) {
7869         case WMI_ROAM_REASON_BEACON_MISS:
7870                 ath11k_mac_handle_beacon_miss(ar, roam_ev.vdev_id);
7871                 break;
7872         case WMI_ROAM_REASON_BETTER_AP:
7873         case WMI_ROAM_REASON_LOW_RSSI:
7874         case WMI_ROAM_REASON_SUITABLE_AP_FOUND:
7875         case WMI_ROAM_REASON_HO_FAILED:
7876                 ath11k_warn(ab, "ignoring not implemented roam event reason %d on vdev %i\n",
7877                             roam_ev.reason, roam_ev.vdev_id);
7878                 break;
7879         }
7880
7881         rcu_read_unlock();
7882 }
7883
7884 static void ath11k_chan_info_event(struct ath11k_base *ab, struct sk_buff *skb)
7885 {
7886         struct wmi_chan_info_event ch_info_ev = {0};
7887         struct ath11k *ar;
7888         struct survey_info *survey;
7889         int idx;
7890         /* HW channel counters frequency value in hertz */
7891         u32 cc_freq_hz = ab->cc_freq_hz;
7892
7893         if (ath11k_pull_chan_info_ev(ab, skb, &ch_info_ev) != 0) {
7894                 ath11k_warn(ab, "failed to extract chan info event");
7895                 return;
7896         }
7897
7898         ath11k_dbg(ab, ATH11K_DBG_WMI,
7899                    "event chan info vdev_id %d err_code %d freq %d cmd_flags %d noise_floor %d rx_clear_count %d cycle_count %d mac_clk_mhz %d\n",
7900                    ch_info_ev.vdev_id, ch_info_ev.err_code, ch_info_ev.freq,
7901                    ch_info_ev.cmd_flags, ch_info_ev.noise_floor,
7902                    ch_info_ev.rx_clear_count, ch_info_ev.cycle_count,
7903                    ch_info_ev.mac_clk_mhz);
7904
7905         if (ch_info_ev.cmd_flags == WMI_CHAN_INFO_END_RESP) {
7906                 ath11k_dbg(ab, ATH11K_DBG_WMI, "chan info report completed\n");
7907                 return;
7908         }
7909
7910         rcu_read_lock();
7911         ar = ath11k_mac_get_ar_by_vdev_id(ab, ch_info_ev.vdev_id);
7912         if (!ar) {
7913                 ath11k_warn(ab, "invalid vdev id in chan info ev %d",
7914                             ch_info_ev.vdev_id);
7915                 rcu_read_unlock();
7916                 return;
7917         }
7918         spin_lock_bh(&ar->data_lock);
7919
7920         switch (ar->scan.state) {
7921         case ATH11K_SCAN_IDLE:
7922         case ATH11K_SCAN_STARTING:
7923                 ath11k_warn(ab, "received chan info event without a scan request, ignoring\n");
7924                 goto exit;
7925         case ATH11K_SCAN_RUNNING:
7926         case ATH11K_SCAN_ABORTING:
7927                 break;
7928         }
7929
7930         idx = freq_to_idx(ar, ch_info_ev.freq);
7931         if (idx >= ARRAY_SIZE(ar->survey)) {
7932                 ath11k_warn(ab, "chan info: invalid frequency %d (idx %d out of bounds)\n",
7933                             ch_info_ev.freq, idx);
7934                 goto exit;
7935         }
7936
7937         /* If FW provides MAC clock frequency in Mhz, overriding the initialized
7938          * HW channel counters frequency value
7939          */
7940         if (ch_info_ev.mac_clk_mhz)
7941                 cc_freq_hz = (ch_info_ev.mac_clk_mhz * 1000);
7942
7943         if (ch_info_ev.cmd_flags == WMI_CHAN_INFO_START_RESP) {
7944                 survey = &ar->survey[idx];
7945                 memset(survey, 0, sizeof(*survey));
7946                 survey->noise = ch_info_ev.noise_floor;
7947                 survey->filled = SURVEY_INFO_NOISE_DBM | SURVEY_INFO_TIME |
7948                                  SURVEY_INFO_TIME_BUSY;
7949                 survey->time = div_u64(ch_info_ev.cycle_count, cc_freq_hz);
7950                 survey->time_busy = div_u64(ch_info_ev.rx_clear_count, cc_freq_hz);
7951         }
7952 exit:
7953         spin_unlock_bh(&ar->data_lock);
7954         rcu_read_unlock();
7955 }
7956
7957 static void
7958 ath11k_pdev_bss_chan_info_event(struct ath11k_base *ab, struct sk_buff *skb)
7959 {
7960         struct wmi_pdev_bss_chan_info_event bss_ch_info_ev = {};
7961         struct survey_info *survey;
7962         struct ath11k *ar;
7963         u32 cc_freq_hz = ab->cc_freq_hz;
7964         u64 busy, total, tx, rx, rx_bss;
7965         int idx;
7966
7967         if (ath11k_pull_pdev_bss_chan_info_ev(ab, skb, &bss_ch_info_ev) != 0) {
7968                 ath11k_warn(ab, "failed to extract pdev bss chan info event");
7969                 return;
7970         }
7971
7972         busy = (u64)(bss_ch_info_ev.rx_clear_count_high) << 32 |
7973                         bss_ch_info_ev.rx_clear_count_low;
7974
7975         total = (u64)(bss_ch_info_ev.cycle_count_high) << 32 |
7976                         bss_ch_info_ev.cycle_count_low;
7977
7978         tx = (u64)(bss_ch_info_ev.tx_cycle_count_high) << 32 |
7979                         bss_ch_info_ev.tx_cycle_count_low;
7980
7981         rx = (u64)(bss_ch_info_ev.rx_cycle_count_high) << 32 |
7982                         bss_ch_info_ev.rx_cycle_count_low;
7983
7984         rx_bss = (u64)(bss_ch_info_ev.rx_bss_cycle_count_high) << 32 |
7985                         bss_ch_info_ev.rx_bss_cycle_count_low;
7986
7987         ath11k_dbg(ab, ATH11K_DBG_WMI,
7988                    "event pdev bss chan info:\n pdev_id: %d freq: %d noise: %d cycle: busy %llu total %llu tx %llu rx %llu rx_bss %llu\n",
7989                    bss_ch_info_ev.pdev_id, bss_ch_info_ev.freq,
7990                    bss_ch_info_ev.noise_floor, busy, total,
7991                    tx, rx, rx_bss);
7992
7993         rcu_read_lock();
7994         ar = ath11k_mac_get_ar_by_pdev_id(ab, bss_ch_info_ev.pdev_id);
7995
7996         if (!ar) {
7997                 ath11k_warn(ab, "invalid pdev id %d in bss_chan_info event\n",
7998                             bss_ch_info_ev.pdev_id);
7999                 rcu_read_unlock();
8000                 return;
8001         }
8002
8003         spin_lock_bh(&ar->data_lock);
8004         idx = freq_to_idx(ar, bss_ch_info_ev.freq);
8005         if (idx >= ARRAY_SIZE(ar->survey)) {
8006                 ath11k_warn(ab, "bss chan info: invalid frequency %d (idx %d out of bounds)\n",
8007                             bss_ch_info_ev.freq, idx);
8008                 goto exit;
8009         }
8010
8011         survey = &ar->survey[idx];
8012
8013         survey->noise     = bss_ch_info_ev.noise_floor;
8014         survey->time      = div_u64(total, cc_freq_hz);
8015         survey->time_busy = div_u64(busy, cc_freq_hz);
8016         survey->time_rx   = div_u64(rx_bss, cc_freq_hz);
8017         survey->time_tx   = div_u64(tx, cc_freq_hz);
8018         survey->filled   |= (SURVEY_INFO_NOISE_DBM |
8019                              SURVEY_INFO_TIME |
8020                              SURVEY_INFO_TIME_BUSY |
8021                              SURVEY_INFO_TIME_RX |
8022                              SURVEY_INFO_TIME_TX);
8023 exit:
8024         spin_unlock_bh(&ar->data_lock);
8025         complete(&ar->bss_survey_done);
8026
8027         rcu_read_unlock();
8028 }
8029
8030 static void ath11k_vdev_install_key_compl_event(struct ath11k_base *ab,
8031                                                 struct sk_buff *skb)
8032 {
8033         struct wmi_vdev_install_key_complete_arg install_key_compl = {0};
8034         struct ath11k *ar;
8035
8036         if (ath11k_pull_vdev_install_key_compl_ev(ab, skb, &install_key_compl) != 0) {
8037                 ath11k_warn(ab, "failed to extract install key compl event");
8038                 return;
8039         }
8040
8041         ath11k_dbg(ab, ATH11K_DBG_WMI,
8042                    "event vdev install key ev idx %d flags %08x macaddr %pM status %d\n",
8043                    install_key_compl.key_idx, install_key_compl.key_flags,
8044                    install_key_compl.macaddr, install_key_compl.status);
8045
8046         rcu_read_lock();
8047         ar = ath11k_mac_get_ar_by_vdev_id(ab, install_key_compl.vdev_id);
8048         if (!ar) {
8049                 ath11k_warn(ab, "invalid vdev id in install key compl ev %d",
8050                             install_key_compl.vdev_id);
8051                 rcu_read_unlock();
8052                 return;
8053         }
8054
8055         ar->install_key_status = 0;
8056
8057         if (install_key_compl.status != WMI_VDEV_INSTALL_KEY_COMPL_STATUS_SUCCESS) {
8058                 ath11k_warn(ab, "install key failed for %pM status %d\n",
8059                             install_key_compl.macaddr, install_key_compl.status);
8060                 ar->install_key_status = install_key_compl.status;
8061         }
8062
8063         complete(&ar->install_key_done);
8064         rcu_read_unlock();
8065 }
8066
8067 static int  ath11k_wmi_tlv_services_parser(struct ath11k_base *ab,
8068                                            u16 tag, u16 len,
8069                                            const void *ptr, void *data)
8070 {
8071         const struct wmi_service_available_event *ev;
8072         u32 *wmi_ext2_service_bitmap;
8073         int i, j;
8074
8075         switch (tag) {
8076         case WMI_TAG_SERVICE_AVAILABLE_EVENT:
8077                 ev = (struct wmi_service_available_event *)ptr;
8078                 for (i = 0, j = WMI_MAX_SERVICE;
8079                         i < WMI_SERVICE_SEGMENT_BM_SIZE32 && j < WMI_MAX_EXT_SERVICE;
8080                         i++) {
8081                         do {
8082                                 if (ev->wmi_service_segment_bitmap[i] &
8083                                     BIT(j % WMI_AVAIL_SERVICE_BITS_IN_SIZE32))
8084                                         set_bit(j, ab->wmi_ab.svc_map);
8085                         } while (++j % WMI_AVAIL_SERVICE_BITS_IN_SIZE32);
8086                 }
8087
8088                 ath11k_dbg(ab, ATH11K_DBG_WMI,
8089                            "wmi_ext_service_bitmap 0:0x%04x, 1:0x%04x, 2:0x%04x, 3:0x%04x",
8090                            ev->wmi_service_segment_bitmap[0],
8091                            ev->wmi_service_segment_bitmap[1],
8092                            ev->wmi_service_segment_bitmap[2],
8093                            ev->wmi_service_segment_bitmap[3]);
8094                 break;
8095         case WMI_TAG_ARRAY_UINT32:
8096                 wmi_ext2_service_bitmap = (u32 *)ptr;
8097                 for (i = 0, j = WMI_MAX_EXT_SERVICE;
8098                         i < WMI_SERVICE_SEGMENT_BM_SIZE32 && j < WMI_MAX_EXT2_SERVICE;
8099                         i++) {
8100                         do {
8101                                 if (wmi_ext2_service_bitmap[i] &
8102                                     BIT(j % WMI_AVAIL_SERVICE_BITS_IN_SIZE32))
8103                                         set_bit(j, ab->wmi_ab.svc_map);
8104                         } while (++j % WMI_AVAIL_SERVICE_BITS_IN_SIZE32);
8105                 }
8106
8107                 ath11k_dbg(ab, ATH11K_DBG_WMI,
8108                            "wmi_ext2_service__bitmap  0:0x%04x, 1:0x%04x, 2:0x%04x, 3:0x%04x",
8109                            wmi_ext2_service_bitmap[0], wmi_ext2_service_bitmap[1],
8110                            wmi_ext2_service_bitmap[2], wmi_ext2_service_bitmap[3]);
8111                 break;
8112         }
8113         return 0;
8114 }
8115
8116 static void ath11k_service_available_event(struct ath11k_base *ab, struct sk_buff *skb)
8117 {
8118         int ret;
8119
8120         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
8121                                   ath11k_wmi_tlv_services_parser,
8122                                   NULL);
8123         if (ret)
8124                 ath11k_warn(ab, "failed to parse services available tlv %d\n", ret);
8125
8126         ath11k_dbg(ab, ATH11K_DBG_WMI, "event service available");
8127 }
8128
8129 static void ath11k_peer_assoc_conf_event(struct ath11k_base *ab, struct sk_buff *skb)
8130 {
8131         struct wmi_peer_assoc_conf_arg peer_assoc_conf = {0};
8132         struct ath11k *ar;
8133
8134         if (ath11k_pull_peer_assoc_conf_ev(ab, skb, &peer_assoc_conf) != 0) {
8135                 ath11k_warn(ab, "failed to extract peer assoc conf event");
8136                 return;
8137         }
8138
8139         ath11k_dbg(ab, ATH11K_DBG_WMI,
8140                    "event peer assoc conf ev vdev id %d macaddr %pM\n",
8141                    peer_assoc_conf.vdev_id, peer_assoc_conf.macaddr);
8142
8143         rcu_read_lock();
8144         ar = ath11k_mac_get_ar_by_vdev_id(ab, peer_assoc_conf.vdev_id);
8145
8146         if (!ar) {
8147                 ath11k_warn(ab, "invalid vdev id in peer assoc conf ev %d",
8148                             peer_assoc_conf.vdev_id);
8149                 rcu_read_unlock();
8150                 return;
8151         }
8152
8153         complete(&ar->peer_assoc_done);
8154         rcu_read_unlock();
8155 }
8156
8157 static void ath11k_update_stats_event(struct ath11k_base *ab, struct sk_buff *skb)
8158 {
8159         struct ath11k_fw_stats stats = {};
8160         struct ath11k *ar;
8161         int ret;
8162
8163         INIT_LIST_HEAD(&stats.pdevs);
8164         INIT_LIST_HEAD(&stats.vdevs);
8165         INIT_LIST_HEAD(&stats.bcn);
8166
8167         ret = ath11k_wmi_pull_fw_stats(ab, skb, &stats);
8168         if (ret) {
8169                 ath11k_warn(ab, "failed to pull fw stats: %d\n", ret);
8170                 goto free;
8171         }
8172
8173         ath11k_dbg(ab, ATH11K_DBG_WMI, "event update stats");
8174
8175         rcu_read_lock();
8176         ar = ath11k_mac_get_ar_by_pdev_id(ab, stats.pdev_id);
8177         if (!ar) {
8178                 rcu_read_unlock();
8179                 ath11k_warn(ab, "failed to get ar for pdev_id %d: %d\n",
8180                             stats.pdev_id, ret);
8181                 goto free;
8182         }
8183
8184         spin_lock_bh(&ar->data_lock);
8185
8186         /* WMI_REQUEST_PDEV_STAT can be requested via .get_txpower mac ops or via
8187          * debugfs fw stats. Therefore, processing it separately.
8188          */
8189         if (stats.stats_id == WMI_REQUEST_PDEV_STAT) {
8190                 list_splice_tail_init(&stats.pdevs, &ar->fw_stats.pdevs);
8191                 ar->fw_stats_done = true;
8192                 goto complete;
8193         }
8194
8195         /* WMI_REQUEST_VDEV_STAT, WMI_REQUEST_BCN_STAT and WMI_REQUEST_RSSI_PER_CHAIN_STAT
8196          * are currently requested only via debugfs fw stats. Hence, processing these
8197          * in debugfs context
8198          */
8199         ath11k_debugfs_fw_stats_process(ar, &stats);
8200
8201 complete:
8202         complete(&ar->fw_stats_complete);
8203         rcu_read_unlock();
8204         spin_unlock_bh(&ar->data_lock);
8205
8206         /* Since the stats's pdev, vdev and beacon list are spliced and reinitialised
8207          * at this point, no need to free the individual list.
8208          */
8209         return;
8210
8211 free:
8212         ath11k_fw_stats_free(&stats);
8213 }
8214
8215 /* PDEV_CTL_FAILSAFE_CHECK_EVENT is received from FW when the frequency scanned
8216  * is not part of BDF CTL(Conformance test limits) table entries.
8217  */
8218 static void ath11k_pdev_ctl_failsafe_check_event(struct ath11k_base *ab,
8219                                                  struct sk_buff *skb)
8220 {
8221         const void **tb;
8222         const struct wmi_pdev_ctl_failsafe_chk_event *ev;
8223         int ret;
8224
8225         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
8226         if (IS_ERR(tb)) {
8227                 ret = PTR_ERR(tb);
8228                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
8229                 return;
8230         }
8231
8232         ev = tb[WMI_TAG_PDEV_CTL_FAILSAFE_CHECK_EVENT];
8233         if (!ev) {
8234                 ath11k_warn(ab, "failed to fetch pdev ctl failsafe check ev");
8235                 kfree(tb);
8236                 return;
8237         }
8238
8239         ath11k_dbg(ab, ATH11K_DBG_WMI,
8240                    "event pdev ctl failsafe check status %d\n",
8241                    ev->ctl_failsafe_status);
8242
8243         /* If ctl_failsafe_status is set to 1 FW will max out the Transmit power
8244          * to 10 dBm else the CTL power entry in the BDF would be picked up.
8245          */
8246         if (ev->ctl_failsafe_status != 0)
8247                 ath11k_warn(ab, "pdev ctl failsafe failure status %d",
8248                             ev->ctl_failsafe_status);
8249
8250         kfree(tb);
8251 }
8252
8253 static void
8254 ath11k_wmi_process_csa_switch_count_event(struct ath11k_base *ab,
8255                                           const struct wmi_pdev_csa_switch_ev *ev,
8256                                           const u32 *vdev_ids)
8257 {
8258         int i;
8259         struct ath11k_vif *arvif;
8260
8261         /* Finish CSA once the switch count becomes NULL */
8262         if (ev->current_switch_count)
8263                 return;
8264
8265         rcu_read_lock();
8266         for (i = 0; i < ev->num_vdevs; i++) {
8267                 arvif = ath11k_mac_get_arvif_by_vdev_id(ab, vdev_ids[i]);
8268
8269                 if (!arvif) {
8270                         ath11k_warn(ab, "Recvd csa status for unknown vdev %d",
8271                                     vdev_ids[i]);
8272                         continue;
8273                 }
8274
8275                 if (arvif->is_up && arvif->vif->bss_conf.csa_active)
8276                         ieee80211_csa_finish(arvif->vif, 0);
8277         }
8278         rcu_read_unlock();
8279 }
8280
8281 static void
8282 ath11k_wmi_pdev_csa_switch_count_status_event(struct ath11k_base *ab,
8283                                               struct sk_buff *skb)
8284 {
8285         const void **tb;
8286         const struct wmi_pdev_csa_switch_ev *ev;
8287         const u32 *vdev_ids;
8288         int ret;
8289
8290         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
8291         if (IS_ERR(tb)) {
8292                 ret = PTR_ERR(tb);
8293                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
8294                 return;
8295         }
8296
8297         ev = tb[WMI_TAG_PDEV_CSA_SWITCH_COUNT_STATUS_EVENT];
8298         vdev_ids = tb[WMI_TAG_ARRAY_UINT32];
8299
8300         if (!ev || !vdev_ids) {
8301                 ath11k_warn(ab, "failed to fetch pdev csa switch count ev");
8302                 kfree(tb);
8303                 return;
8304         }
8305
8306         ath11k_dbg(ab, ATH11K_DBG_WMI,
8307                    "event pdev csa switch count %d for pdev %d, num_vdevs %d",
8308                    ev->current_switch_count, ev->pdev_id,
8309                    ev->num_vdevs);
8310
8311         ath11k_wmi_process_csa_switch_count_event(ab, ev, vdev_ids);
8312
8313         kfree(tb);
8314 }
8315
8316 static void
8317 ath11k_wmi_pdev_dfs_radar_detected_event(struct ath11k_base *ab, struct sk_buff *skb)
8318 {
8319         const void **tb;
8320         const struct wmi_pdev_radar_ev *ev;
8321         struct ath11k *ar;
8322         int ret;
8323
8324         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
8325         if (IS_ERR(tb)) {
8326                 ret = PTR_ERR(tb);
8327                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
8328                 return;
8329         }
8330
8331         ev = tb[WMI_TAG_PDEV_DFS_RADAR_DETECTION_EVENT];
8332
8333         if (!ev) {
8334                 ath11k_warn(ab, "failed to fetch pdev dfs radar detected ev");
8335                 kfree(tb);
8336                 return;
8337         }
8338
8339         ath11k_dbg(ab, ATH11K_DBG_WMI,
8340                    "event pdev dfs radar detected on pdev %d, detection mode %d, chan freq %d, chan_width %d, detector id %d, seg id %d, timestamp %d, chirp %d, freq offset %d, sidx %d",
8341                    ev->pdev_id, ev->detection_mode, ev->chan_freq, ev->chan_width,
8342                    ev->detector_id, ev->segment_id, ev->timestamp, ev->is_chirp,
8343                    ev->freq_offset, ev->sidx);
8344
8345         rcu_read_lock();
8346
8347         ar = ath11k_mac_get_ar_by_pdev_id(ab, ev->pdev_id);
8348
8349         if (!ar) {
8350                 ath11k_warn(ab, "radar detected in invalid pdev %d\n",
8351                             ev->pdev_id);
8352                 goto exit;
8353         }
8354
8355         ath11k_dbg(ar->ab, ATH11K_DBG_REG, "DFS Radar Detected in pdev %d\n",
8356                    ev->pdev_id);
8357
8358         if (ar->dfs_block_radar_events)
8359                 ath11k_info(ab, "DFS Radar detected, but ignored as requested\n");
8360         else
8361                 ieee80211_radar_detected(ar->hw, NULL);
8362
8363 exit:
8364         rcu_read_unlock();
8365
8366         kfree(tb);
8367 }
8368
8369 static void
8370 ath11k_wmi_pdev_temperature_event(struct ath11k_base *ab,
8371                                   struct sk_buff *skb)
8372 {
8373         struct ath11k *ar;
8374         const void **tb;
8375         const struct wmi_pdev_temperature_event *ev;
8376         int ret;
8377
8378         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
8379         if (IS_ERR(tb)) {
8380                 ret = PTR_ERR(tb);
8381                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
8382                 return;
8383         }
8384
8385         ev = tb[WMI_TAG_PDEV_TEMPERATURE_EVENT];
8386         if (!ev) {
8387                 ath11k_warn(ab, "failed to fetch pdev temp ev");
8388                 kfree(tb);
8389                 return;
8390         }
8391
8392         ath11k_dbg(ab, ATH11K_DBG_WMI, "event pdev temperature ev temp %d pdev_id %d\n",
8393                    ev->temp, ev->pdev_id);
8394
8395         rcu_read_lock();
8396
8397         ar = ath11k_mac_get_ar_by_pdev_id(ab, ev->pdev_id);
8398         if (!ar) {
8399                 ath11k_warn(ab, "invalid pdev id in pdev temperature ev %d", ev->pdev_id);
8400                 goto exit;
8401         }
8402
8403         ath11k_thermal_event_temperature(ar, ev->temp);
8404
8405 exit:
8406         rcu_read_unlock();
8407
8408         kfree(tb);
8409 }
8410
8411 static void ath11k_fils_discovery_event(struct ath11k_base *ab,
8412                                         struct sk_buff *skb)
8413 {
8414         const void **tb;
8415         const struct wmi_fils_discovery_event *ev;
8416         int ret;
8417
8418         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
8419         if (IS_ERR(tb)) {
8420                 ret = PTR_ERR(tb);
8421                 ath11k_warn(ab,
8422                             "failed to parse FILS discovery event tlv %d\n",
8423                             ret);
8424                 return;
8425         }
8426
8427         ath11k_dbg(ab, ATH11K_DBG_WMI, "event fils discovery");
8428
8429         ev = tb[WMI_TAG_HOST_SWFDA_EVENT];
8430         if (!ev) {
8431                 ath11k_warn(ab, "failed to fetch FILS discovery event\n");
8432                 kfree(tb);
8433                 return;
8434         }
8435
8436         ath11k_warn(ab,
8437                     "FILS discovery frame expected from host for vdev_id: %u, transmission scheduled at %u, next TBTT: %u\n",
8438                     ev->vdev_id, ev->fils_tt, ev->tbtt);
8439
8440         kfree(tb);
8441 }
8442
8443 static void ath11k_probe_resp_tx_status_event(struct ath11k_base *ab,
8444                                               struct sk_buff *skb)
8445 {
8446         const void **tb;
8447         const struct wmi_probe_resp_tx_status_event *ev;
8448         int ret;
8449
8450         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
8451         if (IS_ERR(tb)) {
8452                 ret = PTR_ERR(tb);
8453                 ath11k_warn(ab,
8454                             "failed to parse probe response transmission status event tlv: %d\n",
8455                             ret);
8456                 return;
8457         }
8458
8459         ath11k_dbg(ab, ATH11K_DBG_WMI, "event probe resp tx status");
8460
8461         ev = tb[WMI_TAG_OFFLOAD_PRB_RSP_TX_STATUS_EVENT];
8462         if (!ev) {
8463                 ath11k_warn(ab,
8464                             "failed to fetch probe response transmission status event");
8465                 kfree(tb);
8466                 return;
8467         }
8468
8469         if (ev->tx_status)
8470                 ath11k_warn(ab,
8471                             "Probe response transmission failed for vdev_id %u, status %u\n",
8472                             ev->vdev_id, ev->tx_status);
8473
8474         kfree(tb);
8475 }
8476
8477 static int ath11k_wmi_tlv_wow_wakeup_host_parse(struct ath11k_base *ab,
8478                                                 u16 tag, u16 len,
8479                                                 const void *ptr, void *data)
8480 {
8481         struct wmi_wow_ev_arg *ev = data;
8482         const char *wow_pg_fault;
8483         int wow_pg_len;
8484
8485         switch (tag) {
8486         case WMI_TAG_WOW_EVENT_INFO:
8487                 memcpy(ev, ptr, sizeof(*ev));
8488                 ath11k_dbg(ab, ATH11K_DBG_WMI, "wow wakeup host reason %d %s\n",
8489                            ev->wake_reason, wow_reason(ev->wake_reason));
8490                 break;
8491
8492         case WMI_TAG_ARRAY_BYTE:
8493                 if (ev && ev->wake_reason == WOW_REASON_PAGE_FAULT) {
8494                         wow_pg_fault = ptr;
8495                         /* the first 4 bytes are length */
8496                         wow_pg_len = *(int *)wow_pg_fault;
8497                         wow_pg_fault += sizeof(int);
8498                         ath11k_dbg(ab, ATH11K_DBG_WMI, "wow data_len = %d\n",
8499                                    wow_pg_len);
8500                         ath11k_dbg_dump(ab, ATH11K_DBG_WMI,
8501                                         "wow_event_info_type packet present",
8502                                         "wow_pg_fault ",
8503                                         wow_pg_fault,
8504                                         wow_pg_len);
8505                 }
8506                 break;
8507         default:
8508                 break;
8509         }
8510
8511         return 0;
8512 }
8513
8514 static void ath11k_wmi_event_wow_wakeup_host(struct ath11k_base *ab, struct sk_buff *skb)
8515 {
8516         struct wmi_wow_ev_arg ev = { };
8517         int ret;
8518
8519         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
8520                                   ath11k_wmi_tlv_wow_wakeup_host_parse,
8521                                   &ev);
8522         if (ret) {
8523                 ath11k_warn(ab, "failed to parse wmi wow tlv: %d\n", ret);
8524                 return;
8525         }
8526
8527         ath11k_dbg(ab, ATH11K_DBG_WMI, "event wow wakeup host");
8528
8529         complete(&ab->wow.wakeup_completed);
8530 }
8531
8532 static void
8533 ath11k_wmi_diag_event(struct ath11k_base *ab,
8534                       struct sk_buff *skb)
8535 {
8536         ath11k_dbg(ab, ATH11K_DBG_WMI, "event diag");
8537
8538         trace_ath11k_wmi_diag(ab, skb->data, skb->len);
8539 }
8540
8541 static const char *ath11k_wmi_twt_add_dialog_event_status(u32 status)
8542 {
8543         switch (status) {
8544         case WMI_ADD_TWT_STATUS_OK:
8545                 return "ok";
8546         case WMI_ADD_TWT_STATUS_TWT_NOT_ENABLED:
8547                 return "twt disabled";
8548         case WMI_ADD_TWT_STATUS_USED_DIALOG_ID:
8549                 return "dialog id in use";
8550         case WMI_ADD_TWT_STATUS_INVALID_PARAM:
8551                 return "invalid parameters";
8552         case WMI_ADD_TWT_STATUS_NOT_READY:
8553                 return "not ready";
8554         case WMI_ADD_TWT_STATUS_NO_RESOURCE:
8555                 return "resource unavailable";
8556         case WMI_ADD_TWT_STATUS_NO_ACK:
8557                 return "no ack";
8558         case WMI_ADD_TWT_STATUS_NO_RESPONSE:
8559                 return "no response";
8560         case WMI_ADD_TWT_STATUS_DENIED:
8561                 return "denied";
8562         case WMI_ADD_TWT_STATUS_UNKNOWN_ERROR:
8563                 fallthrough;
8564         default:
8565                 return "unknown error";
8566         }
8567 }
8568
8569 static void ath11k_wmi_twt_add_dialog_event(struct ath11k_base *ab,
8570                                             struct sk_buff *skb)
8571 {
8572         const void **tb;
8573         const struct wmi_twt_add_dialog_event *ev;
8574         int ret;
8575
8576         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
8577         if (IS_ERR(tb)) {
8578                 ret = PTR_ERR(tb);
8579                 ath11k_warn(ab,
8580                             "failed to parse wmi twt add dialog status event tlv: %d\n",
8581                             ret);
8582                 return;
8583         }
8584
8585         ath11k_dbg(ab, ATH11K_DBG_WMI, "event twt add dialog");
8586
8587         ev = tb[WMI_TAG_TWT_ADD_DIALOG_COMPLETE_EVENT];
8588         if (!ev) {
8589                 ath11k_warn(ab, "failed to fetch twt add dialog wmi event\n");
8590                 goto exit;
8591         }
8592
8593         if (ev->status)
8594                 ath11k_warn(ab,
8595                             "wmi add twt dialog event vdev %d dialog id %d status %s\n",
8596                             ev->vdev_id, ev->dialog_id,
8597                             ath11k_wmi_twt_add_dialog_event_status(ev->status));
8598
8599 exit:
8600         kfree(tb);
8601 }
8602
8603 static void ath11k_wmi_gtk_offload_status_event(struct ath11k_base *ab,
8604                                                 struct sk_buff *skb)
8605 {
8606         const void **tb;
8607         const struct wmi_gtk_offload_status_event *ev;
8608         struct ath11k_vif *arvif;
8609         __be64 replay_ctr_be;
8610         u64    replay_ctr;
8611         int ret;
8612
8613         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
8614         if (IS_ERR(tb)) {
8615                 ret = PTR_ERR(tb);
8616                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
8617                 return;
8618         }
8619
8620         ev = tb[WMI_TAG_GTK_OFFLOAD_STATUS_EVENT];
8621         if (!ev) {
8622                 ath11k_warn(ab, "failed to fetch gtk offload status ev");
8623                 kfree(tb);
8624                 return;
8625         }
8626
8627         rcu_read_lock();
8628
8629         arvif = ath11k_mac_get_arvif_by_vdev_id(ab, ev->vdev_id);
8630         if (!arvif) {
8631                 ath11k_warn(ab, "failed to get arvif for vdev_id:%d\n",
8632                             ev->vdev_id);
8633                 goto exit;
8634         }
8635
8636         ath11k_dbg(ab, ATH11K_DBG_WMI, "event gtk offload refresh_cnt %d\n",
8637                    ev->refresh_cnt);
8638         ath11k_dbg_dump(ab, ATH11K_DBG_WMI, "replay_cnt",
8639                         NULL, ev->replay_ctr.counter, GTK_REPLAY_COUNTER_BYTES);
8640
8641         replay_ctr =  ev->replay_ctr.word1;
8642         replay_ctr = (replay_ctr << 32) | ev->replay_ctr.word0;
8643         arvif->rekey_data.replay_ctr = replay_ctr;
8644
8645         /* supplicant expects big-endian replay counter */
8646         replay_ctr_be = cpu_to_be64(replay_ctr);
8647
8648         ieee80211_gtk_rekey_notify(arvif->vif, arvif->bssid,
8649                                    (void *)&replay_ctr_be, GFP_ATOMIC);
8650 exit:
8651         rcu_read_unlock();
8652
8653         kfree(tb);
8654 }
8655
8656 static void ath11k_wmi_p2p_noa_event(struct ath11k_base *ab,
8657                                      struct sk_buff *skb)
8658 {
8659         const void **tb;
8660         const struct wmi_p2p_noa_event *ev;
8661         const struct ath11k_wmi_p2p_noa_info *noa;
8662         struct ath11k *ar;
8663         int vdev_id;
8664         u8 noa_descriptors;
8665
8666         tb = ath11k_wmi_tlv_parse_alloc(ab, skb, GFP_ATOMIC);
8667         if (IS_ERR(tb)) {
8668                 ath11k_warn(ab, "failed to parse tlv: %ld\n", PTR_ERR(tb));
8669                 return;
8670         }
8671
8672         ev = tb[WMI_TAG_P2P_NOA_EVENT];
8673         noa = tb[WMI_TAG_P2P_NOA_INFO];
8674
8675         if (!ev || !noa)
8676                 goto out;
8677
8678         vdev_id = ev->vdev_id;
8679         noa_descriptors = u32_get_bits(noa->noa_attr,
8680                                        WMI_P2P_NOA_INFO_DESC_NUM);
8681
8682         if (noa_descriptors > WMI_P2P_MAX_NOA_DESCRIPTORS) {
8683                 ath11k_warn(ab, "invalid descriptor num %d in P2P NoA event\n",
8684                             noa_descriptors);
8685                 goto out;
8686         }
8687
8688         ath11k_dbg(ab, ATH11K_DBG_WMI,
8689                    "wmi tlv p2p noa vdev_id %i descriptors %u\n",
8690                    vdev_id, noa_descriptors);
8691
8692         rcu_read_lock();
8693         ar = ath11k_mac_get_ar_by_vdev_id(ab, vdev_id);
8694         if (!ar) {
8695                 ath11k_warn(ab, "invalid vdev id %d in P2P NoA event\n",
8696                             vdev_id);
8697                 goto unlock;
8698         }
8699
8700         ath11k_p2p_noa_update_by_vdev_id(ar, vdev_id, noa);
8701
8702 unlock:
8703         rcu_read_unlock();
8704 out:
8705         kfree(tb);
8706 }
8707
8708 static void ath11k_wmi_tlv_op_rx(struct ath11k_base *ab, struct sk_buff *skb)
8709 {
8710         struct wmi_cmd_hdr *cmd_hdr;
8711         enum wmi_tlv_event_id id;
8712
8713         cmd_hdr = (struct wmi_cmd_hdr *)skb->data;
8714         id = FIELD_GET(WMI_CMD_HDR_CMD_ID, (cmd_hdr->cmd_id));
8715
8716         trace_ath11k_wmi_event(ab, id, skb->data, skb->len);
8717
8718         if (skb_pull(skb, sizeof(struct wmi_cmd_hdr)) == NULL)
8719                 goto out;
8720
8721         switch (id) {
8722                 /* Process all the WMI events here */
8723         case WMI_SERVICE_READY_EVENTID:
8724                 ath11k_service_ready_event(ab, skb);
8725                 break;
8726         case WMI_SERVICE_READY_EXT_EVENTID:
8727                 ath11k_service_ready_ext_event(ab, skb);
8728                 break;
8729         case WMI_SERVICE_READY_EXT2_EVENTID:
8730                 ath11k_service_ready_ext2_event(ab, skb);
8731                 break;
8732         case WMI_REG_CHAN_LIST_CC_EVENTID:
8733                 ath11k_reg_chan_list_event(ab, skb, WMI_REG_CHAN_LIST_CC_ID);
8734                 break;
8735         case WMI_REG_CHAN_LIST_CC_EXT_EVENTID:
8736                 ath11k_reg_chan_list_event(ab, skb, WMI_REG_CHAN_LIST_CC_EXT_ID);
8737                 break;
8738         case WMI_READY_EVENTID:
8739                 ath11k_ready_event(ab, skb);
8740                 break;
8741         case WMI_PEER_DELETE_RESP_EVENTID:
8742                 ath11k_peer_delete_resp_event(ab, skb);
8743                 break;
8744         case WMI_VDEV_START_RESP_EVENTID:
8745                 ath11k_vdev_start_resp_event(ab, skb);
8746                 break;
8747         case WMI_OFFLOAD_BCN_TX_STATUS_EVENTID:
8748                 ath11k_bcn_tx_status_event(ab, skb);
8749                 break;
8750         case WMI_VDEV_STOPPED_EVENTID:
8751                 ath11k_vdev_stopped_event(ab, skb);
8752                 break;
8753         case WMI_MGMT_RX_EVENTID:
8754                 ath11k_mgmt_rx_event(ab, skb);
8755                 /* mgmt_rx_event() owns the skb now! */
8756                 return;
8757         case WMI_MGMT_TX_COMPLETION_EVENTID:
8758                 ath11k_mgmt_tx_compl_event(ab, skb);
8759                 break;
8760         case WMI_SCAN_EVENTID:
8761                 ath11k_scan_event(ab, skb);
8762                 break;
8763         case WMI_PEER_STA_KICKOUT_EVENTID:
8764                 ath11k_peer_sta_kickout_event(ab, skb);
8765                 break;
8766         case WMI_ROAM_EVENTID:
8767                 ath11k_roam_event(ab, skb);
8768                 break;
8769         case WMI_CHAN_INFO_EVENTID:
8770                 ath11k_chan_info_event(ab, skb);
8771                 break;
8772         case WMI_PDEV_BSS_CHAN_INFO_EVENTID:
8773                 ath11k_pdev_bss_chan_info_event(ab, skb);
8774                 break;
8775         case WMI_VDEV_INSTALL_KEY_COMPLETE_EVENTID:
8776                 ath11k_vdev_install_key_compl_event(ab, skb);
8777                 break;
8778         case WMI_SERVICE_AVAILABLE_EVENTID:
8779                 ath11k_service_available_event(ab, skb);
8780                 break;
8781         case WMI_PEER_ASSOC_CONF_EVENTID:
8782                 ath11k_peer_assoc_conf_event(ab, skb);
8783                 break;
8784         case WMI_UPDATE_STATS_EVENTID:
8785                 ath11k_update_stats_event(ab, skb);
8786                 break;
8787         case WMI_PDEV_CTL_FAILSAFE_CHECK_EVENTID:
8788                 ath11k_pdev_ctl_failsafe_check_event(ab, skb);
8789                 break;
8790         case WMI_PDEV_CSA_SWITCH_COUNT_STATUS_EVENTID:
8791                 ath11k_wmi_pdev_csa_switch_count_status_event(ab, skb);
8792                 break;
8793         case WMI_PDEV_UTF_EVENTID:
8794                 ath11k_tm_wmi_event(ab, id, skb);
8795                 break;
8796         case WMI_PDEV_TEMPERATURE_EVENTID:
8797                 ath11k_wmi_pdev_temperature_event(ab, skb);
8798                 break;
8799         case WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID:
8800                 ath11k_wmi_pdev_dma_ring_buf_release_event(ab, skb);
8801                 break;
8802         case WMI_HOST_FILS_DISCOVERY_EVENTID:
8803                 ath11k_fils_discovery_event(ab, skb);
8804                 break;
8805         case WMI_OFFLOAD_PROB_RESP_TX_STATUS_EVENTID:
8806                 ath11k_probe_resp_tx_status_event(ab, skb);
8807                 break;
8808         case WMI_OBSS_COLOR_COLLISION_DETECTION_EVENTID:
8809                 ath11k_wmi_obss_color_collision_event(ab, skb);
8810                 break;
8811         case WMI_TWT_ADD_DIALOG_EVENTID:
8812                 ath11k_wmi_twt_add_dialog_event(ab, skb);
8813                 break;
8814         case WMI_PDEV_DFS_RADAR_DETECTION_EVENTID:
8815                 ath11k_wmi_pdev_dfs_radar_detected_event(ab, skb);
8816                 break;
8817         case WMI_VDEV_DELETE_RESP_EVENTID:
8818                 ath11k_vdev_delete_resp_event(ab, skb);
8819                 break;
8820         case WMI_WOW_WAKEUP_HOST_EVENTID:
8821                 ath11k_wmi_event_wow_wakeup_host(ab, skb);
8822                 break;
8823         case WMI_11D_NEW_COUNTRY_EVENTID:
8824                 ath11k_reg_11d_new_cc_event(ab, skb);
8825                 break;
8826         case WMI_DIAG_EVENTID:
8827                 ath11k_wmi_diag_event(ab, skb);
8828                 break;
8829         case WMI_PEER_STA_PS_STATECHG_EVENTID:
8830                 ath11k_wmi_event_peer_sta_ps_state_chg(ab, skb);
8831                 break;
8832         case WMI_GTK_OFFLOAD_STATUS_EVENTID:
8833                 ath11k_wmi_gtk_offload_status_event(ab, skb);
8834                 break;
8835         case WMI_P2P_NOA_EVENTID:
8836                 ath11k_wmi_p2p_noa_event(ab, skb);
8837                 break;
8838         default:
8839                 ath11k_dbg(ab, ATH11K_DBG_WMI, "unsupported event id 0x%x\n", id);
8840                 break;
8841         }
8842
8843 out:
8844         dev_kfree_skb(skb);
8845 }
8846
8847 static int ath11k_connect_pdev_htc_service(struct ath11k_base *ab,
8848                                            u32 pdev_idx)
8849 {
8850         int status;
8851         u32 svc_id[] = { ATH11K_HTC_SVC_ID_WMI_CONTROL,
8852                          ATH11K_HTC_SVC_ID_WMI_CONTROL_MAC1,
8853                          ATH11K_HTC_SVC_ID_WMI_CONTROL_MAC2 };
8854
8855         struct ath11k_htc_svc_conn_req conn_req;
8856         struct ath11k_htc_svc_conn_resp conn_resp;
8857
8858         memset(&conn_req, 0, sizeof(conn_req));
8859         memset(&conn_resp, 0, sizeof(conn_resp));
8860
8861         /* these fields are the same for all service endpoints */
8862         conn_req.ep_ops.ep_tx_complete = ath11k_wmi_htc_tx_complete;
8863         conn_req.ep_ops.ep_rx_complete = ath11k_wmi_tlv_op_rx;
8864         conn_req.ep_ops.ep_tx_credits = ath11k_wmi_op_ep_tx_credits;
8865
8866         /* connect to control service */
8867         conn_req.service_id = svc_id[pdev_idx];
8868
8869         status = ath11k_htc_connect_service(&ab->htc, &conn_req, &conn_resp);
8870         if (status) {
8871                 ath11k_warn(ab, "failed to connect to WMI CONTROL service status: %d\n",
8872                             status);
8873                 return status;
8874         }
8875
8876         ab->wmi_ab.wmi_endpoint_id[pdev_idx] = conn_resp.eid;
8877         ab->wmi_ab.wmi[pdev_idx].eid = conn_resp.eid;
8878         ab->wmi_ab.max_msg_len[pdev_idx] = conn_resp.max_msg_len;
8879         init_waitqueue_head(&ab->wmi_ab.wmi[pdev_idx].tx_ce_desc_wq);
8880
8881         return 0;
8882 }
8883
8884 static int
8885 ath11k_wmi_send_unit_test_cmd(struct ath11k *ar,
8886                               struct wmi_unit_test_cmd ut_cmd,
8887                               u32 *test_args)
8888 {
8889         struct ath11k_pdev_wmi *wmi = ar->wmi;
8890         struct wmi_unit_test_cmd *cmd;
8891         struct sk_buff *skb;
8892         struct wmi_tlv *tlv;
8893         void *ptr;
8894         u32 *ut_cmd_args;
8895         int buf_len, arg_len;
8896         int ret;
8897         int i;
8898
8899         arg_len = sizeof(u32) * ut_cmd.num_args;
8900         buf_len = sizeof(ut_cmd) + arg_len + TLV_HDR_SIZE;
8901
8902         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, buf_len);
8903         if (!skb)
8904                 return -ENOMEM;
8905
8906         cmd = (struct wmi_unit_test_cmd *)skb->data;
8907         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_UNIT_TEST_CMD) |
8908                           FIELD_PREP(WMI_TLV_LEN, sizeof(ut_cmd) - TLV_HDR_SIZE);
8909
8910         cmd->vdev_id = ut_cmd.vdev_id;
8911         cmd->module_id = ut_cmd.module_id;
8912         cmd->num_args = ut_cmd.num_args;
8913         cmd->diag_token = ut_cmd.diag_token;
8914
8915         ptr = skb->data + sizeof(ut_cmd);
8916
8917         tlv = ptr;
8918         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_UINT32) |
8919                       FIELD_PREP(WMI_TLV_LEN, arg_len);
8920
8921         ptr += TLV_HDR_SIZE;
8922
8923         ut_cmd_args = ptr;
8924         for (i = 0; i < ut_cmd.num_args; i++)
8925                 ut_cmd_args[i] = test_args[i];
8926
8927         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_UNIT_TEST_CMDID);
8928
8929         if (ret) {
8930                 ath11k_warn(ar->ab, "failed to send WMI_UNIT_TEST CMD :%d\n",
8931                             ret);
8932                 dev_kfree_skb(skb);
8933         }
8934
8935         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
8936                    "cmd unit test module %d vdev %d n_args %d token %d\n",
8937                    cmd->module_id, cmd->vdev_id, cmd->num_args,
8938                    cmd->diag_token);
8939
8940         return ret;
8941 }
8942
8943 int ath11k_wmi_simulate_radar(struct ath11k *ar)
8944 {
8945         struct ath11k_vif *arvif;
8946         u32 dfs_args[DFS_MAX_TEST_ARGS];
8947         struct wmi_unit_test_cmd wmi_ut;
8948         bool arvif_found = false;
8949
8950         list_for_each_entry(arvif, &ar->arvifs, list) {
8951                 if (arvif->is_started && arvif->vdev_type == WMI_VDEV_TYPE_AP) {
8952                         arvif_found = true;
8953                         break;
8954                 }
8955         }
8956
8957         if (!arvif_found)
8958                 return -EINVAL;
8959
8960         dfs_args[DFS_TEST_CMDID] = 0;
8961         dfs_args[DFS_TEST_PDEV_ID] = ar->pdev->pdev_id;
8962         /* Currently we could pass segment_id(b0 - b1), chirp(b2)
8963          * freq offset (b3 - b10) to unit test. For simulation
8964          * purpose this can be set to 0 which is valid.
8965          */
8966         dfs_args[DFS_TEST_RADAR_PARAM] = 0;
8967
8968         wmi_ut.vdev_id = arvif->vdev_id;
8969         wmi_ut.module_id = DFS_UNIT_TEST_MODULE;
8970         wmi_ut.num_args = DFS_MAX_TEST_ARGS;
8971         wmi_ut.diag_token = DFS_UNIT_TEST_TOKEN;
8972
8973         ath11k_dbg(ar->ab, ATH11K_DBG_REG, "Triggering Radar Simulation\n");
8974
8975         return ath11k_wmi_send_unit_test_cmd(ar, wmi_ut, dfs_args);
8976 }
8977
8978 int ath11k_wmi_fw_dbglog_cfg(struct ath11k *ar, u32 *module_id_bitmap,
8979                              struct ath11k_fw_dbglog *dbglog)
8980 {
8981         struct ath11k_pdev_wmi *wmi = ar->wmi;
8982         struct wmi_debug_log_config_cmd_fixed_param *cmd;
8983         struct sk_buff *skb;
8984         struct wmi_tlv *tlv;
8985         int ret, len;
8986
8987         len = sizeof(*cmd) + TLV_HDR_SIZE + (MAX_MODULE_ID_BITMAP_WORDS * sizeof(u32));
8988         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
8989         if (!skb)
8990                 return -ENOMEM;
8991
8992         cmd = (struct wmi_debug_log_config_cmd_fixed_param *)skb->data;
8993         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_DEBUG_LOG_CONFIG_CMD) |
8994                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
8995         cmd->dbg_log_param = dbglog->param;
8996
8997         tlv = (struct wmi_tlv *)((u8 *)cmd + sizeof(*cmd));
8998         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_UINT32) |
8999                       FIELD_PREP(WMI_TLV_LEN, MAX_MODULE_ID_BITMAP_WORDS * sizeof(u32));
9000
9001         switch (dbglog->param) {
9002         case WMI_DEBUG_LOG_PARAM_LOG_LEVEL:
9003         case WMI_DEBUG_LOG_PARAM_VDEV_ENABLE:
9004         case WMI_DEBUG_LOG_PARAM_VDEV_DISABLE:
9005         case WMI_DEBUG_LOG_PARAM_VDEV_ENABLE_BITMAP:
9006                 cmd->value = dbglog->value;
9007                 break;
9008         case WMI_DEBUG_LOG_PARAM_MOD_ENABLE_BITMAP:
9009         case WMI_DEBUG_LOG_PARAM_WOW_MOD_ENABLE_BITMAP:
9010                 cmd->value = dbglog->value;
9011                 memcpy(tlv->value, module_id_bitmap,
9012                        MAX_MODULE_ID_BITMAP_WORDS * sizeof(u32));
9013                 /* clear current config to be used for next user config */
9014                 memset(module_id_bitmap, 0,
9015                        MAX_MODULE_ID_BITMAP_WORDS * sizeof(u32));
9016                 break;
9017         default:
9018                 dev_kfree_skb(skb);
9019                 return -EINVAL;
9020         }
9021
9022         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_DBGLOG_CFG_CMDID);
9023         if (ret) {
9024                 ath11k_warn(ar->ab,
9025                             "failed to send WMI_DBGLOG_CFG_CMDID\n");
9026                 dev_kfree_skb(skb);
9027         }
9028
9029         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "cmd dbglog cfg");
9030
9031         return ret;
9032 }
9033
9034 int ath11k_wmi_connect(struct ath11k_base *ab)
9035 {
9036         u32 i;
9037         u8 wmi_ep_count;
9038
9039         wmi_ep_count = ab->htc.wmi_ep_count;
9040         if (wmi_ep_count > ab->hw_params.max_radios)
9041                 return -1;
9042
9043         for (i = 0; i < wmi_ep_count; i++)
9044                 ath11k_connect_pdev_htc_service(ab, i);
9045
9046         return 0;
9047 }
9048
9049 static void ath11k_wmi_pdev_detach(struct ath11k_base *ab, u8 pdev_id)
9050 {
9051         if (WARN_ON(pdev_id >= MAX_RADIOS))
9052                 return;
9053
9054         /* TODO: Deinit any pdev specific wmi resource */
9055 }
9056
9057 int ath11k_wmi_pdev_attach(struct ath11k_base *ab,
9058                            u8 pdev_id)
9059 {
9060         struct ath11k_pdev_wmi *wmi_handle;
9061
9062         if (pdev_id >= ab->hw_params.max_radios)
9063                 return -EINVAL;
9064
9065         wmi_handle = &ab->wmi_ab.wmi[pdev_id];
9066
9067         wmi_handle->wmi_ab = &ab->wmi_ab;
9068
9069         ab->wmi_ab.ab = ab;
9070         /* TODO: Init remaining resource specific to pdev */
9071
9072         return 0;
9073 }
9074
9075 int ath11k_wmi_attach(struct ath11k_base *ab)
9076 {
9077         int ret;
9078
9079         ret = ath11k_wmi_pdev_attach(ab, 0);
9080         if (ret)
9081                 return ret;
9082
9083         ab->wmi_ab.ab = ab;
9084         ab->wmi_ab.preferred_hw_mode = WMI_HOST_HW_MODE_MAX;
9085
9086         /* It's overwritten when service_ext_ready is handled */
9087         if (ab->hw_params.single_pdev_only && ab->hw_params.num_rxdma_per_pdev > 1)
9088                 ab->wmi_ab.preferred_hw_mode = WMI_HOST_HW_MODE_SINGLE;
9089
9090         /* TODO: Init remaining wmi soc resources required */
9091         init_completion(&ab->wmi_ab.service_ready);
9092         init_completion(&ab->wmi_ab.unified_ready);
9093
9094         return 0;
9095 }
9096
9097 void ath11k_wmi_detach(struct ath11k_base *ab)
9098 {
9099         int i;
9100
9101         /* TODO: Deinit wmi resource specific to SOC as required */
9102
9103         for (i = 0; i < ab->htc.wmi_ep_count; i++)
9104                 ath11k_wmi_pdev_detach(ab, i);
9105
9106         ath11k_wmi_free_dbring_caps(ab);
9107 }
9108
9109 int ath11k_wmi_hw_data_filter_cmd(struct ath11k *ar, u32 vdev_id,
9110                                   u32 filter_bitmap, bool enable)
9111 {
9112         struct wmi_hw_data_filter_cmd *cmd;
9113         struct sk_buff *skb;
9114         int len;
9115
9116         len = sizeof(*cmd);
9117         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9118
9119         if (!skb)
9120                 return -ENOMEM;
9121
9122         cmd = (struct wmi_hw_data_filter_cmd *)skb->data;
9123         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_HW_DATA_FILTER_CMD) |
9124                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9125
9126         cmd->vdev_id = vdev_id;
9127         cmd->enable = enable;
9128
9129         /* Set all modes in case of disable */
9130         if (cmd->enable)
9131                 cmd->hw_filter_bitmap = filter_bitmap;
9132         else
9133                 cmd->hw_filter_bitmap = ((u32)~0U);
9134
9135         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
9136                    "hw data filter enable %d filter_bitmap 0x%x\n",
9137                    enable, filter_bitmap);
9138
9139         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_HW_DATA_FILTER_CMDID);
9140 }
9141
9142 int ath11k_wmi_wow_host_wakeup_ind(struct ath11k *ar)
9143 {
9144         struct wmi_wow_host_wakeup_ind *cmd;
9145         struct sk_buff *skb;
9146         size_t len;
9147
9148         len = sizeof(*cmd);
9149         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9150         if (!skb)
9151                 return -ENOMEM;
9152
9153         cmd = (struct wmi_wow_host_wakeup_ind *)skb->data;
9154         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
9155                                      WMI_TAG_WOW_HOSTWAKEUP_FROM_SLEEP_CMD) |
9156                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9157
9158         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "tlv wow host wakeup ind\n");
9159
9160         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_HOSTWAKEUP_FROM_SLEEP_CMDID);
9161 }
9162
9163 int ath11k_wmi_wow_enable(struct ath11k *ar)
9164 {
9165         struct wmi_wow_enable_cmd *cmd;
9166         struct sk_buff *skb;
9167         int len;
9168
9169         len = sizeof(*cmd);
9170         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9171         if (!skb)
9172                 return -ENOMEM;
9173
9174         cmd = (struct wmi_wow_enable_cmd *)skb->data;
9175         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_WOW_ENABLE_CMD) |
9176                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9177
9178         cmd->enable = 1;
9179         cmd->pause_iface_config = WOW_IFACE_PAUSE_ENABLED;
9180         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "tlv wow enable\n");
9181
9182         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_ENABLE_CMDID);
9183 }
9184
9185 int ath11k_wmi_scan_prob_req_oui(struct ath11k *ar,
9186                                  const u8 mac_addr[ETH_ALEN])
9187 {
9188         struct sk_buff *skb;
9189         struct wmi_scan_prob_req_oui_cmd *cmd;
9190         u32 prob_req_oui;
9191         int len;
9192
9193         prob_req_oui = (((u32)mac_addr[0]) << 16) |
9194                        (((u32)mac_addr[1]) << 8) | mac_addr[2];
9195
9196         len = sizeof(*cmd);
9197         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9198         if (!skb)
9199                 return -ENOMEM;
9200
9201         cmd = (struct wmi_scan_prob_req_oui_cmd *)skb->data;
9202         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
9203                                      WMI_TAG_SCAN_PROB_REQ_OUI_CMD) |
9204                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9205         cmd->prob_req_oui = prob_req_oui;
9206
9207         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "scan prob req oui %d\n",
9208                    prob_req_oui);
9209
9210         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_SCAN_PROB_REQ_OUI_CMDID);
9211 }
9212
9213 int ath11k_wmi_wow_add_wakeup_event(struct ath11k *ar, u32 vdev_id,
9214                                     enum wmi_wow_wakeup_event event,
9215                                 u32 enable)
9216 {
9217         struct wmi_wow_add_del_event_cmd *cmd;
9218         struct sk_buff *skb;
9219         size_t len;
9220
9221         len = sizeof(*cmd);
9222         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9223         if (!skb)
9224                 return -ENOMEM;
9225
9226         cmd = (struct wmi_wow_add_del_event_cmd *)skb->data;
9227         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_WOW_ADD_DEL_EVT_CMD) |
9228                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9229
9230         cmd->vdev_id = vdev_id;
9231         cmd->is_add = enable;
9232         cmd->event_bitmap = (1 << event);
9233
9234         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "tlv wow add wakeup event %s enable %d vdev_id %d\n",
9235                    wow_wakeup_event(event), enable, vdev_id);
9236
9237         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_ENABLE_DISABLE_WAKE_EVENT_CMDID);
9238 }
9239
9240 int ath11k_wmi_wow_add_pattern(struct ath11k *ar, u32 vdev_id, u32 pattern_id,
9241                                const u8 *pattern, const u8 *mask,
9242                            int pattern_len, int pattern_offset)
9243 {
9244         struct wmi_wow_add_pattern_cmd *cmd;
9245         struct wmi_wow_bitmap_pattern *bitmap;
9246         struct wmi_tlv *tlv;
9247         struct sk_buff *skb;
9248         u8 *ptr;
9249         size_t len;
9250
9251         len = sizeof(*cmd) +
9252               sizeof(*tlv) +                    /* array struct */
9253               sizeof(*bitmap) +                 /* bitmap */
9254               sizeof(*tlv) +                    /* empty ipv4 sync */
9255               sizeof(*tlv) +                    /* empty ipv6 sync */
9256               sizeof(*tlv) +                    /* empty magic */
9257               sizeof(*tlv) +                    /* empty info timeout */
9258               sizeof(*tlv) + sizeof(u32);       /* ratelimit interval */
9259
9260         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9261         if (!skb)
9262                 return -ENOMEM;
9263
9264         /* cmd */
9265         ptr = (u8 *)skb->data;
9266         cmd = (struct wmi_wow_add_pattern_cmd *)ptr;
9267         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
9268                                      WMI_TAG_WOW_ADD_PATTERN_CMD) |
9269                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9270
9271         cmd->vdev_id = vdev_id;
9272         cmd->pattern_id = pattern_id;
9273         cmd->pattern_type = WOW_BITMAP_PATTERN;
9274
9275         ptr += sizeof(*cmd);
9276
9277         /* bitmap */
9278         tlv = (struct wmi_tlv *)ptr;
9279         tlv->header = FIELD_PREP(WMI_TLV_TAG,
9280                                  WMI_TAG_ARRAY_STRUCT) |
9281                       FIELD_PREP(WMI_TLV_LEN, sizeof(*bitmap));
9282
9283         ptr += sizeof(*tlv);
9284
9285         bitmap = (struct wmi_wow_bitmap_pattern *)ptr;
9286         bitmap->tlv_header = FIELD_PREP(WMI_TLV_TAG,
9287                                         WMI_TAG_WOW_BITMAP_PATTERN_T) |
9288                              FIELD_PREP(WMI_TLV_LEN, sizeof(*bitmap) - TLV_HDR_SIZE);
9289
9290         memcpy(bitmap->patternbuf, pattern, pattern_len);
9291         ath11k_ce_byte_swap(bitmap->patternbuf, roundup(pattern_len, 4));
9292         memcpy(bitmap->bitmaskbuf, mask, pattern_len);
9293         ath11k_ce_byte_swap(bitmap->bitmaskbuf, roundup(pattern_len, 4));
9294         bitmap->pattern_offset = pattern_offset;
9295         bitmap->pattern_len = pattern_len;
9296         bitmap->bitmask_len = pattern_len;
9297         bitmap->pattern_id = pattern_id;
9298
9299         ptr += sizeof(*bitmap);
9300
9301         /* ipv4 sync */
9302         tlv = (struct wmi_tlv *)ptr;
9303         tlv->header = FIELD_PREP(WMI_TLV_TAG,
9304                                  WMI_TAG_ARRAY_STRUCT) |
9305                       FIELD_PREP(WMI_TLV_LEN, 0);
9306
9307         ptr += sizeof(*tlv);
9308
9309         /* ipv6 sync */
9310         tlv = (struct wmi_tlv *)ptr;
9311         tlv->header = FIELD_PREP(WMI_TLV_TAG,
9312                                  WMI_TAG_ARRAY_STRUCT) |
9313                       FIELD_PREP(WMI_TLV_LEN, 0);
9314
9315         ptr += sizeof(*tlv);
9316
9317         /* magic */
9318         tlv = (struct wmi_tlv *)ptr;
9319         tlv->header = FIELD_PREP(WMI_TLV_TAG,
9320                                  WMI_TAG_ARRAY_STRUCT) |
9321                       FIELD_PREP(WMI_TLV_LEN, 0);
9322
9323         ptr += sizeof(*tlv);
9324
9325         /* pattern info timeout */
9326         tlv = (struct wmi_tlv *)ptr;
9327         tlv->header = FIELD_PREP(WMI_TLV_TAG,
9328                                  WMI_TAG_ARRAY_UINT32) |
9329                       FIELD_PREP(WMI_TLV_LEN, 0);
9330
9331         ptr += sizeof(*tlv);
9332
9333         /* ratelimit interval */
9334         tlv = (struct wmi_tlv *)ptr;
9335         tlv->header = FIELD_PREP(WMI_TLV_TAG,
9336                                  WMI_TAG_ARRAY_UINT32) |
9337                       FIELD_PREP(WMI_TLV_LEN, sizeof(u32));
9338
9339         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "tlv wow add pattern vdev_id %d pattern_id %d pattern_offset %d\n",
9340                    vdev_id, pattern_id, pattern_offset);
9341
9342         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_ADD_WAKE_PATTERN_CMDID);
9343 }
9344
9345 int ath11k_wmi_wow_del_pattern(struct ath11k *ar, u32 vdev_id, u32 pattern_id)
9346 {
9347         struct wmi_wow_del_pattern_cmd *cmd;
9348         struct sk_buff *skb;
9349         size_t len;
9350
9351         len = sizeof(*cmd);
9352         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9353         if (!skb)
9354                 return -ENOMEM;
9355
9356         cmd = (struct wmi_wow_del_pattern_cmd *)skb->data;
9357         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
9358                                      WMI_TAG_WOW_DEL_PATTERN_CMD) |
9359                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9360
9361         cmd->vdev_id = vdev_id;
9362         cmd->pattern_id = pattern_id;
9363         cmd->pattern_type = WOW_BITMAP_PATTERN;
9364
9365         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "tlv wow del pattern vdev_id %d pattern_id %d\n",
9366                    vdev_id, pattern_id);
9367
9368         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_WOW_DEL_WAKE_PATTERN_CMDID);
9369 }
9370
9371 static struct sk_buff *
9372 ath11k_wmi_op_gen_config_pno_start(struct ath11k *ar,
9373                                    u32 vdev_id,
9374                                        struct wmi_pno_scan_req *pno)
9375 {
9376         struct nlo_configured_parameters *nlo_list;
9377         struct wmi_wow_nlo_config_cmd *cmd;
9378         struct wmi_tlv *tlv;
9379         struct sk_buff *skb;
9380         u32 *channel_list;
9381         size_t len, nlo_list_len, channel_list_len;
9382         u8 *ptr;
9383         u32 i;
9384
9385         len = sizeof(*cmd) +
9386               sizeof(*tlv) +
9387               /* TLV place holder for array of structures
9388                * nlo_configured_parameters(nlo_list)
9389                */
9390               sizeof(*tlv);
9391               /* TLV place holder for array of uint32 channel_list */
9392
9393         channel_list_len = sizeof(u32) * pno->a_networks[0].channel_count;
9394         len += channel_list_len;
9395
9396         nlo_list_len = sizeof(*nlo_list) * pno->uc_networks_count;
9397         len += nlo_list_len;
9398
9399         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9400         if (!skb)
9401                 return ERR_PTR(-ENOMEM);
9402
9403         ptr = (u8 *)skb->data;
9404         cmd = (struct wmi_wow_nlo_config_cmd *)ptr;
9405         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_NLO_CONFIG_CMD) |
9406                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9407
9408         cmd->vdev_id = pno->vdev_id;
9409         cmd->flags = WMI_NLO_CONFIG_START | WMI_NLO_CONFIG_SSID_HIDE_EN;
9410
9411         /* current FW does not support min-max range for dwell time */
9412         cmd->active_dwell_time = pno->active_max_time;
9413         cmd->passive_dwell_time = pno->passive_max_time;
9414
9415         if (pno->do_passive_scan)
9416                 cmd->flags |= WMI_NLO_CONFIG_SCAN_PASSIVE;
9417
9418         cmd->fast_scan_period = pno->fast_scan_period;
9419         cmd->slow_scan_period = pno->slow_scan_period;
9420         cmd->fast_scan_max_cycles = pno->fast_scan_max_cycles;
9421         cmd->delay_start_time = pno->delay_start_time;
9422
9423         if (pno->enable_pno_scan_randomization) {
9424                 cmd->flags |= WMI_NLO_CONFIG_SPOOFED_MAC_IN_PROBE_REQ |
9425                                 WMI_NLO_CONFIG_RANDOM_SEQ_NO_IN_PROBE_REQ;
9426                 ether_addr_copy(cmd->mac_addr.addr, pno->mac_addr);
9427                 ether_addr_copy(cmd->mac_mask.addr, pno->mac_addr_mask);
9428                 ath11k_ce_byte_swap(cmd->mac_addr.addr, 8);
9429                 ath11k_ce_byte_swap(cmd->mac_mask.addr, 8);
9430         }
9431
9432         ptr += sizeof(*cmd);
9433
9434         /* nlo_configured_parameters(nlo_list) */
9435         cmd->no_of_ssids = pno->uc_networks_count;
9436         tlv = (struct wmi_tlv *)ptr;
9437         tlv->header = FIELD_PREP(WMI_TLV_TAG,
9438                                  WMI_TAG_ARRAY_STRUCT) |
9439                       FIELD_PREP(WMI_TLV_LEN, nlo_list_len);
9440
9441         ptr += sizeof(*tlv);
9442         nlo_list = (struct nlo_configured_parameters *)ptr;
9443         for (i = 0; i < cmd->no_of_ssids; i++) {
9444                 tlv = (struct wmi_tlv *)(&nlo_list[i].tlv_header);
9445                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
9446                               FIELD_PREP(WMI_TLV_LEN, sizeof(*nlo_list) - sizeof(*tlv));
9447
9448                 nlo_list[i].ssid.valid = true;
9449                 nlo_list[i].ssid.ssid.ssid_len = pno->a_networks[i].ssid.ssid_len;
9450                 memcpy(nlo_list[i].ssid.ssid.ssid,
9451                        pno->a_networks[i].ssid.ssid,
9452                        nlo_list[i].ssid.ssid.ssid_len);
9453                 ath11k_ce_byte_swap(nlo_list[i].ssid.ssid.ssid,
9454                                     roundup(nlo_list[i].ssid.ssid.ssid_len, 4));
9455
9456                 if (pno->a_networks[i].rssi_threshold &&
9457                     pno->a_networks[i].rssi_threshold > -300) {
9458                         nlo_list[i].rssi_cond.valid = true;
9459                         nlo_list[i].rssi_cond.rssi =
9460                                 pno->a_networks[i].rssi_threshold;
9461                 }
9462
9463                 nlo_list[i].bcast_nw_type.valid = true;
9464                 nlo_list[i].bcast_nw_type.bcast_nw_type =
9465                         pno->a_networks[i].bcast_nw_type;
9466         }
9467
9468         ptr += nlo_list_len;
9469         cmd->num_of_channels = pno->a_networks[0].channel_count;
9470         tlv = (struct wmi_tlv *)ptr;
9471         tlv->header =  FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_UINT32) |
9472                        FIELD_PREP(WMI_TLV_LEN, channel_list_len);
9473         ptr += sizeof(*tlv);
9474         channel_list = (u32 *)ptr;
9475         for (i = 0; i < cmd->num_of_channels; i++)
9476                 channel_list[i] = pno->a_networks[0].channels[i];
9477
9478         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "tlv start pno config vdev_id %d\n",
9479                    vdev_id);
9480
9481         return skb;
9482 }
9483
9484 static struct sk_buff *ath11k_wmi_op_gen_config_pno_stop(struct ath11k *ar,
9485                                                          u32 vdev_id)
9486 {
9487         struct wmi_wow_nlo_config_cmd *cmd;
9488         struct sk_buff *skb;
9489         size_t len;
9490
9491         len = sizeof(*cmd);
9492         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9493         if (!skb)
9494                 return ERR_PTR(-ENOMEM);
9495
9496         cmd = (struct wmi_wow_nlo_config_cmd *)skb->data;
9497         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_NLO_CONFIG_CMD) |
9498                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
9499
9500         cmd->vdev_id = vdev_id;
9501         cmd->flags = WMI_NLO_CONFIG_STOP;
9502
9503         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
9504                    "tlv stop pno config vdev_id %d\n", vdev_id);
9505         return skb;
9506 }
9507
9508 int ath11k_wmi_wow_config_pno(struct ath11k *ar, u32 vdev_id,
9509                               struct wmi_pno_scan_req  *pno_scan)
9510 {
9511         struct sk_buff *skb;
9512
9513         if (pno_scan->enable)
9514                 skb = ath11k_wmi_op_gen_config_pno_start(ar, vdev_id, pno_scan);
9515         else
9516                 skb = ath11k_wmi_op_gen_config_pno_stop(ar, vdev_id);
9517
9518         if (IS_ERR_OR_NULL(skb))
9519                 return -ENOMEM;
9520
9521         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_NETWORK_LIST_OFFLOAD_CONFIG_CMDID);
9522 }
9523
9524 static void ath11k_wmi_fill_ns_offload(struct ath11k *ar,
9525                                        struct ath11k_arp_ns_offload *offload,
9526                                        u8 **ptr,
9527                                        bool enable,
9528                                        bool ext)
9529 {
9530         struct wmi_ns_offload_tuple *ns;
9531         struct wmi_tlv *tlv;
9532         u8 *buf_ptr = *ptr;
9533         u32 ns_cnt, ns_ext_tuples;
9534         int i, max_offloads;
9535
9536         ns_cnt = offload->ipv6_count;
9537
9538         tlv  = (struct wmi_tlv *)buf_ptr;
9539
9540         if (ext) {
9541                 ns_ext_tuples = offload->ipv6_count - WMI_MAX_NS_OFFLOADS;
9542                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
9543                               FIELD_PREP(WMI_TLV_LEN, ns_ext_tuples * sizeof(*ns));
9544                 i = WMI_MAX_NS_OFFLOADS;
9545                 max_offloads = offload->ipv6_count;
9546         } else {
9547                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
9548                               FIELD_PREP(WMI_TLV_LEN, WMI_MAX_NS_OFFLOADS * sizeof(*ns));
9549                 i = 0;
9550                 max_offloads = WMI_MAX_NS_OFFLOADS;
9551         }
9552
9553         buf_ptr += sizeof(*tlv);
9554
9555         for (; i < max_offloads; i++) {
9556                 ns = (struct wmi_ns_offload_tuple *)buf_ptr;
9557                 ns->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_NS_OFFLOAD_TUPLE) |
9558                                  FIELD_PREP(WMI_TLV_LEN, sizeof(*ns) - TLV_HDR_SIZE);
9559
9560                 if (enable) {
9561                         if (i < ns_cnt)
9562                                 ns->flags |= WMI_NSOL_FLAGS_VALID;
9563
9564                         memcpy(ns->target_ipaddr[0], offload->ipv6_addr[i], 16);
9565                         memcpy(ns->solicitation_ipaddr, offload->self_ipv6_addr[i], 16);
9566                         ath11k_ce_byte_swap(ns->target_ipaddr[0], 16);
9567                         ath11k_ce_byte_swap(ns->solicitation_ipaddr, 16);
9568
9569                         if (offload->ipv6_type[i])
9570                                 ns->flags |= WMI_NSOL_FLAGS_IS_IPV6_ANYCAST;
9571
9572                         memcpy(ns->target_mac.addr, offload->mac_addr, ETH_ALEN);
9573                         ath11k_ce_byte_swap(ns->target_mac.addr, 8);
9574
9575                         if (ns->target_mac.word0 != 0 ||
9576                             ns->target_mac.word1 != 0) {
9577                                 ns->flags |= WMI_NSOL_FLAGS_MAC_VALID;
9578                         }
9579
9580                         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
9581                                    "index %d ns_solicited %pI6 target %pI6",
9582                                    i, ns->solicitation_ipaddr,
9583                                    ns->target_ipaddr[0]);
9584                 }
9585
9586                 buf_ptr += sizeof(*ns);
9587         }
9588
9589         *ptr = buf_ptr;
9590 }
9591
9592 static void ath11k_wmi_fill_arp_offload(struct ath11k *ar,
9593                                         struct ath11k_arp_ns_offload *offload,
9594                                         u8 **ptr,
9595                                         bool enable)
9596 {
9597         struct wmi_arp_offload_tuple *arp;
9598         struct wmi_tlv *tlv;
9599         u8 *buf_ptr = *ptr;
9600         int i;
9601
9602         /* fill arp tuple */
9603         tlv = (struct wmi_tlv *)buf_ptr;
9604         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
9605                       FIELD_PREP(WMI_TLV_LEN, WMI_MAX_ARP_OFFLOADS * sizeof(*arp));
9606         buf_ptr += sizeof(*tlv);
9607
9608         for (i = 0; i < WMI_MAX_ARP_OFFLOADS; i++) {
9609                 arp = (struct wmi_arp_offload_tuple *)buf_ptr;
9610                 arp->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARP_OFFLOAD_TUPLE) |
9611                                   FIELD_PREP(WMI_TLV_LEN, sizeof(*arp) - TLV_HDR_SIZE);
9612
9613                 if (enable && i < offload->ipv4_count) {
9614                         /* Copy the target ip addr and flags */
9615                         arp->flags = WMI_ARPOL_FLAGS_VALID;
9616                         memcpy(arp->target_ipaddr, offload->ipv4_addr[i], 4);
9617                         ath11k_ce_byte_swap(arp->target_ipaddr, 4);
9618
9619                         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "arp offload address %pI4",
9620                                    arp->target_ipaddr);
9621                 }
9622
9623                 buf_ptr += sizeof(*arp);
9624         }
9625
9626         *ptr = buf_ptr;
9627 }
9628
9629 int ath11k_wmi_arp_ns_offload(struct ath11k *ar,
9630                               struct ath11k_vif *arvif, bool enable)
9631 {
9632         struct ath11k_arp_ns_offload *offload;
9633         struct wmi_set_arp_ns_offload_cmd *cmd;
9634         struct wmi_tlv *tlv;
9635         struct sk_buff *skb;
9636         u8 *buf_ptr;
9637         size_t len;
9638         u8 ns_cnt, ns_ext_tuples = 0;
9639
9640         offload = &arvif->arp_ns_offload;
9641         ns_cnt = offload->ipv6_count;
9642
9643         len = sizeof(*cmd) +
9644               sizeof(*tlv) +
9645               WMI_MAX_NS_OFFLOADS * sizeof(struct wmi_ns_offload_tuple) +
9646               sizeof(*tlv) +
9647               WMI_MAX_ARP_OFFLOADS * sizeof(struct wmi_arp_offload_tuple);
9648
9649         if (ns_cnt > WMI_MAX_NS_OFFLOADS) {
9650                 ns_ext_tuples = ns_cnt - WMI_MAX_NS_OFFLOADS;
9651                 len += sizeof(*tlv) +
9652                        ns_ext_tuples * sizeof(struct wmi_ns_offload_tuple);
9653         }
9654
9655         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9656         if (!skb)
9657                 return -ENOMEM;
9658
9659         buf_ptr = skb->data;
9660         cmd = (struct wmi_set_arp_ns_offload_cmd *)buf_ptr;
9661         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
9662                                      WMI_TAG_SET_ARP_NS_OFFLOAD_CMD) |
9663                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9664
9665         cmd->flags = 0;
9666         cmd->vdev_id = arvif->vdev_id;
9667         cmd->num_ns_ext_tuples = ns_ext_tuples;
9668
9669         buf_ptr += sizeof(*cmd);
9670
9671         ath11k_wmi_fill_ns_offload(ar, offload, &buf_ptr, enable, 0);
9672         ath11k_wmi_fill_arp_offload(ar, offload, &buf_ptr, enable);
9673
9674         if (ns_ext_tuples)
9675                 ath11k_wmi_fill_ns_offload(ar, offload, &buf_ptr, enable, 1);
9676
9677         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_SET_ARP_NS_OFFLOAD_CMDID);
9678 }
9679
9680 int ath11k_wmi_gtk_rekey_offload(struct ath11k *ar,
9681                                  struct ath11k_vif *arvif, bool enable)
9682 {
9683         struct wmi_gtk_rekey_offload_cmd *cmd;
9684         struct ath11k_rekey_data *rekey_data = &arvif->rekey_data;
9685         int len;
9686         struct sk_buff *skb;
9687         __le64 replay_ctr;
9688
9689         len = sizeof(*cmd);
9690         skb =  ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9691         if (!skb)
9692                 return -ENOMEM;
9693
9694         cmd = (struct wmi_gtk_rekey_offload_cmd *)skb->data;
9695         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_GTK_OFFLOAD_CMD) |
9696                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9697
9698         cmd->vdev_id = arvif->vdev_id;
9699
9700         if (enable) {
9701                 cmd->flags = GTK_OFFLOAD_ENABLE_OPCODE;
9702
9703                 /* the length in rekey_data and cmd is equal */
9704                 memcpy(cmd->kck, rekey_data->kck, sizeof(cmd->kck));
9705                 ath11k_ce_byte_swap(cmd->kck, GTK_OFFLOAD_KEK_BYTES);
9706                 memcpy(cmd->kek, rekey_data->kek, sizeof(cmd->kek));
9707                 ath11k_ce_byte_swap(cmd->kek, GTK_OFFLOAD_KEK_BYTES);
9708
9709                 replay_ctr = cpu_to_le64(rekey_data->replay_ctr);
9710                 memcpy(cmd->replay_ctr, &replay_ctr,
9711                        sizeof(replay_ctr));
9712                 ath11k_ce_byte_swap(cmd->replay_ctr, GTK_REPLAY_COUNTER_BYTES);
9713         } else {
9714                 cmd->flags = GTK_OFFLOAD_DISABLE_OPCODE;
9715         }
9716
9717         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "offload gtk rekey vdev: %d %d\n",
9718                    arvif->vdev_id, enable);
9719         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_GTK_OFFLOAD_CMDID);
9720 }
9721
9722 int ath11k_wmi_gtk_rekey_getinfo(struct ath11k *ar,
9723                                  struct ath11k_vif *arvif)
9724 {
9725         struct wmi_gtk_rekey_offload_cmd *cmd;
9726         int len;
9727         struct sk_buff *skb;
9728
9729         len = sizeof(*cmd);
9730         skb =  ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, len);
9731         if (!skb)
9732                 return -ENOMEM;
9733
9734         cmd = (struct wmi_gtk_rekey_offload_cmd *)skb->data;
9735         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_GTK_OFFLOAD_CMD) |
9736                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9737
9738         cmd->vdev_id = arvif->vdev_id;
9739         cmd->flags = GTK_OFFLOAD_REQUEST_STATUS_OPCODE;
9740
9741         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "get gtk rekey vdev_id: %d\n",
9742                    arvif->vdev_id);
9743         return ath11k_wmi_cmd_send(ar->wmi, skb, WMI_GTK_OFFLOAD_CMDID);
9744 }
9745
9746 int ath11k_wmi_pdev_set_bios_sar_table_param(struct ath11k *ar, const u8 *sar_val)
9747 {       struct ath11k_pdev_wmi *wmi = ar->wmi;
9748         struct wmi_pdev_set_sar_table_cmd *cmd;
9749         struct wmi_tlv *tlv;
9750         struct sk_buff *skb;
9751         u8 *buf_ptr;
9752         u32 len, sar_len_aligned, rsvd_len_aligned;
9753
9754         sar_len_aligned = roundup(BIOS_SAR_TABLE_LEN, sizeof(u32));
9755         rsvd_len_aligned = roundup(BIOS_SAR_RSVD1_LEN, sizeof(u32));
9756         len = sizeof(*cmd) +
9757               TLV_HDR_SIZE + sar_len_aligned +
9758               TLV_HDR_SIZE + rsvd_len_aligned;
9759
9760         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
9761         if (!skb)
9762                 return -ENOMEM;
9763
9764         cmd = (struct wmi_pdev_set_sar_table_cmd *)skb->data;
9765         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_SET_BIOS_SAR_TABLE_CMD) |
9766                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9767         cmd->pdev_id = ar->pdev->pdev_id;
9768         cmd->sar_len = BIOS_SAR_TABLE_LEN;
9769         cmd->rsvd_len = BIOS_SAR_RSVD1_LEN;
9770
9771         buf_ptr = skb->data + sizeof(*cmd);
9772         tlv = (struct wmi_tlv *)buf_ptr;
9773         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
9774                       FIELD_PREP(WMI_TLV_LEN, sar_len_aligned);
9775         buf_ptr += TLV_HDR_SIZE;
9776         memcpy(buf_ptr, sar_val, BIOS_SAR_TABLE_LEN);
9777
9778         buf_ptr += sar_len_aligned;
9779         tlv = (struct wmi_tlv *)buf_ptr;
9780         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
9781                       FIELD_PREP(WMI_TLV_LEN, rsvd_len_aligned);
9782
9783         return ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_SET_BIOS_SAR_TABLE_CMDID);
9784 }
9785
9786 int ath11k_wmi_pdev_set_bios_geo_table_param(struct ath11k *ar)
9787 {
9788         struct ath11k_pdev_wmi *wmi = ar->wmi;
9789         struct wmi_pdev_set_geo_table_cmd *cmd;
9790         struct wmi_tlv *tlv;
9791         struct sk_buff *skb;
9792         u8 *buf_ptr;
9793         u32 len, rsvd_len_aligned;
9794
9795         rsvd_len_aligned = roundup(BIOS_SAR_RSVD2_LEN, sizeof(u32));
9796         len = sizeof(*cmd) + TLV_HDR_SIZE + rsvd_len_aligned;
9797
9798         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
9799         if (!skb)
9800                 return -ENOMEM;
9801
9802         cmd = (struct wmi_pdev_set_geo_table_cmd *)skb->data;
9803         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_SET_BIOS_GEO_TABLE_CMD) |
9804                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9805         cmd->pdev_id = ar->pdev->pdev_id;
9806         cmd->rsvd_len = BIOS_SAR_RSVD2_LEN;
9807
9808         buf_ptr = skb->data + sizeof(*cmd);
9809         tlv = (struct wmi_tlv *)buf_ptr;
9810         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
9811                       FIELD_PREP(WMI_TLV_LEN, rsvd_len_aligned);
9812
9813         return ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_SET_BIOS_GEO_TABLE_CMDID);
9814 }
9815
9816 int ath11k_wmi_sta_keepalive(struct ath11k *ar,
9817                              const struct wmi_sta_keepalive_arg *arg)
9818 {
9819         struct ath11k_pdev_wmi *wmi = ar->wmi;
9820         struct wmi_sta_keepalive_cmd *cmd;
9821         struct wmi_sta_keepalive_arp_resp *arp;
9822         struct sk_buff *skb;
9823         size_t len;
9824
9825         len = sizeof(*cmd) + sizeof(*arp);
9826         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
9827         if (!skb)
9828                 return -ENOMEM;
9829
9830         cmd = (struct wmi_sta_keepalive_cmd *)skb->data;
9831         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
9832                                      WMI_TAG_STA_KEEPALIVE_CMD) |
9833                                      FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
9834         cmd->vdev_id = arg->vdev_id;
9835         cmd->enabled = arg->enabled;
9836         cmd->interval = arg->interval;
9837         cmd->method = arg->method;
9838
9839         arp = (struct wmi_sta_keepalive_arp_resp *)(cmd + 1);
9840         arp->tlv_header = FIELD_PREP(WMI_TLV_TAG,
9841                                      WMI_TAG_STA_KEEPALIVE_ARP_RESPONSE) |
9842                          FIELD_PREP(WMI_TLV_LEN, sizeof(*arp) - TLV_HDR_SIZE);
9843
9844         if (arg->method == WMI_STA_KEEPALIVE_METHOD_UNSOLICITED_ARP_RESPONSE ||
9845             arg->method == WMI_STA_KEEPALIVE_METHOD_GRATUITOUS_ARP_REQUEST) {
9846                 arp->src_ip4_addr = arg->src_ip4_addr;
9847                 arp->dest_ip4_addr = arg->dest_ip4_addr;
9848                 ether_addr_copy(arp->dest_mac_addr.addr, arg->dest_mac_addr);
9849         }
9850
9851         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
9852                    "sta keepalive vdev %d enabled %d method %d interval %d\n",
9853                    arg->vdev_id, arg->enabled, arg->method, arg->interval);
9854
9855         return ath11k_wmi_cmd_send(wmi, skb, WMI_STA_KEEPALIVE_CMDID);
9856 }
9857
9858 bool ath11k_wmi_supports_6ghz_cc_ext(struct ath11k *ar)
9859 {
9860         return test_bit(WMI_TLV_SERVICE_REG_CC_EXT_EVENT_SUPPORT,
9861                         ar->ab->wmi_ab.svc_map) && ar->supports_6ghz;
9862 }