struct wmi_cmd_map *cmd;
        struct wmi_vdev_param_map *vdev_param;
        struct wmi_pdev_param_map *pdev_param;
+       struct wmi_peer_param_map *peer_param;
        const struct wmi_ops *ops;
        const struct wmi_peer_flags_map *peer_flags;
 
 
        }
 
        ret = ath10k_wmi_peer_set_param(ar, arsta->arvif->vdev_id, sta->addr,
-                                       WMI_PEER_DEBUG, peer_debug_trigger);
+                                       ar->wmi.peer_param->debug, peer_debug_trigger);
        if (ret) {
                ath10k_warn(ar, "failed to set param to trigger peer tid logs for station ret: %d\n",
                            ret);
 
                return -EINVAL;
 
        return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
-                                        WMI_PEER_SMPS_STATE,
+                                        ar->wmi.peer_param->smps_state,
                                         ath10k_smps_map[smps]);
 }
 
         * poked with peer param command.
         */
        ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, arvif->bssid,
-                                       WMI_PEER_DUMMY_VAR, 1);
+                                       ar->wmi.peer_param->dummy_var, 1);
        if (ret) {
                ath10k_warn(ar, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n",
                            arvif->bssid, arvif->vdev_id, ret);
 
        if (sta && sta->tdls)
                ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
-                                         WMI_PEER_AUTHORIZE, 1);
+                                         ar->wmi.peer_param->authorize, 1);
 
 exit:
        mutex_unlock(&ar->conf_mutex);
                           sta->addr, bw, mode);
 
                err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
-                                               WMI_PEER_PHYMODE, mode);
+                                               ar->wmi.peer_param->phymode, mode);
                if (err) {
                        ath10k_warn(ar, "failed to update STA %pM peer phymode %d: %d\n",
                                    sta->addr, mode, err);
                }
 
                err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
-                                               WMI_PEER_CHAN_WIDTH, bw);
+                                               ar->wmi.peer_param->chan_width, bw);
                if (err)
                        ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
                                    sta->addr, bw, err);
                           sta->addr, nss);
 
                err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
-                                               WMI_PEER_NSS, nss);
+                                               ar->wmi.peer_param->nss, nss);
                if (err)
                        ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
                                    sta->addr, nss, err);
                           sta->addr, smps);
 
                err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
-                                               WMI_PEER_SMPS_STATE, smps);
+                                               ar->wmi.peer_param->smps_state, smps);
                if (err)
                        ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
                                    sta->addr, smps, err);
        mutex_lock(&ar->conf_mutex);
 
        ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
-                                       WMI_PEER_USE_FIXED_PWR, txpwr);
+                                       ar->wmi.peer_param->use_fixed_power, txpwr);
        if (ret) {
                ath10k_warn(ar, "failed to set tx power for station ret: %d\n",
                            ret);
 
        .arp_dstaddr = WMI_PDEV_PARAM_UNSUPPORTED,
 };
 
+static struct wmi_peer_param_map wmi_tlv_peer_param_map = {
+       .smps_state = WMI_TLV_PEER_SMPS_STATE,
+       .ampdu = WMI_TLV_PEER_AMPDU,
+       .authorize = WMI_TLV_PEER_AUTHORIZE,
+       .chan_width = WMI_TLV_PEER_CHAN_WIDTH,
+       .nss = WMI_TLV_PEER_NSS,
+       .use_4addr = WMI_TLV_PEER_USE_4ADDR,
+       .membership = WMI_TLV_PEER_MEMBERSHIP,
+       .user_pos = WMI_TLV_PEER_USERPOS,
+       .crit_proto_hint_enabled = WMI_TLV_PEER_CRIT_PROTO_HINT_ENABLED,
+       .tx_fail_cnt_thr = WMI_TLV_PEER_TX_FAIL_CNT_THR,
+       .set_hw_retry_cts2s = WMI_TLV_PEER_SET_HW_RETRY_CTS2S,
+       .ibss_atim_win_len = WMI_TLV_PEER_IBSS_ATIM_WINDOW_LENGTH,
+       .phymode = WMI_TLV_PEER_PHYMODE,
+       .use_fixed_power = WMI_TLV_PEER_USE_FIXED_PWR,
+       .dummy_var = WMI_TLV_PEER_DUMMY_VAR,
+};
+
 static struct wmi_vdev_param_map wmi_tlv_vdev_param_map = {
        .rts_threshold = WMI_TLV_VDEV_PARAM_RTS_THRESHOLD,
        .fragmentation_threshold = WMI_TLV_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
        ar->wmi.cmd = &wmi_tlv_cmd_map;
        ar->wmi.vdev_param = &wmi_tlv_vdev_param_map;
        ar->wmi.pdev_param = &wmi_tlv_pdev_param_map;
+       ar->wmi.peer_param = &wmi_tlv_peer_param_map;
        ar->wmi.ops = &wmi_tlv_ops;
        ar->wmi.peer_flags = &wmi_tlv_peer_flags_map;
 }
 
        WMI_TLV_VDEV_PARAM_IBSS_PS_1RX_CHAIN_IN_ATIM_WINDOW_ENABLE,
 };
 
+enum wmi_tlv_peer_param {
+       WMI_TLV_PEER_SMPS_STATE = 0x1, /* see %wmi_peer_smps_state */
+       WMI_TLV_PEER_AMPDU      = 0x2,
+       WMI_TLV_PEER_AUTHORIZE  = 0x3,
+       WMI_TLV_PEER_CHAN_WIDTH = 0x4,
+       WMI_TLV_PEER_NSS        = 0x5,
+       WMI_TLV_PEER_USE_4ADDR  = 0x6,
+       WMI_TLV_PEER_MEMBERSHIP = 0x7,
+       WMI_TLV_PEER_USERPOS = 0x8,
+       WMI_TLV_PEER_CRIT_PROTO_HINT_ENABLED = 0x9,
+       WMI_TLV_PEER_TX_FAIL_CNT_THR = 0xa,
+       WMI_TLV_PEER_SET_HW_RETRY_CTS2S = 0xb,
+       WMI_TLV_PEER_IBSS_ATIM_WINDOW_LENGTH = 0xc,
+       WMI_TLV_PEER_PHYMODE = 0xd,
+       WMI_TLV_PEER_USE_FIXED_PWR = 0xe,
+       WMI_TLV_PEER_DUMMY_VAR = 0xff,
+};
+
 enum wmi_tlv_peer_flags {
        WMI_TLV_PEER_AUTH = 0x00000001,
        WMI_TLV_PEER_QOS = 0x00000002,
 
        .radar_found_cmdid = WMI_10_4_RADAR_FOUND_CMDID,
 };
 
+static struct wmi_peer_param_map wmi_peer_param_map = {
+       .smps_state = WMI_PEER_SMPS_STATE,
+       .ampdu = WMI_PEER_AMPDU,
+       .authorize = WMI_PEER_AUTHORIZE,
+       .chan_width = WMI_PEER_CHAN_WIDTH,
+       .nss = WMI_PEER_NSS,
+       .use_4addr = WMI_PEER_USE_4ADDR,
+       .use_fixed_power = WMI_PEER_USE_FIXED_PWR,
+       .debug = WMI_PEER_DEBUG,
+       .phymode = WMI_PEER_PHYMODE,
+       .dummy_var = WMI_PEER_DUMMY_VAR,
+};
+
 /* MAIN WMI VDEV param map */
 static struct wmi_vdev_param_map wmi_vdev_param_map = {
        .rts_threshold = WMI_VDEV_PARAM_RTS_THRESHOLD,
                ar->wmi.cmd = &wmi_10_4_cmd_map;
                ar->wmi.vdev_param = &wmi_10_4_vdev_param_map;
                ar->wmi.pdev_param = &wmi_10_4_pdev_param_map;
+               ar->wmi.peer_param = &wmi_peer_param_map;
                ar->wmi.peer_flags = &wmi_10_2_peer_flags_map;
                ar->wmi_key_cipher = wmi_key_cipher_suites;
                break;
                ar->wmi.ops = &wmi_10_2_4_ops;
                ar->wmi.vdev_param = &wmi_10_2_4_vdev_param_map;
                ar->wmi.pdev_param = &wmi_10_2_4_pdev_param_map;
+               ar->wmi.peer_param = &wmi_peer_param_map;
                ar->wmi.peer_flags = &wmi_10_2_peer_flags_map;
                ar->wmi_key_cipher = wmi_key_cipher_suites;
                break;
                ar->wmi.ops = &wmi_10_2_ops;
                ar->wmi.vdev_param = &wmi_10x_vdev_param_map;
                ar->wmi.pdev_param = &wmi_10x_pdev_param_map;
+               ar->wmi.peer_param = &wmi_peer_param_map;
                ar->wmi.peer_flags = &wmi_10_2_peer_flags_map;
                ar->wmi_key_cipher = wmi_key_cipher_suites;
                break;
                ar->wmi.ops = &wmi_10_1_ops;
                ar->wmi.vdev_param = &wmi_10x_vdev_param_map;
                ar->wmi.pdev_param = &wmi_10x_pdev_param_map;
+               ar->wmi.peer_param = &wmi_peer_param_map;
                ar->wmi.peer_flags = &wmi_10x_peer_flags_map;
                ar->wmi_key_cipher = wmi_key_cipher_suites;
                break;
                ar->wmi.ops = &wmi_ops;
                ar->wmi.vdev_param = &wmi_vdev_param_map;
                ar->wmi.pdev_param = &wmi_pdev_param_map;
+               ar->wmi.peer_param = &wmi_peer_param_map;
                ar->wmi.peer_flags = &wmi_peer_flags_map;
                ar->wmi_key_cipher = wmi_key_cipher_suites;
                break;
 
 /* Value to disable fixed rate setting */
 #define WMI_FIXED_RATE_NONE    (0xff)
 
+struct wmi_peer_param_map {
+       u32 smps_state;
+       u32 ampdu;
+       u32 authorize;
+       u32 chan_width;
+       u32 nss;
+       u32 use_4addr;
+       u32 membership;
+       u32 use_fixed_power;
+       u32 user_pos;
+       u32 crit_proto_hint_enabled;
+       u32 tx_fail_cnt_thr;
+       u32 set_hw_retry_cts2s;
+       u32 ibss_atim_win_len;
+       u32 debug;
+       u32 phymode;
+       u32 dummy_var;
+};
+
 struct wmi_vdev_param_map {
        u32 rts_threshold;
        u32 fragmentation_threshold;