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  */
   5 #include <linux/skbuff.h>
   6 #include <linux/ctype.h>
   7 #include <net/mac80211.h>
   8 #include <net/cfg80211.h>
   9 #include <linux/completion.h>
  10 #include <linux/if_ether.h>
  11 #include <linux/types.h>
  12 #include <linux/pci.h>
  13 #include <linux/uuid.h>
  14 #include <linux/time.h>
  15 #include <linux/of.h>
  16 #include "core.h"
  17 #include "debug.h"
  18 #include "mac.h"
  19 #include "hw.h"
  20 #include "peer.h"
  21
  22 struct wmi_tlv_policy {
  23         size_t min_len;
  24 };
  25
  26 struct wmi_tlv_svc_ready_parse {
  27         bool wmi_svc_bitmap_done;
  28 };
  29
  30 struct wmi_tlv_dma_ring_caps_parse {
  31         struct wmi_dma_ring_capabilities *dma_ring_caps;
  32         u32 n_dma_ring_caps;
  33 };
  34
  35 struct wmi_tlv_svc_rdy_ext_parse {
  36         struct ath11k_service_ext_param param;
  37         struct wmi_soc_mac_phy_hw_mode_caps *hw_caps;
  38         struct wmi_hw_mode_capabilities *hw_mode_caps;
  39         u32 n_hw_mode_caps;
  40         u32 tot_phy_id;
  41         struct wmi_hw_mode_capabilities pref_hw_mode_caps;
  42         struct wmi_mac_phy_capabilities *mac_phy_caps;
  43         u32 n_mac_phy_caps;
  44         struct wmi_soc_hal_reg_capabilities *soc_hal_reg_caps;
  45         struct wmi_hal_reg_capabilities_ext *ext_hal_reg_caps;
  46         u32 n_ext_hal_reg_caps;
  47         struct wmi_tlv_dma_ring_caps_parse dma_caps_parse;
  48         bool hw_mode_done;
  49         bool mac_phy_done;
  50         bool ext_hal_reg_done;
  51         bool mac_phy_chainmask_combo_done;
  52         bool mac_phy_chainmask_cap_done;
  53         bool oem_dma_ring_cap_done;
  54         bool dma_ring_cap_done;
  55 };
  56
  57 struct wmi_tlv_svc_rdy_ext2_parse {
  58         struct wmi_tlv_dma_ring_caps_parse dma_caps_parse;
  59         bool dma_ring_cap_done;
  60 };
  61
  62 struct wmi_tlv_rdy_parse {
  63         u32 num_extra_mac_addr;
  64 };
  65
  66 struct wmi_tlv_dma_buf_release_parse {
  67         struct ath11k_wmi_dma_buf_release_fixed_param fixed;
  68         struct wmi_dma_buf_release_entry *buf_entry;
  69         struct wmi_dma_buf_release_meta_data *meta_data;
  70         u32 num_buf_entry;
  71         u32 num_meta;
  72         bool buf_entry_done;
  73         bool meta_data_done;
  74 };
  75
  76 static const struct wmi_tlv_policy wmi_tlv_policies[] = {
  77         [WMI_TAG_ARRAY_BYTE]
  78                 = { .min_len = 0 },
  79         [WMI_TAG_ARRAY_UINT32]
  80                 = { .min_len = 0 },
  81         [WMI_TAG_SERVICE_READY_EVENT]
  82                 = { .min_len = sizeof(struct wmi_service_ready_event) },
  83         [WMI_TAG_SERVICE_READY_EXT_EVENT]
  84                 = { .min_len =  sizeof(struct wmi_service_ready_ext_event) },
  85         [WMI_TAG_SOC_MAC_PHY_HW_MODE_CAPS]
  86                 = { .min_len = sizeof(struct wmi_soc_mac_phy_hw_mode_caps) },
  87         [WMI_TAG_SOC_HAL_REG_CAPABILITIES]
  88                 = { .min_len = sizeof(struct wmi_soc_hal_reg_capabilities) },
  89         [WMI_TAG_VDEV_START_RESPONSE_EVENT]
  90                 = { .min_len = sizeof(struct wmi_vdev_start_resp_event) },
  91         [WMI_TAG_PEER_DELETE_RESP_EVENT]
  92                 = { .min_len = sizeof(struct wmi_peer_delete_resp_event) },
  93         [WMI_TAG_OFFLOAD_BCN_TX_STATUS_EVENT]
  94                 = { .min_len = sizeof(struct wmi_bcn_tx_status_event) },
  95         [WMI_TAG_VDEV_STOPPED_EVENT]
  96                 = { .min_len = sizeof(struct wmi_vdev_stopped_event) },
  97         [WMI_TAG_REG_CHAN_LIST_CC_EVENT]
  98                 = { .min_len = sizeof(struct wmi_reg_chan_list_cc_event) },
  99         [WMI_TAG_MGMT_RX_HDR]
 100                 = { .min_len = sizeof(struct wmi_mgmt_rx_hdr) },
 101         [WMI_TAG_MGMT_TX_COMPL_EVENT]
 102                 = { .min_len = sizeof(struct wmi_mgmt_tx_compl_event) },
 103         [WMI_TAG_SCAN_EVENT]
 104                 = { .min_len = sizeof(struct wmi_scan_event) },
 105         [WMI_TAG_PEER_STA_KICKOUT_EVENT]
 106                 = { .min_len = sizeof(struct wmi_peer_sta_kickout_event) },
 107         [WMI_TAG_ROAM_EVENT]
 108                 = { .min_len = sizeof(struct wmi_roam_event) },
 109         [WMI_TAG_CHAN_INFO_EVENT]
 110                 = { .min_len = sizeof(struct wmi_chan_info_event) },
 111         [WMI_TAG_PDEV_BSS_CHAN_INFO_EVENT]
 112                 = { .min_len = sizeof(struct wmi_pdev_bss_chan_info_event) },
 113         [WMI_TAG_VDEV_INSTALL_KEY_COMPLETE_EVENT]
 114                 = { .min_len = sizeof(struct wmi_vdev_install_key_compl_event) },
 115         [WMI_TAG_READY_EVENT] = {
 116                 .min_len = sizeof(struct wmi_ready_event_min) },
 117         [WMI_TAG_SERVICE_AVAILABLE_EVENT]
 118                 = {.min_len = sizeof(struct wmi_service_available_event) },
 119         [WMI_TAG_PEER_ASSOC_CONF_EVENT]
 120                 = { .min_len = sizeof(struct wmi_peer_assoc_conf_event) },
 121         [WMI_TAG_STATS_EVENT]
 122                 = { .min_len = sizeof(struct wmi_stats_event) },
 123         [WMI_TAG_PDEV_CTL_FAILSAFE_CHECK_EVENT]
 124                 = { .min_len = sizeof(struct wmi_pdev_ctl_failsafe_chk_event) },
 125 };
 126
 127 #define PRIMAP(_hw_mode_) \
 128         [_hw_mode_] = _hw_mode_##_PRI
 129
 130 static const int ath11k_hw_mode_pri_map[] = {
 131         PRIMAP(WMI_HOST_HW_MODE_SINGLE),
 132         PRIMAP(WMI_HOST_HW_MODE_DBS),
 133         PRIMAP(WMI_HOST_HW_MODE_SBS_PASSIVE),
 134         PRIMAP(WMI_HOST_HW_MODE_SBS),
 135         PRIMAP(WMI_HOST_HW_MODE_DBS_SBS),
 136         PRIMAP(WMI_HOST_HW_MODE_DBS_OR_SBS),
 137         /* keep last */
 138         PRIMAP(WMI_HOST_HW_MODE_MAX),
 139 };
 140
 141 static int
 142 ath11k_wmi_tlv_iter(struct ath11k_base *ab, const void *ptr, size_t len,
 143                     int (*iter)(struct ath11k_base *ab, u16 tag, u16 len,
 144                                 const void *ptr, void *data),
 145                     void *data)
 146 {
 147         const void *begin = ptr;
 148         const struct wmi_tlv *tlv;
 149         u16 tlv_tag, tlv_len;
 150         int ret;
 151
 152         while (len > 0) {
 153                 if (len < sizeof(*tlv)) {
 154                         ath11k_err(ab, "wmi tlv parse failure at byte %zd (%zu bytes left, %zu expected)\n",
 155                                    ptr - begin, len, sizeof(*tlv));
 156                         return -EINVAL;
 157                 }
 158
 159                 tlv = ptr;
 160                 tlv_tag = FIELD_GET(WMI_TLV_TAG, tlv->header);
 161                 tlv_len = FIELD_GET(WMI_TLV_LEN, tlv->header);
 162                 ptr += sizeof(*tlv);
 163                 len -= sizeof(*tlv);
 164
 165                 if (tlv_len > len) {
 166                         ath11k_err(ab, "wmi tlv parse failure of tag %hhu at byte %zd (%zu bytes left, %hhu expected)\n",
 167                                    tlv_tag, ptr - begin, len, tlv_len);
 168                         return -EINVAL;
 169                 }
 170
 171                 if (tlv_tag < ARRAY_SIZE(wmi_tlv_policies) &&
 172                     wmi_tlv_policies[tlv_tag].min_len &&
 173                     wmi_tlv_policies[tlv_tag].min_len > tlv_len) {
 174                         ath11k_err(ab, "wmi tlv parse failure of tag %hhu at byte %zd (%hhu bytes is less than min length %zu)\n",
 175                                    tlv_tag, ptr - begin, tlv_len,
 176                                    wmi_tlv_policies[tlv_tag].min_len);
 177                         return -EINVAL;
 178                 }
 179
 180                 ret = iter(ab, tlv_tag, tlv_len, ptr, data);
 181                 if (ret)
 182                         return ret;
 183
 184                 ptr += tlv_len;
 185                 len -= tlv_len;
 186         }
 187
 188         return 0;
 189 }
 190
 191 static int ath11k_wmi_tlv_iter_parse(struct ath11k_base *ab, u16 tag, u16 len,
 192                                      const void *ptr, void *data)
 193 {
 194         const void **tb = data;
 195
 196         if (tag < WMI_TAG_MAX)
 197                 tb[tag] = ptr;
 198
 199         return 0;
 200 }
 201
 202 static int ath11k_wmi_tlv_parse(struct ath11k_base *ar, const void **tb,
 203                                 const void *ptr, size_t len)
 204 {
 205         return ath11k_wmi_tlv_iter(ar, ptr, len, ath11k_wmi_tlv_iter_parse,
 206                                    (void *)tb);
 207 }
 208
 209 static const void **
 210 ath11k_wmi_tlv_parse_alloc(struct ath11k_base *ab, const void *ptr,
 211                            size_t len, gfp_t gfp)
 212 {
 213         const void **tb;
 214         int ret;
 215
 216         tb = kcalloc(WMI_TAG_MAX, sizeof(*tb), gfp);
 217         if (!tb)
 218                 return ERR_PTR(-ENOMEM);
 219
 220         ret = ath11k_wmi_tlv_parse(ab, tb, ptr, len);
 221         if (ret) {
 222                 kfree(tb);
 223                 return ERR_PTR(ret);
 224         }
 225
 226         return tb;
 227 }
 228
 229 static int ath11k_wmi_cmd_send_nowait(struct ath11k_pdev_wmi *wmi, struct sk_buff *skb,
 230                                       u32 cmd_id)
 231 {
 232         struct ath11k_skb_cb *skb_cb = ATH11K_SKB_CB(skb);
 233         struct ath11k_base *ab = wmi->wmi_ab->ab;
 234         struct wmi_cmd_hdr *cmd_hdr;
 235         int ret;
 236         u32 cmd = 0;
 237
 238         if (skb_push(skb, sizeof(struct wmi_cmd_hdr)) == NULL)
 239                 return -ENOMEM;
 240
 241         cmd |= FIELD_PREP(WMI_CMD_HDR_CMD_ID, cmd_id);
 242
 243         cmd_hdr = (struct wmi_cmd_hdr *)skb->data;
 244         cmd_hdr->cmd_id = cmd;
 245
 246         memset(skb_cb, 0, sizeof(*skb_cb));
 247         ret = ath11k_htc_send(&ab->htc, wmi->eid, skb);
 248
 249         if (ret)
 250                 goto err_pull;
 251
 252         return 0;
 253
 254 err_pull:
 255         skb_pull(skb, sizeof(struct wmi_cmd_hdr));
 256         return ret;
 257 }
 258
 259 int ath11k_wmi_cmd_send(struct ath11k_pdev_wmi *wmi, struct sk_buff *skb,
 260                         u32 cmd_id)
 261 {
 262         struct ath11k_wmi_base *wmi_sc = wmi->wmi_ab;
 263         int ret = -EOPNOTSUPP;
 264
 265         might_sleep();
 266
 267         wait_event_timeout(wmi_sc->tx_credits_wq, ({
 268                 ret = ath11k_wmi_cmd_send_nowait(wmi, skb, cmd_id);
 269
 270                 if (ret && test_bit(ATH11K_FLAG_CRASH_FLUSH, &wmi_sc->ab->dev_flags))
 271                         ret = -ESHUTDOWN;
 272
 273                 (ret != -EAGAIN);
 274         }), WMI_SEND_TIMEOUT_HZ);
 275
 276         if (ret == -EAGAIN)
 277                 ath11k_warn(wmi_sc->ab, "wmi command %d timeout\n", cmd_id);
 278
 279         return ret;
 280 }
 281
 282 static int ath11k_pull_svc_ready_ext(struct ath11k_pdev_wmi *wmi_handle,
 283                                      const void *ptr,
 284                                      struct ath11k_service_ext_param *param)
 285 {
 286         const struct wmi_service_ready_ext_event *ev = ptr;
 287
 288         if (!ev)
 289                 return -EINVAL;
 290
 291         /* Move this to host based bitmap */
 292         param->default_conc_scan_config_bits = ev->default_conc_scan_config_bits;
 293         param->default_fw_config_bits = ev->default_fw_config_bits;
 294         param->he_cap_info = ev->he_cap_info;
 295         param->mpdu_density = ev->mpdu_density;
 296         param->max_bssid_rx_filters = ev->max_bssid_rx_filters;
 297         memcpy(&param->ppet, &ev->ppet, sizeof(param->ppet));
 298
 299         return 0;
 300 }
 301
 302 static int
 303 ath11k_pull_mac_phy_cap_svc_ready_ext(struct ath11k_pdev_wmi *wmi_handle,
 304                                       struct wmi_soc_mac_phy_hw_mode_caps *hw_caps,
 305                                       struct wmi_hw_mode_capabilities *wmi_hw_mode_caps,
 306                                       struct wmi_soc_hal_reg_capabilities *hal_reg_caps,
 307                                       struct wmi_mac_phy_capabilities *wmi_mac_phy_caps,
 308                                       u8 hw_mode_id, u8 phy_id,
 309                                       struct ath11k_pdev *pdev)
 310 {
 311         struct wmi_mac_phy_capabilities *mac_phy_caps;
 312         struct ath11k_band_cap *cap_band;
 313         struct ath11k_pdev_cap *pdev_cap = &pdev->cap;
 314         u32 phy_map;
 315         u32 hw_idx, phy_idx = 0;
 316
 317         if (!hw_caps || !wmi_hw_mode_caps || !hal_reg_caps)
 318                 return -EINVAL;
 319
 320         for (hw_idx = 0; hw_idx < hw_caps->num_hw_modes; hw_idx++) {
 321                 if (hw_mode_id == wmi_hw_mode_caps[hw_idx].hw_mode_id)
 322                         break;
 323
 324                 phy_map = wmi_hw_mode_caps[hw_idx].phy_id_map;
 325                 while (phy_map) {
 326                         phy_map >>= 1;
 327                         phy_idx++;
 328                 }
 329         }
 330
 331         if (hw_idx == hw_caps->num_hw_modes)
 332                 return -EINVAL;
 333
 334         phy_idx += phy_id;
 335         if (phy_id >= hal_reg_caps->num_phy)
 336                 return -EINVAL;
 337
 338         mac_phy_caps = wmi_mac_phy_caps + phy_idx;
 339
 340         pdev->pdev_id = mac_phy_caps->pdev_id;
 341         pdev_cap->supported_bands |= mac_phy_caps->supported_bands;
 342         pdev_cap->ampdu_density = mac_phy_caps->ampdu_density;
 343
 344         /* Take non-zero tx/rx chainmask. If tx/rx chainmask differs from
 345          * band to band for a single radio, need to see how this should be
 346          * handled.
 347          */
 348         if (mac_phy_caps->supported_bands & WMI_HOST_WLAN_2G_CAP) {
 349                 pdev_cap->tx_chain_mask = mac_phy_caps->tx_chain_mask_2g;
 350                 pdev_cap->rx_chain_mask = mac_phy_caps->rx_chain_mask_2g;
 351         } else if (mac_phy_caps->supported_bands & WMI_HOST_WLAN_5G_CAP) {
 352                 pdev_cap->vht_cap = mac_phy_caps->vht_cap_info_5g;
 353                 pdev_cap->vht_mcs = mac_phy_caps->vht_supp_mcs_5g;
 354                 pdev_cap->he_mcs = mac_phy_caps->he_supp_mcs_5g;
 355                 pdev_cap->tx_chain_mask = mac_phy_caps->tx_chain_mask_5g;
 356                 pdev_cap->rx_chain_mask = mac_phy_caps->rx_chain_mask_5g;
 357         } else {
 358                 return -EINVAL;
 359         }
 360
 361         /* tx/rx chainmask reported from fw depends on the actual hw chains used,
 362          * For example, for 4x4 capable macphys, first 4 chains can be used for first
 363          * mac and the remaing 4 chains can be used for the second mac or vice-versa.
 364          * In this case, tx/rx chainmask 0xf will be advertised for first mac and 0xf0
 365          * will be advertised for second mac or vice-versa. Compute the shift value for
 366          * for tx/rx chainmask which will be used to advertise supported ht/vht rates to
 367          * mac80211.
 368          */
 369         pdev_cap->tx_chain_mask_shift =
 370                         find_first_bit((unsigned long *)&pdev_cap->tx_chain_mask, 32);
 371         pdev_cap->rx_chain_mask_shift =
 372                         find_first_bit((unsigned long *)&pdev_cap->rx_chain_mask, 32);
 373
 374         if (mac_phy_caps->supported_bands & WMI_HOST_WLAN_2G_CAP) {
 375                 cap_band = &pdev_cap->band[NL80211_BAND_2GHZ];
 376                 cap_band->phy_id = mac_phy_caps->phy_id;
 377                 cap_band->max_bw_supported = mac_phy_caps->max_bw_supported_2g;
 378                 cap_band->ht_cap_info = mac_phy_caps->ht_cap_info_2g;
 379                 cap_band->he_cap_info[0] = mac_phy_caps->he_cap_info_2g;
 380                 cap_band->he_cap_info[1] = mac_phy_caps->he_cap_info_2g_ext;
 381                 cap_band->he_mcs = mac_phy_caps->he_supp_mcs_2g;
 382                 memcpy(cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_2g,
 383                        sizeof(u32) * PSOC_HOST_MAX_PHY_SIZE);
 384                 memcpy(&cap_band->he_ppet, &mac_phy_caps->he_ppet2g,
 385                        sizeof(struct ath11k_ppe_threshold));
 386         }
 387
 388         if (mac_phy_caps->supported_bands & WMI_HOST_WLAN_5G_CAP) {
 389                 cap_band = &pdev_cap->band[NL80211_BAND_5GHZ];
 390                 cap_band->phy_id = mac_phy_caps->phy_id;
 391                 cap_band->max_bw_supported = mac_phy_caps->max_bw_supported_5g;
 392                 cap_band->ht_cap_info = mac_phy_caps->ht_cap_info_5g;
 393                 cap_band->he_cap_info[0] = mac_phy_caps->he_cap_info_5g;
 394                 cap_band->he_cap_info[1] = mac_phy_caps->he_cap_info_5g_ext;
 395                 cap_band->he_mcs = mac_phy_caps->he_supp_mcs_5g;
 396                 memcpy(cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_5g,
 397                        sizeof(u32) * PSOC_HOST_MAX_PHY_SIZE);
 398                 memcpy(&cap_band->he_ppet, &mac_phy_caps->he_ppet5g,
 399                        sizeof(struct ath11k_ppe_threshold));
 400         }
 401
 402         cap_band = &pdev_cap->band[NL80211_BAND_6GHZ];
 403         cap_band->max_bw_supported = mac_phy_caps->max_bw_supported_5g;
 404         cap_band->ht_cap_info = mac_phy_caps->ht_cap_info_5g;
 405         cap_band->he_cap_info[0] = mac_phy_caps->he_cap_info_5g;
 406         cap_band->he_cap_info[1] = mac_phy_caps->he_cap_info_5g_ext;
 407         cap_band->he_mcs = mac_phy_caps->he_supp_mcs_5g;
 408         memcpy(cap_band->he_cap_phy_info, &mac_phy_caps->he_cap_phy_info_5g,
 409                sizeof(u32) * PSOC_HOST_MAX_PHY_SIZE);
 410         memcpy(&cap_band->he_ppet, &mac_phy_caps->he_ppet5g,
 411                sizeof(struct ath11k_ppe_threshold));
 412
 413         return 0;
 414 }
 415
 416 static int
 417 ath11k_pull_reg_cap_svc_rdy_ext(struct ath11k_pdev_wmi *wmi_handle,
 418                                 struct wmi_soc_hal_reg_capabilities *reg_caps,
 419                                 struct wmi_hal_reg_capabilities_ext *wmi_ext_reg_cap,
 420                                 u8 phy_idx,
 421                                 struct ath11k_hal_reg_capabilities_ext *param)
 422 {
 423         struct wmi_hal_reg_capabilities_ext *ext_reg_cap;
 424
 425         if (!reg_caps || !wmi_ext_reg_cap)
 426                 return -EINVAL;
 427
 428         if (phy_idx >= reg_caps->num_phy)
 429                 return -EINVAL;
 430
 431         ext_reg_cap = &wmi_ext_reg_cap[phy_idx];
 432
 433         param->phy_id = ext_reg_cap->phy_id;
 434         param->eeprom_reg_domain = ext_reg_cap->eeprom_reg_domain;
 435         param->eeprom_reg_domain_ext =
 436                               ext_reg_cap->eeprom_reg_domain_ext;
 437         param->regcap1 = ext_reg_cap->regcap1;
 438         param->regcap2 = ext_reg_cap->regcap2;
 439         /* check if param->wireless_mode is needed */
 440         param->low_2ghz_chan = ext_reg_cap->low_2ghz_chan;
 441         param->high_2ghz_chan = ext_reg_cap->high_2ghz_chan;
 442         param->low_5ghz_chan = ext_reg_cap->low_5ghz_chan;
 443         param->high_5ghz_chan = ext_reg_cap->high_5ghz_chan;
 444
 445         return 0;
 446 }
 447
 448 static int ath11k_pull_service_ready_tlv(struct ath11k_base *ab,
 449                                          const void *evt_buf,
 450                                          struct ath11k_targ_cap *cap)
 451 {
 452         const struct wmi_service_ready_event *ev = evt_buf;
 453
 454         if (!ev) {
 455                 ath11k_err(ab, "%s: failed by NULL param\n",
 456                            __func__);
 457                 return -EINVAL;
 458         }
 459
 460         cap->phy_capability = ev->phy_capability;
 461         cap->max_frag_entry = ev->max_frag_entry;
 462         cap->num_rf_chains = ev->num_rf_chains;
 463         cap->ht_cap_info = ev->ht_cap_info;
 464         cap->vht_cap_info = ev->vht_cap_info;
 465         cap->vht_supp_mcs = ev->vht_supp_mcs;
 466         cap->hw_min_tx_power = ev->hw_min_tx_power;
 467         cap->hw_max_tx_power = ev->hw_max_tx_power;
 468         cap->sys_cap_info = ev->sys_cap_info;
 469         cap->min_pkt_size_enable = ev->min_pkt_size_enable;
 470         cap->max_bcn_ie_size = ev->max_bcn_ie_size;
 471         cap->max_num_scan_channels = ev->max_num_scan_channels;
 472         cap->max_supported_macs = ev->max_supported_macs;
 473         cap->wmi_fw_sub_feat_caps = ev->wmi_fw_sub_feat_caps;
 474         cap->txrx_chainmask = ev->txrx_chainmask;
 475         cap->default_dbs_hw_mode_index = ev->default_dbs_hw_mode_index;
 476         cap->num_msdu_desc = ev->num_msdu_desc;
 477
 478         return 0;
 479 }
 480
 481 /* Save the wmi_service_bitmap into a linear bitmap. The wmi_services in
 482  * wmi_service ready event are advertised in b0-b3 (LSB 4-bits) of each
 483  * 4-byte word.
 484  */
 485 static void ath11k_wmi_service_bitmap_copy(struct ath11k_pdev_wmi *wmi,
 486                                            const u32 *wmi_svc_bm)
 487 {
 488         int i, j;
 489
 490         for (i = 0, j = 0; i < WMI_SERVICE_BM_SIZE && j < WMI_MAX_SERVICE; i++) {
 491                 do {
 492                         if (wmi_svc_bm[i] & BIT(j % WMI_SERVICE_BITS_IN_SIZE32))
 493                                 set_bit(j, wmi->wmi_ab->svc_map);
 494                 } while (++j % WMI_SERVICE_BITS_IN_SIZE32);
 495         }
 496 }
 497
 498 static int ath11k_wmi_tlv_svc_rdy_parse(struct ath11k_base *ab, u16 tag, u16 len,
 499                                         const void *ptr, void *data)
 500 {
 501         struct wmi_tlv_svc_ready_parse *svc_ready = data;
 502         struct ath11k_pdev_wmi *wmi_handle = &ab->wmi_ab.wmi[0];
 503         u16 expect_len;
 504
 505         switch (tag) {
 506         case WMI_TAG_SERVICE_READY_EVENT:
 507                 if (ath11k_pull_service_ready_tlv(ab, ptr, &ab->target_caps))
 508                         return -EINVAL;
 509                 break;
 510
 511         case WMI_TAG_ARRAY_UINT32:
 512                 if (!svc_ready->wmi_svc_bitmap_done) {
 513                         expect_len = WMI_SERVICE_BM_SIZE * sizeof(u32);
 514                         if (len < expect_len) {
 515                                 ath11k_warn(ab, "invalid len %d for the tag 0x%x\n",
 516                                             len, tag);
 517                                 return -EINVAL;
 518                         }
 519
 520                         ath11k_wmi_service_bitmap_copy(wmi_handle, ptr);
 521
 522                         svc_ready->wmi_svc_bitmap_done = true;
 523                 }
 524                 break;
 525         default:
 526                 break;
 527         }
 528
 529         return 0;
 530 }
 531
 532 static int ath11k_service_ready_event(struct ath11k_base *ab, struct sk_buff *skb)
 533 {
 534         struct wmi_tlv_svc_ready_parse svc_ready = { };
 535         int ret;
 536
 537         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
 538                                   ath11k_wmi_tlv_svc_rdy_parse,
 539                                   &svc_ready);
 540         if (ret) {
 541                 ath11k_warn(ab, "failed to parse tlv %d\n", ret);
 542                 return ret;
 543         }
 544
 545         return 0;
 546 }
 547
 548 struct sk_buff *ath11k_wmi_alloc_skb(struct ath11k_wmi_base *wmi_sc, u32 len)
 549 {
 550         struct sk_buff *skb;
 551         struct ath11k_base *ab = wmi_sc->ab;
 552         u32 round_len = roundup(len, 4);
 553
 554         skb = ath11k_htc_alloc_skb(ab, WMI_SKB_HEADROOM + round_len);
 555         if (!skb)
 556                 return NULL;
 557
 558         skb_reserve(skb, WMI_SKB_HEADROOM);
 559         if (!IS_ALIGNED((unsigned long)skb->data, 4))
 560                 ath11k_warn(ab, "unaligned WMI skb data\n");
 561
 562         skb_put(skb, round_len);
 563         memset(skb->data, 0, round_len);
 564
 565         return skb;
 566 }
 567
 568 int ath11k_wmi_mgmt_send(struct ath11k *ar, u32 vdev_id, u32 buf_id,
 569                          struct sk_buff *frame)
 570 {
 571         struct ath11k_pdev_wmi *wmi = ar->wmi;
 572         struct wmi_mgmt_send_cmd *cmd;
 573         struct wmi_tlv *frame_tlv;
 574         struct sk_buff *skb;
 575         u32 buf_len;
 576         int ret, len;
 577
 578         buf_len = frame->len < WMI_MGMT_SEND_DOWNLD_LEN ?
 579                   frame->len : WMI_MGMT_SEND_DOWNLD_LEN;
 580
 581         len = sizeof(*cmd) + sizeof(*frame_tlv) + roundup(buf_len, 4);
 582
 583         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
 584         if (!skb)
 585                 return -ENOMEM;
 586
 587         cmd = (struct wmi_mgmt_send_cmd *)skb->data;
 588         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_MGMT_TX_SEND_CMD) |
 589                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 590         cmd->vdev_id = vdev_id;
 591         cmd->desc_id = buf_id;
 592         cmd->chanfreq = 0;
 593         cmd->paddr_lo = lower_32_bits(ATH11K_SKB_CB(frame)->paddr);
 594         cmd->paddr_hi = upper_32_bits(ATH11K_SKB_CB(frame)->paddr);
 595         cmd->frame_len = frame->len;
 596         cmd->buf_len = buf_len;
 597         cmd->tx_params_valid = 0;
 598
 599         frame_tlv = (struct wmi_tlv *)(skb->data + sizeof(*cmd));
 600         frame_tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
 601                             FIELD_PREP(WMI_TLV_LEN, buf_len);
 602
 603         memcpy(frame_tlv->value, frame->data, buf_len);
 604
 605         ath11k_ce_byte_swap(frame_tlv->value, buf_len);
 606
 607         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_MGMT_TX_SEND_CMDID);
 608         if (ret) {
 609                 ath11k_warn(ar->ab,
 610                             "failed to submit WMI_MGMT_TX_SEND_CMDID cmd\n");
 611                 dev_kfree_skb(skb);
 612         }
 613
 614         return ret;
 615 }
 616
 617 int ath11k_wmi_vdev_create(struct ath11k *ar, u8 *macaddr,
 618                            struct vdev_create_params *param)
 619 {
 620         struct ath11k_pdev_wmi *wmi = ar->wmi;
 621         struct wmi_vdev_create_cmd *cmd;
 622         struct sk_buff *skb;
 623         struct wmi_vdev_txrx_streams *txrx_streams;
 624         struct wmi_tlv *tlv;
 625         int ret, len;
 626         void *ptr;
 627
 628         /* It can be optimized my sending tx/rx chain configuration
 629          * only for supported bands instead of always sending it for
 630          * both the bands.
 631          */
 632         len = sizeof(*cmd) + TLV_HDR_SIZE +
 633                 (WMI_NUM_SUPPORTED_BAND_MAX * sizeof(*txrx_streams));
 634
 635         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
 636         if (!skb)
 637                 return -ENOMEM;
 638
 639         cmd = (struct wmi_vdev_create_cmd *)skb->data;
 640         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_CREATE_CMD) |
 641                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 642
 643         cmd->vdev_id = param->if_id;
 644         cmd->vdev_type = param->type;
 645         cmd->vdev_subtype = param->subtype;
 646         cmd->num_cfg_txrx_streams = WMI_NUM_SUPPORTED_BAND_MAX;
 647         cmd->pdev_id = param->pdev_id;
 648         ether_addr_copy(cmd->vdev_macaddr.addr, macaddr);
 649
 650         ptr = skb->data + sizeof(*cmd);
 651         len = WMI_NUM_SUPPORTED_BAND_MAX * sizeof(*txrx_streams);
 652
 653         tlv = ptr;
 654         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
 655                       FIELD_PREP(WMI_TLV_LEN, len);
 656
 657         ptr += TLV_HDR_SIZE;
 658         txrx_streams = ptr;
 659         len = sizeof(*txrx_streams);
 660         txrx_streams->tlv_header =
 661                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_TXRX_STREAMS) |
 662                 FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
 663         txrx_streams->band = WMI_TPC_CHAINMASK_CONFIG_BAND_2G;
 664         txrx_streams->supported_tx_streams =
 665                                  param->chains[NL80211_BAND_2GHZ].tx;
 666         txrx_streams->supported_rx_streams =
 667                                  param->chains[NL80211_BAND_2GHZ].rx;
 668
 669         txrx_streams++;
 670         txrx_streams->tlv_header =
 671                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_TXRX_STREAMS) |
 672                 FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
 673         txrx_streams->band = WMI_TPC_CHAINMASK_CONFIG_BAND_5G;
 674         txrx_streams->supported_tx_streams =
 675                                  param->chains[NL80211_BAND_5GHZ].tx;
 676         txrx_streams->supported_rx_streams =
 677                                  param->chains[NL80211_BAND_5GHZ].rx;
 678
 679         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_CREATE_CMDID);
 680         if (ret) {
 681                 ath11k_warn(ar->ab,
 682                             "failed to submit WMI_VDEV_CREATE_CMDID\n");
 683                 dev_kfree_skb(skb);
 684         }
 685
 686         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
 687                    "WMI vdev create: id %d type %d subtype %d macaddr %pM pdevid %d\n",
 688                    param->if_id, param->type, param->subtype,
 689                    macaddr, param->pdev_id);
 690
 691         return ret;
 692 }
 693
 694 int ath11k_wmi_vdev_delete(struct ath11k *ar, u8 vdev_id)
 695 {
 696         struct ath11k_pdev_wmi *wmi = ar->wmi;
 697         struct wmi_vdev_delete_cmd *cmd;
 698         struct sk_buff *skb;
 699         int ret;
 700
 701         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
 702         if (!skb)
 703                 return -ENOMEM;
 704
 705         cmd = (struct wmi_vdev_delete_cmd *)skb->data;
 706         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_DELETE_CMD) |
 707                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 708         cmd->vdev_id = vdev_id;
 709
 710         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_DELETE_CMDID);
 711         if (ret) {
 712                 ath11k_warn(ar->ab, "failed to submit WMI_VDEV_DELETE_CMDID\n");
 713                 dev_kfree_skb(skb);
 714         }
 715
 716         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "WMI vdev delete id %d\n", vdev_id);
 717
 718         return ret;
 719 }
 720
 721 int ath11k_wmi_vdev_stop(struct ath11k *ar, u8 vdev_id)
 722 {
 723         struct ath11k_pdev_wmi *wmi = ar->wmi;
 724         struct wmi_vdev_stop_cmd *cmd;
 725         struct sk_buff *skb;
 726         int ret;
 727
 728         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
 729         if (!skb)
 730                 return -ENOMEM;
 731
 732         cmd = (struct wmi_vdev_stop_cmd *)skb->data;
 733
 734         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_STOP_CMD) |
 735                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 736         cmd->vdev_id = vdev_id;
 737
 738         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_STOP_CMDID);
 739         if (ret) {
 740                 ath11k_warn(ar->ab, "failed to submit WMI_VDEV_STOP cmd\n");
 741                 dev_kfree_skb(skb);
 742         }
 743
 744         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "WMI vdev stop id 0x%x\n", vdev_id);
 745
 746         return ret;
 747 }
 748
 749 int ath11k_wmi_vdev_down(struct ath11k *ar, u8 vdev_id)
 750 {
 751         struct ath11k_pdev_wmi *wmi = ar->wmi;
 752         struct wmi_vdev_down_cmd *cmd;
 753         struct sk_buff *skb;
 754         int ret;
 755
 756         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
 757         if (!skb)
 758                 return -ENOMEM;
 759
 760         cmd = (struct wmi_vdev_down_cmd *)skb->data;
 761
 762         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_DOWN_CMD) |
 763                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 764         cmd->vdev_id = vdev_id;
 765
 766         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_DOWN_CMDID);
 767         if (ret) {
 768                 ath11k_warn(ar->ab, "failed to submit WMI_VDEV_DOWN cmd\n");
 769                 dev_kfree_skb(skb);
 770         }
 771
 772         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "WMI vdev down id 0x%x\n", vdev_id);
 773
 774         return ret;
 775 }
 776
 777 static void ath11k_wmi_put_wmi_channel(struct wmi_channel *chan,
 778                                        struct wmi_vdev_start_req_arg *arg)
 779 {
 780         memset(chan, 0, sizeof(*chan));
 781
 782         chan->mhz = arg->channel.freq;
 783         chan->band_center_freq1 = arg->channel.band_center_freq1;
 784         if (arg->channel.mode == MODE_11AC_VHT80_80)
 785                 chan->band_center_freq2 = arg->channel.band_center_freq2;
 786         else
 787                 chan->band_center_freq2 = 0;
 788
 789         chan->info |= FIELD_PREP(WMI_CHAN_INFO_MODE, arg->channel.mode);
 790         if (arg->channel.passive)
 791                 chan->info |= WMI_CHAN_INFO_PASSIVE;
 792         if (arg->channel.allow_ibss)
 793                 chan->info |= WMI_CHAN_INFO_ADHOC_ALLOWED;
 794         if (arg->channel.allow_ht)
 795                 chan->info |= WMI_CHAN_INFO_ALLOW_HT;
 796         if (arg->channel.allow_vht)
 797                 chan->info |= WMI_CHAN_INFO_ALLOW_VHT;
 798         if (arg->channel.allow_he)
 799                 chan->info |= WMI_CHAN_INFO_ALLOW_HE;
 800         if (arg->channel.ht40plus)
 801                 chan->info |= WMI_CHAN_INFO_HT40_PLUS;
 802         if (arg->channel.chan_radar)
 803                 chan->info |= WMI_CHAN_INFO_DFS;
 804         if (arg->channel.freq2_radar)
 805                 chan->info |= WMI_CHAN_INFO_DFS_FREQ2;
 806
 807         chan->reg_info_1 = FIELD_PREP(WMI_CHAN_REG_INFO1_MAX_PWR,
 808                                       arg->channel.max_power) |
 809                 FIELD_PREP(WMI_CHAN_REG_INFO1_MAX_REG_PWR,
 810                            arg->channel.max_reg_power);
 811
 812         chan->reg_info_2 = FIELD_PREP(WMI_CHAN_REG_INFO2_ANT_MAX,
 813                                       arg->channel.max_antenna_gain) |
 814                 FIELD_PREP(WMI_CHAN_REG_INFO2_MAX_TX_PWR,
 815                            arg->channel.max_power);
 816 }
 817
 818 int ath11k_wmi_vdev_start(struct ath11k *ar, struct wmi_vdev_start_req_arg *arg,
 819                           bool restart)
 820 {
 821         struct ath11k_pdev_wmi *wmi = ar->wmi;
 822         struct wmi_vdev_start_request_cmd *cmd;
 823         struct sk_buff *skb;
 824         struct wmi_channel *chan;
 825         struct wmi_tlv *tlv;
 826         void *ptr;
 827         int ret, len;
 828
 829         if (WARN_ON(arg->ssid_len > sizeof(cmd->ssid.ssid)))
 830                 return -EINVAL;
 831
 832         len = sizeof(*cmd) + sizeof(*chan) + TLV_HDR_SIZE;
 833
 834         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
 835         if (!skb)
 836                 return -ENOMEM;
 837
 838         cmd = (struct wmi_vdev_start_request_cmd *)skb->data;
 839         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
 840                                      WMI_TAG_VDEV_START_REQUEST_CMD) |
 841                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 842         cmd->vdev_id = arg->vdev_id;
 843         cmd->beacon_interval = arg->bcn_intval;
 844         cmd->bcn_tx_rate = arg->bcn_tx_rate;
 845         cmd->dtim_period = arg->dtim_period;
 846         cmd->num_noa_descriptors = arg->num_noa_descriptors;
 847         cmd->preferred_rx_streams = arg->pref_rx_streams;
 848         cmd->preferred_tx_streams = arg->pref_tx_streams;
 849         cmd->cac_duration_ms = arg->cac_duration_ms;
 850         cmd->regdomain = arg->regdomain;
 851         cmd->he_ops = arg->he_ops;
 852
 853         if (!restart) {
 854                 if (arg->ssid) {
 855                         cmd->ssid.ssid_len = arg->ssid_len;
 856                         memcpy(cmd->ssid.ssid, arg->ssid, arg->ssid_len);
 857                 }
 858                 if (arg->hidden_ssid)
 859                         cmd->flags |= WMI_VDEV_START_HIDDEN_SSID;
 860                 if (arg->pmf_enabled)
 861                         cmd->flags |= WMI_VDEV_START_PMF_ENABLED;
 862         }
 863
 864         cmd->flags |= WMI_VDEV_START_LDPC_RX_ENABLED;
 865
 866         ptr = skb->data + sizeof(*cmd);
 867         chan = ptr;
 868
 869         ath11k_wmi_put_wmi_channel(chan, arg);
 870
 871         chan->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_CHANNEL) |
 872                            FIELD_PREP(WMI_TLV_LEN,
 873                                       sizeof(*chan) - TLV_HDR_SIZE);
 874         ptr += sizeof(*chan);
 875
 876         tlv = ptr;
 877         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
 878                       FIELD_PREP(WMI_TLV_LEN, 0);
 879
 880         /* Note: This is a nested TLV containing:
 881          * [wmi_tlv][wmi_p2p_noa_descriptor][wmi_tlv]..
 882          */
 883
 884         ptr += sizeof(*tlv);
 885
 886         if (restart)
 887                 ret = ath11k_wmi_cmd_send(wmi, skb,
 888                                           WMI_VDEV_RESTART_REQUEST_CMDID);
 889         else
 890                 ret = ath11k_wmi_cmd_send(wmi, skb,
 891                                           WMI_VDEV_START_REQUEST_CMDID);
 892         if (ret) {
 893                 ath11k_warn(ar->ab, "failed to submit vdev_%s cmd\n",
 894                             restart ? "restart" : "start");
 895                 dev_kfree_skb(skb);
 896         }
 897
 898         ath11k_dbg(ar->ab, ATH11K_DBG_WMI, "vdev %s id 0x%x freq 0x%x mode 0x%x\n",
 899                    restart ? "restart" : "start", arg->vdev_id,
 900                    arg->channel.freq, arg->channel.mode);
 901
 902         return ret;
 903 }
 904
 905 int ath11k_wmi_vdev_up(struct ath11k *ar, u32 vdev_id, u32 aid, const u8 *bssid)
 906 {
 907         struct ath11k_pdev_wmi *wmi = ar->wmi;
 908         struct wmi_vdev_up_cmd *cmd;
 909         struct sk_buff *skb;
 910         int ret;
 911
 912         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
 913         if (!skb)
 914                 return -ENOMEM;
 915
 916         cmd = (struct wmi_vdev_up_cmd *)skb->data;
 917
 918         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_UP_CMD) |
 919                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 920         cmd->vdev_id = vdev_id;
 921         cmd->vdev_assoc_id = aid;
 922
 923         ether_addr_copy(cmd->vdev_bssid.addr, bssid);
 924
 925         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_UP_CMDID);
 926         if (ret) {
 927                 ath11k_warn(ar->ab, "failed to submit WMI_VDEV_UP cmd\n");
 928                 dev_kfree_skb(skb);
 929         }
 930
 931         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
 932                    "WMI mgmt vdev up id 0x%x assoc id %d bssid %pM\n",
 933                    vdev_id, aid, bssid);
 934
 935         return ret;
 936 }
 937
 938 int ath11k_wmi_send_peer_create_cmd(struct ath11k *ar,
 939                                     struct peer_create_params *param)
 940 {
 941         struct ath11k_pdev_wmi *wmi = ar->wmi;
 942         struct wmi_peer_create_cmd *cmd;
 943         struct sk_buff *skb;
 944         int ret;
 945
 946         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
 947         if (!skb)
 948                 return -ENOMEM;
 949
 950         cmd = (struct wmi_peer_create_cmd *)skb->data;
 951         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PEER_CREATE_CMD) |
 952                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 953
 954         ether_addr_copy(cmd->peer_macaddr.addr, param->peer_addr);
 955         cmd->peer_type = param->peer_type;
 956         cmd->vdev_id = param->vdev_id;
 957
 958         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PEER_CREATE_CMDID);
 959         if (ret) {
 960                 ath11k_warn(ar->ab, "failed to submit WMI_PEER_CREATE cmd\n");
 961                 dev_kfree_skb(skb);
 962         }
 963
 964         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
 965                    "WMI peer create vdev_id %d peer_addr %pM\n",
 966                    param->vdev_id, param->peer_addr);
 967
 968         return ret;
 969 }
 970
 971 int ath11k_wmi_send_peer_delete_cmd(struct ath11k *ar,
 972                                     const u8 *peer_addr, u8 vdev_id)
 973 {
 974         struct ath11k_pdev_wmi *wmi = ar->wmi;
 975         struct wmi_peer_delete_cmd *cmd;
 976         struct sk_buff *skb;
 977         int ret;
 978
 979         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
 980         if (!skb)
 981                 return -ENOMEM;
 982
 983         cmd = (struct wmi_peer_delete_cmd *)skb->data;
 984         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PEER_DELETE_CMD) |
 985                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
 986
 987         ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
 988         cmd->vdev_id = vdev_id;
 989
 990         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
 991                    "WMI peer delete vdev_id %d peer_addr %pM\n",
 992                    vdev_id,  peer_addr);
 993
 994         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PEER_DELETE_CMDID);
 995         if (ret) {
 996                 ath11k_warn(ar->ab, "failed to send WMI_PEER_DELETE cmd\n");
 997                 dev_kfree_skb(skb);
 998         }
 999
1000         return ret;
1001 }
1002
1003 int ath11k_wmi_send_pdev_set_regdomain(struct ath11k *ar,
1004                                        struct pdev_set_regdomain_params *param)
1005 {
1006         struct ath11k_pdev_wmi *wmi = ar->wmi;
1007         struct wmi_pdev_set_regdomain_cmd *cmd;
1008         struct sk_buff *skb;
1009         int ret;
1010
1011         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1012         if (!skb)
1013                 return -ENOMEM;
1014
1015         cmd = (struct wmi_pdev_set_regdomain_cmd *)skb->data;
1016         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1017                                      WMI_TAG_PDEV_SET_REGDOMAIN_CMD) |
1018                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1019
1020         cmd->reg_domain = param->current_rd_in_use;
1021         cmd->reg_domain_2g = param->current_rd_2g;
1022         cmd->reg_domain_5g = param->current_rd_5g;
1023         cmd->conformance_test_limit_2g = param->ctl_2g;
1024         cmd->conformance_test_limit_5g = param->ctl_5g;
1025         cmd->dfs_domain = param->dfs_domain;
1026         cmd->pdev_id = param->pdev_id;
1027
1028         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1029                    "WMI pdev regd rd %d rd2g %d rd5g %d domain %d pdev id %d\n",
1030                    param->current_rd_in_use, param->current_rd_2g,
1031                    param->current_rd_5g, param->dfs_domain, param->pdev_id);
1032
1033         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_SET_REGDOMAIN_CMDID);
1034         if (ret) {
1035                 ath11k_warn(ar->ab,
1036                             "failed to send WMI_PDEV_SET_REGDOMAIN cmd\n");
1037                 dev_kfree_skb(skb);
1038         }
1039
1040         return ret;
1041 }
1042
1043 int ath11k_wmi_set_peer_param(struct ath11k *ar, const u8 *peer_addr,
1044                               u32 vdev_id, u32 param_id, u32 param_val)
1045 {
1046         struct ath11k_pdev_wmi *wmi = ar->wmi;
1047         struct wmi_peer_set_param_cmd *cmd;
1048         struct sk_buff *skb;
1049         int ret;
1050
1051         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1052         if (!skb)
1053                 return -ENOMEM;
1054
1055         cmd = (struct wmi_peer_set_param_cmd *)skb->data;
1056         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PEER_SET_PARAM_CMD) |
1057                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1058         ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
1059         cmd->vdev_id = vdev_id;
1060         cmd->param_id = param_id;
1061         cmd->param_value = param_val;
1062
1063         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PEER_SET_PARAM_CMDID);
1064         if (ret) {
1065                 ath11k_warn(ar->ab, "failed to send WMI_PEER_SET_PARAM cmd\n");
1066                 dev_kfree_skb(skb);
1067         }
1068
1069         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1070                    "WMI vdev %d peer 0x%pM set param %d value %d\n",
1071                    vdev_id, peer_addr, param_id, param_val);
1072
1073         return ret;
1074 }
1075
1076 int ath11k_wmi_send_peer_flush_tids_cmd(struct ath11k *ar,
1077                                         u8 peer_addr[ETH_ALEN],
1078                                         struct peer_flush_params *param)
1079 {
1080         struct ath11k_pdev_wmi *wmi = ar->wmi;
1081         struct wmi_peer_flush_tids_cmd *cmd;
1082         struct sk_buff *skb;
1083         int ret;
1084
1085         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1086         if (!skb)
1087                 return -ENOMEM;
1088
1089         cmd = (struct wmi_peer_flush_tids_cmd *)skb->data;
1090         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PEER_FLUSH_TIDS_CMD) |
1091                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1092
1093         ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
1094         cmd->peer_tid_bitmap = param->peer_tid_bitmap;
1095         cmd->vdev_id = param->vdev_id;
1096
1097         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PEER_FLUSH_TIDS_CMDID);
1098         if (ret) {
1099                 ath11k_warn(ar->ab,
1100                             "failed to send WMI_PEER_FLUSH_TIDS cmd\n");
1101                 dev_kfree_skb(skb);
1102         }
1103
1104         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1105                    "WMI peer flush vdev_id %d peer_addr %pM tids %08x\n",
1106                    param->vdev_id, peer_addr, param->peer_tid_bitmap);
1107
1108         return ret;
1109 }
1110
1111 int ath11k_wmi_peer_rx_reorder_queue_setup(struct ath11k *ar,
1112                                            int vdev_id, const u8 *addr,
1113                                            dma_addr_t paddr, u8 tid,
1114                                            u8 ba_window_size_valid,
1115                                            u32 ba_window_size)
1116 {
1117         struct wmi_peer_reorder_queue_setup_cmd *cmd;
1118         struct sk_buff *skb;
1119         int ret;
1120
1121         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
1122         if (!skb)
1123                 return -ENOMEM;
1124
1125         cmd = (struct wmi_peer_reorder_queue_setup_cmd *)skb->data;
1126         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1127                                      WMI_TAG_REORDER_QUEUE_SETUP_CMD) |
1128                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1129
1130         ether_addr_copy(cmd->peer_macaddr.addr, addr);
1131         cmd->vdev_id = vdev_id;
1132         cmd->tid = tid;
1133         cmd->queue_ptr_lo = lower_32_bits(paddr);
1134         cmd->queue_ptr_hi = upper_32_bits(paddr);
1135         cmd->queue_no = tid;
1136         cmd->ba_window_size_valid = ba_window_size_valid;
1137         cmd->ba_window_size = ba_window_size;
1138
1139         ret = ath11k_wmi_cmd_send(ar->wmi, skb,
1140                                   WMI_PEER_REORDER_QUEUE_SETUP_CMDID);
1141         if (ret) {
1142                 ath11k_warn(ar->ab,
1143                             "failed to send WMI_PEER_REORDER_QUEUE_SETUP\n");
1144                 dev_kfree_skb(skb);
1145         }
1146
1147         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1148                    "wmi rx reorder queue setup addr %pM vdev_id %d tid %d\n",
1149                    addr, vdev_id, tid);
1150
1151         return ret;
1152 }
1153
1154 int
1155 ath11k_wmi_rx_reord_queue_remove(struct ath11k *ar,
1156                                  struct rx_reorder_queue_remove_params *param)
1157 {
1158         struct ath11k_pdev_wmi *wmi = ar->wmi;
1159         struct wmi_peer_reorder_queue_remove_cmd *cmd;
1160         struct sk_buff *skb;
1161         int ret;
1162
1163         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1164         if (!skb)
1165                 return -ENOMEM;
1166
1167         cmd = (struct wmi_peer_reorder_queue_remove_cmd *)skb->data;
1168         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1169                                      WMI_TAG_REORDER_QUEUE_REMOVE_CMD) |
1170                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1171
1172         ether_addr_copy(cmd->peer_macaddr.addr, param->peer_macaddr);
1173         cmd->vdev_id = param->vdev_id;
1174         cmd->tid_mask = param->peer_tid_bitmap;
1175
1176         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1177                    "%s: peer_macaddr %pM vdev_id %d, tid_map %d", __func__,
1178                    param->peer_macaddr, param->vdev_id, param->peer_tid_bitmap);
1179
1180         ret = ath11k_wmi_cmd_send(wmi, skb,
1181                                   WMI_PEER_REORDER_QUEUE_REMOVE_CMDID);
1182         if (ret) {
1183                 ath11k_warn(ar->ab,
1184                             "failed to send WMI_PEER_REORDER_QUEUE_REMOVE_CMDID");
1185                 dev_kfree_skb(skb);
1186         }
1187
1188         return ret;
1189 }
1190
1191 int ath11k_wmi_pdev_set_param(struct ath11k *ar, u32 param_id,
1192                               u32 param_value, u8 pdev_id)
1193 {
1194         struct ath11k_pdev_wmi *wmi = ar->wmi;
1195         struct wmi_pdev_set_param_cmd *cmd;
1196         struct sk_buff *skb;
1197         int ret;
1198
1199         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1200         if (!skb)
1201                 return -ENOMEM;
1202
1203         cmd = (struct wmi_pdev_set_param_cmd *)skb->data;
1204         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_SET_PARAM_CMD) |
1205                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1206         cmd->pdev_id = pdev_id;
1207         cmd->param_id = param_id;
1208         cmd->param_value = param_value;
1209
1210         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_SET_PARAM_CMDID);
1211         if (ret) {
1212                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_SET_PARAM cmd\n");
1213                 dev_kfree_skb(skb);
1214         }
1215
1216         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1217                    "WMI pdev set param %d pdev id %d value %d\n",
1218                    param_id, pdev_id, param_value);
1219
1220         return ret;
1221 }
1222
1223 int ath11k_wmi_pdev_set_ps_mode(struct ath11k *ar, int vdev_id, u32 enable)
1224 {
1225         struct ath11k_pdev_wmi *wmi = ar->wmi;
1226         struct wmi_pdev_set_ps_mode_cmd *cmd;
1227         struct sk_buff *skb;
1228         int ret;
1229
1230         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1231         if (!skb)
1232                 return -ENOMEM;
1233
1234         cmd = (struct wmi_pdev_set_ps_mode_cmd *)skb->data;
1235         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_STA_POWERSAVE_MODE_CMD) |
1236                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1237         cmd->vdev_id = vdev_id;
1238         cmd->sta_ps_mode = enable;
1239
1240         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_STA_POWERSAVE_MODE_CMDID);
1241         if (ret) {
1242                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_SET_PARAM cmd\n");
1243                 dev_kfree_skb(skb);
1244         }
1245
1246         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1247                    "WMI vdev set psmode %d vdev id %d\n",
1248                    enable, vdev_id);
1249
1250         return ret;
1251 }
1252
1253 int ath11k_wmi_pdev_suspend(struct ath11k *ar, u32 suspend_opt,
1254                             u32 pdev_id)
1255 {
1256         struct ath11k_pdev_wmi *wmi = ar->wmi;
1257         struct wmi_pdev_suspend_cmd *cmd;
1258         struct sk_buff *skb;
1259         int ret;
1260
1261         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1262         if (!skb)
1263                 return -ENOMEM;
1264
1265         cmd = (struct wmi_pdev_suspend_cmd *)skb->data;
1266
1267         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_SUSPEND_CMD) |
1268                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1269
1270         cmd->suspend_opt = suspend_opt;
1271         cmd->pdev_id = pdev_id;
1272
1273         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_SUSPEND_CMDID);
1274         if (ret) {
1275                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_SUSPEND cmd\n");
1276                 dev_kfree_skb(skb);
1277         }
1278
1279         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1280                    "WMI pdev suspend pdev_id %d\n", pdev_id);
1281
1282         return ret;
1283 }
1284
1285 int ath11k_wmi_pdev_resume(struct ath11k *ar, u32 pdev_id)
1286 {
1287         struct ath11k_pdev_wmi *wmi = ar->wmi;
1288         struct wmi_pdev_resume_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_pdev_resume_cmd *)skb->data;
1297
1298         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_RESUME_CMD) |
1299                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1300         cmd->pdev_id = pdev_id;
1301
1302         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1303                    "WMI pdev resume pdev id %d\n", pdev_id);
1304
1305         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_RESUME_CMDID);
1306         if (ret) {
1307                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_RESUME cmd\n");
1308                 dev_kfree_skb(skb);
1309         }
1310
1311         return ret;
1312 }
1313
1314 /* TODO FW Support for the cmd is not available yet.
1315  * Can be tested once the command and corresponding
1316  * event is implemented in FW
1317  */
1318 int ath11k_wmi_pdev_bss_chan_info_request(struct ath11k *ar,
1319                                           enum wmi_bss_chan_info_req_type type)
1320 {
1321         struct ath11k_pdev_wmi *wmi = ar->wmi;
1322         struct wmi_pdev_bss_chan_info_req_cmd *cmd;
1323         struct sk_buff *skb;
1324         int ret;
1325
1326         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1327         if (!skb)
1328                 return -ENOMEM;
1329
1330         cmd = (struct wmi_pdev_bss_chan_info_req_cmd *)skb->data;
1331
1332         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1333                                      WMI_TAG_PDEV_BSS_CHAN_INFO_REQUEST) |
1334                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1335         cmd->req_type = type;
1336
1337         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1338                    "WMI bss chan info req type %d\n", type);
1339
1340         ret = ath11k_wmi_cmd_send(wmi, skb,
1341                                   WMI_PDEV_BSS_CHAN_INFO_REQUEST_CMDID);
1342         if (ret) {
1343                 ath11k_warn(ar->ab,
1344                             "failed to send WMI_PDEV_BSS_CHAN_INFO_REQUEST cmd\n");
1345                 dev_kfree_skb(skb);
1346         }
1347
1348         return ret;
1349 }
1350
1351 int ath11k_wmi_send_set_ap_ps_param_cmd(struct ath11k *ar, u8 *peer_addr,
1352                                         struct ap_ps_params *param)
1353 {
1354         struct ath11k_pdev_wmi *wmi = ar->wmi;
1355         struct wmi_ap_ps_peer_cmd *cmd;
1356         struct sk_buff *skb;
1357         int ret;
1358
1359         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1360         if (!skb)
1361                 return -ENOMEM;
1362
1363         cmd = (struct wmi_ap_ps_peer_cmd *)skb->data;
1364         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_AP_PS_PEER_CMD) |
1365                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1366
1367         cmd->vdev_id = param->vdev_id;
1368         ether_addr_copy(cmd->peer_macaddr.addr, peer_addr);
1369         cmd->param = param->param;
1370         cmd->value = param->value;
1371
1372         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_AP_PS_PEER_PARAM_CMDID);
1373         if (ret) {
1374                 ath11k_warn(ar->ab,
1375                             "failed to send WMI_AP_PS_PEER_PARAM_CMDID\n");
1376                 dev_kfree_skb(skb);
1377         }
1378
1379         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1380                    "WMI set ap ps vdev id %d peer %pM param %d value %d\n",
1381                    param->vdev_id, peer_addr, param->param, param->value);
1382
1383         return ret;
1384 }
1385
1386 int ath11k_wmi_set_sta_ps_param(struct ath11k *ar, u32 vdev_id,
1387                                 u32 param, u32 param_value)
1388 {
1389         struct ath11k_pdev_wmi *wmi = ar->wmi;
1390         struct wmi_sta_powersave_param_cmd *cmd;
1391         struct sk_buff *skb;
1392         int ret;
1393
1394         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1395         if (!skb)
1396                 return -ENOMEM;
1397
1398         cmd = (struct wmi_sta_powersave_param_cmd *)skb->data;
1399         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1400                                      WMI_TAG_STA_POWERSAVE_PARAM_CMD) |
1401                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1402
1403         cmd->vdev_id = vdev_id;
1404         cmd->param = param;
1405         cmd->value = param_value;
1406
1407         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1408                    "WMI set sta ps vdev_id %d param %d value %d\n",
1409                    vdev_id, param, param_value);
1410
1411         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_STA_POWERSAVE_PARAM_CMDID);
1412         if (ret) {
1413                 ath11k_warn(ar->ab, "failed to send WMI_STA_POWERSAVE_PARAM_CMDID");
1414                 dev_kfree_skb(skb);
1415         }
1416
1417         return ret;
1418 }
1419
1420 int ath11k_wmi_force_fw_hang_cmd(struct ath11k *ar, u32 type, u32 delay_time_ms)
1421 {
1422         struct ath11k_pdev_wmi *wmi = ar->wmi;
1423         struct wmi_force_fw_hang_cmd *cmd;
1424         struct sk_buff *skb;
1425         int ret, len;
1426
1427         len = sizeof(*cmd);
1428
1429         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
1430         if (!skb)
1431                 return -ENOMEM;
1432
1433         cmd = (struct wmi_force_fw_hang_cmd *)skb->data;
1434         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_FORCE_FW_HANG_CMD) |
1435                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
1436
1437         cmd->type = type;
1438         cmd->delay_time_ms = delay_time_ms;
1439
1440         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_FORCE_FW_HANG_CMDID);
1441
1442         if (ret) {
1443                 ath11k_warn(ar->ab, "Failed to send WMI_FORCE_FW_HANG_CMDID");
1444                 dev_kfree_skb(skb);
1445         }
1446         return ret;
1447 }
1448
1449 int ath11k_wmi_vdev_set_param_cmd(struct ath11k *ar, u32 vdev_id,
1450                                   u32 param_id, u32 param_value)
1451 {
1452         struct ath11k_pdev_wmi *wmi = ar->wmi;
1453         struct wmi_vdev_set_param_cmd *cmd;
1454         struct sk_buff *skb;
1455         int ret;
1456
1457         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1458         if (!skb)
1459                 return -ENOMEM;
1460
1461         cmd = (struct wmi_vdev_set_param_cmd *)skb->data;
1462         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_SET_PARAM_CMD) |
1463                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1464
1465         cmd->vdev_id = vdev_id;
1466         cmd->param_id = param_id;
1467         cmd->param_value = param_value;
1468
1469         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_SET_PARAM_CMDID);
1470         if (ret) {
1471                 ath11k_warn(ar->ab,
1472                             "failed to send WMI_VDEV_SET_PARAM_CMDID\n");
1473                 dev_kfree_skb(skb);
1474         }
1475
1476         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1477                    "WMI vdev id 0x%x set param %d value %d\n",
1478                    vdev_id, param_id, param_value);
1479
1480         return ret;
1481 }
1482
1483 int ath11k_wmi_send_stats_request_cmd(struct ath11k *ar,
1484                                       struct stats_request_params *param)
1485 {
1486         struct ath11k_pdev_wmi *wmi = ar->wmi;
1487         struct wmi_request_stats_cmd *cmd;
1488         struct sk_buff *skb;
1489         int ret;
1490
1491         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1492         if (!skb)
1493                 return -ENOMEM;
1494
1495         cmd = (struct wmi_request_stats_cmd *)skb->data;
1496         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_REQUEST_STATS_CMD) |
1497                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1498
1499         cmd->stats_id = param->stats_id;
1500         cmd->vdev_id = param->vdev_id;
1501         cmd->pdev_id = param->pdev_id;
1502
1503         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_REQUEST_STATS_CMDID);
1504         if (ret) {
1505                 ath11k_warn(ar->ab, "failed to send WMI_REQUEST_STATS cmd\n");
1506                 dev_kfree_skb(skb);
1507         }
1508
1509         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1510                    "WMI request stats 0x%x vdev id %d pdev id %d\n",
1511                    param->stats_id, param->vdev_id, param->pdev_id);
1512
1513         return ret;
1514 }
1515
1516 int ath11k_wmi_send_pdev_temperature_cmd(struct ath11k *ar)
1517 {
1518         struct ath11k_pdev_wmi *wmi = ar->wmi;
1519         struct wmi_get_pdev_temperature_cmd *cmd;
1520         struct sk_buff *skb;
1521         int ret;
1522
1523         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1524         if (!skb)
1525                 return -ENOMEM;
1526
1527         cmd = (struct wmi_get_pdev_temperature_cmd *)skb->data;
1528         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_GET_TEMPERATURE_CMD) |
1529                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1530         cmd->pdev_id = ar->pdev->pdev_id;
1531
1532         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PDEV_GET_TEMPERATURE_CMDID);
1533         if (ret) {
1534                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_GET_TEMPERATURE cmd\n");
1535                 dev_kfree_skb(skb);
1536         }
1537
1538         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1539                    "WMI pdev get temperature for pdev_id %d\n", ar->pdev->pdev_id);
1540
1541         return ret;
1542 }
1543
1544 int ath11k_wmi_send_bcn_offload_control_cmd(struct ath11k *ar,
1545                                             u32 vdev_id, u32 bcn_ctrl_op)
1546 {
1547         struct ath11k_pdev_wmi *wmi = ar->wmi;
1548         struct wmi_bcn_offload_ctrl_cmd *cmd;
1549         struct sk_buff *skb;
1550         int ret;
1551
1552         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
1553         if (!skb)
1554                 return -ENOMEM;
1555
1556         cmd = (struct wmi_bcn_offload_ctrl_cmd *)skb->data;
1557         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1558                                      WMI_TAG_BCN_OFFLOAD_CTRL_CMD) |
1559                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1560
1561         cmd->vdev_id = vdev_id;
1562         cmd->bcn_ctrl_op = bcn_ctrl_op;
1563
1564         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1565                    "WMI bcn ctrl offload vdev id %d ctrl_op %d\n",
1566                    vdev_id, bcn_ctrl_op);
1567
1568         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_BCN_OFFLOAD_CTRL_CMDID);
1569         if (ret) {
1570                 ath11k_warn(ar->ab,
1571                             "failed to send WMI_BCN_OFFLOAD_CTRL_CMDID\n");
1572                 dev_kfree_skb(skb);
1573         }
1574
1575         return ret;
1576 }
1577
1578 int ath11k_wmi_bcn_tmpl(struct ath11k *ar, u32 vdev_id,
1579                         struct ieee80211_mutable_offsets *offs,
1580                         struct sk_buff *bcn)
1581 {
1582         struct ath11k_pdev_wmi *wmi = ar->wmi;
1583         struct wmi_bcn_tmpl_cmd *cmd;
1584         struct wmi_bcn_prb_info *bcn_prb_info;
1585         struct wmi_tlv *tlv;
1586         struct sk_buff *skb;
1587         void *ptr;
1588         int ret, len;
1589         size_t aligned_len = roundup(bcn->len, 4);
1590
1591         len = sizeof(*cmd) + sizeof(*bcn_prb_info) + TLV_HDR_SIZE + aligned_len;
1592
1593         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
1594         if (!skb)
1595                 return -ENOMEM;
1596
1597         cmd = (struct wmi_bcn_tmpl_cmd *)skb->data;
1598         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_BCN_TMPL_CMD) |
1599                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1600         cmd->vdev_id = vdev_id;
1601         cmd->tim_ie_offset = offs->tim_offset;
1602         cmd->csa_switch_count_offset = offs->csa_counter_offs[0];
1603         cmd->ext_csa_switch_count_offset = offs->csa_counter_offs[1];
1604         cmd->buf_len = bcn->len;
1605
1606         ptr = skb->data + sizeof(*cmd);
1607
1608         bcn_prb_info = ptr;
1609         len = sizeof(*bcn_prb_info);
1610         bcn_prb_info->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1611                                               WMI_TAG_BCN_PRB_INFO) |
1612                                    FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
1613         bcn_prb_info->caps = 0;
1614         bcn_prb_info->erp = 0;
1615
1616         ptr += sizeof(*bcn_prb_info);
1617
1618         tlv = ptr;
1619         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
1620                       FIELD_PREP(WMI_TLV_LEN, aligned_len);
1621         memcpy(tlv->value, bcn->data, bcn->len);
1622
1623         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_BCN_TMPL_CMDID);
1624         if (ret) {
1625                 ath11k_warn(ar->ab, "failed to send WMI_BCN_TMPL_CMDID\n");
1626                 dev_kfree_skb(skb);
1627         }
1628
1629         return ret;
1630 }
1631
1632 int ath11k_wmi_vdev_install_key(struct ath11k *ar,
1633                                 struct wmi_vdev_install_key_arg *arg)
1634 {
1635         struct ath11k_pdev_wmi *wmi = ar->wmi;
1636         struct wmi_vdev_install_key_cmd *cmd;
1637         struct wmi_tlv *tlv;
1638         struct sk_buff *skb;
1639         int ret, len;
1640         int key_len_aligned = roundup(arg->key_len, sizeof(uint32_t));
1641
1642         len = sizeof(*cmd) + TLV_HDR_SIZE + key_len_aligned;
1643
1644         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
1645         if (!skb)
1646                 return -ENOMEM;
1647
1648         cmd = (struct wmi_vdev_install_key_cmd *)skb->data;
1649         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VDEV_INSTALL_KEY_CMD) |
1650                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1651         cmd->vdev_id = arg->vdev_id;
1652         ether_addr_copy(cmd->peer_macaddr.addr, arg->macaddr);
1653         cmd->key_idx = arg->key_idx;
1654         cmd->key_flags = arg->key_flags;
1655         cmd->key_cipher = arg->key_cipher;
1656         cmd->key_len = arg->key_len;
1657         cmd->key_txmic_len = arg->key_txmic_len;
1658         cmd->key_rxmic_len = arg->key_rxmic_len;
1659
1660         if (arg->key_rsc_counter)
1661                 memcpy(&cmd->key_rsc_counter, &arg->key_rsc_counter,
1662                        sizeof(struct wmi_key_seq_counter));
1663
1664         tlv = (struct wmi_tlv *)(skb->data + sizeof(*cmd));
1665         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
1666                       FIELD_PREP(WMI_TLV_LEN, key_len_aligned);
1667         memcpy(tlv->value, (u8 *)arg->key_data, key_len_aligned);
1668
1669         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_VDEV_INSTALL_KEY_CMDID);
1670         if (ret) {
1671                 ath11k_warn(ar->ab,
1672                             "failed to send WMI_VDEV_INSTALL_KEY cmd\n");
1673                 dev_kfree_skb(skb);
1674         }
1675
1676         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1677                    "WMI vdev install key idx %d cipher %d len %d\n",
1678                    arg->key_idx, arg->key_cipher, arg->key_len);
1679
1680         return ret;
1681 }
1682
1683 static inline void
1684 ath11k_wmi_copy_peer_flags(struct wmi_peer_assoc_complete_cmd *cmd,
1685                            struct peer_assoc_params *param)
1686 {
1687         cmd->peer_flags = 0;
1688
1689         if (param->is_wme_set) {
1690                 if (param->qos_flag)
1691                         cmd->peer_flags |= WMI_PEER_QOS;
1692                 if (param->apsd_flag)
1693                         cmd->peer_flags |= WMI_PEER_APSD;
1694                 if (param->ht_flag)
1695                         cmd->peer_flags |= WMI_PEER_HT;
1696                 if (param->bw_40)
1697                         cmd->peer_flags |= WMI_PEER_40MHZ;
1698                 if (param->bw_80)
1699                         cmd->peer_flags |= WMI_PEER_80MHZ;
1700                 if (param->bw_160)
1701                         cmd->peer_flags |= WMI_PEER_160MHZ;
1702
1703                 /* Typically if STBC is enabled for VHT it should be enabled
1704                  * for HT as well
1705                  **/
1706                 if (param->stbc_flag)
1707                         cmd->peer_flags |= WMI_PEER_STBC;
1708
1709                 /* Typically if LDPC is enabled for VHT it should be enabled
1710                  * for HT as well
1711                  **/
1712                 if (param->ldpc_flag)
1713                         cmd->peer_flags |= WMI_PEER_LDPC;
1714
1715                 if (param->static_mimops_flag)
1716                         cmd->peer_flags |= WMI_PEER_STATIC_MIMOPS;
1717                 if (param->dynamic_mimops_flag)
1718                         cmd->peer_flags |= WMI_PEER_DYN_MIMOPS;
1719                 if (param->spatial_mux_flag)
1720                         cmd->peer_flags |= WMI_PEER_SPATIAL_MUX;
1721                 if (param->vht_flag)
1722                         cmd->peer_flags |= WMI_PEER_VHT;
1723                 if (param->he_flag)
1724                         cmd->peer_flags |= WMI_PEER_HE;
1725                 if (param->twt_requester)
1726                         cmd->peer_flags |= WMI_PEER_TWT_REQ;
1727                 if (param->twt_responder)
1728                         cmd->peer_flags |= WMI_PEER_TWT_RESP;
1729         }
1730
1731         /* Suppress authorization for all AUTH modes that need 4-way handshake
1732          * (during re-association).
1733          * Authorization will be done for these modes on key installation.
1734          */
1735         if (param->auth_flag)
1736                 cmd->peer_flags |= WMI_PEER_AUTH;
1737         if (param->need_ptk_4_way) {
1738                 cmd->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1739                 cmd->peer_flags &= ~WMI_PEER_AUTH;
1740         }
1741         if (param->need_gtk_2_way)
1742                 cmd->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1743         /* safe mode bypass the 4-way handshake */
1744         if (param->safe_mode_enabled)
1745                 cmd->peer_flags &= ~(WMI_PEER_NEED_PTK_4_WAY |
1746                                      WMI_PEER_NEED_GTK_2_WAY);
1747
1748         if (param->is_pmf_enabled)
1749                 cmd->peer_flags |= WMI_PEER_PMF;
1750
1751         /* Disable AMSDU for station transmit, if user configures it */
1752         /* Disable AMSDU for AP transmit to 11n Stations, if user configures
1753          * it
1754          * if (param->amsdu_disable) Add after FW support
1755          **/
1756
1757         /* Target asserts if node is marked HT and all MCS is set to 0.
1758          * Mark the node as non-HT if all the mcs rates are disabled through
1759          * iwpriv
1760          **/
1761         if (param->peer_ht_rates.num_rates == 0)
1762                 cmd->peer_flags &= ~WMI_PEER_HT;
1763 }
1764
1765 int ath11k_wmi_send_peer_assoc_cmd(struct ath11k *ar,
1766                                    struct peer_assoc_params *param)
1767 {
1768         struct ath11k_pdev_wmi *wmi = ar->wmi;
1769         struct wmi_peer_assoc_complete_cmd *cmd;
1770         struct wmi_vht_rate_set *mcs;
1771         struct wmi_he_rate_set *he_mcs;
1772         struct sk_buff *skb;
1773         struct wmi_tlv *tlv;
1774         void *ptr;
1775         u32 peer_legacy_rates_align;
1776         u32 peer_ht_rates_align;
1777         int i, ret, len;
1778
1779         peer_legacy_rates_align = roundup(param->peer_legacy_rates.num_rates,
1780                                           sizeof(u32));
1781         peer_ht_rates_align = roundup(param->peer_ht_rates.num_rates,
1782                                       sizeof(u32));
1783
1784         len = sizeof(*cmd) +
1785               TLV_HDR_SIZE + (peer_legacy_rates_align * sizeof(u8)) +
1786               TLV_HDR_SIZE + (peer_ht_rates_align * sizeof(u8)) +
1787               sizeof(*mcs) + TLV_HDR_SIZE +
1788               (sizeof(*he_mcs) * param->peer_he_mcs_count);
1789
1790         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
1791         if (!skb)
1792                 return -ENOMEM;
1793
1794         ptr = skb->data;
1795
1796         cmd = ptr;
1797         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1798                                      WMI_TAG_PEER_ASSOC_COMPLETE_CMD) |
1799                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
1800
1801         cmd->vdev_id = param->vdev_id;
1802
1803         cmd->peer_new_assoc = param->peer_new_assoc;
1804         cmd->peer_associd = param->peer_associd;
1805
1806         ath11k_wmi_copy_peer_flags(cmd, param);
1807
1808         ether_addr_copy(cmd->peer_macaddr.addr, param->peer_mac);
1809
1810         cmd->peer_rate_caps = param->peer_rate_caps;
1811         cmd->peer_caps = param->peer_caps;
1812         cmd->peer_listen_intval = param->peer_listen_intval;
1813         cmd->peer_ht_caps = param->peer_ht_caps;
1814         cmd->peer_max_mpdu = param->peer_max_mpdu;
1815         cmd->peer_mpdu_density = param->peer_mpdu_density;
1816         cmd->peer_vht_caps = param->peer_vht_caps;
1817         cmd->peer_phymode = param->peer_phymode;
1818
1819         /* Update 11ax capabilities */
1820         cmd->peer_he_cap_info = param->peer_he_cap_macinfo[0];
1821         cmd->peer_he_cap_info_ext = param->peer_he_cap_macinfo[1];
1822         cmd->peer_he_cap_info_internal = param->peer_he_cap_macinfo_internal;
1823         cmd->peer_he_caps_6ghz = param->peer_he_caps_6ghz;
1824         cmd->peer_he_ops = param->peer_he_ops;
1825         memcpy(&cmd->peer_he_cap_phy, &param->peer_he_cap_phyinfo,
1826                sizeof(param->peer_he_cap_phyinfo));
1827         memcpy(&cmd->peer_ppet, &param->peer_ppet,
1828                sizeof(param->peer_ppet));
1829
1830         /* Update peer legacy rate information */
1831         ptr += sizeof(*cmd);
1832
1833         tlv = ptr;
1834         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
1835                       FIELD_PREP(WMI_TLV_LEN, peer_legacy_rates_align);
1836
1837         ptr += TLV_HDR_SIZE;
1838
1839         cmd->num_peer_legacy_rates = param->peer_legacy_rates.num_rates;
1840         memcpy(ptr, param->peer_legacy_rates.rates,
1841                param->peer_legacy_rates.num_rates);
1842
1843         /* Update peer HT rate information */
1844         ptr += peer_legacy_rates_align;
1845
1846         tlv = ptr;
1847         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
1848                       FIELD_PREP(WMI_TLV_LEN, peer_ht_rates_align);
1849         ptr += TLV_HDR_SIZE;
1850         cmd->num_peer_ht_rates = param->peer_ht_rates.num_rates;
1851         memcpy(ptr, param->peer_ht_rates.rates,
1852                param->peer_ht_rates.num_rates);
1853
1854         /* VHT Rates */
1855         ptr += peer_ht_rates_align;
1856
1857         mcs = ptr;
1858
1859         mcs->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_VHT_RATE_SET) |
1860                           FIELD_PREP(WMI_TLV_LEN, sizeof(*mcs) - TLV_HDR_SIZE);
1861
1862         cmd->peer_nss = param->peer_nss;
1863
1864         /* Update bandwidth-NSS mapping */
1865         cmd->peer_bw_rxnss_override = 0;
1866         cmd->peer_bw_rxnss_override |= param->peer_bw_rxnss_override;
1867
1868         if (param->vht_capable) {
1869                 mcs->rx_max_rate = param->rx_max_rate;
1870                 mcs->rx_mcs_set = param->rx_mcs_set;
1871                 mcs->tx_max_rate = param->tx_max_rate;
1872                 mcs->tx_mcs_set = param->tx_mcs_set;
1873         }
1874
1875         /* HE Rates */
1876         cmd->peer_he_mcs = param->peer_he_mcs_count;
1877         cmd->min_data_rate = param->min_data_rate;
1878
1879         ptr += sizeof(*mcs);
1880
1881         len = param->peer_he_mcs_count * sizeof(*he_mcs);
1882
1883         tlv = ptr;
1884         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
1885                       FIELD_PREP(WMI_TLV_LEN, len);
1886         ptr += TLV_HDR_SIZE;
1887
1888         /* Loop through the HE rate set */
1889         for (i = 0; i < param->peer_he_mcs_count; i++) {
1890                 he_mcs = ptr;
1891                 he_mcs->tlv_header = FIELD_PREP(WMI_TLV_TAG,
1892                                                 WMI_TAG_HE_RATE_SET) |
1893                                      FIELD_PREP(WMI_TLV_LEN,
1894                                                 sizeof(*he_mcs) - TLV_HDR_SIZE);
1895
1896                 he_mcs->rx_mcs_set = param->peer_he_rx_mcs_set[i];
1897                 he_mcs->tx_mcs_set = param->peer_he_tx_mcs_set[i];
1898                 ptr += sizeof(*he_mcs);
1899         }
1900
1901         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_PEER_ASSOC_CMDID);
1902         if (ret) {
1903                 ath11k_warn(ar->ab,
1904                             "failed to send WMI_PEER_ASSOC_CMDID\n");
1905                 dev_kfree_skb(skb);
1906         }
1907
1908         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
1909                    "wmi 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",
1910                    cmd->vdev_id, cmd->peer_associd, param->peer_mac,
1911                    cmd->peer_flags, cmd->peer_rate_caps, cmd->peer_caps,
1912                    cmd->peer_listen_intval, cmd->peer_ht_caps,
1913                    cmd->peer_max_mpdu, cmd->peer_nss, cmd->peer_phymode,
1914                    cmd->peer_mpdu_density,
1915                    cmd->peer_vht_caps, cmd->peer_he_cap_info,
1916                    cmd->peer_he_ops, cmd->peer_he_cap_info_ext,
1917                    cmd->peer_he_cap_phy[0], cmd->peer_he_cap_phy[1],
1918                    cmd->peer_he_cap_phy[2],
1919                    cmd->peer_bw_rxnss_override);
1920
1921         return ret;
1922 }
1923
1924 void ath11k_wmi_start_scan_init(struct ath11k *ar,
1925                                 struct scan_req_params *arg)
1926 {
1927         /* setup commonly used values */
1928         arg->scan_req_id = 1;
1929         arg->scan_priority = WMI_SCAN_PRIORITY_LOW;
1930         arg->dwell_time_active = 50;
1931         arg->dwell_time_active_2g = 0;
1932         arg->dwell_time_passive = 150;
1933         arg->dwell_time_active_6g = 40;
1934         arg->dwell_time_passive_6g = 30;
1935         arg->min_rest_time = 50;
1936         arg->max_rest_time = 500;
1937         arg->repeat_probe_time = 0;
1938         arg->probe_spacing_time = 0;
1939         arg->idle_time = 0;
1940         arg->max_scan_time = 20000;
1941         arg->probe_delay = 5;
1942         arg->notify_scan_events = WMI_SCAN_EVENT_STARTED |
1943                                   WMI_SCAN_EVENT_COMPLETED |
1944                                   WMI_SCAN_EVENT_BSS_CHANNEL |
1945                                   WMI_SCAN_EVENT_FOREIGN_CHAN |
1946                                   WMI_SCAN_EVENT_DEQUEUED;
1947         arg->scan_flags |= WMI_SCAN_CHAN_STAT_EVENT;
1948         arg->num_bssid = 1;
1949 }
1950
1951 static inline void
1952 ath11k_wmi_copy_scan_event_cntrl_flags(struct wmi_start_scan_cmd *cmd,
1953                                        struct scan_req_params *param)
1954 {
1955         /* Scan events subscription */
1956         if (param->scan_ev_started)
1957                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_STARTED;
1958         if (param->scan_ev_completed)
1959                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_COMPLETED;
1960         if (param->scan_ev_bss_chan)
1961                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_BSS_CHANNEL;
1962         if (param->scan_ev_foreign_chan)
1963                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_FOREIGN_CHAN;
1964         if (param->scan_ev_dequeued)
1965                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_DEQUEUED;
1966         if (param->scan_ev_preempted)
1967                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_PREEMPTED;
1968         if (param->scan_ev_start_failed)
1969                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_START_FAILED;
1970         if (param->scan_ev_restarted)
1971                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_RESTARTED;
1972         if (param->scan_ev_foreign_chn_exit)
1973                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_FOREIGN_CHAN_EXIT;
1974         if (param->scan_ev_suspended)
1975                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_SUSPENDED;
1976         if (param->scan_ev_resumed)
1977                 cmd->notify_scan_events |=  WMI_SCAN_EVENT_RESUMED;
1978
1979         /** Set scan control flags */
1980         cmd->scan_ctrl_flags = 0;
1981         if (param->scan_f_passive)
1982                 cmd->scan_ctrl_flags |=  WMI_SCAN_FLAG_PASSIVE;
1983         if (param->scan_f_strict_passive_pch)
1984                 cmd->scan_ctrl_flags |=  WMI_SCAN_FLAG_STRICT_PASSIVE_ON_PCHN;
1985         if (param->scan_f_promisc_mode)
1986                 cmd->scan_ctrl_flags |=  WMI_SCAN_FILTER_PROMISCUOS;
1987         if (param->scan_f_capture_phy_err)
1988                 cmd->scan_ctrl_flags |=  WMI_SCAN_CAPTURE_PHY_ERROR;
1989         if (param->scan_f_half_rate)
1990                 cmd->scan_ctrl_flags |=  WMI_SCAN_FLAG_HALF_RATE_SUPPORT;
1991         if (param->scan_f_quarter_rate)
1992                 cmd->scan_ctrl_flags |=  WMI_SCAN_FLAG_QUARTER_RATE_SUPPORT;
1993         if (param->scan_f_cck_rates)
1994                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_CCK_RATES;
1995         if (param->scan_f_ofdm_rates)
1996                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_OFDM_RATES;
1997         if (param->scan_f_chan_stat_evnt)
1998                 cmd->scan_ctrl_flags |=  WMI_SCAN_CHAN_STAT_EVENT;
1999         if (param->scan_f_filter_prb_req)
2000                 cmd->scan_ctrl_flags |=  WMI_SCAN_FILTER_PROBE_REQ;
2001         if (param->scan_f_bcast_probe)
2002                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_BCAST_PROBE_REQ;
2003         if (param->scan_f_offchan_mgmt_tx)
2004                 cmd->scan_ctrl_flags |=  WMI_SCAN_OFFCHAN_MGMT_TX;
2005         if (param->scan_f_offchan_data_tx)
2006                 cmd->scan_ctrl_flags |=  WMI_SCAN_OFFCHAN_DATA_TX;
2007         if (param->scan_f_force_active_dfs_chn)
2008                 cmd->scan_ctrl_flags |=  WMI_SCAN_FLAG_FORCE_ACTIVE_ON_DFS;
2009         if (param->scan_f_add_tpc_ie_in_probe)
2010                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_TPC_IE_IN_PROBE_REQ;
2011         if (param->scan_f_add_ds_ie_in_probe)
2012                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_DS_IE_IN_PROBE_REQ;
2013         if (param->scan_f_add_spoofed_mac_in_probe)
2014                 cmd->scan_ctrl_flags |=  WMI_SCAN_ADD_SPOOF_MAC_IN_PROBE_REQ;
2015         if (param->scan_f_add_rand_seq_in_probe)
2016                 cmd->scan_ctrl_flags |=  WMI_SCAN_RANDOM_SEQ_NO_IN_PROBE_REQ;
2017         if (param->scan_f_en_ie_whitelist_in_probe)
2018                 cmd->scan_ctrl_flags |=
2019                          WMI_SCAN_ENABLE_IE_WHTELIST_IN_PROBE_REQ;
2020
2021         /* for adaptive scan mode using 3 bits (21 - 23 bits) */
2022         WMI_SCAN_SET_DWELL_MODE(cmd->scan_ctrl_flags,
2023                                 param->adaptive_dwell_time_mode);
2024 }
2025
2026 int ath11k_wmi_send_scan_start_cmd(struct ath11k *ar,
2027                                    struct scan_req_params *params)
2028 {
2029         struct ath11k_pdev_wmi *wmi = ar->wmi;
2030         struct wmi_start_scan_cmd *cmd;
2031         struct wmi_ssid *ssid = NULL;
2032         struct wmi_mac_addr *bssid;
2033         struct sk_buff *skb;
2034         struct wmi_tlv *tlv;
2035         void *ptr;
2036         int i, ret, len;
2037         u32 *tmp_ptr;
2038         u8 extraie_len_with_pad = 0;
2039         struct hint_short_ssid *s_ssid = NULL;
2040         struct hint_bssid *hint_bssid = NULL;
2041
2042         len = sizeof(*cmd);
2043
2044         len += TLV_HDR_SIZE;
2045         if (params->num_chan)
2046                 len += params->num_chan * sizeof(u32);
2047
2048         len += TLV_HDR_SIZE;
2049         if (params->num_ssids)
2050                 len += params->num_ssids * sizeof(*ssid);
2051
2052         len += TLV_HDR_SIZE;
2053         if (params->num_bssid)
2054                 len += sizeof(*bssid) * params->num_bssid;
2055
2056         len += TLV_HDR_SIZE;
2057         if (params->extraie.len)
2058                 extraie_len_with_pad =
2059                         roundup(params->extraie.len, sizeof(u32));
2060         len += extraie_len_with_pad;
2061
2062         if (params->num_hint_bssid)
2063                 len += TLV_HDR_SIZE +
2064                        params->num_hint_bssid * sizeof(struct hint_bssid);
2065
2066         if (params->num_hint_s_ssid)
2067                 len += TLV_HDR_SIZE +
2068                        params->num_hint_s_ssid * sizeof(struct hint_short_ssid);
2069
2070         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2071         if (!skb)
2072                 return -ENOMEM;
2073
2074         ptr = skb->data;
2075
2076         cmd = ptr;
2077         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_START_SCAN_CMD) |
2078                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2079
2080         cmd->scan_id = params->scan_id;
2081         cmd->scan_req_id = params->scan_req_id;
2082         cmd->vdev_id = params->vdev_id;
2083         cmd->scan_priority = params->scan_priority;
2084         cmd->notify_scan_events = params->notify_scan_events;
2085
2086         ath11k_wmi_copy_scan_event_cntrl_flags(cmd, params);
2087
2088         cmd->dwell_time_active = params->dwell_time_active;
2089         cmd->dwell_time_active_2g = params->dwell_time_active_2g;
2090         cmd->dwell_time_passive = params->dwell_time_passive;
2091         cmd->dwell_time_active_6g = params->dwell_time_active_6g;
2092         cmd->dwell_time_passive_6g = params->dwell_time_passive_6g;
2093         cmd->min_rest_time = params->min_rest_time;
2094         cmd->max_rest_time = params->max_rest_time;
2095         cmd->repeat_probe_time = params->repeat_probe_time;
2096         cmd->probe_spacing_time = params->probe_spacing_time;
2097         cmd->idle_time = params->idle_time;
2098         cmd->max_scan_time = params->max_scan_time;
2099         cmd->probe_delay = params->probe_delay;
2100         cmd->burst_duration = params->burst_duration;
2101         cmd->num_chan = params->num_chan;
2102         cmd->num_bssid = params->num_bssid;
2103         cmd->num_ssids = params->num_ssids;
2104         cmd->ie_len = params->extraie.len;
2105         cmd->n_probes = params->n_probes;
2106
2107         ptr += sizeof(*cmd);
2108
2109         len = params->num_chan * sizeof(u32);
2110
2111         tlv = ptr;
2112         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_UINT32) |
2113                       FIELD_PREP(WMI_TLV_LEN, len);
2114         ptr += TLV_HDR_SIZE;
2115         tmp_ptr = (u32 *)ptr;
2116
2117         for (i = 0; i < params->num_chan; ++i)
2118                 tmp_ptr[i] = params->chan_list[i];
2119
2120         ptr += len;
2121
2122         len = params->num_ssids * sizeof(*ssid);
2123         tlv = ptr;
2124         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_FIXED_STRUCT) |
2125                       FIELD_PREP(WMI_TLV_LEN, len);
2126
2127         ptr += TLV_HDR_SIZE;
2128
2129         if (params->num_ssids) {
2130                 ssid = ptr;
2131                 for (i = 0; i < params->num_ssids; ++i) {
2132                         ssid->ssid_len = params->ssid[i].length;
2133                         memcpy(ssid->ssid, params->ssid[i].ssid,
2134                                params->ssid[i].length);
2135                         ssid++;
2136                 }
2137         }
2138
2139         ptr += (params->num_ssids * sizeof(*ssid));
2140         len = params->num_bssid * sizeof(*bssid);
2141         tlv = ptr;
2142         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_FIXED_STRUCT) |
2143                       FIELD_PREP(WMI_TLV_LEN, len);
2144
2145         ptr += TLV_HDR_SIZE;
2146         bssid = ptr;
2147
2148         if (params->num_bssid) {
2149                 for (i = 0; i < params->num_bssid; ++i) {
2150                         ether_addr_copy(bssid->addr,
2151                                         params->bssid_list[i].addr);
2152                         bssid++;
2153                 }
2154         }
2155
2156         ptr += params->num_bssid * sizeof(*bssid);
2157
2158         len = extraie_len_with_pad;
2159         tlv = ptr;
2160         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_BYTE) |
2161                       FIELD_PREP(WMI_TLV_LEN, len);
2162         ptr += TLV_HDR_SIZE;
2163
2164         if (params->extraie.len)
2165                 memcpy(ptr, params->extraie.ptr,
2166                        params->extraie.len);
2167
2168         ptr += extraie_len_with_pad;
2169
2170         if (params->num_hint_s_ssid) {
2171                 len = params->num_hint_s_ssid * sizeof(struct hint_short_ssid);
2172                 tlv = ptr;
2173                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_FIXED_STRUCT) |
2174                               FIELD_PREP(WMI_TLV_LEN, len);
2175                 ptr += TLV_HDR_SIZE;
2176                 s_ssid = ptr;
2177                 for (i = 0; i < params->num_hint_s_ssid; ++i) {
2178                         s_ssid->freq_flags = params->hint_s_ssid[i].freq_flags;
2179                         s_ssid->short_ssid = params->hint_s_ssid[i].short_ssid;
2180                         s_ssid++;
2181                 }
2182                 ptr += len;
2183         }
2184
2185         if (params->num_hint_bssid) {
2186                 len = params->num_hint_bssid * sizeof(struct hint_bssid);
2187                 tlv = ptr;
2188                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_FIXED_STRUCT) |
2189                               FIELD_PREP(WMI_TLV_LEN, len);
2190                 ptr += TLV_HDR_SIZE;
2191                 hint_bssid = ptr;
2192                 for (i = 0; i < params->num_hint_bssid; ++i) {
2193                         hint_bssid->freq_flags =
2194                                 params->hint_bssid[i].freq_flags;
2195                         ether_addr_copy(&params->hint_bssid[i].bssid.addr[0],
2196                                         &hint_bssid->bssid.addr[0]);
2197                         hint_bssid++;
2198                 }
2199         }
2200
2201         len = params->num_hint_s_ssid * sizeof(struct hint_short_ssid);
2202         tlv = ptr;
2203         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_FIXED_STRUCT) |
2204                       FIELD_PREP(WMI_TLV_LEN, len);
2205         ptr += TLV_HDR_SIZE;
2206         if (params->num_hint_s_ssid) {
2207                 s_ssid = ptr;
2208                 for (i = 0; i < params->num_hint_s_ssid; ++i) {
2209                         s_ssid->freq_flags = params->hint_s_ssid[i].freq_flags;
2210                         s_ssid->short_ssid = params->hint_s_ssid[i].short_ssid;
2211                         s_ssid++;
2212                 }
2213         }
2214         ptr += len;
2215
2216         len = params->num_hint_bssid * sizeof(struct hint_bssid);
2217         tlv = ptr;
2218         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_FIXED_STRUCT) |
2219                       FIELD_PREP(WMI_TLV_LEN, len);
2220         ptr += TLV_HDR_SIZE;
2221         if (params->num_hint_bssid) {
2222                 hint_bssid = ptr;
2223                 for (i = 0; i < params->num_hint_bssid; ++i) {
2224                         hint_bssid->freq_flags =
2225                                 params->hint_bssid[i].freq_flags;
2226                         ether_addr_copy(&params->hint_bssid[i].bssid.addr[0],
2227                                         &hint_bssid->bssid.addr[0]);
2228                         hint_bssid++;
2229                 }
2230         }
2231
2232         ret = ath11k_wmi_cmd_send(wmi, skb,
2233                                   WMI_START_SCAN_CMDID);
2234         if (ret) {
2235                 ath11k_warn(ar->ab, "failed to send WMI_START_SCAN_CMDID\n");
2236                 dev_kfree_skb(skb);
2237         }
2238
2239         return ret;
2240 }
2241
2242 int ath11k_wmi_send_scan_stop_cmd(struct ath11k *ar,
2243                                   struct scan_cancel_param *param)
2244 {
2245         struct ath11k_pdev_wmi *wmi = ar->wmi;
2246         struct wmi_stop_scan_cmd *cmd;
2247         struct sk_buff *skb;
2248         int ret;
2249
2250         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2251         if (!skb)
2252                 return -ENOMEM;
2253
2254         cmd = (struct wmi_stop_scan_cmd *)skb->data;
2255
2256         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_STOP_SCAN_CMD) |
2257                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2258
2259         cmd->vdev_id = param->vdev_id;
2260         cmd->requestor = param->requester;
2261         cmd->scan_id = param->scan_id;
2262         cmd->pdev_id = param->pdev_id;
2263         /* stop the scan with the corresponding scan_id */
2264         if (param->req_type == WLAN_SCAN_CANCEL_PDEV_ALL) {
2265                 /* Cancelling all scans */
2266                 cmd->req_type =  WMI_SCAN_STOP_ALL;
2267         } else if (param->req_type == WLAN_SCAN_CANCEL_VDEV_ALL) {
2268                 /* Cancelling VAP scans */
2269                 cmd->req_type =  WMI_SCN_STOP_VAP_ALL;
2270         } else if (param->req_type == WLAN_SCAN_CANCEL_SINGLE) {
2271                 /* Cancelling specific scan */
2272                 cmd->req_type =  WMI_SCAN_STOP_ONE;
2273         } else {
2274                 ath11k_warn(ar->ab, "invalid scan cancel param %d",
2275                             param->req_type);
2276                 dev_kfree_skb(skb);
2277                 return -EINVAL;
2278         }
2279
2280         ret = ath11k_wmi_cmd_send(wmi, skb,
2281                                   WMI_STOP_SCAN_CMDID);
2282         if (ret) {
2283                 ath11k_warn(ar->ab, "failed to send WMI_STOP_SCAN_CMDID\n");
2284                 dev_kfree_skb(skb);
2285         }
2286
2287         return ret;
2288 }
2289
2290 int ath11k_wmi_send_scan_chan_list_cmd(struct ath11k *ar,
2291                                        struct scan_chan_list_params *chan_list)
2292 {
2293         struct ath11k_pdev_wmi *wmi = ar->wmi;
2294         struct wmi_scan_chan_list_cmd *cmd;
2295         struct sk_buff *skb;
2296         struct wmi_channel *chan_info;
2297         struct channel_param *tchan_info;
2298         struct wmi_tlv *tlv;
2299         void *ptr;
2300         int i, ret, len;
2301         u16 num_send_chans, num_sends = 0, max_chan_limit = 0;
2302         u32 *reg1, *reg2;
2303
2304         tchan_info = &chan_list->ch_param[0];
2305         while (chan_list->nallchans) {
2306                 len = sizeof(*cmd) + TLV_HDR_SIZE;
2307                 max_chan_limit = (wmi->wmi_ab->max_msg_len[ar->pdev_idx] - len) /
2308                         sizeof(*chan_info);
2309
2310                 if (chan_list->nallchans > max_chan_limit)
2311                         num_send_chans = max_chan_limit;
2312                 else
2313                         num_send_chans = chan_list->nallchans;
2314
2315                 chan_list->nallchans -= num_send_chans;
2316                 len += sizeof(*chan_info) * num_send_chans;
2317
2318                 skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2319                 if (!skb)
2320                         return -ENOMEM;
2321
2322                 cmd = (struct wmi_scan_chan_list_cmd *)skb->data;
2323                 cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_SCAN_CHAN_LIST_CMD) |
2324                         FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2325                 cmd->pdev_id = chan_list->pdev_id;
2326                 cmd->num_scan_chans = num_send_chans;
2327                 if (num_sends)
2328                         cmd->flags |= WMI_APPEND_TO_EXISTING_CHAN_LIST_FLAG;
2329
2330                 ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2331                            "WMI no.of chan = %d len = %d pdev_id = %d num_sends = %d\n",
2332                            num_send_chans, len, cmd->pdev_id, num_sends);
2333
2334                 ptr = skb->data + sizeof(*cmd);
2335
2336                 len = sizeof(*chan_info) * num_send_chans;
2337                 tlv = ptr;
2338                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
2339                               FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
2340                 ptr += TLV_HDR_SIZE;
2341
2342                 for (i = 0; i < num_send_chans; ++i) {
2343                         chan_info = ptr;
2344                         memset(chan_info, 0, sizeof(*chan_info));
2345                         len = sizeof(*chan_info);
2346                         chan_info->tlv_header = FIELD_PREP(WMI_TLV_TAG,
2347                                                            WMI_TAG_CHANNEL) |
2348                                                 FIELD_PREP(WMI_TLV_LEN,
2349                                                            len - TLV_HDR_SIZE);
2350
2351                         reg1 = &chan_info->reg_info_1;
2352                         reg2 = &chan_info->reg_info_2;
2353                         chan_info->mhz = tchan_info->mhz;
2354                         chan_info->band_center_freq1 = tchan_info->cfreq1;
2355                         chan_info->band_center_freq2 = tchan_info->cfreq2;
2356
2357                         if (tchan_info->is_chan_passive)
2358                                 chan_info->info |= WMI_CHAN_INFO_PASSIVE;
2359                         if (tchan_info->allow_he)
2360                                 chan_info->info |= WMI_CHAN_INFO_ALLOW_HE;
2361                         else if (tchan_info->allow_vht)
2362                                 chan_info->info |= WMI_CHAN_INFO_ALLOW_VHT;
2363                         else if (tchan_info->allow_ht)
2364                                 chan_info->info |= WMI_CHAN_INFO_ALLOW_HT;
2365                         if (tchan_info->half_rate)
2366                                 chan_info->info |= WMI_CHAN_INFO_HALF_RATE;
2367                         if (tchan_info->quarter_rate)
2368                                 chan_info->info |= WMI_CHAN_INFO_QUARTER_RATE;
2369                         if (tchan_info->psc_channel)
2370                                 chan_info->info |= WMI_CHAN_INFO_PSC;
2371
2372                         chan_info->info |= FIELD_PREP(WMI_CHAN_INFO_MODE,
2373                                                       tchan_info->phy_mode);
2374                         *reg1 |= FIELD_PREP(WMI_CHAN_REG_INFO1_MIN_PWR,
2375                                             tchan_info->minpower);
2376                         *reg1 |= FIELD_PREP(WMI_CHAN_REG_INFO1_MAX_PWR,
2377                                             tchan_info->maxpower);
2378                         *reg1 |= FIELD_PREP(WMI_CHAN_REG_INFO1_MAX_REG_PWR,
2379                                             tchan_info->maxregpower);
2380                         *reg1 |= FIELD_PREP(WMI_CHAN_REG_INFO1_REG_CLS,
2381                                             tchan_info->reg_class_id);
2382                         *reg2 |= FIELD_PREP(WMI_CHAN_REG_INFO2_ANT_MAX,
2383                                             tchan_info->antennamax);
2384
2385                         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2386                                    "WMI chan scan list chan[%d] = %u, chan_info->info %8x\n",
2387                                    i, chan_info->mhz, chan_info->info);
2388
2389                         ptr += sizeof(*chan_info);
2390
2391                         tchan_info++;
2392                 }
2393
2394                 ret = ath11k_wmi_cmd_send(wmi, skb, WMI_SCAN_CHAN_LIST_CMDID);
2395                 if (ret) {
2396                         ath11k_warn(ar->ab, "failed to send WMI_SCAN_CHAN_LIST cmd\n");
2397                         dev_kfree_skb(skb);
2398                         return ret;
2399                 }
2400
2401                 num_sends++;
2402         }
2403
2404         return 0;
2405 }
2406
2407 int ath11k_wmi_send_wmm_update_cmd_tlv(struct ath11k *ar, u32 vdev_id,
2408                                        struct wmi_wmm_params_all_arg *param)
2409 {
2410         struct ath11k_pdev_wmi *wmi = ar->wmi;
2411         struct wmi_vdev_set_wmm_params_cmd *cmd;
2412         struct wmi_wmm_params *wmm_param;
2413         struct wmi_wmm_params_arg *wmi_wmm_arg;
2414         struct sk_buff *skb;
2415         int ret, ac;
2416
2417         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2418         if (!skb)
2419                 return -ENOMEM;
2420
2421         cmd = (struct wmi_vdev_set_wmm_params_cmd *)skb->data;
2422         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
2423                                      WMI_TAG_VDEV_SET_WMM_PARAMS_CMD) |
2424                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2425
2426         cmd->vdev_id = vdev_id;
2427         cmd->wmm_param_type = 0;
2428
2429         for (ac = 0; ac < WME_NUM_AC; ac++) {
2430                 switch (ac) {
2431                 case WME_AC_BE:
2432                         wmi_wmm_arg = &param->ac_be;
2433                         break;
2434                 case WME_AC_BK:
2435                         wmi_wmm_arg = &param->ac_bk;
2436                         break;
2437                 case WME_AC_VI:
2438                         wmi_wmm_arg = &param->ac_vi;
2439                         break;
2440                 case WME_AC_VO:
2441                         wmi_wmm_arg = &param->ac_vo;
2442                         break;
2443                 }
2444
2445                 wmm_param = (struct wmi_wmm_params *)&cmd->wmm_params[ac];
2446                 wmm_param->tlv_header =
2447                                 FIELD_PREP(WMI_TLV_TAG,
2448                                            WMI_TAG_VDEV_SET_WMM_PARAMS_CMD) |
2449                                 FIELD_PREP(WMI_TLV_LEN,
2450                                            sizeof(*wmm_param) - TLV_HDR_SIZE);
2451
2452                 wmm_param->aifs = wmi_wmm_arg->aifs;
2453                 wmm_param->cwmin = wmi_wmm_arg->cwmin;
2454                 wmm_param->cwmax = wmi_wmm_arg->cwmax;
2455                 wmm_param->txoplimit = wmi_wmm_arg->txop;
2456                 wmm_param->acm = wmi_wmm_arg->acm;
2457                 wmm_param->no_ack = wmi_wmm_arg->no_ack;
2458
2459                 ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2460                            "wmi wmm set ac %d aifs %d cwmin %d cwmax %d txop %d acm %d no_ack %d\n",
2461                            ac, wmm_param->aifs, wmm_param->cwmin,
2462                            wmm_param->cwmax, wmm_param->txoplimit,
2463                            wmm_param->acm, wmm_param->no_ack);
2464         }
2465         ret = ath11k_wmi_cmd_send(wmi, skb,
2466                                   WMI_VDEV_SET_WMM_PARAMS_CMDID);
2467         if (ret) {
2468                 ath11k_warn(ar->ab,
2469                             "failed to send WMI_VDEV_SET_WMM_PARAMS_CMDID");
2470                 dev_kfree_skb(skb);
2471         }
2472
2473         return ret;
2474 }
2475
2476 int ath11k_wmi_send_dfs_phyerr_offload_enable_cmd(struct ath11k *ar,
2477                                                   u32 pdev_id)
2478 {
2479         struct ath11k_pdev_wmi *wmi = ar->wmi;
2480         struct wmi_dfs_phyerr_offload_cmd *cmd;
2481         struct sk_buff *skb;
2482         int ret;
2483
2484         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2485         if (!skb)
2486                 return -ENOMEM;
2487
2488         cmd = (struct wmi_dfs_phyerr_offload_cmd *)skb->data;
2489         cmd->tlv_header =
2490                 FIELD_PREP(WMI_TLV_TAG,
2491                            WMI_TAG_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMD) |
2492                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2493
2494         cmd->pdev_id = pdev_id;
2495
2496         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2497                    "WMI dfs phy err offload enable pdev id %d\n", pdev_id);
2498
2499         ret = ath11k_wmi_cmd_send(wmi, skb,
2500                                   WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE_CMDID);
2501         if (ret) {
2502                 ath11k_warn(ar->ab,
2503                             "failed to send WMI_PDEV_DFS_PHYERR_OFFLOAD_ENABLE cmd\n");
2504                 dev_kfree_skb(skb);
2505         }
2506
2507         return ret;
2508 }
2509
2510 int ath11k_wmi_delba_send(struct ath11k *ar, u32 vdev_id, const u8 *mac,
2511                           u32 tid, u32 initiator, u32 reason)
2512 {
2513         struct ath11k_pdev_wmi *wmi = ar->wmi;
2514         struct wmi_delba_send_cmd *cmd;
2515         struct sk_buff *skb;
2516         int ret;
2517
2518         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2519         if (!skb)
2520                 return -ENOMEM;
2521
2522         cmd = (struct wmi_delba_send_cmd *)skb->data;
2523         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_DELBA_SEND_CMD) |
2524                         FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2525         cmd->vdev_id = vdev_id;
2526         ether_addr_copy(cmd->peer_macaddr.addr, mac);
2527         cmd->tid = tid;
2528         cmd->initiator = initiator;
2529         cmd->reasoncode = reason;
2530
2531         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2532                    "wmi delba send vdev_id 0x%X mac_addr %pM tid %u initiator %u reason %u\n",
2533                    vdev_id, mac, tid, initiator, reason);
2534
2535         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_DELBA_SEND_CMDID);
2536
2537         if (ret) {
2538                 ath11k_warn(ar->ab,
2539                             "failed to send WMI_DELBA_SEND_CMDID cmd\n");
2540                 dev_kfree_skb(skb);
2541         }
2542
2543         return ret;
2544 }
2545
2546 int ath11k_wmi_addba_set_resp(struct ath11k *ar, u32 vdev_id, const u8 *mac,
2547                               u32 tid, u32 status)
2548 {
2549         struct ath11k_pdev_wmi *wmi = ar->wmi;
2550         struct wmi_addba_setresponse_cmd *cmd;
2551         struct sk_buff *skb;
2552         int ret;
2553
2554         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2555         if (!skb)
2556                 return -ENOMEM;
2557
2558         cmd = (struct wmi_addba_setresponse_cmd *)skb->data;
2559         cmd->tlv_header =
2560                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ADDBA_SETRESPONSE_CMD) |
2561                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2562         cmd->vdev_id = vdev_id;
2563         ether_addr_copy(cmd->peer_macaddr.addr, mac);
2564         cmd->tid = tid;
2565         cmd->statuscode = status;
2566
2567         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2568                    "wmi addba set resp vdev_id 0x%X mac_addr %pM tid %u status %u\n",
2569                    vdev_id, mac, tid, status);
2570
2571         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_ADDBA_SET_RESP_CMDID);
2572
2573         if (ret) {
2574                 ath11k_warn(ar->ab,
2575                             "failed to send WMI_ADDBA_SET_RESP_CMDID cmd\n");
2576                 dev_kfree_skb(skb);
2577         }
2578
2579         return ret;
2580 }
2581
2582 int ath11k_wmi_addba_send(struct ath11k *ar, u32 vdev_id, const u8 *mac,
2583                           u32 tid, u32 buf_size)
2584 {
2585         struct ath11k_pdev_wmi *wmi = ar->wmi;
2586         struct wmi_addba_send_cmd *cmd;
2587         struct sk_buff *skb;
2588         int ret;
2589
2590         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2591         if (!skb)
2592                 return -ENOMEM;
2593
2594         cmd = (struct wmi_addba_send_cmd *)skb->data;
2595         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ADDBA_SEND_CMD) |
2596                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2597         cmd->vdev_id = vdev_id;
2598         ether_addr_copy(cmd->peer_macaddr.addr, mac);
2599         cmd->tid = tid;
2600         cmd->buffersize = buf_size;
2601
2602         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2603                    "wmi addba send vdev_id 0x%X mac_addr %pM tid %u bufsize %u\n",
2604                    vdev_id, mac, tid, buf_size);
2605
2606         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_ADDBA_SEND_CMDID);
2607
2608         if (ret) {
2609                 ath11k_warn(ar->ab,
2610                             "failed to send WMI_ADDBA_SEND_CMDID cmd\n");
2611                 dev_kfree_skb(skb);
2612         }
2613
2614         return ret;
2615 }
2616
2617 int ath11k_wmi_addba_clear_resp(struct ath11k *ar, u32 vdev_id, const u8 *mac)
2618 {
2619         struct ath11k_pdev_wmi *wmi = ar->wmi;
2620         struct wmi_addba_clear_resp_cmd *cmd;
2621         struct sk_buff *skb;
2622         int ret;
2623
2624         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2625         if (!skb)
2626                 return -ENOMEM;
2627
2628         cmd = (struct wmi_addba_clear_resp_cmd *)skb->data;
2629         cmd->tlv_header =
2630                 FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ADDBA_CLEAR_RESP_CMD) |
2631                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2632         cmd->vdev_id = vdev_id;
2633         ether_addr_copy(cmd->peer_macaddr.addr, mac);
2634
2635         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2636                    "wmi addba clear resp vdev_id 0x%X mac_addr %pM\n",
2637                    vdev_id, mac);
2638
2639         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_ADDBA_CLEAR_RESP_CMDID);
2640
2641         if (ret) {
2642                 ath11k_warn(ar->ab,
2643                             "failed to send WMI_ADDBA_CLEAR_RESP_CMDID cmd\n");
2644                 dev_kfree_skb(skb);
2645         }
2646
2647         return ret;
2648 }
2649
2650 int ath11k_wmi_pdev_peer_pktlog_filter(struct ath11k *ar, u8 *addr, u8 enable)
2651 {
2652         struct ath11k_pdev_wmi *wmi = ar->wmi;
2653         struct wmi_pdev_pktlog_filter_cmd *cmd;
2654         struct wmi_pdev_pktlog_filter_info *info;
2655         struct sk_buff *skb;
2656         struct wmi_tlv *tlv;
2657         void *ptr;
2658         int ret, len;
2659
2660         len = sizeof(*cmd) + sizeof(*info) + TLV_HDR_SIZE;
2661         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2662         if (!skb)
2663                 return -ENOMEM;
2664
2665         cmd = (struct wmi_pdev_pktlog_filter_cmd *)skb->data;
2666
2667         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_PEER_PKTLOG_FILTER_CMD) |
2668                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2669
2670         cmd->pdev_id = DP_HW2SW_MACID(ar->pdev->pdev_id);
2671         cmd->num_mac = 1;
2672         cmd->enable = enable;
2673
2674         ptr = skb->data + sizeof(*cmd);
2675
2676         tlv = ptr;
2677         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
2678                       FIELD_PREP(WMI_TLV_LEN, sizeof(*info));
2679
2680         ptr += TLV_HDR_SIZE;
2681         info = ptr;
2682
2683         ether_addr_copy(info->peer_macaddr.addr, addr);
2684         info->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_PEER_PKTLOG_FILTER_INFO) |
2685                            FIELD_PREP(WMI_TLV_LEN,
2686                                       sizeof(*info) - TLV_HDR_SIZE);
2687
2688         ret = ath11k_wmi_cmd_send(wmi, skb,
2689                                   WMI_PDEV_PKTLOG_FILTER_CMDID);
2690         if (ret) {
2691                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_PKTLOG_ENABLE_CMDID\n");
2692                 dev_kfree_skb(skb);
2693         }
2694
2695         return ret;
2696 }
2697
2698 int
2699 ath11k_wmi_send_init_country_cmd(struct ath11k *ar,
2700                                  struct wmi_init_country_params init_cc_params)
2701 {
2702         struct ath11k_pdev_wmi *wmi = ar->wmi;
2703         struct wmi_init_country_cmd *cmd;
2704         struct sk_buff *skb;
2705         int ret;
2706
2707         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2708         if (!skb)
2709                 return -ENOMEM;
2710
2711         cmd = (struct wmi_init_country_cmd *)skb->data;
2712         cmd->tlv_header =
2713                 FIELD_PREP(WMI_TLV_TAG,
2714                            WMI_TAG_SET_INIT_COUNTRY_CMD) |
2715                 FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2716
2717         cmd->pdev_id = ar->pdev->pdev_id;
2718
2719         switch (init_cc_params.flags) {
2720         case ALPHA_IS_SET:
2721                 cmd->init_cc_type = WMI_COUNTRY_INFO_TYPE_ALPHA;
2722                 memcpy((u8 *)&cmd->cc_info.alpha2,
2723                        init_cc_params.cc_info.alpha2, 3);
2724                 break;
2725         case CC_IS_SET:
2726                 cmd->init_cc_type = WMI_COUNTRY_INFO_TYPE_COUNTRY_CODE;
2727                 cmd->cc_info.country_code = init_cc_params.cc_info.country_code;
2728                 break;
2729         case REGDMN_IS_SET:
2730                 cmd->init_cc_type = WMI_COUNTRY_INFO_TYPE_REGDOMAIN;
2731                 cmd->cc_info.regdom_id = init_cc_params.cc_info.regdom_id;
2732                 break;
2733         default:
2734                 ret = -EINVAL;
2735                 goto out;
2736         }
2737
2738         ret = ath11k_wmi_cmd_send(wmi, skb,
2739                                   WMI_SET_INIT_COUNTRY_CMDID);
2740
2741 out:
2742         if (ret) {
2743                 ath11k_warn(ar->ab,
2744                             "failed to send WMI_SET_INIT_COUNTRY CMD :%d\n",
2745                             ret);
2746                 dev_kfree_skb(skb);
2747         }
2748
2749         return ret;
2750 }
2751
2752 int
2753 ath11k_wmi_send_thermal_mitigation_param_cmd(struct ath11k *ar,
2754                                              struct thermal_mitigation_params *param)
2755 {
2756         struct ath11k_pdev_wmi *wmi = ar->wmi;
2757         struct wmi_therm_throt_config_request_cmd *cmd;
2758         struct wmi_therm_throt_level_config_info *lvl_conf;
2759         struct wmi_tlv *tlv;
2760         struct sk_buff *skb;
2761         int i, ret, len;
2762
2763         len = sizeof(*cmd) + TLV_HDR_SIZE +
2764               THERMAL_LEVELS * sizeof(struct wmi_therm_throt_level_config_info);
2765
2766         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2767         if (!skb)
2768                 return -ENOMEM;
2769
2770         cmd = (struct wmi_therm_throt_config_request_cmd *)skb->data;
2771
2772         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_THERM_THROT_CONFIG_REQUEST) |
2773                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2774
2775         cmd->pdev_id = ar->pdev->pdev_id;
2776         cmd->enable = param->enable;
2777         cmd->dc = param->dc;
2778         cmd->dc_per_event = param->dc_per_event;
2779         cmd->therm_throt_levels = THERMAL_LEVELS;
2780
2781         tlv = (struct wmi_tlv *)(skb->data + sizeof(*cmd));
2782         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
2783                       FIELD_PREP(WMI_TLV_LEN,
2784                                  (THERMAL_LEVELS *
2785                                   sizeof(struct wmi_therm_throt_level_config_info)));
2786
2787         lvl_conf = (struct wmi_therm_throt_level_config_info *)(skb->data +
2788                                                                 sizeof(*cmd) +
2789                                                                 TLV_HDR_SIZE);
2790         for (i = 0; i < THERMAL_LEVELS; i++) {
2791                 lvl_conf->tlv_header =
2792                         FIELD_PREP(WMI_TLV_TAG, WMI_TAG_THERM_THROT_LEVEL_CONFIG_INFO) |
2793                         FIELD_PREP(WMI_TLV_LEN, sizeof(*lvl_conf) - TLV_HDR_SIZE);
2794
2795                 lvl_conf->temp_lwm = param->levelconf[i].tmplwm;
2796                 lvl_conf->temp_hwm = param->levelconf[i].tmphwm;
2797                 lvl_conf->dc_off_percent = param->levelconf[i].dcoffpercent;
2798                 lvl_conf->prio = param->levelconf[i].priority;
2799                 lvl_conf++;
2800         }
2801
2802         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_THERM_THROT_SET_CONF_CMDID);
2803         if (ret) {
2804                 ath11k_warn(ar->ab, "failed to send THERM_THROT_SET_CONF cmd\n");
2805                 dev_kfree_skb(skb);
2806         }
2807
2808         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
2809                    "WMI vdev set thermal throt pdev_id %d enable %d dc %d dc_per_event %x levels %d\n",
2810                    ar->pdev->pdev_id, param->enable, param->dc,
2811                    param->dc_per_event, THERMAL_LEVELS);
2812
2813         return ret;
2814 }
2815
2816 int ath11k_wmi_pdev_pktlog_enable(struct ath11k *ar, u32 pktlog_filter)
2817 {
2818         struct ath11k_pdev_wmi *wmi = ar->wmi;
2819         struct wmi_pktlog_enable_cmd *cmd;
2820         struct sk_buff *skb;
2821         int ret;
2822
2823         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2824         if (!skb)
2825                 return -ENOMEM;
2826
2827         cmd = (struct wmi_pktlog_enable_cmd *)skb->data;
2828
2829         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_PKTLOG_ENABLE_CMD) |
2830                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2831
2832         cmd->pdev_id = DP_HW2SW_MACID(ar->pdev->pdev_id);
2833         cmd->evlist = pktlog_filter;
2834         cmd->enable = ATH11K_WMI_PKTLOG_ENABLE_FORCE;
2835
2836         ret = ath11k_wmi_cmd_send(wmi, skb,
2837                                   WMI_PDEV_PKTLOG_ENABLE_CMDID);
2838         if (ret) {
2839                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_PKTLOG_ENABLE_CMDID\n");
2840                 dev_kfree_skb(skb);
2841         }
2842
2843         return ret;
2844 }
2845
2846 int ath11k_wmi_pdev_pktlog_disable(struct ath11k *ar)
2847 {
2848         struct ath11k_pdev_wmi *wmi = ar->wmi;
2849         struct wmi_pktlog_disable_cmd *cmd;
2850         struct sk_buff *skb;
2851         int ret;
2852
2853         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, sizeof(*cmd));
2854         if (!skb)
2855                 return -ENOMEM;
2856
2857         cmd = (struct wmi_pktlog_disable_cmd *)skb->data;
2858
2859         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_PDEV_PKTLOG_DISABLE_CMD) |
2860                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
2861
2862         cmd->pdev_id = DP_HW2SW_MACID(ar->pdev->pdev_id);
2863
2864         ret = ath11k_wmi_cmd_send(wmi, skb,
2865                                   WMI_PDEV_PKTLOG_DISABLE_CMDID);
2866         if (ret) {
2867                 ath11k_warn(ar->ab, "failed to send WMI_PDEV_PKTLOG_ENABLE_CMDID\n");
2868                 dev_kfree_skb(skb);
2869         }
2870
2871         return ret;
2872 }
2873
2874 int
2875 ath11k_wmi_send_twt_enable_cmd(struct ath11k *ar, u32 pdev_id)
2876 {
2877         struct ath11k_pdev_wmi *wmi = ar->wmi;
2878         struct ath11k_base *ab = wmi->wmi_ab->ab;
2879         struct wmi_twt_enable_params_cmd *cmd;
2880         struct sk_buff *skb;
2881         int ret, len;
2882
2883         len = sizeof(*cmd);
2884
2885         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2886         if (!skb)
2887                 return -ENOMEM;
2888
2889         cmd = (struct wmi_twt_enable_params_cmd *)skb->data;
2890         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_TWT_ENABLE_CMD) |
2891                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
2892         cmd->pdev_id = pdev_id;
2893         cmd->sta_cong_timer_ms = ATH11K_TWT_DEF_STA_CONG_TIMER_MS;
2894         cmd->default_slot_size = ATH11K_TWT_DEF_DEFAULT_SLOT_SIZE;
2895         cmd->congestion_thresh_setup = ATH11K_TWT_DEF_CONGESTION_THRESH_SETUP;
2896         cmd->congestion_thresh_teardown =
2897                 ATH11K_TWT_DEF_CONGESTION_THRESH_TEARDOWN;
2898         cmd->congestion_thresh_critical =
2899                 ATH11K_TWT_DEF_CONGESTION_THRESH_CRITICAL;
2900         cmd->interference_thresh_teardown =
2901                 ATH11K_TWT_DEF_INTERFERENCE_THRESH_TEARDOWN;
2902         cmd->interference_thresh_setup =
2903                 ATH11K_TWT_DEF_INTERFERENCE_THRESH_SETUP;
2904         cmd->min_no_sta_setup = ATH11K_TWT_DEF_MIN_NO_STA_SETUP;
2905         cmd->min_no_sta_teardown = ATH11K_TWT_DEF_MIN_NO_STA_TEARDOWN;
2906         cmd->no_of_bcast_mcast_slots = ATH11K_TWT_DEF_NO_OF_BCAST_MCAST_SLOTS;
2907         cmd->min_no_twt_slots = ATH11K_TWT_DEF_MIN_NO_TWT_SLOTS;
2908         cmd->max_no_sta_twt = ATH11K_TWT_DEF_MAX_NO_STA_TWT;
2909         cmd->mode_check_interval = ATH11K_TWT_DEF_MODE_CHECK_INTERVAL;
2910         cmd->add_sta_slot_interval = ATH11K_TWT_DEF_ADD_STA_SLOT_INTERVAL;
2911         cmd->remove_sta_slot_interval =
2912                 ATH11K_TWT_DEF_REMOVE_STA_SLOT_INTERVAL;
2913         /* TODO add MBSSID support */
2914         cmd->mbss_support = 0;
2915
2916         ret = ath11k_wmi_cmd_send(wmi, skb,
2917                                   WMI_TWT_ENABLE_CMDID);
2918         if (ret) {
2919                 ath11k_warn(ab, "Failed to send WMI_TWT_ENABLE_CMDID");
2920                 dev_kfree_skb(skb);
2921         }
2922         return ret;
2923 }
2924
2925 int
2926 ath11k_wmi_send_twt_disable_cmd(struct ath11k *ar, u32 pdev_id)
2927 {
2928         struct ath11k_pdev_wmi *wmi = ar->wmi;
2929         struct ath11k_base *ab = wmi->wmi_ab->ab;
2930         struct wmi_twt_disable_params_cmd *cmd;
2931         struct sk_buff *skb;
2932         int ret, len;
2933
2934         len = sizeof(*cmd);
2935
2936         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2937         if (!skb)
2938                 return -ENOMEM;
2939
2940         cmd = (struct wmi_twt_disable_params_cmd *)skb->data;
2941         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_TWT_DISABLE_CMD) |
2942                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
2943         cmd->pdev_id = pdev_id;
2944
2945         ret = ath11k_wmi_cmd_send(wmi, skb,
2946                                   WMI_TWT_DISABLE_CMDID);
2947         if (ret) {
2948                 ath11k_warn(ab, "Failed to send WMI_TWT_DISABLE_CMDID");
2949                 dev_kfree_skb(skb);
2950         }
2951         return ret;
2952 }
2953
2954 int
2955 ath11k_wmi_send_obss_spr_cmd(struct ath11k *ar, u32 vdev_id,
2956                              struct ieee80211_he_obss_pd *he_obss_pd)
2957 {
2958         struct ath11k_pdev_wmi *wmi = ar->wmi;
2959         struct ath11k_base *ab = wmi->wmi_ab->ab;
2960         struct wmi_obss_spatial_reuse_params_cmd *cmd;
2961         struct sk_buff *skb;
2962         int ret, len;
2963
2964         len = sizeof(*cmd);
2965
2966         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
2967         if (!skb)
2968                 return -ENOMEM;
2969
2970         cmd = (struct wmi_obss_spatial_reuse_params_cmd *)skb->data;
2971         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
2972                                      WMI_TAG_OBSS_SPATIAL_REUSE_SET_CMD) |
2973                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
2974         cmd->vdev_id = vdev_id;
2975         cmd->enable = he_obss_pd->enable;
2976         cmd->obss_min = he_obss_pd->min_offset;
2977         cmd->obss_max = he_obss_pd->max_offset;
2978
2979         ret = ath11k_wmi_cmd_send(wmi, skb,
2980                                   WMI_PDEV_OBSS_PD_SPATIAL_REUSE_CMDID);
2981         if (ret) {
2982                 ath11k_warn(ab,
2983                             "Failed to send WMI_PDEV_OBSS_PD_SPATIAL_REUSE_CMDID");
2984                 dev_kfree_skb(skb);
2985         }
2986         return ret;
2987 }
2988
2989 int
2990 ath11k_wmi_send_obss_color_collision_cfg_cmd(struct ath11k *ar, u32 vdev_id,
2991                                              u8 bss_color, u32 period,
2992                                              bool enable)
2993 {
2994         struct ath11k_pdev_wmi *wmi = ar->wmi;
2995         struct ath11k_base *ab = wmi->wmi_ab->ab;
2996         struct wmi_obss_color_collision_cfg_params_cmd *cmd;
2997         struct sk_buff *skb;
2998         int ret, len;
2999
3000         len = sizeof(*cmd);
3001
3002         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3003         if (!skb)
3004                 return -ENOMEM;
3005
3006         cmd = (struct wmi_obss_color_collision_cfg_params_cmd *)skb->data;
3007         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3008                                      WMI_TAG_OBSS_COLOR_COLLISION_DET_CONFIG) |
3009                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3010         cmd->vdev_id = vdev_id;
3011         cmd->evt_type = enable ? ATH11K_OBSS_COLOR_COLLISION_DETECTION :
3012                                  ATH11K_OBSS_COLOR_COLLISION_DETECTION_DISABLE;
3013         cmd->current_bss_color = bss_color;
3014         cmd->detection_period_ms = period;
3015         cmd->scan_period_ms = ATH11K_BSS_COLOR_COLLISION_SCAN_PERIOD_MS;
3016         cmd->free_slot_expiry_time_ms = 0;
3017         cmd->flags = 0;
3018
3019         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3020                    "wmi_send_obss_color_collision_cfg id %d type %d bss_color %d detect_period %d scan_period %d\n",
3021                    cmd->vdev_id, cmd->evt_type, cmd->current_bss_color,
3022                    cmd->detection_period_ms, cmd->scan_period_ms);
3023
3024         ret = ath11k_wmi_cmd_send(wmi, skb,
3025                                   WMI_OBSS_COLOR_COLLISION_DET_CONFIG_CMDID);
3026         if (ret) {
3027                 ath11k_warn(ab, "Failed to send WMI_OBSS_COLOR_COLLISION_DET_CONFIG_CMDID");
3028                 dev_kfree_skb(skb);
3029         }
3030         return ret;
3031 }
3032
3033 int ath11k_wmi_send_bss_color_change_enable_cmd(struct ath11k *ar, u32 vdev_id,
3034                                                 bool enable)
3035 {
3036         struct ath11k_pdev_wmi *wmi = ar->wmi;
3037         struct ath11k_base *ab = wmi->wmi_ab->ab;
3038         struct wmi_bss_color_change_enable_params_cmd *cmd;
3039         struct sk_buff *skb;
3040         int ret, len;
3041
3042         len = sizeof(*cmd);
3043
3044         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3045         if (!skb)
3046                 return -ENOMEM;
3047
3048         cmd = (struct wmi_bss_color_change_enable_params_cmd *)skb->data;
3049         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_BSS_COLOR_CHANGE_ENABLE) |
3050                           FIELD_PREP(WMI_TLV_LEN, len - TLV_HDR_SIZE);
3051         cmd->vdev_id = vdev_id;
3052         cmd->enable = enable ? 1 : 0;
3053
3054         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3055                    "wmi_send_bss_color_change_enable id %d enable %d\n",
3056                    cmd->vdev_id, cmd->enable);
3057
3058         ret = ath11k_wmi_cmd_send(wmi, skb,
3059                                   WMI_BSS_COLOR_CHANGE_ENABLE_CMDID);
3060         if (ret) {
3061                 ath11k_warn(ab, "Failed to send WMI_BSS_COLOR_CHANGE_ENABLE_CMDID");
3062                 dev_kfree_skb(skb);
3063         }
3064         return ret;
3065 }
3066
3067 static void
3068 ath11k_fill_band_to_mac_param(struct ath11k_base  *soc,
3069                               struct wmi_host_pdev_band_to_mac *band_to_mac)
3070 {
3071         u8 i;
3072         struct ath11k_hal_reg_capabilities_ext *hal_reg_cap;
3073         struct ath11k_pdev *pdev;
3074
3075         for (i = 0; i < soc->num_radios; i++) {
3076                 pdev = &soc->pdevs[i];
3077                 hal_reg_cap = &soc->hal_reg_cap[i];
3078                 band_to_mac[i].pdev_id = pdev->pdev_id;
3079
3080                 switch (pdev->cap.supported_bands) {
3081                 case WMI_HOST_WLAN_2G_5G_CAP:
3082                         band_to_mac[i].start_freq = hal_reg_cap->low_2ghz_chan;
3083                         band_to_mac[i].end_freq = hal_reg_cap->high_5ghz_chan;
3084                         break;
3085                 case WMI_HOST_WLAN_2G_CAP:
3086                         band_to_mac[i].start_freq = hal_reg_cap->low_2ghz_chan;
3087                         band_to_mac[i].end_freq = hal_reg_cap->high_2ghz_chan;
3088                         break;
3089                 case WMI_HOST_WLAN_5G_CAP:
3090                         band_to_mac[i].start_freq = hal_reg_cap->low_5ghz_chan;
3091                         band_to_mac[i].end_freq = hal_reg_cap->high_5ghz_chan;
3092                         break;
3093                 default:
3094                         break;
3095                 }
3096         }
3097 }
3098
3099 static void
3100 ath11k_wmi_copy_resource_config(struct wmi_resource_config *wmi_cfg,
3101                                 struct target_resource_config *tg_cfg)
3102 {
3103         wmi_cfg->num_vdevs = tg_cfg->num_vdevs;
3104         wmi_cfg->num_peers = tg_cfg->num_peers;
3105         wmi_cfg->num_offload_peers = tg_cfg->num_offload_peers;
3106         wmi_cfg->num_offload_reorder_buffs = tg_cfg->num_offload_reorder_buffs;
3107         wmi_cfg->num_peer_keys = tg_cfg->num_peer_keys;
3108         wmi_cfg->num_tids = tg_cfg->num_tids;
3109         wmi_cfg->ast_skid_limit = tg_cfg->ast_skid_limit;
3110         wmi_cfg->tx_chain_mask = tg_cfg->tx_chain_mask;
3111         wmi_cfg->rx_chain_mask = tg_cfg->rx_chain_mask;
3112         wmi_cfg->rx_timeout_pri[0] = tg_cfg->rx_timeout_pri[0];
3113         wmi_cfg->rx_timeout_pri[1] = tg_cfg->rx_timeout_pri[1];
3114         wmi_cfg->rx_timeout_pri[2] = tg_cfg->rx_timeout_pri[2];
3115         wmi_cfg->rx_timeout_pri[3] = tg_cfg->rx_timeout_pri[3];
3116         wmi_cfg->rx_decap_mode = tg_cfg->rx_decap_mode;
3117         wmi_cfg->scan_max_pending_req = tg_cfg->scan_max_pending_req;
3118         wmi_cfg->bmiss_offload_max_vdev = tg_cfg->bmiss_offload_max_vdev;
3119         wmi_cfg->roam_offload_max_vdev = tg_cfg->roam_offload_max_vdev;
3120         wmi_cfg->roam_offload_max_ap_profiles =
3121                 tg_cfg->roam_offload_max_ap_profiles;
3122         wmi_cfg->num_mcast_groups = tg_cfg->num_mcast_groups;
3123         wmi_cfg->num_mcast_table_elems = tg_cfg->num_mcast_table_elems;
3124         wmi_cfg->mcast2ucast_mode = tg_cfg->mcast2ucast_mode;
3125         wmi_cfg->tx_dbg_log_size = tg_cfg->tx_dbg_log_size;
3126         wmi_cfg->num_wds_entries = tg_cfg->num_wds_entries;
3127         wmi_cfg->dma_burst_size = tg_cfg->dma_burst_size;
3128         wmi_cfg->mac_aggr_delim = tg_cfg->mac_aggr_delim;
3129         wmi_cfg->rx_skip_defrag_timeout_dup_detection_check =
3130                 tg_cfg->rx_skip_defrag_timeout_dup_detection_check;
3131         wmi_cfg->vow_config = tg_cfg->vow_config;
3132         wmi_cfg->gtk_offload_max_vdev = tg_cfg->gtk_offload_max_vdev;
3133         wmi_cfg->num_msdu_desc = tg_cfg->num_msdu_desc;
3134         wmi_cfg->max_frag_entries = tg_cfg->max_frag_entries;
3135         wmi_cfg->num_tdls_vdevs = tg_cfg->num_tdls_vdevs;
3136         wmi_cfg->num_tdls_conn_table_entries =
3137                 tg_cfg->num_tdls_conn_table_entries;
3138         wmi_cfg->beacon_tx_offload_max_vdev =
3139                 tg_cfg->beacon_tx_offload_max_vdev;
3140         wmi_cfg->num_multicast_filter_entries =
3141                 tg_cfg->num_multicast_filter_entries;
3142         wmi_cfg->num_wow_filters = tg_cfg->num_wow_filters;
3143         wmi_cfg->num_keep_alive_pattern = tg_cfg->num_keep_alive_pattern;
3144         wmi_cfg->keep_alive_pattern_size = tg_cfg->keep_alive_pattern_size;
3145         wmi_cfg->max_tdls_concurrent_sleep_sta =
3146                 tg_cfg->max_tdls_concurrent_sleep_sta;
3147         wmi_cfg->max_tdls_concurrent_buffer_sta =
3148                 tg_cfg->max_tdls_concurrent_buffer_sta;
3149         wmi_cfg->wmi_send_separate = tg_cfg->wmi_send_separate;
3150         wmi_cfg->num_ocb_vdevs = tg_cfg->num_ocb_vdevs;
3151         wmi_cfg->num_ocb_channels = tg_cfg->num_ocb_channels;
3152         wmi_cfg->num_ocb_schedules = tg_cfg->num_ocb_schedules;
3153         wmi_cfg->bpf_instruction_size = tg_cfg->bpf_instruction_size;
3154         wmi_cfg->max_bssid_rx_filters = tg_cfg->max_bssid_rx_filters;
3155         wmi_cfg->use_pdev_id = tg_cfg->use_pdev_id;
3156         wmi_cfg->flag1 = tg_cfg->atf_config;
3157         wmi_cfg->peer_map_unmap_v2_support = tg_cfg->peer_map_unmap_v2_support;
3158         wmi_cfg->sched_params = tg_cfg->sched_params;
3159         wmi_cfg->twt_ap_pdev_count = tg_cfg->twt_ap_pdev_count;
3160         wmi_cfg->twt_ap_sta_count = tg_cfg->twt_ap_sta_count;
3161 }
3162
3163 static int ath11k_init_cmd_send(struct ath11k_pdev_wmi *wmi,
3164                                 struct wmi_init_cmd_param *param)
3165 {
3166         struct ath11k_base *ab = wmi->wmi_ab->ab;
3167         struct sk_buff *skb;
3168         struct wmi_init_cmd *cmd;
3169         struct wmi_resource_config *cfg;
3170         struct wmi_pdev_set_hw_mode_cmd_param *hw_mode;
3171         struct wmi_pdev_band_to_mac *band_to_mac;
3172         struct wlan_host_mem_chunk *host_mem_chunks;
3173         struct wmi_tlv *tlv;
3174         size_t ret, len;
3175         void *ptr;
3176         u32 hw_mode_len = 0;
3177         u16 idx;
3178
3179         if (param->hw_mode_id != WMI_HOST_HW_MODE_MAX)
3180                 hw_mode_len = sizeof(*hw_mode) + TLV_HDR_SIZE +
3181                               (param->num_band_to_mac * sizeof(*band_to_mac));
3182
3183         len = sizeof(*cmd) + TLV_HDR_SIZE + sizeof(*cfg) + hw_mode_len +
3184               (param->num_mem_chunks ? (sizeof(*host_mem_chunks) * WMI_MAX_MEM_REQS) : 0);
3185
3186         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, len);
3187         if (!skb)
3188                 return -ENOMEM;
3189
3190         cmd = (struct wmi_init_cmd *)skb->data;
3191
3192         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_INIT_CMD) |
3193                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3194
3195         ptr = skb->data + sizeof(*cmd);
3196         cfg = ptr;
3197
3198         ath11k_wmi_copy_resource_config(cfg, param->res_cfg);
3199
3200         cfg->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_RESOURCE_CONFIG) |
3201                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cfg) - TLV_HDR_SIZE);
3202
3203         ptr += sizeof(*cfg);
3204         host_mem_chunks = ptr + TLV_HDR_SIZE;
3205         len = sizeof(struct wlan_host_mem_chunk);
3206
3207         for (idx = 0; idx < param->num_mem_chunks; ++idx) {
3208                 host_mem_chunks[idx].tlv_header =
3209                                 FIELD_PREP(WMI_TLV_TAG,
3210                                            WMI_TAG_WLAN_HOST_MEMORY_CHUNK) |
3211                                 FIELD_PREP(WMI_TLV_LEN, len);
3212
3213                 host_mem_chunks[idx].ptr = param->mem_chunks[idx].paddr;
3214                 host_mem_chunks[idx].size = param->mem_chunks[idx].len;
3215                 host_mem_chunks[idx].req_id = param->mem_chunks[idx].req_id;
3216
3217                 ath11k_dbg(ab, ATH11K_DBG_WMI,
3218                            "WMI host mem chunk req_id %d paddr 0x%llx len %d\n",
3219                            param->mem_chunks[idx].req_id,
3220                            (u64)param->mem_chunks[idx].paddr,
3221                            param->mem_chunks[idx].len);
3222         }
3223         cmd->num_host_mem_chunks = param->num_mem_chunks;
3224         len = sizeof(struct wlan_host_mem_chunk) * param->num_mem_chunks;
3225
3226         /* num_mem_chunks is zero */
3227         tlv = ptr;
3228         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
3229                       FIELD_PREP(WMI_TLV_LEN, len);
3230         ptr += TLV_HDR_SIZE + len;
3231
3232         if (param->hw_mode_id != WMI_HOST_HW_MODE_MAX) {
3233                 hw_mode = (struct wmi_pdev_set_hw_mode_cmd_param *)ptr;
3234                 hw_mode->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3235                                                  WMI_TAG_PDEV_SET_HW_MODE_CMD) |
3236                                       FIELD_PREP(WMI_TLV_LEN,
3237                                                  sizeof(*hw_mode) - TLV_HDR_SIZE);
3238
3239                 hw_mode->hw_mode_index = param->hw_mode_id;
3240                 hw_mode->num_band_to_mac = param->num_band_to_mac;
3241
3242                 ptr += sizeof(*hw_mode);
3243
3244                 len = param->num_band_to_mac * sizeof(*band_to_mac);
3245                 tlv = ptr;
3246                 tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_STRUCT) |
3247                               FIELD_PREP(WMI_TLV_LEN, len);
3248
3249                 ptr += TLV_HDR_SIZE;
3250                 len = sizeof(*band_to_mac);
3251
3252                 for (idx = 0; idx < param->num_band_to_mac; idx++) {
3253                         band_to_mac = (void *)ptr;
3254
3255                         band_to_mac->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3256                                                              WMI_TAG_PDEV_BAND_TO_MAC) |
3257                                                   FIELD_PREP(WMI_TLV_LEN,
3258                                                              len - TLV_HDR_SIZE);
3259                         band_to_mac->pdev_id = param->band_to_mac[idx].pdev_id;
3260                         band_to_mac->start_freq =
3261                                 param->band_to_mac[idx].start_freq;
3262                         band_to_mac->end_freq =
3263                                 param->band_to_mac[idx].end_freq;
3264                         ptr += sizeof(*band_to_mac);
3265                 }
3266         }
3267
3268         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_INIT_CMDID);
3269         if (ret) {
3270                 ath11k_warn(ab, "failed to send WMI_INIT_CMDID\n");
3271                 dev_kfree_skb(skb);
3272         }
3273
3274         return ret;
3275 }
3276
3277 int ath11k_wmi_pdev_lro_cfg(struct ath11k *ar,
3278                             int pdev_id)
3279 {
3280         struct ath11k_wmi_pdev_lro_config_cmd *cmd;
3281         struct sk_buff *skb;
3282         int ret;
3283
3284         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
3285         if (!skb)
3286                 return -ENOMEM;
3287
3288         cmd = (struct ath11k_wmi_pdev_lro_config_cmd *)skb->data;
3289         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_LRO_INFO_CMD) |
3290                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3291
3292         get_random_bytes(cmd->th_4, sizeof(uint32_t) * ATH11K_IPV4_TH_SEED_SIZE);
3293         get_random_bytes(cmd->th_6, sizeof(uint32_t) * ATH11K_IPV6_TH_SEED_SIZE);
3294
3295         cmd->pdev_id = pdev_id;
3296
3297         ret = ath11k_wmi_cmd_send(ar->wmi, skb, WMI_LRO_CONFIG_CMDID);
3298         if (ret) {
3299                 ath11k_warn(ar->ab,
3300                             "failed to send lro cfg req wmi cmd\n");
3301                 goto err;
3302         }
3303
3304         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3305                    "WMI lro cfg cmd pdev_id 0x%x\n", pdev_id);
3306         return 0;
3307 err:
3308         dev_kfree_skb(skb);
3309         return ret;
3310 }
3311
3312 int ath11k_wmi_wait_for_service_ready(struct ath11k_base *ab)
3313 {
3314         unsigned long time_left;
3315
3316         time_left = wait_for_completion_timeout(&ab->wmi_ab.service_ready,
3317                                                 WMI_SERVICE_READY_TIMEOUT_HZ);
3318         if (!time_left)
3319                 return -ETIMEDOUT;
3320
3321         return 0;
3322 }
3323
3324 int ath11k_wmi_wait_for_unified_ready(struct ath11k_base *ab)
3325 {
3326         unsigned long time_left;
3327
3328         time_left = wait_for_completion_timeout(&ab->wmi_ab.unified_ready,
3329                                                 WMI_SERVICE_READY_TIMEOUT_HZ);
3330         if (!time_left)
3331                 return -ETIMEDOUT;
3332
3333         return 0;
3334 }
3335
3336 int ath11k_wmi_cmd_init(struct ath11k_base *ab)
3337 {
3338         struct ath11k_wmi_base *wmi_sc = &ab->wmi_ab;
3339         struct wmi_init_cmd_param init_param;
3340         struct target_resource_config  config;
3341
3342         memset(&init_param, 0, sizeof(init_param));
3343         memset(&config, 0, sizeof(config));
3344
3345         config.num_vdevs = ab->num_radios * TARGET_NUM_VDEVS;
3346
3347         if (ab->num_radios == 2) {
3348                 config.num_peers = TARGET_NUM_PEERS(DBS);
3349                 config.num_tids = TARGET_NUM_TIDS(DBS);
3350         } else if (ab->num_radios == 3) {
3351                 config.num_peers = TARGET_NUM_PEERS(DBS_SBS);
3352                 config.num_tids = TARGET_NUM_TIDS(DBS_SBS);
3353         } else {
3354                 /* Control should not reach here */
3355                 config.num_peers = TARGET_NUM_PEERS(SINGLE);
3356                 config.num_tids = TARGET_NUM_TIDS(SINGLE);
3357         }
3358         config.num_offload_peers = TARGET_NUM_OFFLD_PEERS;
3359         config.num_offload_reorder_buffs = TARGET_NUM_OFFLD_REORDER_BUFFS;
3360         config.num_peer_keys = TARGET_NUM_PEER_KEYS;
3361         config.ast_skid_limit = TARGET_AST_SKID_LIMIT;
3362         config.tx_chain_mask = (1 << ab->target_caps.num_rf_chains) - 1;
3363         config.rx_chain_mask = (1 << ab->target_caps.num_rf_chains) - 1;
3364         config.rx_timeout_pri[0] = TARGET_RX_TIMEOUT_LO_PRI;
3365         config.rx_timeout_pri[1] = TARGET_RX_TIMEOUT_LO_PRI;
3366         config.rx_timeout_pri[2] = TARGET_RX_TIMEOUT_LO_PRI;
3367         config.rx_timeout_pri[3] = TARGET_RX_TIMEOUT_HI_PRI;
3368         config.rx_decap_mode = TARGET_DECAP_MODE_NATIVE_WIFI;
3369         config.scan_max_pending_req = TARGET_SCAN_MAX_PENDING_REQS;
3370         config.bmiss_offload_max_vdev = TARGET_BMISS_OFFLOAD_MAX_VDEV;
3371         config.roam_offload_max_vdev = TARGET_ROAM_OFFLOAD_MAX_VDEV;
3372         config.roam_offload_max_ap_profiles = TARGET_ROAM_OFFLOAD_MAX_AP_PROFILES;
3373         config.num_mcast_groups = TARGET_NUM_MCAST_GROUPS;
3374         config.num_mcast_table_elems = TARGET_NUM_MCAST_TABLE_ELEMS;
3375         config.mcast2ucast_mode = TARGET_MCAST2UCAST_MODE;
3376         config.tx_dbg_log_size = TARGET_TX_DBG_LOG_SIZE;
3377         config.num_wds_entries = TARGET_NUM_WDS_ENTRIES;
3378         config.dma_burst_size = TARGET_DMA_BURST_SIZE;
3379         config.rx_skip_defrag_timeout_dup_detection_check =
3380                 TARGET_RX_SKIP_DEFRAG_TIMEOUT_DUP_DETECTION_CHECK;
3381         config.vow_config = TARGET_VOW_CONFIG;
3382         config.gtk_offload_max_vdev = TARGET_GTK_OFFLOAD_MAX_VDEV;
3383         config.num_msdu_desc = TARGET_NUM_MSDU_DESC;
3384         config.beacon_tx_offload_max_vdev = ab->num_radios * TARGET_MAX_BCN_OFFLD;
3385         config.rx_batchmode = TARGET_RX_BATCHMODE;
3386         config.peer_map_unmap_v2_support = 1;
3387         config.twt_ap_pdev_count = ab->num_radios;
3388         config.twt_ap_sta_count = 1000;
3389
3390         ab->hw_params.hw_ops->wmi_init_config(ab, &config);
3391
3392         memcpy(&wmi_sc->wlan_resource_config, &config, sizeof(config));
3393
3394         init_param.res_cfg = &wmi_sc->wlan_resource_config;
3395         init_param.num_mem_chunks = wmi_sc->num_mem_chunks;
3396         init_param.hw_mode_id = wmi_sc->preferred_hw_mode;
3397         init_param.mem_chunks = wmi_sc->mem_chunks;
3398
3399         if (wmi_sc->preferred_hw_mode == WMI_HOST_HW_MODE_SINGLE)
3400                 init_param.hw_mode_id = WMI_HOST_HW_MODE_MAX;
3401
3402         if (ab->hw_params.needs_band_to_mac) {
3403                 init_param.num_band_to_mac = ab->num_radios;
3404                 ath11k_fill_band_to_mac_param(ab, init_param.band_to_mac);
3405         }
3406
3407         return ath11k_init_cmd_send(&wmi_sc->wmi[0], &init_param);
3408 }
3409
3410 int ath11k_wmi_vdev_spectral_conf(struct ath11k *ar,
3411                                   struct ath11k_wmi_vdev_spectral_conf_param *param)
3412 {
3413         struct ath11k_wmi_vdev_spectral_conf_cmd *cmd;
3414         struct sk_buff *skb;
3415         int ret;
3416
3417         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
3418         if (!skb)
3419                 return -ENOMEM;
3420
3421         cmd = (struct ath11k_wmi_vdev_spectral_conf_cmd *)skb->data;
3422         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3423                                      WMI_TAG_VDEV_SPECTRAL_CONFIGURE_CMD) |
3424                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3425
3426         memcpy(&cmd->param, param, sizeof(*param));
3427
3428         ret = ath11k_wmi_cmd_send(ar->wmi, skb,
3429                                   WMI_VDEV_SPECTRAL_SCAN_CONFIGURE_CMDID);
3430         if (ret) {
3431                 ath11k_warn(ar->ab,
3432                             "failed to send spectral scan config wmi cmd\n");
3433                 goto err;
3434         }
3435
3436         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3437                    "WMI spectral scan config cmd vdev_id 0x%x\n",
3438                    param->vdev_id);
3439
3440         return 0;
3441 err:
3442         dev_kfree_skb(skb);
3443         return ret;
3444 }
3445
3446 int ath11k_wmi_vdev_spectral_enable(struct ath11k *ar, u32 vdev_id,
3447                                     u32 trigger, u32 enable)
3448 {
3449         struct ath11k_wmi_vdev_spectral_enable_cmd *cmd;
3450         struct sk_buff *skb;
3451         int ret;
3452
3453         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
3454         if (!skb)
3455                 return -ENOMEM;
3456
3457         cmd = (struct ath11k_wmi_vdev_spectral_enable_cmd *)skb->data;
3458         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG,
3459                                      WMI_TAG_VDEV_SPECTRAL_ENABLE_CMD) |
3460                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3461
3462         cmd->vdev_id = vdev_id;
3463         cmd->trigger_cmd = trigger;
3464         cmd->enable_cmd = enable;
3465
3466         ret = ath11k_wmi_cmd_send(ar->wmi, skb,
3467                                   WMI_VDEV_SPECTRAL_SCAN_ENABLE_CMDID);
3468         if (ret) {
3469                 ath11k_warn(ar->ab,
3470                             "failed to send spectral enable wmi cmd\n");
3471                 goto err;
3472         }
3473
3474         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3475                    "WMI spectral enable cmd vdev id 0x%x\n",
3476                    vdev_id);
3477
3478         return 0;
3479 err:
3480         dev_kfree_skb(skb);
3481         return ret;
3482 }
3483
3484 int ath11k_wmi_pdev_dma_ring_cfg(struct ath11k *ar,
3485                                  struct ath11k_wmi_pdev_dma_ring_cfg_req_cmd *param)
3486 {
3487         struct ath11k_wmi_pdev_dma_ring_cfg_req_cmd *cmd;
3488         struct sk_buff *skb;
3489         int ret;
3490
3491         skb = ath11k_wmi_alloc_skb(ar->wmi->wmi_ab, sizeof(*cmd));
3492         if (!skb)
3493                 return -ENOMEM;
3494
3495         cmd = (struct ath11k_wmi_pdev_dma_ring_cfg_req_cmd *)skb->data;
3496         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_DMA_RING_CFG_REQ) |
3497                           FIELD_PREP(WMI_TLV_LEN, sizeof(*cmd) - TLV_HDR_SIZE);
3498
3499         cmd->pdev_id            = param->pdev_id;
3500         cmd->module_id          = param->module_id;
3501         cmd->base_paddr_lo      = param->base_paddr_lo;
3502         cmd->base_paddr_hi      = param->base_paddr_hi;
3503         cmd->head_idx_paddr_lo  = param->head_idx_paddr_lo;
3504         cmd->head_idx_paddr_hi  = param->head_idx_paddr_hi;
3505         cmd->tail_idx_paddr_lo  = param->tail_idx_paddr_lo;
3506         cmd->tail_idx_paddr_hi  = param->tail_idx_paddr_hi;
3507         cmd->num_elems          = param->num_elems;
3508         cmd->buf_size           = param->buf_size;
3509         cmd->num_resp_per_event = param->num_resp_per_event;
3510         cmd->event_timeout_ms   = param->event_timeout_ms;
3511
3512         ret = ath11k_wmi_cmd_send(ar->wmi, skb,
3513                                   WMI_PDEV_DMA_RING_CFG_REQ_CMDID);
3514         if (ret) {
3515                 ath11k_warn(ar->ab,
3516                             "failed to send dma ring cfg req wmi cmd\n");
3517                 goto err;
3518         }
3519
3520         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
3521                    "WMI DMA ring cfg req cmd pdev_id 0x%x\n",
3522                    param->pdev_id);
3523
3524         return 0;
3525 err:
3526         dev_kfree_skb(skb);
3527         return ret;
3528 }
3529
3530 static int ath11k_wmi_tlv_dma_buf_entry_parse(struct ath11k_base *soc,
3531                                               u16 tag, u16 len,
3532                                               const void *ptr, void *data)
3533 {
3534         struct wmi_tlv_dma_buf_release_parse *parse = data;
3535
3536         if (tag != WMI_TAG_DMA_BUF_RELEASE_ENTRY)
3537                 return -EPROTO;
3538
3539         if (parse->num_buf_entry >= parse->fixed.num_buf_release_entry)
3540                 return -ENOBUFS;
3541
3542         parse->num_buf_entry++;
3543         return 0;
3544 }
3545
3546 static int ath11k_wmi_tlv_dma_buf_meta_parse(struct ath11k_base *soc,
3547                                              u16 tag, u16 len,
3548                                              const void *ptr, void *data)
3549 {
3550         struct wmi_tlv_dma_buf_release_parse *parse = data;
3551
3552         if (tag != WMI_TAG_DMA_BUF_RELEASE_SPECTRAL_META_DATA)
3553                 return -EPROTO;
3554
3555         if (parse->num_meta >= parse->fixed.num_meta_data_entry)
3556                 return -ENOBUFS;
3557
3558         parse->num_meta++;
3559         return 0;
3560 }
3561
3562 static int ath11k_wmi_tlv_dma_buf_parse(struct ath11k_base *ab,
3563                                         u16 tag, u16 len,
3564                                         const void *ptr, void *data)
3565 {
3566         struct wmi_tlv_dma_buf_release_parse *parse = data;
3567         int ret;
3568
3569         switch (tag) {
3570         case WMI_TAG_DMA_BUF_RELEASE:
3571                 memcpy(&parse->fixed, ptr,
3572                        sizeof(struct ath11k_wmi_dma_buf_release_fixed_param));
3573                 parse->fixed.pdev_id = DP_HW2SW_MACID(parse->fixed.pdev_id);
3574                 break;
3575         case WMI_TAG_ARRAY_STRUCT:
3576                 if (!parse->buf_entry_done) {
3577                         parse->num_buf_entry = 0;
3578                         parse->buf_entry = (struct wmi_dma_buf_release_entry *)ptr;
3579
3580                         ret = ath11k_wmi_tlv_iter(ab, ptr, len,
3581                                                   ath11k_wmi_tlv_dma_buf_entry_parse,
3582                                                   parse);
3583                         if (ret) {
3584                                 ath11k_warn(ab, "failed to parse dma buf entry tlv %d\n",
3585                                             ret);
3586                                 return ret;
3587                         }
3588
3589                         parse->buf_entry_done = true;
3590                 } else if (!parse->meta_data_done) {
3591                         parse->num_meta = 0;
3592                         parse->meta_data = (struct wmi_dma_buf_release_meta_data *)ptr;
3593
3594                         ret = ath11k_wmi_tlv_iter(ab, ptr, len,
3595                                                   ath11k_wmi_tlv_dma_buf_meta_parse,
3596                                                   parse);
3597                         if (ret) {
3598                                 ath11k_warn(ab, "failed to parse dma buf meta tlv %d\n",
3599                                             ret);
3600                                 return ret;
3601                         }
3602
3603                         parse->meta_data_done = true;
3604                 }
3605                 break;
3606         default:
3607                 break;
3608         }
3609         return 0;
3610 }
3611
3612 static void ath11k_wmi_pdev_dma_ring_buf_release_event(struct ath11k_base *ab,
3613                                                        struct sk_buff *skb)
3614 {
3615         struct wmi_tlv_dma_buf_release_parse parse = { };
3616         struct ath11k_dbring_buf_release_event param;
3617         int ret;
3618
3619         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
3620                                   ath11k_wmi_tlv_dma_buf_parse,
3621                                   &parse);
3622         if (ret) {
3623                 ath11k_warn(ab, "failed to parse dma buf release tlv %d\n", ret);
3624                 return;
3625         }
3626
3627         param.fixed             = parse.fixed;
3628         param.buf_entry         = parse.buf_entry;
3629         param.num_buf_entry     = parse.num_buf_entry;
3630         param.meta_data         = parse.meta_data;
3631         param.num_meta          = parse.num_meta;
3632
3633         ret = ath11k_dbring_buffer_release_event(ab, &param);
3634         if (ret) {
3635                 ath11k_warn(ab, "failed to handle dma buf release event %d\n", ret);
3636                 return;
3637         }
3638 }
3639
3640 static int ath11k_wmi_tlv_hw_mode_caps_parse(struct ath11k_base *soc,
3641                                              u16 tag, u16 len,
3642                                              const void *ptr, void *data)
3643 {
3644         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
3645         struct wmi_hw_mode_capabilities *hw_mode_cap;
3646         u32 phy_map = 0;
3647
3648         if (tag != WMI_TAG_HW_MODE_CAPABILITIES)
3649                 return -EPROTO;
3650
3651         if (svc_rdy_ext->n_hw_mode_caps >= svc_rdy_ext->param.num_hw_modes)
3652                 return -ENOBUFS;
3653
3654         hw_mode_cap = container_of(ptr, struct wmi_hw_mode_capabilities,
3655                                    hw_mode_id);
3656         svc_rdy_ext->n_hw_mode_caps++;
3657
3658         phy_map = hw_mode_cap->phy_id_map;
3659         while (phy_map) {
3660                 svc_rdy_ext->tot_phy_id++;
3661                 phy_map = phy_map >> 1;
3662         }
3663
3664         return 0;
3665 }
3666
3667 static int ath11k_wmi_tlv_hw_mode_caps(struct ath11k_base *soc,
3668                                        u16 len, const void *ptr, void *data)
3669 {
3670         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
3671         struct wmi_hw_mode_capabilities *hw_mode_caps;
3672         enum wmi_host_hw_mode_config_type mode, pref;
3673         u32 i;
3674         int ret;
3675
3676         svc_rdy_ext->n_hw_mode_caps = 0;
3677         svc_rdy_ext->hw_mode_caps = (struct wmi_hw_mode_capabilities *)ptr;
3678
3679         ret = ath11k_wmi_tlv_iter(soc, ptr, len,
3680                                   ath11k_wmi_tlv_hw_mode_caps_parse,
3681                                   svc_rdy_ext);
3682         if (ret) {
3683                 ath11k_warn(soc, "failed to parse tlv %d\n", ret);
3684                 return ret;
3685         }
3686
3687         i = 0;
3688         while (i < svc_rdy_ext->n_hw_mode_caps) {
3689                 hw_mode_caps = &svc_rdy_ext->hw_mode_caps[i];
3690                 mode = hw_mode_caps->hw_mode_id;
3691                 pref = soc->wmi_ab.preferred_hw_mode;
3692
3693                 if (ath11k_hw_mode_pri_map[mode] < ath11k_hw_mode_pri_map[pref]) {
3694                         svc_rdy_ext->pref_hw_mode_caps = *hw_mode_caps;
3695                         soc->wmi_ab.preferred_hw_mode = mode;
3696                 }
3697                 i++;
3698         }
3699
3700         ath11k_dbg(soc, ATH11K_DBG_WMI, "preferred_hw_mode:%d\n",
3701                    soc->wmi_ab.preferred_hw_mode);
3702         if (soc->wmi_ab.preferred_hw_mode == WMI_HOST_HW_MODE_MAX)
3703                 return -EINVAL;
3704
3705         return 0;
3706 }
3707
3708 static int ath11k_wmi_tlv_mac_phy_caps_parse(struct ath11k_base *soc,
3709                                              u16 tag, u16 len,
3710                                              const void *ptr, void *data)
3711 {
3712         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
3713
3714         if (tag != WMI_TAG_MAC_PHY_CAPABILITIES)
3715                 return -EPROTO;
3716
3717         if (svc_rdy_ext->n_mac_phy_caps >= svc_rdy_ext->tot_phy_id)
3718                 return -ENOBUFS;
3719
3720         len = min_t(u16, len, sizeof(struct wmi_mac_phy_capabilities));
3721         if (!svc_rdy_ext->n_mac_phy_caps) {
3722                 svc_rdy_ext->mac_phy_caps = kzalloc((svc_rdy_ext->tot_phy_id) * len,
3723                                                     GFP_ATOMIC);
3724                 if (!svc_rdy_ext->mac_phy_caps)
3725                         return -ENOMEM;
3726         }
3727
3728         memcpy(svc_rdy_ext->mac_phy_caps + svc_rdy_ext->n_mac_phy_caps, ptr, len);
3729         svc_rdy_ext->n_mac_phy_caps++;
3730         return 0;
3731 }
3732
3733 static int ath11k_wmi_tlv_ext_hal_reg_caps_parse(struct ath11k_base *soc,
3734                                                  u16 tag, u16 len,
3735                                                  const void *ptr, void *data)
3736 {
3737         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
3738
3739         if (tag != WMI_TAG_HAL_REG_CAPABILITIES_EXT)
3740                 return -EPROTO;
3741
3742         if (svc_rdy_ext->n_ext_hal_reg_caps >= svc_rdy_ext->param.num_phy)
3743                 return -ENOBUFS;
3744
3745         svc_rdy_ext->n_ext_hal_reg_caps++;
3746         return 0;
3747 }
3748
3749 static int ath11k_wmi_tlv_ext_hal_reg_caps(struct ath11k_base *soc,
3750                                            u16 len, const void *ptr, void *data)
3751 {
3752         struct ath11k_pdev_wmi *wmi_handle = &soc->wmi_ab.wmi[0];
3753         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
3754         struct ath11k_hal_reg_capabilities_ext reg_cap;
3755         int ret;
3756         u32 i;
3757
3758         svc_rdy_ext->n_ext_hal_reg_caps = 0;
3759         svc_rdy_ext->ext_hal_reg_caps = (struct wmi_hal_reg_capabilities_ext *)ptr;
3760         ret = ath11k_wmi_tlv_iter(soc, ptr, len,
3761                                   ath11k_wmi_tlv_ext_hal_reg_caps_parse,
3762                                   svc_rdy_ext);
3763         if (ret) {
3764                 ath11k_warn(soc, "failed to parse tlv %d\n", ret);
3765                 return ret;
3766         }
3767
3768         for (i = 0; i < svc_rdy_ext->param.num_phy; i++) {
3769                 ret = ath11k_pull_reg_cap_svc_rdy_ext(wmi_handle,
3770                                                       svc_rdy_ext->soc_hal_reg_caps,
3771                                                       svc_rdy_ext->ext_hal_reg_caps, i,
3772                                                       &reg_cap);
3773                 if (ret) {
3774                         ath11k_warn(soc, "failed to extract reg cap %d\n", i);
3775                         return ret;
3776                 }
3777
3778                 memcpy(&soc->hal_reg_cap[reg_cap.phy_id],
3779                        &reg_cap, sizeof(reg_cap));
3780         }
3781         return 0;
3782 }
3783
3784 static int ath11k_wmi_tlv_ext_soc_hal_reg_caps_parse(struct ath11k_base *soc,
3785                                                      u16 len, const void *ptr,
3786                                                      void *data)
3787 {
3788         struct ath11k_pdev_wmi *wmi_handle = &soc->wmi_ab.wmi[0];
3789         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
3790         u8 hw_mode_id = svc_rdy_ext->pref_hw_mode_caps.hw_mode_id;
3791         u32 phy_id_map;
3792         int pdev_index = 0;
3793         int ret;
3794
3795         svc_rdy_ext->soc_hal_reg_caps = (struct wmi_soc_hal_reg_capabilities *)ptr;
3796         svc_rdy_ext->param.num_phy = svc_rdy_ext->soc_hal_reg_caps->num_phy;
3797
3798         soc->num_radios = 0;
3799         phy_id_map = svc_rdy_ext->pref_hw_mode_caps.phy_id_map;
3800
3801         while (phy_id_map && soc->num_radios < MAX_RADIOS) {
3802                 ret = ath11k_pull_mac_phy_cap_svc_ready_ext(wmi_handle,
3803                                                             svc_rdy_ext->hw_caps,
3804                                                             svc_rdy_ext->hw_mode_caps,
3805                                                             svc_rdy_ext->soc_hal_reg_caps,
3806                                                             svc_rdy_ext->mac_phy_caps,
3807                                                             hw_mode_id, soc->num_radios,
3808                                                             &soc->pdevs[pdev_index]);
3809                 if (ret) {
3810                         ath11k_warn(soc, "failed to extract mac caps, idx :%d\n",
3811                                     soc->num_radios);
3812                         return ret;
3813                 }
3814
3815                 soc->num_radios++;
3816
3817                 /* For QCA6390, save mac_phy capability in the same pdev */
3818                 if (soc->hw_params.single_pdev_only)
3819                         pdev_index = 0;
3820                 else
3821                         pdev_index = soc->num_radios;
3822
3823                 /* TODO: mac_phy_cap prints */
3824                 phy_id_map >>= 1;
3825         }
3826
3827         /* For QCA6390, set num_radios to 1 because host manages
3828          * both 2G and 5G radio in one pdev.
3829          * Set pdev_id = 0 and 0 means soc level.
3830          */
3831         if (soc->hw_params.single_pdev_only) {
3832                 soc->num_radios = 1;
3833                 soc->pdevs[0].pdev_id = 0;
3834         }
3835
3836         return 0;
3837 }
3838
3839 static int ath11k_wmi_tlv_dma_ring_caps_parse(struct ath11k_base *soc,
3840                                               u16 tag, u16 len,
3841                                               const void *ptr, void *data)
3842 {
3843         struct wmi_tlv_dma_ring_caps_parse *parse = data;
3844
3845         if (tag != WMI_TAG_DMA_RING_CAPABILITIES)
3846                 return -EPROTO;
3847
3848         parse->n_dma_ring_caps++;
3849         return 0;
3850 }
3851
3852 static int ath11k_wmi_alloc_dbring_caps(struct ath11k_base *ab,
3853                                         u32 num_cap)
3854 {
3855         size_t sz;
3856         void *ptr;
3857
3858         sz = num_cap * sizeof(struct ath11k_dbring_cap);
3859         ptr = kzalloc(sz, GFP_ATOMIC);
3860         if (!ptr)
3861                 return -ENOMEM;
3862
3863         ab->db_caps = ptr;
3864         ab->num_db_cap = num_cap;
3865
3866         return 0;
3867 }
3868
3869 static void ath11k_wmi_free_dbring_caps(struct ath11k_base *ab)
3870 {
3871         kfree(ab->db_caps);
3872         ab->db_caps = NULL;
3873 }
3874
3875 static int ath11k_wmi_tlv_dma_ring_caps(struct ath11k_base *ab,
3876                                         u16 len, const void *ptr, void *data)
3877 {
3878         struct wmi_tlv_dma_ring_caps_parse *dma_caps_parse = data;
3879         struct wmi_dma_ring_capabilities *dma_caps;
3880         struct ath11k_dbring_cap *dir_buff_caps;
3881         int ret;
3882         u32 i;
3883
3884         dma_caps_parse->n_dma_ring_caps = 0;
3885         dma_caps = (struct wmi_dma_ring_capabilities *)ptr;
3886         ret = ath11k_wmi_tlv_iter(ab, ptr, len,
3887                                   ath11k_wmi_tlv_dma_ring_caps_parse,
3888                                   dma_caps_parse);
3889         if (ret) {
3890                 ath11k_warn(ab, "failed to parse dma ring caps tlv %d\n", ret);
3891                 return ret;
3892         }
3893
3894         if (!dma_caps_parse->n_dma_ring_caps)
3895                 return 0;
3896
3897         if (ab->num_db_cap) {
3898                 ath11k_warn(ab, "Already processed, so ignoring dma ring caps\n");
3899                 return 0;
3900         }
3901
3902         ret = ath11k_wmi_alloc_dbring_caps(ab, dma_caps_parse->n_dma_ring_caps);
3903         if (ret)
3904                 return ret;
3905
3906         dir_buff_caps = ab->db_caps;
3907         for (i = 0; i < dma_caps_parse->n_dma_ring_caps; i++) {
3908                 if (dma_caps[i].module_id >= WMI_DIRECT_BUF_MAX) {
3909                         ath11k_warn(ab, "Invalid module id %d\n", dma_caps[i].module_id);
3910                         ret = -EINVAL;
3911                         goto free_dir_buff;
3912                 }
3913
3914                 dir_buff_caps[i].id = dma_caps[i].module_id;
3915                 dir_buff_caps[i].pdev_id = DP_HW2SW_MACID(dma_caps[i].pdev_id);
3916                 dir_buff_caps[i].min_elem = dma_caps[i].min_elem;
3917                 dir_buff_caps[i].min_buf_sz = dma_caps[i].min_buf_sz;
3918                 dir_buff_caps[i].min_buf_align = dma_caps[i].min_buf_align;
3919         }
3920
3921         return 0;
3922
3923 free_dir_buff:
3924         ath11k_wmi_free_dbring_caps(ab);
3925         return ret;
3926 }
3927
3928 static int ath11k_wmi_tlv_svc_rdy_ext_parse(struct ath11k_base *ab,
3929                                             u16 tag, u16 len,
3930                                             const void *ptr, void *data)
3931 {
3932         struct ath11k_pdev_wmi *wmi_handle = &ab->wmi_ab.wmi[0];
3933         struct wmi_tlv_svc_rdy_ext_parse *svc_rdy_ext = data;
3934         int ret;
3935
3936         switch (tag) {
3937         case WMI_TAG_SERVICE_READY_EXT_EVENT:
3938                 ret = ath11k_pull_svc_ready_ext(wmi_handle, ptr,
3939                                                 &svc_rdy_ext->param);
3940                 if (ret) {
3941                         ath11k_warn(ab, "unable to extract ext params\n");
3942                         return ret;
3943                 }
3944                 break;
3945
3946         case WMI_TAG_SOC_MAC_PHY_HW_MODE_CAPS:
3947                 svc_rdy_ext->hw_caps = (struct wmi_soc_mac_phy_hw_mode_caps *)ptr;
3948                 svc_rdy_ext->param.num_hw_modes = svc_rdy_ext->hw_caps->num_hw_modes;
3949                 break;
3950
3951         case WMI_TAG_SOC_HAL_REG_CAPABILITIES:
3952                 ret = ath11k_wmi_tlv_ext_soc_hal_reg_caps_parse(ab, len, ptr,
3953                                                                 svc_rdy_ext);
3954                 if (ret)
3955                         return ret;
3956                 break;
3957
3958         case WMI_TAG_ARRAY_STRUCT:
3959                 if (!svc_rdy_ext->hw_mode_done) {
3960                         ret = ath11k_wmi_tlv_hw_mode_caps(ab, len, ptr,
3961                                                           svc_rdy_ext);
3962                         if (ret)
3963                                 return ret;
3964
3965                         svc_rdy_ext->hw_mode_done = true;
3966                 } else if (!svc_rdy_ext->mac_phy_done) {
3967                         svc_rdy_ext->n_mac_phy_caps = 0;
3968                         ret = ath11k_wmi_tlv_iter(ab, ptr, len,
3969                                                   ath11k_wmi_tlv_mac_phy_caps_parse,
3970                                                   svc_rdy_ext);
3971                         if (ret) {
3972                                 ath11k_warn(ab, "failed to parse tlv %d\n", ret);
3973                                 return ret;
3974                         }
3975
3976                         svc_rdy_ext->mac_phy_done = true;
3977                 } else if (!svc_rdy_ext->ext_hal_reg_done) {
3978                         ret = ath11k_wmi_tlv_ext_hal_reg_caps(ab, len, ptr,
3979                                                               svc_rdy_ext);
3980                         if (ret)
3981                                 return ret;
3982
3983                         svc_rdy_ext->ext_hal_reg_done = true;
3984                 } else if (!svc_rdy_ext->mac_phy_chainmask_combo_done) {
3985                         svc_rdy_ext->mac_phy_chainmask_combo_done = true;
3986                 } else if (!svc_rdy_ext->mac_phy_chainmask_cap_done) {
3987                         svc_rdy_ext->mac_phy_chainmask_cap_done = true;
3988                 } else if (!svc_rdy_ext->oem_dma_ring_cap_done) {
3989                         svc_rdy_ext->oem_dma_ring_cap_done = true;
3990                 } else if (!svc_rdy_ext->dma_ring_cap_done) {
3991                         ret = ath11k_wmi_tlv_dma_ring_caps(ab, len, ptr,
3992                                                            &svc_rdy_ext->dma_caps_parse);
3993                         if (ret)
3994                                 return ret;
3995
3996                         svc_rdy_ext->dma_ring_cap_done = true;
3997                 }
3998                 break;
3999
4000         default:
4001                 break;
4002         }
4003         return 0;
4004 }
4005
4006 static int ath11k_service_ready_ext_event(struct ath11k_base *ab,
4007                                           struct sk_buff *skb)
4008 {
4009         struct wmi_tlv_svc_rdy_ext_parse svc_rdy_ext = { };
4010         int ret;
4011
4012         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
4013                                   ath11k_wmi_tlv_svc_rdy_ext_parse,
4014                                   &svc_rdy_ext);
4015         if (ret) {
4016                 ath11k_warn(ab, "failed to parse tlv %d\n", ret);
4017                 goto err;
4018         }
4019
4020         if (!test_bit(WMI_TLV_SERVICE_EXT2_MSG, ab->wmi_ab.svc_map))
4021                 complete(&ab->wmi_ab.service_ready);
4022
4023         kfree(svc_rdy_ext.mac_phy_caps);
4024         return 0;
4025
4026 err:
4027         ath11k_wmi_free_dbring_caps(ab);
4028         return ret;
4029 }
4030
4031 static int ath11k_wmi_tlv_svc_rdy_ext2_parse(struct ath11k_base *ab,
4032                                              u16 tag, u16 len,
4033                                              const void *ptr, void *data)
4034 {
4035         struct wmi_tlv_svc_rdy_ext2_parse *parse = data;
4036         int ret;
4037
4038         switch (tag) {
4039         case WMI_TAG_ARRAY_STRUCT:
4040                 if (!parse->dma_ring_cap_done) {
4041                         ret = ath11k_wmi_tlv_dma_ring_caps(ab, len, ptr,
4042                                                            &parse->dma_caps_parse);
4043                         if (ret)
4044                                 return ret;
4045
4046                         parse->dma_ring_cap_done = true;
4047                 }
4048                 break;
4049         default:
4050                 break;
4051         }
4052
4053         return 0;
4054 }
4055
4056 static int ath11k_service_ready_ext2_event(struct ath11k_base *ab,
4057                                            struct sk_buff *skb)
4058 {
4059         struct wmi_tlv_svc_rdy_ext2_parse svc_rdy_ext2 = { };
4060         int ret;
4061
4062         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
4063                                   ath11k_wmi_tlv_svc_rdy_ext2_parse,
4064                                   &svc_rdy_ext2);
4065         if (ret) {
4066                 ath11k_warn(ab, "failed to parse ext2 event tlv %d\n", ret);
4067                 goto err;
4068         }
4069
4070         complete(&ab->wmi_ab.service_ready);
4071
4072         return 0;
4073
4074 err:
4075         ath11k_wmi_free_dbring_caps(ab);
4076         return ret;
4077 }
4078
4079 static int ath11k_pull_vdev_start_resp_tlv(struct ath11k_base *ab, struct sk_buff *skb,
4080                                            struct wmi_vdev_start_resp_event *vdev_rsp)
4081 {
4082         const void **tb;
4083         const struct wmi_vdev_start_resp_event *ev;
4084         int ret;
4085
4086         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4087         if (IS_ERR(tb)) {
4088                 ret = PTR_ERR(tb);
4089                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4090                 return ret;
4091         }
4092
4093         ev = tb[WMI_TAG_VDEV_START_RESPONSE_EVENT];
4094         if (!ev) {
4095                 ath11k_warn(ab, "failed to fetch vdev start resp ev");
4096                 kfree(tb);
4097                 return -EPROTO;
4098         }
4099
4100         memset(vdev_rsp, 0, sizeof(*vdev_rsp));
4101
4102         vdev_rsp->vdev_id = ev->vdev_id;
4103         vdev_rsp->requestor_id = ev->requestor_id;
4104         vdev_rsp->resp_type = ev->resp_type;
4105         vdev_rsp->status = ev->status;
4106         vdev_rsp->chain_mask = ev->chain_mask;
4107         vdev_rsp->smps_mode = ev->smps_mode;
4108         vdev_rsp->mac_id = ev->mac_id;
4109         vdev_rsp->cfgd_tx_streams = ev->cfgd_tx_streams;
4110         vdev_rsp->cfgd_rx_streams = ev->cfgd_rx_streams;
4111
4112         kfree(tb);
4113         return 0;
4114 }
4115
4116 static struct cur_reg_rule
4117 *create_reg_rules_from_wmi(u32 num_reg_rules,
4118                            struct wmi_regulatory_rule_struct *wmi_reg_rule)
4119 {
4120         struct cur_reg_rule *reg_rule_ptr;
4121         u32 count;
4122
4123         reg_rule_ptr =  kzalloc((num_reg_rules * sizeof(*reg_rule_ptr)),
4124                                 GFP_ATOMIC);
4125
4126         if (!reg_rule_ptr)
4127                 return NULL;
4128
4129         for (count = 0; count < num_reg_rules; count++) {
4130                 reg_rule_ptr[count].start_freq =
4131                         FIELD_GET(REG_RULE_START_FREQ,
4132                                   wmi_reg_rule[count].freq_info);
4133                 reg_rule_ptr[count].end_freq =
4134                         FIELD_GET(REG_RULE_END_FREQ,
4135                                   wmi_reg_rule[count].freq_info);
4136                 reg_rule_ptr[count].max_bw =
4137                         FIELD_GET(REG_RULE_MAX_BW,
4138                                   wmi_reg_rule[count].bw_pwr_info);
4139                 reg_rule_ptr[count].reg_power =
4140                         FIELD_GET(REG_RULE_REG_PWR,
4141                                   wmi_reg_rule[count].bw_pwr_info);
4142                 reg_rule_ptr[count].ant_gain =
4143                         FIELD_GET(REG_RULE_ANT_GAIN,
4144                                   wmi_reg_rule[count].bw_pwr_info);
4145                 reg_rule_ptr[count].flags =
4146                         FIELD_GET(REG_RULE_FLAGS,
4147                                   wmi_reg_rule[count].flag_info);
4148         }
4149
4150         return reg_rule_ptr;
4151 }
4152
4153 static int ath11k_pull_reg_chan_list_update_ev(struct ath11k_base *ab,
4154                                                struct sk_buff *skb,
4155                                                struct cur_regulatory_info *reg_info)
4156 {
4157         const void **tb;
4158         const struct wmi_reg_chan_list_cc_event *chan_list_event_hdr;
4159         struct wmi_regulatory_rule_struct *wmi_reg_rule;
4160         u32 num_2g_reg_rules, num_5g_reg_rules;
4161         int ret;
4162
4163         ath11k_dbg(ab, ATH11K_DBG_WMI, "processing regulatory channel list\n");
4164
4165         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4166         if (IS_ERR(tb)) {
4167                 ret = PTR_ERR(tb);
4168                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4169                 return ret;
4170         }
4171
4172         chan_list_event_hdr = tb[WMI_TAG_REG_CHAN_LIST_CC_EVENT];
4173         if (!chan_list_event_hdr) {
4174                 ath11k_warn(ab, "failed to fetch reg chan list update ev\n");
4175                 kfree(tb);
4176                 return -EPROTO;
4177         }
4178
4179         reg_info->num_2g_reg_rules = chan_list_event_hdr->num_2g_reg_rules;
4180         reg_info->num_5g_reg_rules = chan_list_event_hdr->num_5g_reg_rules;
4181
4182         if (!(reg_info->num_2g_reg_rules + reg_info->num_5g_reg_rules)) {
4183                 ath11k_warn(ab, "No regulatory rules available in the event info\n");
4184                 kfree(tb);
4185                 return -EINVAL;
4186         }
4187
4188         memcpy(reg_info->alpha2, &chan_list_event_hdr->alpha2,
4189                REG_ALPHA2_LEN);
4190         reg_info->dfs_region = chan_list_event_hdr->dfs_region;
4191         reg_info->phybitmap = chan_list_event_hdr->phybitmap;
4192         reg_info->num_phy = chan_list_event_hdr->num_phy;
4193         reg_info->phy_id = chan_list_event_hdr->phy_id;
4194         reg_info->ctry_code = chan_list_event_hdr->country_id;
4195         reg_info->reg_dmn_pair = chan_list_event_hdr->domain_code;
4196         if (chan_list_event_hdr->status_code == WMI_REG_SET_CC_STATUS_PASS)
4197                 reg_info->status_code = REG_SET_CC_STATUS_PASS;
4198         else if (chan_list_event_hdr->status_code == WMI_REG_CURRENT_ALPHA2_NOT_FOUND)
4199                 reg_info->status_code = REG_CURRENT_ALPHA2_NOT_FOUND;
4200         else if (chan_list_event_hdr->status_code == WMI_REG_INIT_ALPHA2_NOT_FOUND)
4201                 reg_info->status_code = REG_INIT_ALPHA2_NOT_FOUND;
4202         else if (chan_list_event_hdr->status_code == WMI_REG_SET_CC_CHANGE_NOT_ALLOWED)
4203                 reg_info->status_code = REG_SET_CC_CHANGE_NOT_ALLOWED;
4204         else if (chan_list_event_hdr->status_code == WMI_REG_SET_CC_STATUS_NO_MEMORY)
4205                 reg_info->status_code = REG_SET_CC_STATUS_NO_MEMORY;
4206         else if (chan_list_event_hdr->status_code == WMI_REG_SET_CC_STATUS_FAIL)
4207                 reg_info->status_code = REG_SET_CC_STATUS_FAIL;
4208
4209         reg_info->min_bw_2g = chan_list_event_hdr->min_bw_2g;
4210         reg_info->max_bw_2g = chan_list_event_hdr->max_bw_2g;
4211         reg_info->min_bw_5g = chan_list_event_hdr->min_bw_5g;
4212         reg_info->max_bw_5g = chan_list_event_hdr->max_bw_5g;
4213
4214         num_2g_reg_rules = reg_info->num_2g_reg_rules;
4215         num_5g_reg_rules = reg_info->num_5g_reg_rules;
4216
4217         ath11k_dbg(ab, ATH11K_DBG_WMI,
4218                    "%s:cc %s dsf %d BW: min_2g %d max_2g %d min_5g %d max_5g %d",
4219                    __func__, reg_info->alpha2, reg_info->dfs_region,
4220                    reg_info->min_bw_2g, reg_info->max_bw_2g,
4221                    reg_info->min_bw_5g, reg_info->max_bw_5g);
4222
4223         ath11k_dbg(ab, ATH11K_DBG_WMI,
4224                    "%s: num_2g_reg_rules %d num_5g_reg_rules %d", __func__,
4225                    num_2g_reg_rules, num_5g_reg_rules);
4226
4227         wmi_reg_rule =
4228                 (struct wmi_regulatory_rule_struct *)((u8 *)chan_list_event_hdr
4229                                                 + sizeof(*chan_list_event_hdr)
4230                                                 + sizeof(struct wmi_tlv));
4231
4232         if (num_2g_reg_rules) {
4233                 reg_info->reg_rules_2g_ptr = create_reg_rules_from_wmi(num_2g_reg_rules,
4234                                                                        wmi_reg_rule);
4235                 if (!reg_info->reg_rules_2g_ptr) {
4236                         kfree(tb);
4237                         ath11k_warn(ab, "Unable to Allocate memory for 2g rules\n");
4238                         return -ENOMEM;
4239                 }
4240         }
4241
4242         if (num_5g_reg_rules) {
4243                 wmi_reg_rule += num_2g_reg_rules;
4244                 reg_info->reg_rules_5g_ptr = create_reg_rules_from_wmi(num_5g_reg_rules,
4245                                                                        wmi_reg_rule);
4246                 if (!reg_info->reg_rules_5g_ptr) {
4247                         kfree(tb);
4248                         ath11k_warn(ab, "Unable to Allocate memory for 5g rules\n");
4249                         return -ENOMEM;
4250                 }
4251         }
4252
4253         ath11k_dbg(ab, ATH11K_DBG_WMI, "processed regulatory channel list\n");
4254
4255         kfree(tb);
4256         return 0;
4257 }
4258
4259 static int ath11k_pull_peer_del_resp_ev(struct ath11k_base *ab, struct sk_buff *skb,
4260                                         struct wmi_peer_delete_resp_event *peer_del_resp)
4261 {
4262         const void **tb;
4263         const struct wmi_peer_delete_resp_event *ev;
4264         int ret;
4265
4266         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4267         if (IS_ERR(tb)) {
4268                 ret = PTR_ERR(tb);
4269                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4270                 return ret;
4271         }
4272
4273         ev = tb[WMI_TAG_PEER_DELETE_RESP_EVENT];
4274         if (!ev) {
4275                 ath11k_warn(ab, "failed to fetch peer delete resp ev");
4276                 kfree(tb);
4277                 return -EPROTO;
4278         }
4279
4280         memset(peer_del_resp, 0, sizeof(*peer_del_resp));
4281
4282         peer_del_resp->vdev_id = ev->vdev_id;
4283         ether_addr_copy(peer_del_resp->peer_macaddr.addr,
4284                         ev->peer_macaddr.addr);
4285
4286         kfree(tb);
4287         return 0;
4288 }
4289
4290 static int ath11k_pull_bcn_tx_status_ev(struct ath11k_base *ab, void *evt_buf,
4291                                         u32 len, u32 *vdev_id,
4292                                         u32 *tx_status)
4293 {
4294         const void **tb;
4295         const struct wmi_bcn_tx_status_event *ev;
4296         int ret;
4297
4298         tb = ath11k_wmi_tlv_parse_alloc(ab, evt_buf, len, GFP_ATOMIC);
4299         if (IS_ERR(tb)) {
4300                 ret = PTR_ERR(tb);
4301                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4302                 return ret;
4303         }
4304
4305         ev = tb[WMI_TAG_OFFLOAD_BCN_TX_STATUS_EVENT];
4306         if (!ev) {
4307                 ath11k_warn(ab, "failed to fetch bcn tx status ev");
4308                 kfree(tb);
4309                 return -EPROTO;
4310         }
4311
4312         *vdev_id   = ev->vdev_id;
4313         *tx_status = ev->tx_status;
4314
4315         kfree(tb);
4316         return 0;
4317 }
4318
4319 static int ath11k_pull_vdev_stopped_param_tlv(struct ath11k_base *ab, struct sk_buff *skb,
4320                                               u32 *vdev_id)
4321 {
4322         const void **tb;
4323         const struct wmi_vdev_stopped_event *ev;
4324         int ret;
4325
4326         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4327         if (IS_ERR(tb)) {
4328                 ret = PTR_ERR(tb);
4329                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4330                 return ret;
4331         }
4332
4333         ev = tb[WMI_TAG_VDEV_STOPPED_EVENT];
4334         if (!ev) {
4335                 ath11k_warn(ab, "failed to fetch vdev stop ev");
4336                 kfree(tb);
4337                 return -EPROTO;
4338         }
4339
4340         *vdev_id =  ev->vdev_id;
4341
4342         kfree(tb);
4343         return 0;
4344 }
4345
4346 static int ath11k_pull_mgmt_rx_params_tlv(struct ath11k_base *ab,
4347                                           struct sk_buff *skb,
4348                                           struct mgmt_rx_event_params *hdr)
4349 {
4350         const void **tb;
4351         const struct wmi_mgmt_rx_hdr *ev;
4352         const u8 *frame;
4353         int ret;
4354
4355         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4356         if (IS_ERR(tb)) {
4357                 ret = PTR_ERR(tb);
4358                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4359                 return ret;
4360         }
4361
4362         ev = tb[WMI_TAG_MGMT_RX_HDR];
4363         frame = tb[WMI_TAG_ARRAY_BYTE];
4364
4365         if (!ev || !frame) {
4366                 ath11k_warn(ab, "failed to fetch mgmt rx hdr");
4367                 kfree(tb);
4368                 return -EPROTO;
4369         }
4370
4371         hdr->pdev_id =  ev->pdev_id;
4372         hdr->chan_freq = ev->chan_freq;
4373         hdr->channel =  ev->channel;
4374         hdr->snr =  ev->snr;
4375         hdr->rate =  ev->rate;
4376         hdr->phy_mode =  ev->phy_mode;
4377         hdr->buf_len =  ev->buf_len;
4378         hdr->status =  ev->status;
4379         hdr->flags =  ev->flags;
4380         hdr->rssi =  ev->rssi;
4381         hdr->tsf_delta =  ev->tsf_delta;
4382         memcpy(hdr->rssi_ctl, ev->rssi_ctl, sizeof(hdr->rssi_ctl));
4383
4384         if (skb->len < (frame - skb->data) + hdr->buf_len) {
4385                 ath11k_warn(ab, "invalid length in mgmt rx hdr ev");
4386                 kfree(tb);
4387                 return -EPROTO;
4388         }
4389
4390         /* shift the sk_buff to point to `frame` */
4391         skb_trim(skb, 0);
4392         skb_put(skb, frame - skb->data);
4393         skb_pull(skb, frame - skb->data);
4394         skb_put(skb, hdr->buf_len);
4395
4396         ath11k_ce_byte_swap(skb->data, hdr->buf_len);
4397
4398         kfree(tb);
4399         return 0;
4400 }
4401
4402 static int wmi_process_mgmt_tx_comp(struct ath11k *ar, u32 desc_id,
4403                                     u32 status)
4404 {
4405         struct sk_buff *msdu;
4406         struct ieee80211_tx_info *info;
4407         struct ath11k_skb_cb *skb_cb;
4408
4409         spin_lock_bh(&ar->txmgmt_idr_lock);
4410         msdu = idr_find(&ar->txmgmt_idr, desc_id);
4411
4412         if (!msdu) {
4413                 ath11k_warn(ar->ab, "received mgmt tx compl for invalid msdu_id: %d\n",
4414                             desc_id);
4415                 spin_unlock_bh(&ar->txmgmt_idr_lock);
4416                 return -ENOENT;
4417         }
4418
4419         idr_remove(&ar->txmgmt_idr, desc_id);
4420         spin_unlock_bh(&ar->txmgmt_idr_lock);
4421
4422         skb_cb = ATH11K_SKB_CB(msdu);
4423         dma_unmap_single(ar->ab->dev, skb_cb->paddr, msdu->len, DMA_TO_DEVICE);
4424
4425         info = IEEE80211_SKB_CB(msdu);
4426         if ((!(info->flags & IEEE80211_TX_CTL_NO_ACK)) && !status)
4427                 info->flags |= IEEE80211_TX_STAT_ACK;
4428
4429         ieee80211_tx_status_irqsafe(ar->hw, msdu);
4430
4431         /* WARN when we received this event without doing any mgmt tx */
4432         if (atomic_dec_if_positive(&ar->num_pending_mgmt_tx) < 0)
4433                 WARN_ON_ONCE(1);
4434
4435         return 0;
4436 }
4437
4438 static int ath11k_pull_mgmt_tx_compl_param_tlv(struct ath11k_base *ab,
4439                                                struct sk_buff *skb,
4440                                                struct wmi_mgmt_tx_compl_event *param)
4441 {
4442         const void **tb;
4443         const struct wmi_mgmt_tx_compl_event *ev;
4444         int ret;
4445
4446         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4447         if (IS_ERR(tb)) {
4448                 ret = PTR_ERR(tb);
4449                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4450                 return ret;
4451         }
4452
4453         ev = tb[WMI_TAG_MGMT_TX_COMPL_EVENT];
4454         if (!ev) {
4455                 ath11k_warn(ab, "failed to fetch mgmt tx compl ev");
4456                 kfree(tb);
4457                 return -EPROTO;
4458         }
4459
4460         param->pdev_id = ev->pdev_id;
4461         param->desc_id = ev->desc_id;
4462         param->status = ev->status;
4463
4464         kfree(tb);
4465         return 0;
4466 }
4467
4468 static void ath11k_wmi_event_scan_started(struct ath11k *ar)
4469 {
4470         lockdep_assert_held(&ar->data_lock);
4471
4472         switch (ar->scan.state) {
4473         case ATH11K_SCAN_IDLE:
4474         case ATH11K_SCAN_RUNNING:
4475         case ATH11K_SCAN_ABORTING:
4476                 ath11k_warn(ar->ab, "received scan started event in an invalid scan state: %s (%d)\n",
4477                             ath11k_scan_state_str(ar->scan.state),
4478                             ar->scan.state);
4479                 break;
4480         case ATH11K_SCAN_STARTING:
4481                 ar->scan.state = ATH11K_SCAN_RUNNING;
4482                 complete(&ar->scan.started);
4483                 break;
4484         }
4485 }
4486
4487 static void ath11k_wmi_event_scan_start_failed(struct ath11k *ar)
4488 {
4489         lockdep_assert_held(&ar->data_lock);
4490
4491         switch (ar->scan.state) {
4492         case ATH11K_SCAN_IDLE:
4493         case ATH11K_SCAN_RUNNING:
4494         case ATH11K_SCAN_ABORTING:
4495                 ath11k_warn(ar->ab, "received scan start failed event in an invalid scan state: %s (%d)\n",
4496                             ath11k_scan_state_str(ar->scan.state),
4497                             ar->scan.state);
4498                 break;
4499         case ATH11K_SCAN_STARTING:
4500                 complete(&ar->scan.started);
4501                 __ath11k_mac_scan_finish(ar);
4502                 break;
4503         }
4504 }
4505
4506 static void ath11k_wmi_event_scan_completed(struct ath11k *ar)
4507 {
4508         lockdep_assert_held(&ar->data_lock);
4509
4510         switch (ar->scan.state) {
4511         case ATH11K_SCAN_IDLE:
4512         case ATH11K_SCAN_STARTING:
4513                 /* One suspected reason scan can be completed while starting is
4514                  * if firmware fails to deliver all scan events to the host,
4515                  * e.g. when transport pipe is full. This has been observed
4516                  * with spectral scan phyerr events starving wmi transport
4517                  * pipe. In such case the "scan completed" event should be (and
4518                  * is) ignored by the host as it may be just firmware's scan
4519                  * state machine recovering.
4520                  */
4521                 ath11k_warn(ar->ab, "received scan completed event in an invalid scan state: %s (%d)\n",
4522                             ath11k_scan_state_str(ar->scan.state),
4523                             ar->scan.state);
4524                 break;
4525         case ATH11K_SCAN_RUNNING:
4526         case ATH11K_SCAN_ABORTING:
4527                 __ath11k_mac_scan_finish(ar);
4528                 break;
4529         }
4530 }
4531
4532 static void ath11k_wmi_event_scan_bss_chan(struct ath11k *ar)
4533 {
4534         lockdep_assert_held(&ar->data_lock);
4535
4536         switch (ar->scan.state) {
4537         case ATH11K_SCAN_IDLE:
4538         case ATH11K_SCAN_STARTING:
4539                 ath11k_warn(ar->ab, "received scan bss chan event in an invalid scan state: %s (%d)\n",
4540                             ath11k_scan_state_str(ar->scan.state),
4541                             ar->scan.state);
4542                 break;
4543         case ATH11K_SCAN_RUNNING:
4544         case ATH11K_SCAN_ABORTING:
4545                 ar->scan_channel = NULL;
4546                 break;
4547         }
4548 }
4549
4550 static void ath11k_wmi_event_scan_foreign_chan(struct ath11k *ar, u32 freq)
4551 {
4552         lockdep_assert_held(&ar->data_lock);
4553
4554         switch (ar->scan.state) {
4555         case ATH11K_SCAN_IDLE:
4556         case ATH11K_SCAN_STARTING:
4557                 ath11k_warn(ar->ab, "received scan foreign chan event in an invalid scan state: %s (%d)\n",
4558                             ath11k_scan_state_str(ar->scan.state),
4559                             ar->scan.state);
4560                 break;
4561         case ATH11K_SCAN_RUNNING:
4562         case ATH11K_SCAN_ABORTING:
4563                 ar->scan_channel = ieee80211_get_channel(ar->hw->wiphy, freq);
4564                 break;
4565         }
4566 }
4567
4568 static const char *
4569 ath11k_wmi_event_scan_type_str(enum wmi_scan_event_type type,
4570                                enum wmi_scan_completion_reason reason)
4571 {
4572         switch (type) {
4573         case WMI_SCAN_EVENT_STARTED:
4574                 return "started";
4575         case WMI_SCAN_EVENT_COMPLETED:
4576                 switch (reason) {
4577                 case WMI_SCAN_REASON_COMPLETED:
4578                         return "completed";
4579                 case WMI_SCAN_REASON_CANCELLED:
4580                         return "completed [cancelled]";
4581                 case WMI_SCAN_REASON_PREEMPTED:
4582                         return "completed [preempted]";
4583                 case WMI_SCAN_REASON_TIMEDOUT:
4584                         return "completed [timedout]";
4585                 case WMI_SCAN_REASON_INTERNAL_FAILURE:
4586                         return "completed [internal err]";
4587                 case WMI_SCAN_REASON_MAX:
4588                         break;
4589                 }
4590                 return "completed [unknown]";
4591         case WMI_SCAN_EVENT_BSS_CHANNEL:
4592                 return "bss channel";
4593         case WMI_SCAN_EVENT_FOREIGN_CHAN:
4594                 return "foreign channel";
4595         case WMI_SCAN_EVENT_DEQUEUED:
4596                 return "dequeued";
4597         case WMI_SCAN_EVENT_PREEMPTED:
4598                 return "preempted";
4599         case WMI_SCAN_EVENT_START_FAILED:
4600                 return "start failed";
4601         case WMI_SCAN_EVENT_RESTARTED:
4602                 return "restarted";
4603         case WMI_SCAN_EVENT_FOREIGN_CHAN_EXIT:
4604                 return "foreign channel exit";
4605         default:
4606                 return "unknown";
4607         }
4608 }
4609
4610 static int ath11k_pull_scan_ev(struct ath11k_base *ab, struct sk_buff *skb,
4611                                struct wmi_scan_event *scan_evt_param)
4612 {
4613         const void **tb;
4614         const struct wmi_scan_event *ev;
4615         int ret;
4616
4617         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4618         if (IS_ERR(tb)) {
4619                 ret = PTR_ERR(tb);
4620                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4621                 return ret;
4622         }
4623
4624         ev = tb[WMI_TAG_SCAN_EVENT];
4625         if (!ev) {
4626                 ath11k_warn(ab, "failed to fetch scan ev");
4627                 kfree(tb);
4628                 return -EPROTO;
4629         }
4630
4631         scan_evt_param->event_type = ev->event_type;
4632         scan_evt_param->reason = ev->reason;
4633         scan_evt_param->channel_freq = ev->channel_freq;
4634         scan_evt_param->scan_req_id = ev->scan_req_id;
4635         scan_evt_param->scan_id = ev->scan_id;
4636         scan_evt_param->vdev_id = ev->vdev_id;
4637         scan_evt_param->tsf_timestamp = ev->tsf_timestamp;
4638
4639         kfree(tb);
4640         return 0;
4641 }
4642
4643 static int ath11k_pull_peer_sta_kickout_ev(struct ath11k_base *ab, struct sk_buff *skb,
4644                                            struct wmi_peer_sta_kickout_arg *arg)
4645 {
4646         const void **tb;
4647         const struct wmi_peer_sta_kickout_event *ev;
4648         int ret;
4649
4650         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4651         if (IS_ERR(tb)) {
4652                 ret = PTR_ERR(tb);
4653                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4654                 return ret;
4655         }
4656
4657         ev = tb[WMI_TAG_PEER_STA_KICKOUT_EVENT];
4658         if (!ev) {
4659                 ath11k_warn(ab, "failed to fetch peer sta kickout ev");
4660                 kfree(tb);
4661                 return -EPROTO;
4662         }
4663
4664         arg->mac_addr = ev->peer_macaddr.addr;
4665
4666         kfree(tb);
4667         return 0;
4668 }
4669
4670 static int ath11k_pull_roam_ev(struct ath11k_base *ab, struct sk_buff *skb,
4671                                struct wmi_roam_event *roam_ev)
4672 {
4673         const void **tb;
4674         const struct wmi_roam_event *ev;
4675         int ret;
4676
4677         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4678         if (IS_ERR(tb)) {
4679                 ret = PTR_ERR(tb);
4680                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4681                 return ret;
4682         }
4683
4684         ev = tb[WMI_TAG_ROAM_EVENT];
4685         if (!ev) {
4686                 ath11k_warn(ab, "failed to fetch roam ev");
4687                 kfree(tb);
4688                 return -EPROTO;
4689         }
4690
4691         roam_ev->vdev_id = ev->vdev_id;
4692         roam_ev->reason = ev->reason;
4693         roam_ev->rssi = ev->rssi;
4694
4695         kfree(tb);
4696         return 0;
4697 }
4698
4699 static int freq_to_idx(struct ath11k *ar, int freq)
4700 {
4701         struct ieee80211_supported_band *sband;
4702         int band, ch, idx = 0;
4703
4704         for (band = NL80211_BAND_2GHZ; band < NUM_NL80211_BANDS; band++) {
4705                 sband = ar->hw->wiphy->bands[band];
4706                 if (!sband)
4707                         continue;
4708
4709                 for (ch = 0; ch < sband->n_channels; ch++, idx++)
4710                         if (sband->channels[ch].center_freq == freq)
4711                                 goto exit;
4712         }
4713
4714 exit:
4715         return idx;
4716 }
4717
4718 static int ath11k_pull_chan_info_ev(struct ath11k_base *ab, u8 *evt_buf,
4719                                     u32 len, struct wmi_chan_info_event *ch_info_ev)
4720 {
4721         const void **tb;
4722         const struct wmi_chan_info_event *ev;
4723         int ret;
4724
4725         tb = ath11k_wmi_tlv_parse_alloc(ab, evt_buf, len, GFP_ATOMIC);
4726         if (IS_ERR(tb)) {
4727                 ret = PTR_ERR(tb);
4728                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4729                 return ret;
4730         }
4731
4732         ev = tb[WMI_TAG_CHAN_INFO_EVENT];
4733         if (!ev) {
4734                 ath11k_warn(ab, "failed to fetch chan info ev");
4735                 kfree(tb);
4736                 return -EPROTO;
4737         }
4738
4739         ch_info_ev->err_code = ev->err_code;
4740         ch_info_ev->freq = ev->freq;
4741         ch_info_ev->cmd_flags = ev->cmd_flags;
4742         ch_info_ev->noise_floor = ev->noise_floor;
4743         ch_info_ev->rx_clear_count = ev->rx_clear_count;
4744         ch_info_ev->cycle_count = ev->cycle_count;
4745         ch_info_ev->chan_tx_pwr_range = ev->chan_tx_pwr_range;
4746         ch_info_ev->chan_tx_pwr_tp = ev->chan_tx_pwr_tp;
4747         ch_info_ev->rx_frame_count = ev->rx_frame_count;
4748         ch_info_ev->tx_frame_cnt = ev->tx_frame_cnt;
4749         ch_info_ev->mac_clk_mhz = ev->mac_clk_mhz;
4750         ch_info_ev->vdev_id = ev->vdev_id;
4751
4752         kfree(tb);
4753         return 0;
4754 }
4755
4756 static int
4757 ath11k_pull_pdev_bss_chan_info_ev(struct ath11k_base *ab, struct sk_buff *skb,
4758                                   struct wmi_pdev_bss_chan_info_event *bss_ch_info_ev)
4759 {
4760         const void **tb;
4761         const struct wmi_pdev_bss_chan_info_event *ev;
4762         int ret;
4763
4764         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4765         if (IS_ERR(tb)) {
4766                 ret = PTR_ERR(tb);
4767                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4768                 return ret;
4769         }
4770
4771         ev = tb[WMI_TAG_PDEV_BSS_CHAN_INFO_EVENT];
4772         if (!ev) {
4773                 ath11k_warn(ab, "failed to fetch pdev bss chan info ev");
4774                 kfree(tb);
4775                 return -EPROTO;
4776         }
4777
4778         bss_ch_info_ev->pdev_id = ev->pdev_id;
4779         bss_ch_info_ev->freq = ev->freq;
4780         bss_ch_info_ev->noise_floor = ev->noise_floor;
4781         bss_ch_info_ev->rx_clear_count_low = ev->rx_clear_count_low;
4782         bss_ch_info_ev->rx_clear_count_high = ev->rx_clear_count_high;
4783         bss_ch_info_ev->cycle_count_low = ev->cycle_count_low;
4784         bss_ch_info_ev->cycle_count_high = ev->cycle_count_high;
4785         bss_ch_info_ev->tx_cycle_count_low = ev->tx_cycle_count_low;
4786         bss_ch_info_ev->tx_cycle_count_high = ev->tx_cycle_count_high;
4787         bss_ch_info_ev->rx_cycle_count_low = ev->rx_cycle_count_low;
4788         bss_ch_info_ev->rx_cycle_count_high = ev->rx_cycle_count_high;
4789         bss_ch_info_ev->rx_bss_cycle_count_low = ev->rx_bss_cycle_count_low;
4790         bss_ch_info_ev->rx_bss_cycle_count_high = ev->rx_bss_cycle_count_high;
4791
4792         kfree(tb);
4793         return 0;
4794 }
4795
4796 static int
4797 ath11k_pull_vdev_install_key_compl_ev(struct ath11k_base *ab, struct sk_buff *skb,
4798                                       struct wmi_vdev_install_key_complete_arg *arg)
4799 {
4800         const void **tb;
4801         const struct wmi_vdev_install_key_compl_event *ev;
4802         int ret;
4803
4804         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4805         if (IS_ERR(tb)) {
4806                 ret = PTR_ERR(tb);
4807                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4808                 return ret;
4809         }
4810
4811         ev = tb[WMI_TAG_VDEV_INSTALL_KEY_COMPLETE_EVENT];
4812         if (!ev) {
4813                 ath11k_warn(ab, "failed to fetch vdev install key compl ev");
4814                 kfree(tb);
4815                 return -EPROTO;
4816         }
4817
4818         arg->vdev_id = ev->vdev_id;
4819         arg->macaddr = ev->peer_macaddr.addr;
4820         arg->key_idx = ev->key_idx;
4821         arg->key_flags = ev->key_flags;
4822         arg->status = ev->status;
4823
4824         kfree(tb);
4825         return 0;
4826 }
4827
4828 static int ath11k_pull_peer_assoc_conf_ev(struct ath11k_base *ab, struct sk_buff *skb,
4829                                           struct wmi_peer_assoc_conf_arg *peer_assoc_conf)
4830 {
4831         const void **tb;
4832         const struct wmi_peer_assoc_conf_event *ev;
4833         int ret;
4834
4835         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
4836         if (IS_ERR(tb)) {
4837                 ret = PTR_ERR(tb);
4838                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4839                 return ret;
4840         }
4841
4842         ev = tb[WMI_TAG_PEER_ASSOC_CONF_EVENT];
4843         if (!ev) {
4844                 ath11k_warn(ab, "failed to fetch peer assoc conf ev");
4845                 kfree(tb);
4846                 return -EPROTO;
4847         }
4848
4849         peer_assoc_conf->vdev_id = ev->vdev_id;
4850         peer_assoc_conf->macaddr = ev->peer_macaddr.addr;
4851
4852         kfree(tb);
4853         return 0;
4854 }
4855
4856 static void ath11k_wmi_pull_pdev_stats_base(const struct wmi_pdev_stats_base *src,
4857                                             struct ath11k_fw_stats_pdev *dst)
4858 {
4859         dst->ch_noise_floor = src->chan_nf;
4860         dst->tx_frame_count = src->tx_frame_count;
4861         dst->rx_frame_count = src->rx_frame_count;
4862         dst->rx_clear_count = src->rx_clear_count;
4863         dst->cycle_count = src->cycle_count;
4864         dst->phy_err_count = src->phy_err_count;
4865         dst->chan_tx_power = src->chan_tx_pwr;
4866 }
4867
4868 static void
4869 ath11k_wmi_pull_pdev_stats_tx(const struct wmi_pdev_stats_tx *src,
4870                               struct ath11k_fw_stats_pdev *dst)
4871 {
4872         dst->comp_queued = src->comp_queued;
4873         dst->comp_delivered = src->comp_delivered;
4874         dst->msdu_enqued = src->msdu_enqued;
4875         dst->mpdu_enqued = src->mpdu_enqued;
4876         dst->wmm_drop = src->wmm_drop;
4877         dst->local_enqued = src->local_enqued;
4878         dst->local_freed = src->local_freed;
4879         dst->hw_queued = src->hw_queued;
4880         dst->hw_reaped = src->hw_reaped;
4881         dst->underrun = src->underrun;
4882         dst->tx_abort = src->tx_abort;
4883         dst->mpdus_requed = src->mpdus_requed;
4884         dst->tx_ko = src->tx_ko;
4885         dst->data_rc = src->data_rc;
4886         dst->self_triggers = src->self_triggers;
4887         dst->sw_retry_failure = src->sw_retry_failure;
4888         dst->illgl_rate_phy_err = src->illgl_rate_phy_err;
4889         dst->pdev_cont_xretry = src->pdev_cont_xretry;
4890         dst->pdev_tx_timeout = src->pdev_tx_timeout;
4891         dst->pdev_resets = src->pdev_resets;
4892         dst->stateless_tid_alloc_failure = src->stateless_tid_alloc_failure;
4893         dst->phy_underrun = src->phy_underrun;
4894         dst->txop_ovf = src->txop_ovf;
4895 }
4896
4897 static void ath11k_wmi_pull_pdev_stats_rx(const struct wmi_pdev_stats_rx *src,
4898                                           struct ath11k_fw_stats_pdev *dst)
4899 {
4900         dst->mid_ppdu_route_change = src->mid_ppdu_route_change;
4901         dst->status_rcvd = src->status_rcvd;
4902         dst->r0_frags = src->r0_frags;
4903         dst->r1_frags = src->r1_frags;
4904         dst->r2_frags = src->r2_frags;
4905         dst->r3_frags = src->r3_frags;
4906         dst->htt_msdus = src->htt_msdus;
4907         dst->htt_mpdus = src->htt_mpdus;
4908         dst->loc_msdus = src->loc_msdus;
4909         dst->loc_mpdus = src->loc_mpdus;
4910         dst->oversize_amsdu = src->oversize_amsdu;
4911         dst->phy_errs = src->phy_errs;
4912         dst->phy_err_drop = src->phy_err_drop;
4913         dst->mpdu_errs = src->mpdu_errs;
4914 }
4915
4916 static void
4917 ath11k_wmi_pull_vdev_stats(const struct wmi_vdev_stats *src,
4918                            struct ath11k_fw_stats_vdev *dst)
4919 {
4920         int i;
4921
4922         dst->vdev_id = src->vdev_id;
4923         dst->beacon_snr = src->beacon_snr;
4924         dst->data_snr = src->data_snr;
4925         dst->num_rx_frames = src->num_rx_frames;
4926         dst->num_rts_fail = src->num_rts_fail;
4927         dst->num_rts_success = src->num_rts_success;
4928         dst->num_rx_err = src->num_rx_err;
4929         dst->num_rx_discard = src->num_rx_discard;
4930         dst->num_tx_not_acked = src->num_tx_not_acked;
4931
4932         for (i = 0; i < ARRAY_SIZE(src->num_tx_frames); i++)
4933                 dst->num_tx_frames[i] = src->num_tx_frames[i];
4934
4935         for (i = 0; i < ARRAY_SIZE(src->num_tx_frames_retries); i++)
4936                 dst->num_tx_frames_retries[i] = src->num_tx_frames_retries[i];
4937
4938         for (i = 0; i < ARRAY_SIZE(src->num_tx_frames_failures); i++)
4939                 dst->num_tx_frames_failures[i] = src->num_tx_frames_failures[i];
4940
4941         for (i = 0; i < ARRAY_SIZE(src->tx_rate_history); i++)
4942                 dst->tx_rate_history[i] = src->tx_rate_history[i];
4943
4944         for (i = 0; i < ARRAY_SIZE(src->beacon_rssi_history); i++)
4945                 dst->beacon_rssi_history[i] = src->beacon_rssi_history[i];
4946 }
4947
4948 static void
4949 ath11k_wmi_pull_bcn_stats(const struct wmi_bcn_stats *src,
4950                           struct ath11k_fw_stats_bcn *dst)
4951 {
4952         dst->vdev_id = src->vdev_id;
4953         dst->tx_bcn_succ_cnt = src->tx_bcn_succ_cnt;
4954         dst->tx_bcn_outage_cnt = src->tx_bcn_outage_cnt;
4955 }
4956
4957 int ath11k_wmi_pull_fw_stats(struct ath11k_base *ab, struct sk_buff *skb,
4958                              struct ath11k_fw_stats *stats)
4959 {
4960         const void **tb;
4961         const struct wmi_stats_event *ev;
4962         const void *data;
4963         int i, ret;
4964         u32 len = skb->len;
4965
4966         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, len, GFP_ATOMIC);
4967         if (IS_ERR(tb)) {
4968                 ret = PTR_ERR(tb);
4969                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
4970                 return ret;
4971         }
4972
4973         ev = tb[WMI_TAG_STATS_EVENT];
4974         data = tb[WMI_TAG_ARRAY_BYTE];
4975         if (!ev || !data) {
4976                 ath11k_warn(ab, "failed to fetch update stats ev");
4977                 kfree(tb);
4978                 return -EPROTO;
4979         }
4980
4981         ath11k_dbg(ab, ATH11K_DBG_WMI,
4982                    "wmi stats update ev pdev_id %d pdev %i vdev %i bcn %i\n",
4983                    ev->pdev_id,
4984                    ev->num_pdev_stats, ev->num_vdev_stats,
4985                    ev->num_bcn_stats);
4986
4987         stats->pdev_id = ev->pdev_id;
4988         stats->stats_id = 0;
4989
4990         for (i = 0; i < ev->num_pdev_stats; i++) {
4991                 const struct wmi_pdev_stats *src;
4992                 struct ath11k_fw_stats_pdev *dst;
4993
4994                 src = data;
4995                 if (len < sizeof(*src)) {
4996                         kfree(tb);
4997                         return -EPROTO;
4998                 }
4999
5000                 stats->stats_id = WMI_REQUEST_PDEV_STAT;
5001
5002                 data += sizeof(*src);
5003                 len -= sizeof(*src);
5004
5005                 dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
5006                 if (!dst)
5007                         continue;
5008
5009                 ath11k_wmi_pull_pdev_stats_base(&src->base, dst);
5010                 ath11k_wmi_pull_pdev_stats_tx(&src->tx, dst);
5011                 ath11k_wmi_pull_pdev_stats_rx(&src->rx, dst);
5012                 list_add_tail(&dst->list, &stats->pdevs);
5013         }
5014
5015         for (i = 0; i < ev->num_vdev_stats; i++) {
5016                 const struct wmi_vdev_stats *src;
5017                 struct ath11k_fw_stats_vdev *dst;
5018
5019                 src = data;
5020                 if (len < sizeof(*src)) {
5021                         kfree(tb);
5022                         return -EPROTO;
5023                 }
5024
5025                 stats->stats_id = WMI_REQUEST_VDEV_STAT;
5026
5027                 data += sizeof(*src);
5028                 len -= sizeof(*src);
5029
5030                 dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
5031                 if (!dst)
5032                         continue;
5033
5034                 ath11k_wmi_pull_vdev_stats(src, dst);
5035                 list_add_tail(&dst->list, &stats->vdevs);
5036         }
5037
5038         for (i = 0; i < ev->num_bcn_stats; i++) {
5039                 const struct wmi_bcn_stats *src;
5040                 struct ath11k_fw_stats_bcn *dst;
5041
5042                 src = data;
5043                 if (len < sizeof(*src)) {
5044                         kfree(tb);
5045                         return -EPROTO;
5046                 }
5047
5048                 stats->stats_id = WMI_REQUEST_BCN_STAT;
5049
5050                 data += sizeof(*src);
5051                 len -= sizeof(*src);
5052
5053                 dst = kzalloc(sizeof(*dst), GFP_ATOMIC);
5054                 if (!dst)
5055                         continue;
5056
5057                 ath11k_wmi_pull_bcn_stats(src, dst);
5058                 list_add_tail(&dst->list, &stats->bcn);
5059         }
5060
5061         kfree(tb);
5062         return 0;
5063 }
5064
5065 static int
5066 ath11k_pull_pdev_temp_ev(struct ath11k_base *ab, u8 *evt_buf,
5067                          u32 len, const struct wmi_pdev_temperature_event *ev)
5068 {
5069         const void **tb;
5070         int ret;
5071
5072         tb = ath11k_wmi_tlv_parse_alloc(ab, evt_buf, len, GFP_ATOMIC);
5073         if (IS_ERR(tb)) {
5074                 ret = PTR_ERR(tb);
5075                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
5076                 return ret;
5077         }
5078
5079         ev = tb[WMI_TAG_PDEV_TEMPERATURE_EVENT];
5080         if (!ev) {
5081                 ath11k_warn(ab, "failed to fetch pdev temp ev");
5082                 kfree(tb);
5083                 return -EPROTO;
5084         }
5085
5086         kfree(tb);
5087         return 0;
5088 }
5089
5090 size_t ath11k_wmi_fw_stats_num_vdevs(struct list_head *head)
5091 {
5092         struct ath11k_fw_stats_vdev *i;
5093         size_t num = 0;
5094
5095         list_for_each_entry(i, head, list)
5096                 ++num;
5097
5098         return num;
5099 }
5100
5101 static size_t ath11k_wmi_fw_stats_num_bcn(struct list_head *head)
5102 {
5103         struct ath11k_fw_stats_bcn *i;
5104         size_t num = 0;
5105
5106         list_for_each_entry(i, head, list)
5107                 ++num;
5108
5109         return num;
5110 }
5111
5112 static void
5113 ath11k_wmi_fw_pdev_base_stats_fill(const struct ath11k_fw_stats_pdev *pdev,
5114                                    char *buf, u32 *length)
5115 {
5116         u32 len = *length;
5117         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
5118
5119         len += scnprintf(buf + len, buf_len - len, "\n");
5120         len += scnprintf(buf + len, buf_len - len, "%30s\n",
5121                         "ath11k PDEV stats");
5122         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
5123                         "=================");
5124
5125         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5126                         "Channel noise floor", pdev->ch_noise_floor);
5127         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5128                         "Channel TX power", pdev->chan_tx_power);
5129         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5130                         "TX frame count", pdev->tx_frame_count);
5131         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5132                         "RX frame count", pdev->rx_frame_count);
5133         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5134                         "RX clear count", pdev->rx_clear_count);
5135         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5136                         "Cycle count", pdev->cycle_count);
5137         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5138                         "PHY error count", pdev->phy_err_count);
5139
5140         *length = len;
5141 }
5142
5143 static void
5144 ath11k_wmi_fw_pdev_tx_stats_fill(const struct ath11k_fw_stats_pdev *pdev,
5145                                  char *buf, u32 *length)
5146 {
5147         u32 len = *length;
5148         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
5149
5150         len += scnprintf(buf + len, buf_len - len, "\n%30s\n",
5151                          "ath11k PDEV TX stats");
5152         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
5153                          "====================");
5154
5155         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5156                          "HTT cookies queued", pdev->comp_queued);
5157         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5158                          "HTT cookies disp.", pdev->comp_delivered);
5159         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5160                          "MSDU queued", pdev->msdu_enqued);
5161         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5162                          "MPDU queued", pdev->mpdu_enqued);
5163         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5164                          "MSDUs dropped", pdev->wmm_drop);
5165         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5166                          "Local enqued", pdev->local_enqued);
5167         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5168                          "Local freed", pdev->local_freed);
5169         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5170                          "HW queued", pdev->hw_queued);
5171         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5172                          "PPDUs reaped", pdev->hw_reaped);
5173         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5174                          "Num underruns", pdev->underrun);
5175         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5176                          "PPDUs cleaned", pdev->tx_abort);
5177         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5178                          "MPDUs requed", pdev->mpdus_requed);
5179         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5180                          "Excessive retries", pdev->tx_ko);
5181         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5182                          "HW rate", pdev->data_rc);
5183         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5184                          "Sched self triggers", pdev->self_triggers);
5185         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5186                          "Dropped due to SW retries",
5187                          pdev->sw_retry_failure);
5188         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5189                          "Illegal rate phy errors",
5190                          pdev->illgl_rate_phy_err);
5191         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5192                          "PDEV continuous xretry", pdev->pdev_cont_xretry);
5193         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5194                          "TX timeout", pdev->pdev_tx_timeout);
5195         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5196                          "PDEV resets", pdev->pdev_resets);
5197         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5198                          "Stateless TIDs alloc failures",
5199                          pdev->stateless_tid_alloc_failure);
5200         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5201                          "PHY underrun", pdev->phy_underrun);
5202         len += scnprintf(buf + len, buf_len - len, "%30s %10u\n",
5203                          "MPDU is more than txop limit", pdev->txop_ovf);
5204         *length = len;
5205 }
5206
5207 static void
5208 ath11k_wmi_fw_pdev_rx_stats_fill(const struct ath11k_fw_stats_pdev *pdev,
5209                                  char *buf, u32 *length)
5210 {
5211         u32 len = *length;
5212         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
5213
5214         len += scnprintf(buf + len, buf_len - len, "\n%30s\n",
5215                          "ath11k PDEV RX stats");
5216         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
5217                          "====================");
5218
5219         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5220                          "Mid PPDU route change",
5221                          pdev->mid_ppdu_route_change);
5222         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5223                          "Tot. number of statuses", pdev->status_rcvd);
5224         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5225                          "Extra frags on rings 0", pdev->r0_frags);
5226         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5227                          "Extra frags on rings 1", pdev->r1_frags);
5228         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5229                          "Extra frags on rings 2", pdev->r2_frags);
5230         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5231                          "Extra frags on rings 3", pdev->r3_frags);
5232         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5233                          "MSDUs delivered to HTT", pdev->htt_msdus);
5234         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5235                          "MPDUs delivered to HTT", pdev->htt_mpdus);
5236         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5237                          "MSDUs delivered to stack", pdev->loc_msdus);
5238         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5239                          "MPDUs delivered to stack", pdev->loc_mpdus);
5240         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5241                          "Oversized AMSUs", pdev->oversize_amsdu);
5242         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5243                          "PHY errors", pdev->phy_errs);
5244         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5245                          "PHY errors drops", pdev->phy_err_drop);
5246         len += scnprintf(buf + len, buf_len - len, "%30s %10d\n",
5247                          "MPDU errors (FCS, MIC, ENC)", pdev->mpdu_errs);
5248         *length = len;
5249 }
5250
5251 static void
5252 ath11k_wmi_fw_vdev_stats_fill(struct ath11k *ar,
5253                               const struct ath11k_fw_stats_vdev *vdev,
5254                               char *buf, u32 *length)
5255 {
5256         u32 len = *length;
5257         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
5258         struct ath11k_vif *arvif = ath11k_mac_get_arvif(ar, vdev->vdev_id);
5259         u8 *vif_macaddr;
5260         int i;
5261
5262         /* VDEV stats has all the active VDEVs of other PDEVs as well,
5263          * ignoring those not part of requested PDEV
5264          */
5265         if (!arvif)
5266                 return;
5267
5268         vif_macaddr = arvif->vif->addr;
5269
5270         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5271                          "VDEV ID", vdev->vdev_id);
5272         len += scnprintf(buf + len, buf_len - len, "%30s %pM\n",
5273                          "VDEV MAC address", vif_macaddr);
5274         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5275                          "beacon snr", vdev->beacon_snr);
5276         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5277                          "data snr", vdev->data_snr);
5278         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5279                          "num rx frames", vdev->num_rx_frames);
5280         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5281                          "num rts fail", vdev->num_rts_fail);
5282         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5283                          "num rts success", vdev->num_rts_success);
5284         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5285                          "num rx err", vdev->num_rx_err);
5286         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5287                          "num rx discard", vdev->num_rx_discard);
5288         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5289                          "num tx not acked", vdev->num_tx_not_acked);
5290
5291         for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames); i++)
5292                 len += scnprintf(buf + len, buf_len - len,
5293                                 "%25s [%02d] %u\n",
5294                                 "num tx frames", i,
5295                                 vdev->num_tx_frames[i]);
5296
5297         for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames_retries); i++)
5298                 len += scnprintf(buf + len, buf_len - len,
5299                                 "%25s [%02d] %u\n",
5300                                 "num tx frames retries", i,
5301                                 vdev->num_tx_frames_retries[i]);
5302
5303         for (i = 0 ; i < ARRAY_SIZE(vdev->num_tx_frames_failures); i++)
5304                 len += scnprintf(buf + len, buf_len - len,
5305                                 "%25s [%02d] %u\n",
5306                                 "num tx frames failures", i,
5307                                 vdev->num_tx_frames_failures[i]);
5308
5309         for (i = 0 ; i < ARRAY_SIZE(vdev->tx_rate_history); i++)
5310                 len += scnprintf(buf + len, buf_len - len,
5311                                 "%25s [%02d] 0x%08x\n",
5312                                 "tx rate history", i,
5313                                 vdev->tx_rate_history[i]);
5314
5315         for (i = 0 ; i < ARRAY_SIZE(vdev->beacon_rssi_history); i++)
5316                 len += scnprintf(buf + len, buf_len - len,
5317                                 "%25s [%02d] %u\n",
5318                                 "beacon rssi history", i,
5319                                 vdev->beacon_rssi_history[i]);
5320
5321         len += scnprintf(buf + len, buf_len - len, "\n");
5322         *length = len;
5323 }
5324
5325 static void
5326 ath11k_wmi_fw_bcn_stats_fill(struct ath11k *ar,
5327                              const struct ath11k_fw_stats_bcn *bcn,
5328                              char *buf, u32 *length)
5329 {
5330         u32 len = *length;
5331         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
5332         struct ath11k_vif *arvif = ath11k_mac_get_arvif(ar, bcn->vdev_id);
5333         u8 *vdev_macaddr;
5334
5335         if (!arvif) {
5336                 ath11k_warn(ar->ab, "invalid vdev id %d in bcn stats",
5337                             bcn->vdev_id);
5338                 return;
5339         }
5340
5341         vdev_macaddr = arvif->vif->addr;
5342
5343         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5344                          "VDEV ID", bcn->vdev_id);
5345         len += scnprintf(buf + len, buf_len - len, "%30s %pM\n",
5346                          "VDEV MAC address", vdev_macaddr);
5347         len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
5348                          "================");
5349         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5350                          "Num of beacon tx success", bcn->tx_bcn_succ_cnt);
5351         len += scnprintf(buf + len, buf_len - len, "%30s %u\n",
5352                          "Num of beacon tx failures", bcn->tx_bcn_outage_cnt);
5353
5354         len += scnprintf(buf + len, buf_len - len, "\n");
5355         *length = len;
5356 }
5357
5358 void ath11k_wmi_fw_stats_fill(struct ath11k *ar,
5359                               struct ath11k_fw_stats *fw_stats,
5360                               u32 stats_id, char *buf)
5361 {
5362         u32 len = 0;
5363         u32 buf_len = ATH11K_FW_STATS_BUF_SIZE;
5364         const struct ath11k_fw_stats_pdev *pdev;
5365         const struct ath11k_fw_stats_vdev *vdev;
5366         const struct ath11k_fw_stats_bcn *bcn;
5367         size_t num_bcn;
5368
5369         spin_lock_bh(&ar->data_lock);
5370
5371         if (stats_id == WMI_REQUEST_PDEV_STAT) {
5372                 pdev = list_first_entry_or_null(&fw_stats->pdevs,
5373                                                 struct ath11k_fw_stats_pdev, list);
5374                 if (!pdev) {
5375                         ath11k_warn(ar->ab, "failed to get pdev stats\n");
5376                         goto unlock;
5377                 }
5378
5379                 ath11k_wmi_fw_pdev_base_stats_fill(pdev, buf, &len);
5380                 ath11k_wmi_fw_pdev_tx_stats_fill(pdev, buf, &len);
5381                 ath11k_wmi_fw_pdev_rx_stats_fill(pdev, buf, &len);
5382         }
5383
5384         if (stats_id == WMI_REQUEST_VDEV_STAT) {
5385                 len += scnprintf(buf + len, buf_len - len, "\n");
5386                 len += scnprintf(buf + len, buf_len - len, "%30s\n",
5387                                  "ath11k VDEV stats");
5388                 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
5389                                  "=================");
5390
5391                 list_for_each_entry(vdev, &fw_stats->vdevs, list)
5392                         ath11k_wmi_fw_vdev_stats_fill(ar, vdev, buf, &len);
5393         }
5394
5395         if (stats_id == WMI_REQUEST_BCN_STAT) {
5396                 num_bcn = ath11k_wmi_fw_stats_num_bcn(&fw_stats->bcn);
5397
5398                 len += scnprintf(buf + len, buf_len - len, "\n");
5399                 len += scnprintf(buf + len, buf_len - len, "%30s (%zu)\n",
5400                                  "ath11k Beacon stats", num_bcn);
5401                 len += scnprintf(buf + len, buf_len - len, "%30s\n\n",
5402                                  "===================");
5403
5404                 list_for_each_entry(bcn, &fw_stats->bcn, list)
5405                         ath11k_wmi_fw_bcn_stats_fill(ar, bcn, buf, &len);
5406         }
5407
5408 unlock:
5409         spin_unlock_bh(&ar->data_lock);
5410
5411         if (len >= buf_len)
5412                 buf[len - 1] = 0;
5413         else
5414                 buf[len] = 0;
5415 }
5416
5417 static void ath11k_wmi_op_ep_tx_credits(struct ath11k_base *ab)
5418 {
5419         /* try to send pending beacons first. they take priority */
5420         wake_up(&ab->wmi_ab.tx_credits_wq);
5421 }
5422
5423 static void ath11k_wmi_htc_tx_complete(struct ath11k_base *ab,
5424                                        struct sk_buff *skb)
5425 {
5426         dev_kfree_skb(skb);
5427 }
5428
5429 static bool ath11k_reg_is_world_alpha(char *alpha)
5430 {
5431         return alpha[0] == '0' && alpha[1] == '0';
5432 }
5433
5434 static int ath11k_reg_chan_list_event(struct ath11k_base *ab, struct sk_buff *skb)
5435 {
5436         struct cur_regulatory_info *reg_info = NULL;
5437         struct ieee80211_regdomain *regd = NULL;
5438         bool intersect = false;
5439         int ret = 0, pdev_idx;
5440         struct ath11k *ar;
5441
5442         reg_info = kzalloc(sizeof(*reg_info), GFP_ATOMIC);
5443         if (!reg_info) {
5444                 ret = -ENOMEM;
5445                 goto fallback;
5446         }
5447
5448         ret = ath11k_pull_reg_chan_list_update_ev(ab, skb, reg_info);
5449         if (ret) {
5450                 ath11k_warn(ab, "failed to extract regulatory info from received event\n");
5451                 goto fallback;
5452         }
5453
5454         if (reg_info->status_code != REG_SET_CC_STATUS_PASS) {
5455                 /* In case of failure to set the requested ctry,
5456                  * fw retains the current regd. We print a failure info
5457                  * and return from here.
5458                  */
5459                 ath11k_warn(ab, "Failed to set the requested Country regulatory setting\n");
5460                 goto mem_free;
5461         }
5462
5463         pdev_idx = reg_info->phy_id;
5464
5465         if (pdev_idx >= ab->num_radios) {
5466                 /* Process the event for phy0 only if single_pdev_only
5467                  * is true. If pdev_idx is valid but not 0, discard the
5468                  * event. Otherwise, it goes to fallback.
5469                  */
5470                 if (ab->hw_params.single_pdev_only &&
5471                     pdev_idx < ab->hw_params.num_rxmda_per_pdev)
5472                         goto mem_free;
5473                 else
5474                         goto fallback;
5475         }
5476
5477         /* Avoid multiple overwrites to default regd, during core
5478          * stop-start after mac registration.
5479          */
5480         if (ab->default_regd[pdev_idx] && !ab->new_regd[pdev_idx] &&
5481             !memcmp((char *)ab->default_regd[pdev_idx]->alpha2,
5482                     (char *)reg_info->alpha2, 2))
5483                 goto mem_free;
5484
5485         /* Intersect new rules with default regd if a new country setting was
5486          * requested, i.e a default regd was already set during initialization
5487          * and the regd coming from this event has a valid country info.
5488          */
5489         if (ab->default_regd[pdev_idx] &&
5490             !ath11k_reg_is_world_alpha((char *)
5491                 ab->default_regd[pdev_idx]->alpha2) &&
5492             !ath11k_reg_is_world_alpha((char *)reg_info->alpha2))
5493                 intersect = true;
5494
5495         regd = ath11k_reg_build_regd(ab, reg_info, intersect);
5496         if (!regd) {
5497                 ath11k_warn(ab, "failed to build regd from reg_info\n");
5498                 goto fallback;
5499         }
5500
5501         spin_lock(&ab->base_lock);
5502         if (test_bit(ATH11K_FLAG_REGISTERED, &ab->dev_flags)) {
5503                 /* Once mac is registered, ar is valid and all CC events from
5504                  * fw is considered to be received due to user requests
5505                  * currently.
5506                  * Free previously built regd before assigning the newly
5507                  * generated regd to ar. NULL pointer handling will be
5508                  * taken care by kfree itself.
5509                  */
5510                 ar = ab->pdevs[pdev_idx].ar;
5511                 kfree(ab->new_regd[pdev_idx]);
5512                 ab->new_regd[pdev_idx] = regd;
5513                 ieee80211_queue_work(ar->hw, &ar->regd_update_work);
5514         } else {
5515                 /* Multiple events for the same *ar is not expected. But we
5516                  * can still clear any previously stored default_regd if we
5517                  * are receiving this event for the same radio by mistake.
5518                  * NULL pointer handling will be taken care by kfree itself.
5519                  */
5520                 kfree(ab->default_regd[pdev_idx]);
5521                 /* This regd would be applied during mac registration */
5522                 ab->default_regd[pdev_idx] = regd;
5523         }
5524         ab->dfs_region = reg_info->dfs_region;
5525         spin_unlock(&ab->base_lock);
5526
5527         goto mem_free;
5528
5529 fallback:
5530         /* Fallback to older reg (by sending previous country setting
5531          * again if fw has succeded and we failed to process here.
5532          * The Regdomain should be uniform across driver and fw. Since the
5533          * FW has processed the command and sent a success status, we expect
5534          * this function to succeed as well. If it doesn't, CTRY needs to be
5535          * reverted at the fw and the old SCAN_CHAN_LIST cmd needs to be sent.
5536          */
5537         /* TODO: This is rare, but still should also be handled */
5538         WARN_ON(1);
5539 mem_free:
5540         if (reg_info) {
5541                 kfree(reg_info->reg_rules_2g_ptr);
5542                 kfree(reg_info->reg_rules_5g_ptr);
5543                 kfree(reg_info);
5544         }
5545         return ret;
5546 }
5547
5548 static int ath11k_wmi_tlv_rdy_parse(struct ath11k_base *ab, u16 tag, u16 len,
5549                                     const void *ptr, void *data)
5550 {
5551         struct wmi_tlv_rdy_parse *rdy_parse = data;
5552         struct wmi_ready_event fixed_param;
5553         struct wmi_mac_addr *addr_list;
5554         struct ath11k_pdev *pdev;
5555         u32 num_mac_addr;
5556         int i;
5557
5558         switch (tag) {
5559         case WMI_TAG_READY_EVENT:
5560                 memset(&fixed_param, 0, sizeof(fixed_param));
5561                 memcpy(&fixed_param, (struct wmi_ready_event *)ptr,
5562                        min_t(u16, sizeof(fixed_param), len));
5563                 ab->wlan_init_status = fixed_param.ready_event_min.status;
5564                 rdy_parse->num_extra_mac_addr =
5565                         fixed_param.ready_event_min.num_extra_mac_addr;
5566
5567                 ether_addr_copy(ab->mac_addr,
5568                                 fixed_param.ready_event_min.mac_addr.addr);
5569                 ab->pktlog_defs_checksum = fixed_param.pktlog_defs_checksum;
5570                 ab->wmi_ready = true;
5571                 break;
5572         case WMI_TAG_ARRAY_FIXED_STRUCT:
5573                 addr_list = (struct wmi_mac_addr *)ptr;
5574                 num_mac_addr = rdy_parse->num_extra_mac_addr;
5575
5576                 if (!(ab->num_radios > 1 && num_mac_addr >= ab->num_radios))
5577                         break;
5578
5579                 for (i = 0; i < ab->num_radios; i++) {
5580                         pdev = &ab->pdevs[i];
5581                         ether_addr_copy(pdev->mac_addr, addr_list[i].addr);
5582                 }
5583                 ab->pdevs_macaddr_valid = true;
5584                 break;
5585         default:
5586                 break;
5587         }
5588
5589         return 0;
5590 }
5591
5592 static int ath11k_ready_event(struct ath11k_base *ab, struct sk_buff *skb)
5593 {
5594         struct wmi_tlv_rdy_parse rdy_parse = { };
5595         int ret;
5596
5597         ret = ath11k_wmi_tlv_iter(ab, skb->data, skb->len,
5598                                   ath11k_wmi_tlv_rdy_parse, &rdy_parse);
5599         if (ret) {
5600                 ath11k_warn(ab, "failed to parse tlv %d\n", ret);
5601                 return ret;
5602         }
5603
5604         complete(&ab->wmi_ab.unified_ready);
5605         return 0;
5606 }
5607
5608 static void ath11k_peer_delete_resp_event(struct ath11k_base *ab, struct sk_buff *skb)
5609 {
5610         struct wmi_peer_delete_resp_event peer_del_resp;
5611
5612         if (ath11k_pull_peer_del_resp_ev(ab, skb, &peer_del_resp) != 0) {
5613                 ath11k_warn(ab, "failed to extract peer delete resp");
5614                 return;
5615         }
5616
5617         /* TODO: Do we need to validate whether ath11k_peer_find() return NULL
5618          *       Why this is needed when there is HTT event for peer delete
5619          */
5620 }
5621
5622 static inline const char *ath11k_wmi_vdev_resp_print(u32 vdev_resp_status)
5623 {
5624         switch (vdev_resp_status) {
5625         case WMI_VDEV_START_RESPONSE_INVALID_VDEVID:
5626                 return "invalid vdev id";
5627         case WMI_VDEV_START_RESPONSE_NOT_SUPPORTED:
5628                 return "not supported";
5629         case WMI_VDEV_START_RESPONSE_DFS_VIOLATION:
5630                 return "dfs violation";
5631         case WMI_VDEV_START_RESPONSE_INVALID_REGDOMAIN:
5632                 return "invalid regdomain";
5633         default:
5634                 return "unknown";
5635         }
5636 }
5637
5638 static void ath11k_vdev_start_resp_event(struct ath11k_base *ab, struct sk_buff *skb)
5639 {
5640         struct wmi_vdev_start_resp_event vdev_start_resp;
5641         struct ath11k *ar;
5642         u32 status;
5643
5644         if (ath11k_pull_vdev_start_resp_tlv(ab, skb, &vdev_start_resp) != 0) {
5645                 ath11k_warn(ab, "failed to extract vdev start resp");
5646                 return;
5647         }
5648
5649         rcu_read_lock();
5650         ar = ath11k_mac_get_ar_by_vdev_id(ab, vdev_start_resp.vdev_id);
5651         if (!ar) {
5652                 ath11k_warn(ab, "invalid vdev id in vdev start resp ev %d",
5653                             vdev_start_resp.vdev_id);
5654                 rcu_read_unlock();
5655                 return;
5656         }
5657
5658         ar->last_wmi_vdev_start_status = 0;
5659
5660         status = vdev_start_resp.status;
5661
5662         if (WARN_ON_ONCE(status)) {
5663                 ath11k_warn(ab, "vdev start resp error status %d (%s)\n",
5664                             status, ath11k_wmi_vdev_resp_print(status));
5665                 ar->last_wmi_vdev_start_status = status;
5666         }
5667
5668         complete(&ar->vdev_setup_done);
5669
5670         rcu_read_unlock();
5671
5672         ath11k_dbg(ab, ATH11K_DBG_WMI, "vdev start resp for vdev id %d",
5673                    vdev_start_resp.vdev_id);
5674 }
5675
5676 static void ath11k_bcn_tx_status_event(struct ath11k_base *ab, struct sk_buff *skb)
5677 {
5678         u32 vdev_id, tx_status;
5679
5680         if (ath11k_pull_bcn_tx_status_ev(ab, skb->data, skb->len,
5681                                          &vdev_id, &tx_status) != 0) {
5682                 ath11k_warn(ab, "failed to extract bcn tx status");
5683                 return;
5684         }
5685 }
5686
5687 static void ath11k_vdev_stopped_event(struct ath11k_base *ab, struct sk_buff *skb)
5688 {
5689         struct ath11k *ar;
5690         u32 vdev_id = 0;
5691
5692         if (ath11k_pull_vdev_stopped_param_tlv(ab, skb, &vdev_id) != 0) {
5693                 ath11k_warn(ab, "failed to extract vdev stopped event");
5694                 return;
5695         }
5696
5697         rcu_read_lock();
5698         ar = ath11k_mac_get_ar_vdev_stop_status(ab, vdev_id);
5699         if (!ar) {
5700                 ath11k_warn(ab, "invalid vdev id in vdev stopped ev %d",
5701                             vdev_id);
5702                 rcu_read_unlock();
5703                 return;
5704         }
5705
5706         complete(&ar->vdev_setup_done);
5707
5708         rcu_read_unlock();
5709
5710         ath11k_dbg(ab, ATH11K_DBG_WMI, "vdev stopped for vdev id %d", vdev_id);
5711 }
5712
5713 static void ath11k_mgmt_rx_event(struct ath11k_base *ab, struct sk_buff *skb)
5714 {
5715         struct mgmt_rx_event_params rx_ev = {0};
5716         struct ath11k *ar;
5717         struct ieee80211_rx_status *status = IEEE80211_SKB_RXCB(skb);
5718         struct ieee80211_hdr *hdr;
5719         u16 fc;
5720         struct ieee80211_supported_band *sband;
5721
5722         if (ath11k_pull_mgmt_rx_params_tlv(ab, skb, &rx_ev) != 0) {
5723                 ath11k_warn(ab, "failed to extract mgmt rx event");
5724                 dev_kfree_skb(skb);
5725                 return;
5726         }
5727
5728         memset(status, 0, sizeof(*status));
5729
5730         ath11k_dbg(ab, ATH11K_DBG_MGMT, "mgmt rx event status %08x\n",
5731                    rx_ev.status);
5732
5733         rcu_read_lock();
5734         ar = ath11k_mac_get_ar_by_pdev_id(ab, rx_ev.pdev_id);
5735
5736         if (!ar) {
5737                 ath11k_warn(ab, "invalid pdev_id %d in mgmt_rx_event\n",
5738                             rx_ev.pdev_id);
5739                 dev_kfree_skb(skb);
5740                 goto exit;
5741         }
5742
5743         if ((test_bit(ATH11K_CAC_RUNNING, &ar->dev_flags)) ||
5744             (rx_ev.status & (WMI_RX_STATUS_ERR_DECRYPT |
5745             WMI_RX_STATUS_ERR_KEY_CACHE_MISS | WMI_RX_STATUS_ERR_CRC))) {
5746                 dev_kfree_skb(skb);
5747                 goto exit;
5748         }
5749
5750         if (rx_ev.status & WMI_RX_STATUS_ERR_MIC)
5751                 status->flag |= RX_FLAG_MMIC_ERROR;
5752
5753         if (rx_ev.chan_freq >= ATH11K_MIN_6G_FREQ) {
5754                 status->band = NL80211_BAND_6GHZ;
5755         } else if (rx_ev.channel >= 1 && rx_ev.channel <= 14) {
5756                 status->band = NL80211_BAND_2GHZ;
5757         } else if (rx_ev.channel >= 36 && rx_ev.channel <= ATH11K_MAX_5G_CHAN) {
5758                 status->band = NL80211_BAND_5GHZ;
5759         } else {
5760                 /* Shouldn't happen unless list of advertised channels to
5761                  * mac80211 has been changed.
5762                  */
5763                 WARN_ON_ONCE(1);
5764                 dev_kfree_skb(skb);
5765                 goto exit;
5766         }
5767
5768         if (rx_ev.phy_mode == MODE_11B &&
5769             (status->band == NL80211_BAND_5GHZ || status->band == NL80211_BAND_6GHZ))
5770                 ath11k_dbg(ab, ATH11K_DBG_WMI,
5771                            "wmi mgmt rx 11b (CCK) on 5/6GHz, band = %d\n", status->band);
5772
5773         sband = &ar->mac.sbands[status->band];
5774
5775         status->freq = ieee80211_channel_to_frequency(rx_ev.channel,
5776                                                       status->band);
5777         status->signal = rx_ev.snr + ATH11K_DEFAULT_NOISE_FLOOR;
5778         status->rate_idx = ath11k_mac_bitrate_to_idx(sband, rx_ev.rate / 100);
5779
5780         hdr = (struct ieee80211_hdr *)skb->data;
5781         fc = le16_to_cpu(hdr->frame_control);
5782
5783         /* Firmware is guaranteed to report all essential management frames via
5784          * WMI while it can deliver some extra via HTT. Since there can be
5785          * duplicates split the reporting wrt monitor/sniffing.
5786          */
5787         status->flag |= RX_FLAG_SKIP_MONITOR;
5788
5789         /* In case of PMF, FW delivers decrypted frames with Protected Bit set.
5790          * Don't clear that. Also, FW delivers broadcast management frames
5791          * (ex: group privacy action frames in mesh) as encrypted payload.
5792          */
5793         if (ieee80211_has_protected(hdr->frame_control) &&
5794             !is_multicast_ether_addr(ieee80211_get_DA(hdr))) {
5795                 status->flag |= RX_FLAG_DECRYPTED;
5796
5797                 if (!ieee80211_is_robust_mgmt_frame(skb)) {
5798                         status->flag |= RX_FLAG_IV_STRIPPED |
5799                                         RX_FLAG_MMIC_STRIPPED;
5800                         hdr->frame_control = __cpu_to_le16(fc &
5801                                              ~IEEE80211_FCTL_PROTECTED);
5802                 }
5803         }
5804
5805         /* TODO: Pending handle beacon implementation
5806          *if (ieee80211_is_beacon(hdr->frame_control))
5807          *      ath11k_mac_handle_beacon(ar, skb);
5808          */
5809
5810         ath11k_dbg(ab, ATH11K_DBG_MGMT,
5811                    "event mgmt rx skb %pK len %d ftype %02x stype %02x\n",
5812                    skb, skb->len,
5813                    fc & IEEE80211_FCTL_FTYPE, fc & IEEE80211_FCTL_STYPE);
5814
5815         ath11k_dbg(ab, ATH11K_DBG_MGMT,
5816                    "event mgmt rx freq %d band %d snr %d, rate_idx %d\n",
5817                    status->freq, status->band, status->signal,
5818                    status->rate_idx);
5819
5820         ieee80211_rx_ni(ar->hw, skb);
5821
5822 exit:
5823         rcu_read_unlock();
5824 }
5825
5826 static void ath11k_mgmt_tx_compl_event(struct ath11k_base *ab, struct sk_buff *skb)
5827 {
5828         struct wmi_mgmt_tx_compl_event tx_compl_param = {0};
5829         struct ath11k *ar;
5830
5831         if (ath11k_pull_mgmt_tx_compl_param_tlv(ab, skb, &tx_compl_param) != 0) {
5832                 ath11k_warn(ab, "failed to extract mgmt tx compl event");
5833                 return;
5834         }
5835
5836         rcu_read_lock();
5837         ar = ath11k_mac_get_ar_by_pdev_id(ab, tx_compl_param.pdev_id);
5838         if (!ar) {
5839                 ath11k_warn(ab, "invalid pdev id %d in mgmt_tx_compl_event\n",
5840                             tx_compl_param.pdev_id);
5841                 goto exit;
5842         }
5843
5844         wmi_process_mgmt_tx_comp(ar, tx_compl_param.desc_id,
5845                                  tx_compl_param.status);
5846
5847         ath11k_dbg(ab, ATH11K_DBG_MGMT,
5848                    "mgmt tx compl ev pdev_id %d, desc_id %d, status %d",
5849                    tx_compl_param.pdev_id, tx_compl_param.desc_id,
5850                    tx_compl_param.status);
5851
5852 exit:
5853         rcu_read_unlock();
5854 }
5855
5856 static struct ath11k *ath11k_get_ar_on_scan_abort(struct ath11k_base *ab,
5857                                                   u32 vdev_id)
5858 {
5859         int i;
5860         struct ath11k_pdev *pdev;
5861         struct ath11k *ar;
5862
5863         for (i = 0; i < ab->num_radios; i++) {
5864                 pdev = rcu_dereference(ab->pdevs_active[i]);
5865                 if (pdev && pdev->ar) {
5866                         ar = pdev->ar;
5867
5868                         spin_lock_bh(&ar->data_lock);
5869                         if (ar->scan.state == ATH11K_SCAN_ABORTING &&
5870                             ar->scan.vdev_id == vdev_id) {
5871                                 spin_unlock_bh(&ar->data_lock);
5872                                 return ar;
5873                         }
5874                         spin_unlock_bh(&ar->data_lock);
5875                 }
5876         }
5877         return NULL;
5878 }
5879
5880 static void ath11k_scan_event(struct ath11k_base *ab, struct sk_buff *skb)
5881 {
5882         struct ath11k *ar;
5883         struct wmi_scan_event scan_ev = {0};
5884
5885         if (ath11k_pull_scan_ev(ab, skb, &scan_ev) != 0) {
5886                 ath11k_warn(ab, "failed to extract scan event");
5887                 return;
5888         }
5889
5890         rcu_read_lock();
5891
5892         /* In case the scan was cancelled, ex. during interface teardown,
5893          * the interface will not be found in active interfaces.
5894          * Rather, in such scenarios, iterate over the active pdev's to
5895          * search 'ar' if the corresponding 'ar' scan is ABORTING and the
5896          * aborting scan's vdev id matches this event info.
5897          */
5898         if (scan_ev.event_type == WMI_SCAN_EVENT_COMPLETED &&
5899             scan_ev.reason == WMI_SCAN_REASON_CANCELLED)
5900                 ar = ath11k_get_ar_on_scan_abort(ab, scan_ev.vdev_id);
5901         else
5902                 ar = ath11k_mac_get_ar_by_vdev_id(ab, scan_ev.vdev_id);
5903
5904         if (!ar) {
5905                 ath11k_warn(ab, "Received scan event for unknown vdev");
5906                 rcu_read_unlock();
5907                 return;
5908         }
5909
5910         spin_lock_bh(&ar->data_lock);
5911
5912         ath11k_dbg(ab, ATH11K_DBG_WMI,
5913                    "scan event %s type %d reason %d freq %d req_id %d scan_id %d vdev_id %d state %s (%d)\n",
5914                    ath11k_wmi_event_scan_type_str(scan_ev.event_type, scan_ev.reason),
5915                    scan_ev.event_type, scan_ev.reason, scan_ev.channel_freq,
5916                    scan_ev.scan_req_id, scan_ev.scan_id, scan_ev.vdev_id,
5917                    ath11k_scan_state_str(ar->scan.state), ar->scan.state);
5918
5919         switch (scan_ev.event_type) {
5920         case WMI_SCAN_EVENT_STARTED:
5921                 ath11k_wmi_event_scan_started(ar);
5922                 break;
5923         case WMI_SCAN_EVENT_COMPLETED:
5924                 ath11k_wmi_event_scan_completed(ar);
5925                 break;
5926         case WMI_SCAN_EVENT_BSS_CHANNEL:
5927                 ath11k_wmi_event_scan_bss_chan(ar);
5928                 break;
5929         case WMI_SCAN_EVENT_FOREIGN_CHAN:
5930                 ath11k_wmi_event_scan_foreign_chan(ar, scan_ev.channel_freq);
5931                 break;
5932         case WMI_SCAN_EVENT_START_FAILED:
5933                 ath11k_warn(ab, "received scan start failure event\n");
5934                 ath11k_wmi_event_scan_start_failed(ar);
5935                 break;
5936         case WMI_SCAN_EVENT_DEQUEUED:
5937         case WMI_SCAN_EVENT_PREEMPTED:
5938         case WMI_SCAN_EVENT_RESTARTED:
5939         case WMI_SCAN_EVENT_FOREIGN_CHAN_EXIT:
5940         default:
5941                 break;
5942         }
5943
5944         spin_unlock_bh(&ar->data_lock);
5945
5946         rcu_read_unlock();
5947 }
5948
5949 static void ath11k_peer_sta_kickout_event(struct ath11k_base *ab, struct sk_buff *skb)
5950 {
5951         struct wmi_peer_sta_kickout_arg arg = {};
5952         struct ieee80211_sta *sta;
5953         struct ath11k_peer *peer;
5954         struct ath11k *ar;
5955
5956         if (ath11k_pull_peer_sta_kickout_ev(ab, skb, &arg) != 0) {
5957                 ath11k_warn(ab, "failed to extract peer sta kickout event");
5958                 return;
5959         }
5960
5961         rcu_read_lock();
5962
5963         spin_lock_bh(&ab->base_lock);
5964
5965         peer = ath11k_peer_find_by_addr(ab, arg.mac_addr);
5966
5967         if (!peer) {
5968                 ath11k_warn(ab, "peer not found %pM\n",
5969                             arg.mac_addr);
5970                 goto exit;
5971         }
5972
5973         ar = ath11k_mac_get_ar_by_vdev_id(ab, peer->vdev_id);
5974         if (!ar) {
5975                 ath11k_warn(ab, "invalid vdev id in peer sta kickout ev %d",
5976                             peer->vdev_id);
5977                 goto exit;
5978         }
5979
5980         sta = ieee80211_find_sta_by_ifaddr(ar->hw,
5981                                            arg.mac_addr, NULL);
5982         if (!sta) {
5983                 ath11k_warn(ab, "Spurious quick kickout for STA %pM\n",
5984                             arg.mac_addr);
5985                 goto exit;
5986         }
5987
5988         ath11k_dbg(ab, ATH11K_DBG_WMI, "peer sta kickout event %pM",
5989                    arg.mac_addr);
5990
5991         ieee80211_report_low_ack(sta, 10);
5992
5993 exit:
5994         spin_unlock_bh(&ab->base_lock);
5995         rcu_read_unlock();
5996 }
5997
5998 static void ath11k_roam_event(struct ath11k_base *ab, struct sk_buff *skb)
5999 {
6000         struct wmi_roam_event roam_ev = {};
6001         struct ath11k *ar;
6002
6003         if (ath11k_pull_roam_ev(ab, skb, &roam_ev) != 0) {
6004                 ath11k_warn(ab, "failed to extract roam event");
6005                 return;
6006         }
6007
6008         ath11k_dbg(ab, ATH11K_DBG_WMI,
6009                    "wmi roam event vdev %u reason 0x%08x rssi %d\n",
6010                    roam_ev.vdev_id, roam_ev.reason, roam_ev.rssi);
6011
6012         rcu_read_lock();
6013         ar = ath11k_mac_get_ar_by_vdev_id(ab, roam_ev.vdev_id);
6014         if (!ar) {
6015                 ath11k_warn(ab, "invalid vdev id in roam ev %d",
6016                             roam_ev.vdev_id);
6017                 rcu_read_unlock();
6018                 return;
6019         }
6020
6021         if (roam_ev.reason >= WMI_ROAM_REASON_MAX)
6022                 ath11k_warn(ab, "ignoring unknown roam event reason %d on vdev %i\n",
6023                             roam_ev.reason, roam_ev.vdev_id);
6024
6025         switch (roam_ev.reason) {
6026         case WMI_ROAM_REASON_BEACON_MISS:
6027                 /* TODO: Pending beacon miss and connection_loss_work
6028                  * implementation
6029                  * ath11k_mac_handle_beacon_miss(ar, vdev_id);
6030                  */
6031                 break;
6032         case WMI_ROAM_REASON_BETTER_AP:
6033         case WMI_ROAM_REASON_LOW_RSSI:
6034         case WMI_ROAM_REASON_SUITABLE_AP_FOUND:
6035         case WMI_ROAM_REASON_HO_FAILED:
6036                 ath11k_warn(ab, "ignoring not implemented roam event reason %d on vdev %i\n",
6037                             roam_ev.reason, roam_ev.vdev_id);
6038                 break;
6039         }
6040
6041         rcu_read_unlock();
6042 }
6043
6044 static void ath11k_chan_info_event(struct ath11k_base *ab, struct sk_buff *skb)
6045 {
6046         struct wmi_chan_info_event ch_info_ev = {0};
6047         struct ath11k *ar;
6048         struct survey_info *survey;
6049         int idx;
6050         /* HW channel counters frequency value in hertz */
6051         u32 cc_freq_hz = ab->cc_freq_hz;
6052
6053         if (ath11k_pull_chan_info_ev(ab, skb->data, skb->len, &ch_info_ev) != 0) {
6054                 ath11k_warn(ab, "failed to extract chan info event");
6055                 return;
6056         }
6057
6058         ath11k_dbg(ab, ATH11K_DBG_WMI,
6059                    "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",
6060                    ch_info_ev.vdev_id, ch_info_ev.err_code, ch_info_ev.freq,
6061                    ch_info_ev.cmd_flags, ch_info_ev.noise_floor,
6062                    ch_info_ev.rx_clear_count, ch_info_ev.cycle_count,
6063                    ch_info_ev.mac_clk_mhz);
6064
6065         if (ch_info_ev.cmd_flags == WMI_CHAN_INFO_END_RESP) {
6066                 ath11k_dbg(ab, ATH11K_DBG_WMI, "chan info report completed\n");
6067                 return;
6068         }
6069
6070         rcu_read_lock();
6071         ar = ath11k_mac_get_ar_by_vdev_id(ab, ch_info_ev.vdev_id);
6072         if (!ar) {
6073                 ath11k_warn(ab, "invalid vdev id in chan info ev %d",
6074                             ch_info_ev.vdev_id);
6075                 rcu_read_unlock();
6076                 return;
6077         }
6078         spin_lock_bh(&ar->data_lock);
6079
6080         switch (ar->scan.state) {
6081         case ATH11K_SCAN_IDLE:
6082         case ATH11K_SCAN_STARTING:
6083                 ath11k_warn(ab, "received chan info event without a scan request, ignoring\n");
6084                 goto exit;
6085         case ATH11K_SCAN_RUNNING:
6086         case ATH11K_SCAN_ABORTING:
6087                 break;
6088         }
6089
6090         idx = freq_to_idx(ar, ch_info_ev.freq);
6091         if (idx >= ARRAY_SIZE(ar->survey)) {
6092                 ath11k_warn(ab, "chan info: invalid frequency %d (idx %d out of bounds)\n",
6093                             ch_info_ev.freq, idx);
6094                 goto exit;
6095         }
6096
6097         /* If FW provides MAC clock frequency in Mhz, overriding the initialized
6098          * HW channel counters frequency value
6099          */
6100         if (ch_info_ev.mac_clk_mhz)
6101                 cc_freq_hz = (ch_info_ev.mac_clk_mhz * 1000);
6102
6103         if (ch_info_ev.cmd_flags == WMI_CHAN_INFO_START_RESP) {
6104                 survey = &ar->survey[idx];
6105                 memset(survey, 0, sizeof(*survey));
6106                 survey->noise = ch_info_ev.noise_floor;
6107                 survey->filled = SURVEY_INFO_NOISE_DBM | SURVEY_INFO_TIME |
6108                                  SURVEY_INFO_TIME_BUSY;
6109                 survey->time = div_u64(ch_info_ev.cycle_count, cc_freq_hz);
6110                 survey->time_busy = div_u64(ch_info_ev.rx_clear_count, cc_freq_hz);
6111         }
6112 exit:
6113         spin_unlock_bh(&ar->data_lock);
6114         rcu_read_unlock();
6115 }
6116
6117 static void
6118 ath11k_pdev_bss_chan_info_event(struct ath11k_base *ab, struct sk_buff *skb)
6119 {
6120         struct wmi_pdev_bss_chan_info_event bss_ch_info_ev = {};
6121         struct survey_info *survey;
6122         struct ath11k *ar;
6123         u32 cc_freq_hz = ab->cc_freq_hz;
6124         u64 busy, total, tx, rx, rx_bss;
6125         int idx;
6126
6127         if (ath11k_pull_pdev_bss_chan_info_ev(ab, skb, &bss_ch_info_ev) != 0) {
6128                 ath11k_warn(ab, "failed to extract pdev bss chan info event");
6129                 return;
6130         }
6131
6132         busy = (u64)(bss_ch_info_ev.rx_clear_count_high) << 32 |
6133                         bss_ch_info_ev.rx_clear_count_low;
6134
6135         total = (u64)(bss_ch_info_ev.cycle_count_high) << 32 |
6136                         bss_ch_info_ev.cycle_count_low;
6137
6138         tx = (u64)(bss_ch_info_ev.tx_cycle_count_high) << 32 |
6139                         bss_ch_info_ev.tx_cycle_count_low;
6140
6141         rx = (u64)(bss_ch_info_ev.rx_cycle_count_high) << 32 |
6142                         bss_ch_info_ev.rx_cycle_count_low;
6143
6144         rx_bss = (u64)(bss_ch_info_ev.rx_bss_cycle_count_high) << 32 |
6145                         bss_ch_info_ev.rx_bss_cycle_count_low;
6146
6147         ath11k_dbg(ab, ATH11K_DBG_WMI,
6148                    "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",
6149                    bss_ch_info_ev.pdev_id, bss_ch_info_ev.freq,
6150                    bss_ch_info_ev.noise_floor, busy, total,
6151                    tx, rx, rx_bss);
6152
6153         rcu_read_lock();
6154         ar = ath11k_mac_get_ar_by_pdev_id(ab, bss_ch_info_ev.pdev_id);
6155
6156         if (!ar) {
6157                 ath11k_warn(ab, "invalid pdev id %d in bss_chan_info event\n",
6158                             bss_ch_info_ev.pdev_id);
6159                 rcu_read_unlock();
6160                 return;
6161         }
6162
6163         spin_lock_bh(&ar->data_lock);
6164         idx = freq_to_idx(ar, bss_ch_info_ev.freq);
6165         if (idx >= ARRAY_SIZE(ar->survey)) {
6166                 ath11k_warn(ab, "bss chan info: invalid frequency %d (idx %d out of bounds)\n",
6167                             bss_ch_info_ev.freq, idx);
6168                 goto exit;
6169         }
6170
6171         survey = &ar->survey[idx];
6172
6173         survey->noise     = bss_ch_info_ev.noise_floor;
6174         survey->time      = div_u64(total, cc_freq_hz);
6175         survey->time_busy = div_u64(busy, cc_freq_hz);
6176         survey->time_rx   = div_u64(rx_bss, cc_freq_hz);
6177         survey->time_tx   = div_u64(tx, cc_freq_hz);
6178         survey->filled   |= (SURVEY_INFO_NOISE_DBM |
6179                              SURVEY_INFO_TIME |
6180                              SURVEY_INFO_TIME_BUSY |
6181                              SURVEY_INFO_TIME_RX |
6182                              SURVEY_INFO_TIME_TX);
6183 exit:
6184         spin_unlock_bh(&ar->data_lock);
6185         complete(&ar->bss_survey_done);
6186
6187         rcu_read_unlock();
6188 }
6189
6190 static void ath11k_vdev_install_key_compl_event(struct ath11k_base *ab,
6191                                                 struct sk_buff *skb)
6192 {
6193         struct wmi_vdev_install_key_complete_arg install_key_compl = {0};
6194         struct ath11k *ar;
6195
6196         if (ath11k_pull_vdev_install_key_compl_ev(ab, skb, &install_key_compl) != 0) {
6197                 ath11k_warn(ab, "failed to extract install key compl event");
6198                 return;
6199         }
6200
6201         ath11k_dbg(ab, ATH11K_DBG_WMI,
6202                    "vdev install key ev idx %d flags %08x macaddr %pM status %d\n",
6203                    install_key_compl.key_idx, install_key_compl.key_flags,
6204                    install_key_compl.macaddr, install_key_compl.status);
6205
6206         rcu_read_lock();
6207         ar = ath11k_mac_get_ar_by_vdev_id(ab, install_key_compl.vdev_id);
6208         if (!ar) {
6209                 ath11k_warn(ab, "invalid vdev id in install key compl ev %d",
6210                             install_key_compl.vdev_id);
6211                 rcu_read_unlock();
6212                 return;
6213         }
6214
6215         ar->install_key_status = 0;
6216
6217         if (install_key_compl.status != WMI_VDEV_INSTALL_KEY_COMPL_STATUS_SUCCESS) {
6218                 ath11k_warn(ab, "install key failed for %pM status %d\n",
6219                             install_key_compl.macaddr, install_key_compl.status);
6220                 ar->install_key_status = install_key_compl.status;
6221         }
6222
6223         complete(&ar->install_key_done);
6224         rcu_read_unlock();
6225 }
6226
6227 static void ath11k_service_available_event(struct ath11k_base *ab, struct sk_buff *skb)
6228 {
6229         const void **tb;
6230         const struct wmi_service_available_event *ev;
6231         int ret;
6232         int i, j;
6233
6234         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
6235         if (IS_ERR(tb)) {
6236                 ret = PTR_ERR(tb);
6237                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6238                 return;
6239         }
6240
6241         ev = tb[WMI_TAG_SERVICE_AVAILABLE_EVENT];
6242         if (!ev) {
6243                 ath11k_warn(ab, "failed to fetch svc available ev");
6244                 kfree(tb);
6245                 return;
6246         }
6247
6248         /* TODO: Use wmi_service_segment_offset information to get the service
6249          * especially when more services are advertised in multiple sevice
6250          * available events.
6251          */
6252         for (i = 0, j = WMI_MAX_SERVICE;
6253              i < WMI_SERVICE_SEGMENT_BM_SIZE32 && j < WMI_MAX_EXT_SERVICE;
6254              i++) {
6255                 do {
6256                         if (ev->wmi_service_segment_bitmap[i] &
6257                             BIT(j % WMI_AVAIL_SERVICE_BITS_IN_SIZE32))
6258                                 set_bit(j, ab->wmi_ab.svc_map);
6259                 } while (++j % WMI_AVAIL_SERVICE_BITS_IN_SIZE32);
6260         }
6261
6262         ath11k_dbg(ab, ATH11K_DBG_WMI,
6263                    "wmi_ext_service_bitmap 0:0x%x, 1:0x%x, 2:0x%x, 3:0x%x",
6264                    ev->wmi_service_segment_bitmap[0], ev->wmi_service_segment_bitmap[1],
6265                    ev->wmi_service_segment_bitmap[2], ev->wmi_service_segment_bitmap[3]);
6266
6267         kfree(tb);
6268 }
6269
6270 static void ath11k_peer_assoc_conf_event(struct ath11k_base *ab, struct sk_buff *skb)
6271 {
6272         struct wmi_peer_assoc_conf_arg peer_assoc_conf = {0};
6273         struct ath11k *ar;
6274
6275         if (ath11k_pull_peer_assoc_conf_ev(ab, skb, &peer_assoc_conf) != 0) {
6276                 ath11k_warn(ab, "failed to extract peer assoc conf event");
6277                 return;
6278         }
6279
6280         ath11k_dbg(ab, ATH11K_DBG_WMI,
6281                    "peer assoc conf ev vdev id %d macaddr %pM\n",
6282                    peer_assoc_conf.vdev_id, peer_assoc_conf.macaddr);
6283
6284         rcu_read_lock();
6285         ar = ath11k_mac_get_ar_by_vdev_id(ab, peer_assoc_conf.vdev_id);
6286
6287         if (!ar) {
6288                 ath11k_warn(ab, "invalid vdev id in peer assoc conf ev %d",
6289                             peer_assoc_conf.vdev_id);
6290                 rcu_read_unlock();
6291                 return;
6292         }
6293
6294         complete(&ar->peer_assoc_done);
6295         rcu_read_unlock();
6296 }
6297
6298 static void ath11k_update_stats_event(struct ath11k_base *ab, struct sk_buff *skb)
6299 {
6300         ath11k_debug_fw_stats_process(ab, skb);
6301 }
6302
6303 /* PDEV_CTL_FAILSAFE_CHECK_EVENT is received from FW when the frequency scanned
6304  * is not part of BDF CTL(Conformance test limits) table entries.
6305  */
6306 static void ath11k_pdev_ctl_failsafe_check_event(struct ath11k_base *ab,
6307                                                  struct sk_buff *skb)
6308 {
6309         const void **tb;
6310         const struct wmi_pdev_ctl_failsafe_chk_event *ev;
6311         int ret;
6312
6313         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
6314         if (IS_ERR(tb)) {
6315                 ret = PTR_ERR(tb);
6316                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6317                 return;
6318         }
6319
6320         ev = tb[WMI_TAG_PDEV_CTL_FAILSAFE_CHECK_EVENT];
6321         if (!ev) {
6322                 ath11k_warn(ab, "failed to fetch pdev ctl failsafe check ev");
6323                 kfree(tb);
6324                 return;
6325         }
6326
6327         ath11k_dbg(ab, ATH11K_DBG_WMI,
6328                    "pdev ctl failsafe check ev status %d\n",
6329                    ev->ctl_failsafe_status);
6330
6331         /* If ctl_failsafe_status is set to 1 FW will max out the Transmit power
6332          * to 10 dBm else the CTL power entry in the BDF would be picked up.
6333          */
6334         if (ev->ctl_failsafe_status != 0)
6335                 ath11k_warn(ab, "pdev ctl failsafe failure status %d",
6336                             ev->ctl_failsafe_status);
6337
6338         kfree(tb);
6339 }
6340
6341 static void
6342 ath11k_wmi_process_csa_switch_count_event(struct ath11k_base *ab,
6343                                           const struct wmi_pdev_csa_switch_ev *ev,
6344                                           const u32 *vdev_ids)
6345 {
6346         int i;
6347         struct ath11k_vif *arvif;
6348
6349         /* Finish CSA once the switch count becomes NULL */
6350         if (ev->current_switch_count)
6351                 return;
6352
6353         rcu_read_lock();
6354         for (i = 0; i < ev->num_vdevs; i++) {
6355                 arvif = ath11k_mac_get_arvif_by_vdev_id(ab, vdev_ids[i]);
6356
6357                 if (!arvif) {
6358                         ath11k_warn(ab, "Recvd csa status for unknown vdev %d",
6359                                     vdev_ids[i]);
6360                         continue;
6361                 }
6362
6363                 if (arvif->is_up && arvif->vif->csa_active)
6364                         ieee80211_csa_finish(arvif->vif);
6365         }
6366         rcu_read_unlock();
6367 }
6368
6369 static void
6370 ath11k_wmi_pdev_csa_switch_count_status_event(struct ath11k_base *ab,
6371                                               struct sk_buff *skb)
6372 {
6373         const void **tb;
6374         const struct wmi_pdev_csa_switch_ev *ev;
6375         const u32 *vdev_ids;
6376         int ret;
6377
6378         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
6379         if (IS_ERR(tb)) {
6380                 ret = PTR_ERR(tb);
6381                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6382                 return;
6383         }
6384
6385         ev = tb[WMI_TAG_PDEV_CSA_SWITCH_COUNT_STATUS_EVENT];
6386         vdev_ids = tb[WMI_TAG_ARRAY_UINT32];
6387
6388         if (!ev || !vdev_ids) {
6389                 ath11k_warn(ab, "failed to fetch pdev csa switch count ev");
6390                 kfree(tb);
6391                 return;
6392         }
6393
6394         ath11k_dbg(ab, ATH11K_DBG_WMI,
6395                    "pdev csa switch count %d for pdev %d, num_vdevs %d",
6396                    ev->current_switch_count, ev->pdev_id,
6397                    ev->num_vdevs);
6398
6399         ath11k_wmi_process_csa_switch_count_event(ab, ev, vdev_ids);
6400
6401         kfree(tb);
6402 }
6403
6404 static void
6405 ath11k_wmi_pdev_dfs_radar_detected_event(struct ath11k_base *ab, struct sk_buff *skb)
6406 {
6407         const void **tb;
6408         const struct wmi_pdev_radar_ev *ev;
6409         struct ath11k *ar;
6410         int ret;
6411
6412         tb = ath11k_wmi_tlv_parse_alloc(ab, skb->data, skb->len, GFP_ATOMIC);
6413         if (IS_ERR(tb)) {
6414                 ret = PTR_ERR(tb);
6415                 ath11k_warn(ab, "failed to parse tlv: %d\n", ret);
6416                 return;
6417         }
6418
6419         ev = tb[WMI_TAG_PDEV_DFS_RADAR_DETECTION_EVENT];
6420
6421         if (!ev) {
6422                 ath11k_warn(ab, "failed to fetch pdev dfs radar detected ev");
6423                 kfree(tb);
6424                 return;
6425         }
6426
6427         ath11k_dbg(ab, ATH11K_DBG_WMI,
6428                    "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",
6429                    ev->pdev_id, ev->detection_mode, ev->chan_freq, ev->chan_width,
6430                    ev->detector_id, ev->segment_id, ev->timestamp, ev->is_chirp,
6431                    ev->freq_offset, ev->sidx);
6432
6433         ar = ath11k_mac_get_ar_by_pdev_id(ab, ev->pdev_id);
6434
6435         if (!ar) {
6436                 ath11k_warn(ab, "radar detected in invalid pdev %d\n",
6437                             ev->pdev_id);
6438                 goto exit;
6439         }
6440
6441         ath11k_dbg(ar->ab, ATH11K_DBG_REG, "DFS Radar Detected in pdev %d\n",
6442                    ev->pdev_id);
6443
6444         if (ar->dfs_block_radar_events)
6445                 ath11k_info(ab, "DFS Radar detected, but ignored as requested\n");
6446         else
6447                 ieee80211_radar_detected(ar->hw);
6448
6449 exit:
6450         kfree(tb);
6451 }
6452
6453 static void
6454 ath11k_wmi_pdev_temperature_event(struct ath11k_base *ab,
6455                                   struct sk_buff *skb)
6456 {
6457         struct ath11k *ar;
6458         struct wmi_pdev_temperature_event ev = {0};
6459
6460         if (ath11k_pull_pdev_temp_ev(ab, skb->data, skb->len, &ev) != 0) {
6461                 ath11k_warn(ab, "failed to extract pdev temperature event");
6462                 return;
6463         }
6464
6465         ath11k_dbg(ab, ATH11K_DBG_WMI,
6466                    "pdev temperature ev temp %d pdev_id %d\n", ev.temp, ev.pdev_id);
6467
6468         ar = ath11k_mac_get_ar_by_pdev_id(ab, ev.pdev_id);
6469         if (!ar) {
6470                 ath11k_warn(ab, "invalid pdev id in pdev temperature ev %d", ev.pdev_id);
6471                 return;
6472         }
6473
6474         ath11k_thermal_event_temperature(ar, ev.temp);
6475 }
6476
6477 static void ath11k_wmi_tlv_op_rx(struct ath11k_base *ab, struct sk_buff *skb)
6478 {
6479         struct wmi_cmd_hdr *cmd_hdr;
6480         enum wmi_tlv_event_id id;
6481
6482         cmd_hdr = (struct wmi_cmd_hdr *)skb->data;
6483         id = FIELD_GET(WMI_CMD_HDR_CMD_ID, (cmd_hdr->cmd_id));
6484
6485         if (skb_pull(skb, sizeof(struct wmi_cmd_hdr)) == NULL)
6486                 goto out;
6487
6488         switch (id) {
6489                 /* Process all the WMI events here */
6490         case WMI_SERVICE_READY_EVENTID:
6491                 ath11k_service_ready_event(ab, skb);
6492                 break;
6493         case WMI_SERVICE_READY_EXT_EVENTID:
6494                 ath11k_service_ready_ext_event(ab, skb);
6495                 break;
6496         case WMI_SERVICE_READY_EXT2_EVENTID:
6497                 ath11k_service_ready_ext2_event(ab, skb);
6498                 break;
6499         case WMI_REG_CHAN_LIST_CC_EVENTID:
6500                 ath11k_reg_chan_list_event(ab, skb);
6501                 break;
6502         case WMI_READY_EVENTID:
6503                 ath11k_ready_event(ab, skb);
6504                 break;
6505         case WMI_PEER_DELETE_RESP_EVENTID:
6506                 ath11k_peer_delete_resp_event(ab, skb);
6507                 break;
6508         case WMI_VDEV_START_RESP_EVENTID:
6509                 ath11k_vdev_start_resp_event(ab, skb);
6510                 break;
6511         case WMI_OFFLOAD_BCN_TX_STATUS_EVENTID:
6512                 ath11k_bcn_tx_status_event(ab, skb);
6513                 break;
6514         case WMI_VDEV_STOPPED_EVENTID:
6515                 ath11k_vdev_stopped_event(ab, skb);
6516                 break;
6517         case WMI_MGMT_RX_EVENTID:
6518                 ath11k_mgmt_rx_event(ab, skb);
6519                 /* mgmt_rx_event() owns the skb now! */
6520                 return;
6521         case WMI_MGMT_TX_COMPLETION_EVENTID:
6522                 ath11k_mgmt_tx_compl_event(ab, skb);
6523                 break;
6524         case WMI_SCAN_EVENTID:
6525                 ath11k_scan_event(ab, skb);
6526                 break;
6527         case WMI_PEER_STA_KICKOUT_EVENTID:
6528                 ath11k_peer_sta_kickout_event(ab, skb);
6529                 break;
6530         case WMI_ROAM_EVENTID:
6531                 ath11k_roam_event(ab, skb);
6532                 break;
6533         case WMI_CHAN_INFO_EVENTID:
6534                 ath11k_chan_info_event(ab, skb);
6535                 break;
6536         case WMI_PDEV_BSS_CHAN_INFO_EVENTID:
6537                 ath11k_pdev_bss_chan_info_event(ab, skb);
6538                 break;
6539         case WMI_VDEV_INSTALL_KEY_COMPLETE_EVENTID:
6540                 ath11k_vdev_install_key_compl_event(ab, skb);
6541                 break;
6542         case WMI_SERVICE_AVAILABLE_EVENTID:
6543                 ath11k_service_available_event(ab, skb);
6544                 break;
6545         case WMI_PEER_ASSOC_CONF_EVENTID:
6546                 ath11k_peer_assoc_conf_event(ab, skb);
6547                 break;
6548         case WMI_UPDATE_STATS_EVENTID:
6549                 ath11k_update_stats_event(ab, skb);
6550                 break;
6551         case WMI_PDEV_CTL_FAILSAFE_CHECK_EVENTID:
6552                 ath11k_pdev_ctl_failsafe_check_event(ab, skb);
6553                 break;
6554         case WMI_PDEV_CSA_SWITCH_COUNT_STATUS_EVENTID:
6555                 ath11k_wmi_pdev_csa_switch_count_status_event(ab, skb);
6556                 break;
6557         case WMI_PDEV_TEMPERATURE_EVENTID:
6558                 ath11k_wmi_pdev_temperature_event(ab, skb);
6559                 break;
6560         case WMI_PDEV_DMA_RING_BUF_RELEASE_EVENTID:
6561                 ath11k_wmi_pdev_dma_ring_buf_release_event(ab, skb);
6562                 break;
6563         /* add Unsupported events here */
6564         case WMI_TBTTOFFSET_EXT_UPDATE_EVENTID:
6565         case WMI_VDEV_DELETE_RESP_EVENTID:
6566         case WMI_PEER_OPER_MODE_CHANGE_EVENTID:
6567         case WMI_TWT_ENABLE_EVENTID:
6568         case WMI_TWT_DISABLE_EVENTID:
6569         case WMI_PDEV_DMA_RING_CFG_RSP_EVENTID:
6570                 ath11k_dbg(ab, ATH11K_DBG_WMI,
6571                            "ignoring unsupported event 0x%x\n", id);
6572                 break;
6573         case WMI_PDEV_DFS_RADAR_DETECTION_EVENTID:
6574                 ath11k_wmi_pdev_dfs_radar_detected_event(ab, skb);
6575                 break;
6576         /* TODO: Add remaining events */
6577         default:
6578                 ath11k_warn(ab, "Unknown eventid: 0x%x\n", id);
6579                 break;
6580         }
6581
6582 out:
6583         dev_kfree_skb(skb);
6584 }
6585
6586 static int ath11k_connect_pdev_htc_service(struct ath11k_base *ab,
6587                                            u32 pdev_idx)
6588 {
6589         int status;
6590         u32 svc_id[] = { ATH11K_HTC_SVC_ID_WMI_CONTROL,
6591                          ATH11K_HTC_SVC_ID_WMI_CONTROL_MAC1,
6592                          ATH11K_HTC_SVC_ID_WMI_CONTROL_MAC2 };
6593
6594         struct ath11k_htc_svc_conn_req conn_req;
6595         struct ath11k_htc_svc_conn_resp conn_resp;
6596
6597         memset(&conn_req, 0, sizeof(conn_req));
6598         memset(&conn_resp, 0, sizeof(conn_resp));
6599
6600         /* these fields are the same for all service endpoints */
6601         conn_req.ep_ops.ep_tx_complete = ath11k_wmi_htc_tx_complete;
6602         conn_req.ep_ops.ep_rx_complete = ath11k_wmi_tlv_op_rx;
6603         conn_req.ep_ops.ep_tx_credits = ath11k_wmi_op_ep_tx_credits;
6604
6605         /* connect to control service */
6606         conn_req.service_id = svc_id[pdev_idx];
6607
6608         status = ath11k_htc_connect_service(&ab->htc, &conn_req, &conn_resp);
6609         if (status) {
6610                 ath11k_warn(ab, "failed to connect to WMI CONTROL service status: %d\n",
6611                             status);
6612                 return status;
6613         }
6614
6615         ab->wmi_ab.wmi_endpoint_id[pdev_idx] = conn_resp.eid;
6616         ab->wmi_ab.wmi[pdev_idx].eid = conn_resp.eid;
6617         ab->wmi_ab.max_msg_len[pdev_idx] = conn_resp.max_msg_len;
6618
6619         return 0;
6620 }
6621
6622 static int
6623 ath11k_wmi_send_unit_test_cmd(struct ath11k *ar,
6624                               struct wmi_unit_test_cmd ut_cmd,
6625                               u32 *test_args)
6626 {
6627         struct ath11k_pdev_wmi *wmi = ar->wmi;
6628         struct wmi_unit_test_cmd *cmd;
6629         struct sk_buff *skb;
6630         struct wmi_tlv *tlv;
6631         void *ptr;
6632         u32 *ut_cmd_args;
6633         int buf_len, arg_len;
6634         int ret;
6635         int i;
6636
6637         arg_len = sizeof(u32) * ut_cmd.num_args;
6638         buf_len = sizeof(ut_cmd) + arg_len + TLV_HDR_SIZE;
6639
6640         skb = ath11k_wmi_alloc_skb(wmi->wmi_ab, buf_len);
6641         if (!skb)
6642                 return -ENOMEM;
6643
6644         cmd = (struct wmi_unit_test_cmd *)skb->data;
6645         cmd->tlv_header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_UNIT_TEST_CMD) |
6646                           FIELD_PREP(WMI_TLV_LEN, sizeof(ut_cmd) - TLV_HDR_SIZE);
6647
6648         cmd->vdev_id = ut_cmd.vdev_id;
6649         cmd->module_id = ut_cmd.module_id;
6650         cmd->num_args = ut_cmd.num_args;
6651         cmd->diag_token = ut_cmd.diag_token;
6652
6653         ptr = skb->data + sizeof(ut_cmd);
6654
6655         tlv = ptr;
6656         tlv->header = FIELD_PREP(WMI_TLV_TAG, WMI_TAG_ARRAY_UINT32) |
6657                       FIELD_PREP(WMI_TLV_LEN, arg_len);
6658
6659         ptr += TLV_HDR_SIZE;
6660
6661         ut_cmd_args = ptr;
6662         for (i = 0; i < ut_cmd.num_args; i++)
6663                 ut_cmd_args[i] = test_args[i];
6664
6665         ret = ath11k_wmi_cmd_send(wmi, skb, WMI_UNIT_TEST_CMDID);
6666
6667         if (ret) {
6668                 ath11k_warn(ar->ab, "failed to send WMI_UNIT_TEST CMD :%d\n",
6669                             ret);
6670                 dev_kfree_skb(skb);
6671         }
6672
6673         ath11k_dbg(ar->ab, ATH11K_DBG_WMI,
6674                    "WMI unit test : module %d vdev %d n_args %d token %d\n",
6675                    cmd->module_id, cmd->vdev_id, cmd->num_args,
6676                    cmd->diag_token);
6677
6678         return ret;
6679 }
6680
6681 int ath11k_wmi_simulate_radar(struct ath11k *ar)
6682 {
6683         struct ath11k_vif *arvif;
6684         u32 dfs_args[DFS_MAX_TEST_ARGS];
6685         struct wmi_unit_test_cmd wmi_ut;
6686         bool arvif_found = false;
6687
6688         list_for_each_entry(arvif, &ar->arvifs, list) {
6689                 if (arvif->is_started && arvif->vdev_type == WMI_VDEV_TYPE_AP) {
6690                         arvif_found = true;
6691                         break;
6692                 }
6693         }
6694
6695         if (!arvif_found)
6696                 return -EINVAL;
6697
6698         dfs_args[DFS_TEST_CMDID] = 0;
6699         dfs_args[DFS_TEST_PDEV_ID] = ar->pdev->pdev_id;
6700         /* Currently we could pass segment_id(b0 - b1), chirp(b2)
6701          * freq offset (b3 - b10) to unit test. For simulation
6702          * purpose this can be set to 0 which is valid.
6703          */
6704         dfs_args[DFS_TEST_RADAR_PARAM] = 0;
6705
6706         wmi_ut.vdev_id = arvif->vdev_id;
6707         wmi_ut.module_id = DFS_UNIT_TEST_MODULE;
6708         wmi_ut.num_args = DFS_MAX_TEST_ARGS;
6709         wmi_ut.diag_token = DFS_UNIT_TEST_TOKEN;
6710
6711         ath11k_dbg(ar->ab, ATH11K_DBG_REG, "Triggering Radar Simulation\n");
6712
6713         return ath11k_wmi_send_unit_test_cmd(ar, wmi_ut, dfs_args);
6714 }
6715
6716 int ath11k_wmi_connect(struct ath11k_base *ab)
6717 {
6718         u32 i;
6719         u8 wmi_ep_count;
6720
6721         wmi_ep_count = ab->htc.wmi_ep_count;
6722         if (wmi_ep_count > ab->hw_params.max_radios)
6723                 return -1;
6724
6725         for (i = 0; i < wmi_ep_count; i++)
6726                 ath11k_connect_pdev_htc_service(ab, i);
6727
6728         return 0;
6729 }
6730
6731 static void ath11k_wmi_pdev_detach(struct ath11k_base *ab, u8 pdev_id)
6732 {
6733         if (WARN_ON(pdev_id >= MAX_RADIOS))
6734                 return;
6735
6736         /* TODO: Deinit any pdev specific wmi resource */
6737 }
6738
6739 int ath11k_wmi_pdev_attach(struct ath11k_base *ab,
6740                            u8 pdev_id)
6741 {
6742         struct ath11k_pdev_wmi *wmi_handle;
6743
6744         if (pdev_id >= ab->hw_params.max_radios)
6745                 return -EINVAL;
6746
6747         wmi_handle = &ab->wmi_ab.wmi[pdev_id];
6748
6749         wmi_handle->wmi_ab = &ab->wmi_ab;
6750
6751         ab->wmi_ab.ab = ab;
6752         /* TODO: Init remaining resource specific to pdev */
6753
6754         return 0;
6755 }
6756
6757 int ath11k_wmi_attach(struct ath11k_base *ab)
6758 {
6759         int ret;
6760
6761         ret = ath11k_wmi_pdev_attach(ab, 0);
6762         if (ret)
6763                 return ret;
6764
6765         ab->wmi_ab.ab = ab;
6766         ab->wmi_ab.preferred_hw_mode = WMI_HOST_HW_MODE_MAX;
6767
6768         /* It's overwritten when service_ext_ready is handled */
6769         if (ab->hw_params.single_pdev_only)
6770                 ab->wmi_ab.preferred_hw_mode = WMI_HOST_HW_MODE_SINGLE;
6771
6772         /* TODO: Init remaining wmi soc resources required */
6773         init_completion(&ab->wmi_ab.service_ready);
6774         init_completion(&ab->wmi_ab.unified_ready);
6775
6776         return 0;
6777 }
6778
6779 void ath11k_wmi_detach(struct ath11k_base *ab)
6780 {
6781         int i;
6782
6783         /* TODO: Deinit wmi resource specific to SOC as required */
6784
6785         for (i = 0; i < ab->htc.wmi_ep_count; i++)
6786                 ath11k_wmi_pdev_detach(ab, i);
6787
6788         ath11k_wmi_free_dbring_caps(ab);
6789 }