drivers/net/wireless/ath/wcn36xx/smd.c

   1 /*
   2  * Copyright (c) 2013 Eugene Krasnikov <[email protected]>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  18
  19 #include <linux/bitfield.h>
  20 #include <linux/etherdevice.h>
  21 #include <linux/firmware.h>
  22 #include <linux/bitops.h>
  23 #include <linux/rpmsg.h>
  24 #include "smd.h"
  25 #include "firmware.h"
  26
  27 struct wcn36xx_cfg_val {
  28         u32 cfg_id;
  29         u32 value;
  30 };
  31
  32 #define WCN36XX_CFG_VAL(id, val) \
  33 { \
  34         .cfg_id = WCN36XX_HAL_CFG_ ## id, \
  35         .value = val \
  36 }
  37
  38 static struct wcn36xx_cfg_val wcn36xx_cfg_vals[] = {
  39         WCN36XX_CFG_VAL(CURRENT_TX_ANTENNA, 1),
  40         WCN36XX_CFG_VAL(CURRENT_RX_ANTENNA, 1),
  41         WCN36XX_CFG_VAL(LOW_GAIN_OVERRIDE, 0),
  42         WCN36XX_CFG_VAL(POWER_STATE_PER_CHAIN, 785),
  43         WCN36XX_CFG_VAL(CAL_PERIOD, 5),
  44         WCN36XX_CFG_VAL(CAL_CONTROL, 1),
  45         WCN36XX_CFG_VAL(PROXIMITY, 0),
  46         WCN36XX_CFG_VAL(NETWORK_DENSITY, 3),
  47         WCN36XX_CFG_VAL(MAX_MEDIUM_TIME, 6000),
  48         WCN36XX_CFG_VAL(MAX_MPDUS_IN_AMPDU, 64),
  49         WCN36XX_CFG_VAL(RTS_THRESHOLD, 2347),
  50         WCN36XX_CFG_VAL(SHORT_RETRY_LIMIT, 15),
  51         WCN36XX_CFG_VAL(LONG_RETRY_LIMIT, 15),
  52         WCN36XX_CFG_VAL(FRAGMENTATION_THRESHOLD, 8000),
  53         WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_ZERO, 5),
  54         WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_ONE, 10),
  55         WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_TWO, 15),
  56         WCN36XX_CFG_VAL(FIXED_RATE, 0),
  57         WCN36XX_CFG_VAL(RETRYRATE_POLICY, 4),
  58         WCN36XX_CFG_VAL(RETRYRATE_SECONDARY, 0),
  59         WCN36XX_CFG_VAL(RETRYRATE_TERTIARY, 0),
  60         WCN36XX_CFG_VAL(FORCE_POLICY_PROTECTION, 5),
  61         WCN36XX_CFG_VAL(FIXED_RATE_MULTICAST_24GHZ, 1),
  62         WCN36XX_CFG_VAL(FIXED_RATE_MULTICAST_5GHZ, 5),
  63         WCN36XX_CFG_VAL(DEFAULT_RATE_INDEX_5GHZ, 5),
  64         WCN36XX_CFG_VAL(MAX_BA_SESSIONS, 40),
  65         WCN36XX_CFG_VAL(PS_DATA_INACTIVITY_TIMEOUT, 200),
  66         WCN36XX_CFG_VAL(PS_ENABLE_BCN_FILTER, 1),
  67         WCN36XX_CFG_VAL(PS_ENABLE_RSSI_MONITOR, 1),
  68         WCN36XX_CFG_VAL(NUM_BEACON_PER_RSSI_AVERAGE, 20),
  69         WCN36XX_CFG_VAL(STATS_PERIOD, 10),
  70         WCN36XX_CFG_VAL(CFP_MAX_DURATION, 30000),
  71         WCN36XX_CFG_VAL(FRAME_TRANS_ENABLED, 0),
  72         WCN36XX_CFG_VAL(BA_THRESHOLD_HIGH, 128),
  73         WCN36XX_CFG_VAL(MAX_BA_BUFFERS, 2560),
  74         WCN36XX_CFG_VAL(DYNAMIC_PS_POLL_VALUE, 0),
  75         WCN36XX_CFG_VAL(TX_PWR_CTRL_ENABLE, 1),
  76         WCN36XX_CFG_VAL(ENABLE_CLOSE_LOOP, 1),
  77         WCN36XX_CFG_VAL(ENABLE_LPWR_IMG_TRANSITION, 0),
  78         WCN36XX_CFG_VAL(BTC_STATIC_LEN_LE_BT, 120000),
  79         WCN36XX_CFG_VAL(BTC_STATIC_LEN_LE_WLAN, 30000),
  80         WCN36XX_CFG_VAL(MAX_ASSOC_LIMIT, 10),
  81         WCN36XX_CFG_VAL(ENABLE_MCC_ADAPTIVE_SCHEDULER, 0),
  82         WCN36XX_CFG_VAL(ENABLE_DYNAMIC_RA_START_RATE, 133), /* MCS 5 */
  83         WCN36XX_CFG_VAL(LINK_FAIL_TX_CNT, 1000),
  84 };
  85
  86 static struct wcn36xx_cfg_val wcn3680_cfg_vals[] = {
  87         WCN36XX_CFG_VAL(CURRENT_TX_ANTENNA, 1),
  88         WCN36XX_CFG_VAL(CURRENT_RX_ANTENNA, 1),
  89         WCN36XX_CFG_VAL(LOW_GAIN_OVERRIDE, 0),
  90         WCN36XX_CFG_VAL(POWER_STATE_PER_CHAIN, 785),
  91         WCN36XX_CFG_VAL(CAL_PERIOD, 5),
  92         WCN36XX_CFG_VAL(CAL_CONTROL, 1),
  93         WCN36XX_CFG_VAL(PROXIMITY, 0),
  94         WCN36XX_CFG_VAL(NETWORK_DENSITY, 3),
  95         WCN36XX_CFG_VAL(MAX_MEDIUM_TIME, 4096),
  96         WCN36XX_CFG_VAL(MAX_MPDUS_IN_AMPDU, 64),
  97         WCN36XX_CFG_VAL(RTS_THRESHOLD, 2347),
  98         WCN36XX_CFG_VAL(SHORT_RETRY_LIMIT, 15),
  99         WCN36XX_CFG_VAL(LONG_RETRY_LIMIT, 15),
 100         WCN36XX_CFG_VAL(FRAGMENTATION_THRESHOLD, 8000),
 101         WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_ZERO, 5),
 102         WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_ONE, 10),
 103         WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_TWO, 15),
 104         WCN36XX_CFG_VAL(FIXED_RATE, 0),
 105         WCN36XX_CFG_VAL(RETRYRATE_POLICY, 4),
 106         WCN36XX_CFG_VAL(RETRYRATE_SECONDARY, 0),
 107         WCN36XX_CFG_VAL(RETRYRATE_TERTIARY, 0),
 108         WCN36XX_CFG_VAL(FORCE_POLICY_PROTECTION, 5),
 109         WCN36XX_CFG_VAL(FIXED_RATE_MULTICAST_24GHZ, 1),
 110         WCN36XX_CFG_VAL(FIXED_RATE_MULTICAST_5GHZ, 5),
 111         WCN36XX_CFG_VAL(DEFAULT_RATE_INDEX_24GHZ, 1),
 112         WCN36XX_CFG_VAL(DEFAULT_RATE_INDEX_5GHZ, 5),
 113         WCN36XX_CFG_VAL(MAX_BA_SESSIONS, 40),
 114         WCN36XX_CFG_VAL(PS_DATA_INACTIVITY_TIMEOUT, 200),
 115         WCN36XX_CFG_VAL(PS_ENABLE_BCN_FILTER, 1),
 116         WCN36XX_CFG_VAL(PS_ENABLE_RSSI_MONITOR, 1),
 117         WCN36XX_CFG_VAL(NUM_BEACON_PER_RSSI_AVERAGE, 20),
 118         WCN36XX_CFG_VAL(STATS_PERIOD, 10),
 119         WCN36XX_CFG_VAL(CFP_MAX_DURATION, 30000),
 120         WCN36XX_CFG_VAL(FRAME_TRANS_ENABLED, 0),
 121         WCN36XX_CFG_VAL(BA_THRESHOLD_HIGH, 128),
 122         WCN36XX_CFG_VAL(MAX_BA_BUFFERS, 2560),
 123         WCN36XX_CFG_VAL(DYNAMIC_PS_POLL_VALUE, 0),
 124         WCN36XX_CFG_VAL(TX_PWR_CTRL_ENABLE, 1),
 125         WCN36XX_CFG_VAL(ENABLE_CLOSE_LOOP, 1),
 126         WCN36XX_CFG_VAL(ENABLE_LPWR_IMG_TRANSITION, 0),
 127         WCN36XX_CFG_VAL(BTC_STATIC_LEN_LE_BT, 120000),
 128         WCN36XX_CFG_VAL(BTC_STATIC_LEN_LE_WLAN, 30000),
 129         WCN36XX_CFG_VAL(MAX_ASSOC_LIMIT, 10),
 130         WCN36XX_CFG_VAL(ENABLE_MCC_ADAPTIVE_SCHEDULER, 0),
 131         WCN36XX_CFG_VAL(TDLS_PUAPSD_MASK, 0),
 132         WCN36XX_CFG_VAL(TDLS_PUAPSD_BUFFER_STA_CAPABLE, 1),
 133         WCN36XX_CFG_VAL(TDLS_PUAPSD_INACTIVITY_TIME, 0),
 134         WCN36XX_CFG_VAL(TDLS_PUAPSD_RX_FRAME_THRESHOLD, 10),
 135         WCN36XX_CFG_VAL(TDLS_OFF_CHANNEL_CAPABLE, 1),
 136         WCN36XX_CFG_VAL(ENABLE_ADAPTIVE_RX_DRAIN, 1),
 137         WCN36XX_CFG_VAL(FLEXCONNECT_POWER_FACTOR, 0),
 138         WCN36XX_CFG_VAL(ANTENNA_DIVERSITY, 3),
 139         WCN36XX_CFG_VAL(ATH_DISABLE, 0),
 140         WCN36XX_CFG_VAL(BTC_STATIC_OPP_WLAN_ACTIVE_WLAN_LEN, 60000),
 141         WCN36XX_CFG_VAL(BTC_STATIC_OPP_WLAN_ACTIVE_BT_LEN, 90000),
 142         WCN36XX_CFG_VAL(BTC_SAP_STATIC_OPP_ACTIVE_WLAN_LEN, 30000),
 143         WCN36XX_CFG_VAL(BTC_SAP_STATIC_OPP_ACTIVE_BT_LEN, 30000),
 144         WCN36XX_CFG_VAL(ASD_PROBE_INTERVAL, 50),
 145         WCN36XX_CFG_VAL(ASD_TRIGGER_THRESHOLD, -60),
 146         WCN36XX_CFG_VAL(ASD_RTT_RSSI_HYST_THRESHOLD, 3),
 147         WCN36XX_CFG_VAL(BTC_CTS2S_ON_STA_DURING_SCO, 0),
 148         WCN36XX_CFG_VAL(RA_FILTER_ENABLE, 0),
 149         WCN36XX_CFG_VAL(RA_RATE_LIMIT_INTERVAL, 60),
 150         WCN36XX_CFG_VAL(BTC_FATAL_HID_NSNIFF_BLK, 2),
 151         WCN36XX_CFG_VAL(BTC_CRITICAL_HID_NSNIFF_BLK, 1),
 152         WCN36XX_CFG_VAL(BTC_DYN_A2DP_TX_QUEUE_THOLD, 0),
 153         WCN36XX_CFG_VAL(BTC_DYN_OPP_TX_QUEUE_THOLD, 1),
 154         WCN36XX_CFG_VAL(MAX_UAPSD_CONSEC_SP, 10),
 155         WCN36XX_CFG_VAL(MAX_UAPSD_CONSEC_RX_CNT, 50),
 156         WCN36XX_CFG_VAL(MAX_UAPSD_CONSEC_TX_CNT, 50),
 157         WCN36XX_CFG_VAL(MAX_UAPSD_CONSEC_TX_CNT_MEAS_WINDOW, 500),
 158         WCN36XX_CFG_VAL(MAX_UAPSD_CONSEC_RX_CNT_MEAS_WINDOW, 500),
 159         WCN36XX_CFG_VAL(MAX_PSPOLL_IN_WMM_UAPSD_PS_MODE, 0),
 160         WCN36XX_CFG_VAL(MAX_UAPSD_INACTIVITY_INTERVALS, 10),
 161         WCN36XX_CFG_VAL(ENABLE_DYNAMIC_WMMPS, 1),
 162         WCN36XX_CFG_VAL(BURST_MODE_BE_TXOP_VALUE, 0),
 163         WCN36XX_CFG_VAL(ENABLE_DYNAMIC_RA_START_RATE, 136),
 164         WCN36XX_CFG_VAL(BTC_FAST_WLAN_CONN_PREF, 1),
 165         WCN36XX_CFG_VAL(ENABLE_RTSCTS_HTVHT, 0),
 166         WCN36XX_CFG_VAL(BTC_STATIC_OPP_WLAN_IDLE_WLAN_LEN, 30000),
 167         WCN36XX_CFG_VAL(BTC_STATIC_OPP_WLAN_IDLE_BT_LEN, 120000),
 168         WCN36XX_CFG_VAL(LINK_FAIL_TX_CNT, 1000),
 169         WCN36XX_CFG_VAL(TOGGLE_ARP_BDRATES, 0),
 170         WCN36XX_CFG_VAL(OPTIMIZE_CA_EVENT, 0),
 171         WCN36XX_CFG_VAL(EXT_SCAN_CONC_MODE, 0),
 172         WCN36XX_CFG_VAL(BAR_WAKEUP_HOST_DISABLE, 0),
 173         WCN36XX_CFG_VAL(SAR_BOFFSET_CORRECTION_ENABLE, 0),
 174         WCN36XX_CFG_VAL(BTC_DISABLE_WLAN_LINK_CRITICAL, 5),
 175         WCN36XX_CFG_VAL(DISABLE_SCAN_DURING_SCO, 2),
 176         WCN36XX_CFG_VAL(CONS_BCNMISS_COUNT, 0),
 177         WCN36XX_CFG_VAL(UNITS_OF_BCN_WAIT_TIME, 0),
 178         WCN36XX_CFG_VAL(TRIGGER_NULLFRAME_BEFORE_HB, 0),
 179         WCN36XX_CFG_VAL(ENABLE_POWERSAVE_OFFLOAD, 0),
 180 };
 181
 182 static int put_cfg_tlv_u32(struct wcn36xx *wcn, size_t *len, u32 id, u32 value)
 183 {
 184         struct wcn36xx_hal_cfg *entry;
 185         u32 *val;
 186
 187         if (*len + sizeof(*entry) + sizeof(u32) >= WCN36XX_HAL_BUF_SIZE) {
 188                 wcn36xx_err("Not enough room for TLV entry\n");
 189                 return -ENOMEM;
 190         }
 191
 192         entry = (struct wcn36xx_hal_cfg *) (wcn->hal_buf + *len);
 193         entry->id = id;
 194         entry->len = sizeof(u32);
 195         entry->pad_bytes = 0;
 196         entry->reserve = 0;
 197
 198         val = (u32 *) (entry + 1);
 199         *val = value;
 200
 201         *len += sizeof(*entry) + sizeof(u32);
 202
 203         return 0;
 204 }
 205
 206 static void wcn36xx_smd_set_bss_nw_type(struct wcn36xx *wcn,
 207                 struct ieee80211_sta *sta,
 208                 struct wcn36xx_hal_config_bss_params *bss_params)
 209 {
 210         if (NL80211_BAND_5GHZ == WCN36XX_BAND(wcn))
 211                 bss_params->nw_type = WCN36XX_HAL_11A_NW_TYPE;
 212         else if (sta && sta->deflink.ht_cap.ht_supported)
 213                 bss_params->nw_type = WCN36XX_HAL_11N_NW_TYPE;
 214         else if (sta && (sta->deflink.supp_rates[NL80211_BAND_2GHZ] & 0x7f))
 215                 bss_params->nw_type = WCN36XX_HAL_11G_NW_TYPE;
 216         else
 217                 bss_params->nw_type = WCN36XX_HAL_11B_NW_TYPE;
 218 }
 219
 220 static inline u8 is_cap_supported(unsigned long caps, unsigned long flag)
 221 {
 222         return caps & flag ? 1 : 0;
 223 }
 224
 225 static void wcn36xx_smd_set_bss_ht_params(struct ieee80211_vif *vif,
 226                 struct ieee80211_sta *sta,
 227                 struct wcn36xx_hal_config_bss_params *bss_params)
 228 {
 229         if (sta && sta->deflink.ht_cap.ht_supported) {
 230                 unsigned long caps = sta->deflink.ht_cap.cap;
 231
 232                 bss_params->ht = sta->deflink.ht_cap.ht_supported;
 233                 bss_params->tx_channel_width_set = is_cap_supported(caps,
 234                         IEEE80211_HT_CAP_SUP_WIDTH_20_40);
 235                 bss_params->lsig_tx_op_protection_full_support =
 236                         is_cap_supported(caps,
 237                                          IEEE80211_HT_CAP_LSIG_TXOP_PROT);
 238
 239                 bss_params->ht_oper_mode = vif->bss_conf.ht_operation_mode;
 240                 bss_params->lln_non_gf_coexist =
 241                         !!(vif->bss_conf.ht_operation_mode &
 242                            IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
 243                 /* IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT */
 244                 bss_params->dual_cts_protection = 0;
 245                 /* IEEE80211_HT_OP_MODE_PROTECTION_20MHZ */
 246                 bss_params->ht20_coexist = 0;
 247         }
 248 }
 249
 250 static void
 251 wcn36xx_smd_set_bss_vht_params(struct ieee80211_vif *vif,
 252                                struct ieee80211_sta *sta,
 253                                struct wcn36xx_hal_config_bss_params_v1 *bss)
 254 {
 255         if (sta && sta->deflink.vht_cap.vht_supported)
 256                 bss->vht_capable = 1;
 257 }
 258
 259 static void wcn36xx_smd_set_sta_ht_params(struct ieee80211_sta *sta,
 260                 struct wcn36xx_hal_config_sta_params *sta_params)
 261 {
 262         if (sta->deflink.ht_cap.ht_supported) {
 263                 unsigned long caps = sta->deflink.ht_cap.cap;
 264
 265                 sta_params->ht_capable = sta->deflink.ht_cap.ht_supported;
 266                 sta_params->tx_channel_width_set = is_cap_supported(caps,
 267                         IEEE80211_HT_CAP_SUP_WIDTH_20_40);
 268                 sta_params->lsig_txop_protection = is_cap_supported(caps,
 269                         IEEE80211_HT_CAP_LSIG_TXOP_PROT);
 270
 271                 sta_params->max_ampdu_size = sta->deflink.ht_cap.ampdu_factor;
 272                 sta_params->max_ampdu_density = sta->deflink.ht_cap.ampdu_density;
 273                 /* max_amsdu_size: 1 : 3839 bytes, 0 : 7935 bytes (max) */
 274                 sta_params->max_amsdu_size = !is_cap_supported(caps,
 275                         IEEE80211_HT_CAP_MAX_AMSDU);
 276                 sta_params->sgi_20Mhz = is_cap_supported(caps,
 277                         IEEE80211_HT_CAP_SGI_20);
 278                 sta_params->sgi_40mhz = is_cap_supported(caps,
 279                         IEEE80211_HT_CAP_SGI_40);
 280                 sta_params->green_field_capable = is_cap_supported(caps,
 281                         IEEE80211_HT_CAP_GRN_FLD);
 282                 sta_params->delayed_ba_support = is_cap_supported(caps,
 283                         IEEE80211_HT_CAP_DELAY_BA);
 284                 sta_params->dsss_cck_mode_40mhz = is_cap_supported(caps,
 285                         IEEE80211_HT_CAP_DSSSCCK40);
 286         }
 287 }
 288
 289 static void wcn36xx_smd_set_sta_vht_params(struct wcn36xx *wcn,
 290                 struct ieee80211_sta *sta,
 291                 struct wcn36xx_hal_config_sta_params_v1 *sta_params)
 292 {
 293         if (sta->deflink.vht_cap.vht_supported) {
 294                 unsigned long caps = sta->deflink.vht_cap.cap;
 295
 296                 sta_params->vht_capable = sta->deflink.vht_cap.vht_supported;
 297                 sta_params->vht_ldpc_enabled =
 298                         is_cap_supported(caps, IEEE80211_VHT_CAP_RXLDPC);
 299                 if (wcn36xx_firmware_get_feat_caps(wcn->fw_feat_caps, MU_MIMO)) {
 300                         sta_params->vht_tx_mu_beamformee_capable =
 301                                 is_cap_supported(caps, IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE);
 302                         if (sta_params->vht_tx_mu_beamformee_capable)
 303                                sta_params->vht_tx_bf_enabled = 1;
 304                 } else {
 305                         sta_params->vht_tx_mu_beamformee_capable = 0;
 306                 }
 307                 sta_params->vht_tx_channel_width_set = 0;
 308         }
 309 }
 310
 311 static void wcn36xx_smd_set_sta_ht_ldpc_params(struct ieee80211_sta *sta,
 312                 struct wcn36xx_hal_config_sta_params_v1 *sta_params)
 313 {
 314         if (sta->deflink.ht_cap.ht_supported) {
 315                 sta_params->ht_ldpc_enabled =
 316                         is_cap_supported(sta->deflink.ht_cap.cap,
 317                                          IEEE80211_HT_CAP_LDPC_CODING);
 318         }
 319 }
 320
 321 static void wcn36xx_smd_set_sta_default_ht_params(
 322                 struct wcn36xx_hal_config_sta_params *sta_params)
 323 {
 324         sta_params->ht_capable = 1;
 325         sta_params->tx_channel_width_set = 1;
 326         sta_params->lsig_txop_protection = 1;
 327         sta_params->max_ampdu_size = 3;
 328         sta_params->max_ampdu_density = 5;
 329         sta_params->max_amsdu_size = 0;
 330         sta_params->sgi_20Mhz = 1;
 331         sta_params->sgi_40mhz = 1;
 332         sta_params->green_field_capable = 1;
 333         sta_params->delayed_ba_support = 0;
 334         sta_params->dsss_cck_mode_40mhz = 1;
 335 }
 336
 337 static void wcn36xx_smd_set_sta_default_vht_params(struct wcn36xx *wcn,
 338                 struct wcn36xx_hal_config_sta_params_v1 *sta_params)
 339 {
 340         if (wcn->rf_id == RF_IRIS_WCN3680) {
 341                 sta_params->vht_capable = 1;
 342                 sta_params->vht_tx_mu_beamformee_capable = 1;
 343         } else {
 344                 sta_params->vht_capable = 0;
 345                 sta_params->vht_tx_mu_beamformee_capable = 0;
 346         }
 347
 348         sta_params->vht_ldpc_enabled = 0;
 349         sta_params->vht_tx_channel_width_set = 0;
 350         sta_params->vht_tx_bf_enabled = 0;
 351 }
 352
 353 static void wcn36xx_smd_set_sta_default_ht_ldpc_params(struct wcn36xx *wcn,
 354                 struct wcn36xx_hal_config_sta_params_v1 *sta_params)
 355 {
 356         if (wcn->rf_id == RF_IRIS_WCN3680)
 357                 sta_params->ht_ldpc_enabled = 1;
 358         else
 359                 sta_params->ht_ldpc_enabled = 0;
 360 }
 361
 362 static void wcn36xx_smd_set_sta_params(struct wcn36xx *wcn,
 363                 struct ieee80211_vif *vif,
 364                 struct ieee80211_sta *sta,
 365                 struct wcn36xx_hal_config_sta_params *sta_params)
 366 {
 367         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
 368         struct wcn36xx_sta *sta_priv = NULL;
 369         if (vif->type == NL80211_IFTYPE_ADHOC ||
 370             vif->type == NL80211_IFTYPE_AP ||
 371             vif->type == NL80211_IFTYPE_MESH_POINT) {
 372                 sta_params->type = 1;
 373                 sta_params->sta_index = WCN36XX_HAL_STA_INVALID_IDX;
 374         } else {
 375                 sta_params->type = 0;
 376                 sta_params->sta_index = vif_priv->self_sta_index;
 377         }
 378
 379         sta_params->listen_interval = WCN36XX_LISTEN_INTERVAL(wcn);
 380
 381         /*
 382          * In STA mode ieee80211_sta contains bssid and ieee80211_vif
 383          * contains our mac address. In  AP mode we are bssid so vif
 384          * contains bssid and ieee80211_sta contains mac.
 385          */
 386         if (NL80211_IFTYPE_STATION == vif->type)
 387                 memcpy(&sta_params->mac, vif->addr, ETH_ALEN);
 388         else
 389                 memcpy(&sta_params->bssid, vif->addr, ETH_ALEN);
 390
 391         sta_params->encrypt_type = vif_priv->encrypt_type;
 392         sta_params->short_preamble_supported = true;
 393
 394         sta_params->rifs_mode = 0;
 395         sta_params->rmf = 0;
 396         sta_params->action = 0;
 397         sta_params->uapsd = 0;
 398         sta_params->mimo_ps = WCN36XX_HAL_HT_MIMO_PS_STATIC;
 399         sta_params->max_ampdu_duration = 0;
 400         sta_params->bssid_index = vif_priv->bss_index;
 401         sta_params->p2p = 0;
 402
 403         if (sta) {
 404                 sta_priv = wcn36xx_sta_to_priv(sta);
 405                 if (NL80211_IFTYPE_STATION == vif->type)
 406                         memcpy(&sta_params->bssid, sta->addr, ETH_ALEN);
 407                 else
 408                         memcpy(&sta_params->mac, sta->addr, ETH_ALEN);
 409                 sta_params->wmm_enabled = sta->wme;
 410                 sta_params->max_sp_len = sta->max_sp;
 411                 sta_params->aid = sta_priv->aid;
 412                 wcn36xx_smd_set_sta_ht_params(sta, sta_params);
 413                 memcpy(&sta_params->supported_rates, &sta_priv->supported_rates,
 414                         sizeof(struct wcn36xx_hal_supported_rates));
 415         } else {
 416                 wcn36xx_set_default_rates((struct wcn36xx_hal_supported_rates *)
 417                                           &sta_params->supported_rates);
 418                 wcn36xx_smd_set_sta_default_ht_params(sta_params);
 419         }
 420 }
 421
 422 static int wcn36xx_smd_send_and_wait(struct wcn36xx *wcn, size_t len)
 423 {
 424         int ret;
 425         unsigned long start;
 426         struct wcn36xx_hal_msg_header *hdr =
 427                 (struct wcn36xx_hal_msg_header *)wcn->hal_buf;
 428         u16 req_type = hdr->msg_type;
 429
 430         wcn36xx_dbg_dump(WCN36XX_DBG_SMD_DUMP, "HAL >>> ", wcn->hal_buf, len);
 431
 432         init_completion(&wcn->hal_rsp_compl);
 433         start = jiffies;
 434         ret = rpmsg_send(wcn->smd_channel, wcn->hal_buf, len);
 435         if (ret) {
 436                 wcn36xx_err("HAL TX failed for req %d\n", req_type);
 437                 goto out;
 438         }
 439         if (wait_for_completion_timeout(&wcn->hal_rsp_compl,
 440                 msecs_to_jiffies(HAL_MSG_TIMEOUT)) <= 0) {
 441                 wcn36xx_err("Timeout! No SMD response to req %d in %dms\n",
 442                             req_type, HAL_MSG_TIMEOUT);
 443                 ret = -ETIME;
 444                 goto out;
 445         }
 446         wcn36xx_dbg(WCN36XX_DBG_SMD,
 447                     "SMD command (req %d, rsp %d) completed in %dms\n",
 448                     req_type, hdr->msg_type,
 449                     jiffies_to_msecs(jiffies - start));
 450 out:
 451         return ret;
 452 }
 453
 454 #define __INIT_HAL_MSG(msg_body, type, version) \
 455         do {                                                            \
 456                 memset(&(msg_body), 0, sizeof(msg_body));               \
 457                 (msg_body).header.msg_type = type;                      \
 458                 (msg_body).header.msg_version = version;                \
 459                 (msg_body).header.len = sizeof(msg_body);               \
 460         } while (0)                                                     \
 461
 462 #define INIT_HAL_MSG(msg_body, type)    \
 463         __INIT_HAL_MSG(msg_body, type, WCN36XX_HAL_MSG_VERSION0)
 464
 465 #define INIT_HAL_MSG_V1(msg_body, type) \
 466         __INIT_HAL_MSG(msg_body, type, WCN36XX_HAL_MSG_VERSION1)
 467
 468 #define INIT_HAL_PTT_MSG(p_msg_body, ppt_msg_len) \
 469         do { \
 470                 memset(p_msg_body, 0, sizeof(*p_msg_body) + ppt_msg_len); \
 471                 p_msg_body->header.msg_type = WCN36XX_HAL_PROCESS_PTT_REQ; \
 472                 p_msg_body->header.msg_version = WCN36XX_HAL_MSG_VERSION0; \
 473                 p_msg_body->header.len = sizeof(*p_msg_body) + ppt_msg_len; \
 474         } while (0)
 475
 476 #define PREPARE_HAL_BUF(send_buf, msg_body) \
 477         do {                                                    \
 478                 memcpy_and_pad(send_buf, msg_body.header.len,   \
 479                                &msg_body, sizeof(msg_body), 0); \
 480         } while (0)                                             \
 481
 482 #define PREPARE_HAL_PTT_MSG_BUF(send_buf, p_msg_body) \
 483         do {                                                    \
 484                 memcpy(send_buf, p_msg_body, p_msg_body->header.len); \
 485         } while (0)
 486
 487 static int wcn36xx_smd_rsp_status_check(void *buf, size_t len)
 488 {
 489         struct wcn36xx_fw_msg_status_rsp *rsp;
 490
 491         if (len < sizeof(struct wcn36xx_hal_msg_header) +
 492             sizeof(struct wcn36xx_fw_msg_status_rsp))
 493                 return -EIO;
 494
 495         rsp = (struct wcn36xx_fw_msg_status_rsp *)
 496                 (buf + sizeof(struct wcn36xx_hal_msg_header));
 497
 498         if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->status)
 499                 return rsp->status;
 500
 501         return 0;
 502 }
 503
 504 int wcn36xx_smd_load_nv(struct wcn36xx *wcn)
 505 {
 506         struct nv_data *nv_d;
 507         struct wcn36xx_hal_nv_img_download_req_msg msg_body;
 508         int fw_bytes_left;
 509         int ret;
 510         u16 fm_offset = 0;
 511
 512         if (!wcn->nv) {
 513                 ret = request_firmware(&wcn->nv, wcn->nv_file, wcn->dev);
 514                 if (ret) {
 515                         wcn36xx_err("Failed to load nv file %s: %d\n",
 516                                     wcn->nv_file, ret);
 517                         goto out;
 518                 }
 519         }
 520
 521         nv_d = (struct nv_data *)wcn->nv->data;
 522         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DOWNLOAD_NV_REQ);
 523
 524         msg_body.header.len += WCN36XX_NV_FRAGMENT_SIZE;
 525
 526         msg_body.frag_number = 0;
 527         /* hal_buf must be protected with  mutex */
 528         mutex_lock(&wcn->hal_mutex);
 529
 530         do {
 531                 fw_bytes_left = wcn->nv->size - fm_offset - 4;
 532                 if (fw_bytes_left > WCN36XX_NV_FRAGMENT_SIZE) {
 533                         msg_body.last_fragment = 0;
 534                         msg_body.nv_img_buffer_size = WCN36XX_NV_FRAGMENT_SIZE;
 535                 } else {
 536                         msg_body.last_fragment = 1;
 537                         msg_body.nv_img_buffer_size = fw_bytes_left;
 538
 539                         /* Do not forget update general message len */
 540                         msg_body.header.len = sizeof(msg_body) + fw_bytes_left;
 541
 542                 }
 543
 544                 /* Add load NV request message header */
 545                 memcpy(wcn->hal_buf, &msg_body, sizeof(msg_body));
 546
 547                 /* Add NV body itself */
 548                 memcpy(wcn->hal_buf + sizeof(msg_body),
 549                        &nv_d->table + fm_offset,
 550                        msg_body.nv_img_buffer_size);
 551
 552                 ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 553                 if (ret)
 554                         goto out_unlock;
 555                 ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf,
 556                                                    wcn->hal_rsp_len);
 557                 if (ret) {
 558                         wcn36xx_err("hal_load_nv response failed err=%d\n",
 559                                     ret);
 560                         goto out_unlock;
 561                 }
 562                 msg_body.frag_number++;
 563                 fm_offset += WCN36XX_NV_FRAGMENT_SIZE;
 564
 565         } while (msg_body.last_fragment != 1);
 566
 567 out_unlock:
 568         mutex_unlock(&wcn->hal_mutex);
 569 out:    return ret;
 570 }
 571
 572 static int wcn36xx_smd_start_rsp(struct wcn36xx *wcn, void *buf, size_t len)
 573 {
 574         struct wcn36xx_hal_mac_start_rsp_msg *rsp;
 575
 576         if (len < sizeof(*rsp))
 577                 return -EIO;
 578
 579         rsp = buf;
 580
 581         if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->start_rsp_params.status)
 582                 return -EIO;
 583
 584         memcpy(wcn->crm_version, rsp->start_rsp_params.crm_version,
 585                WCN36XX_HAL_VERSION_LENGTH);
 586         memcpy(wcn->wlan_version, rsp->start_rsp_params.wlan_version,
 587                WCN36XX_HAL_VERSION_LENGTH);
 588
 589         /* null terminate the strings, just in case */
 590         wcn->crm_version[WCN36XX_HAL_VERSION_LENGTH] = '\0';
 591         wcn->wlan_version[WCN36XX_HAL_VERSION_LENGTH] = '\0';
 592
 593         wcn->fw_revision = rsp->start_rsp_params.version.revision;
 594         wcn->fw_version = rsp->start_rsp_params.version.version;
 595         wcn->fw_minor = rsp->start_rsp_params.version.minor;
 596         wcn->fw_major = rsp->start_rsp_params.version.major;
 597
 598         if (wcn->first_boot) {
 599                 wcn->first_boot = false;
 600                 wcn36xx_info("firmware WLAN version '%s' and CRM version '%s'\n",
 601                              wcn->wlan_version, wcn->crm_version);
 602
 603                 wcn36xx_info("firmware API %u.%u.%u.%u, %u stations, %u bssids\n",
 604                              wcn->fw_major, wcn->fw_minor,
 605                              wcn->fw_version, wcn->fw_revision,
 606                              rsp->start_rsp_params.stations,
 607                              rsp->start_rsp_params.bssids);
 608         }
 609         return 0;
 610 }
 611
 612 int wcn36xx_smd_start(struct wcn36xx *wcn)
 613 {
 614         struct wcn36xx_hal_mac_start_req_msg msg_body, *body;
 615         int ret;
 616         int i;
 617         size_t len;
 618         int cfg_elements;
 619         static struct wcn36xx_cfg_val *cfg_vals;
 620
 621         mutex_lock(&wcn->hal_mutex);
 622         INIT_HAL_MSG(msg_body, WCN36XX_HAL_START_REQ);
 623
 624         msg_body.params.type = DRIVER_TYPE_PRODUCTION;
 625         msg_body.params.len = 0;
 626
 627         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 628
 629         body = (struct wcn36xx_hal_mac_start_req_msg *)wcn->hal_buf;
 630         len = body->header.len;
 631
 632         if (wcn->rf_id == RF_IRIS_WCN3680) {
 633                 cfg_vals = wcn3680_cfg_vals;
 634                 cfg_elements = ARRAY_SIZE(wcn3680_cfg_vals);
 635         } else {
 636                 cfg_vals = wcn36xx_cfg_vals;
 637                 cfg_elements = ARRAY_SIZE(wcn36xx_cfg_vals);
 638         }
 639
 640         for (i = 0; i < cfg_elements; i++) {
 641                 ret = put_cfg_tlv_u32(wcn, &len, cfg_vals[i].cfg_id,
 642                                       cfg_vals[i].value);
 643                 if (ret)
 644                         goto out;
 645         }
 646         body->header.len = len;
 647         body->params.len = len - sizeof(*body);
 648
 649         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal start type %d\n",
 650                     msg_body.params.type);
 651
 652         ret = wcn36xx_smd_send_and_wait(wcn, body->header.len);
 653         if (ret) {
 654                 wcn36xx_err("Sending hal_start failed\n");
 655                 goto out;
 656         }
 657
 658         ret = wcn36xx_smd_start_rsp(wcn, wcn->hal_buf, wcn->hal_rsp_len);
 659         if (ret) {
 660                 wcn36xx_err("hal_start response failed err=%d\n", ret);
 661                 goto out;
 662         }
 663
 664 out:
 665         mutex_unlock(&wcn->hal_mutex);
 666         return ret;
 667 }
 668
 669 int wcn36xx_smd_stop(struct wcn36xx *wcn)
 670 {
 671         struct wcn36xx_hal_mac_stop_req_msg msg_body;
 672         int ret;
 673
 674         mutex_lock(&wcn->hal_mutex);
 675         INIT_HAL_MSG(msg_body, WCN36XX_HAL_STOP_REQ);
 676
 677         msg_body.stop_req_params.reason = HAL_STOP_TYPE_RF_KILL;
 678
 679         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 680
 681         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 682         if (ret) {
 683                 wcn36xx_err("Sending hal_stop failed\n");
 684                 goto out;
 685         }
 686         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 687         if (ret) {
 688                 wcn36xx_err("hal_stop response failed err=%d\n", ret);
 689                 goto out;
 690         }
 691 out:
 692         mutex_unlock(&wcn->hal_mutex);
 693         return ret;
 694 }
 695
 696 int wcn36xx_smd_init_scan(struct wcn36xx *wcn, enum wcn36xx_hal_sys_mode mode,
 697                           struct ieee80211_vif *vif)
 698 {
 699         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
 700         struct wcn36xx_hal_init_scan_req_msg msg_body;
 701         int ret;
 702
 703         mutex_lock(&wcn->hal_mutex);
 704         INIT_HAL_MSG(msg_body, WCN36XX_HAL_INIT_SCAN_REQ);
 705
 706         msg_body.mode = mode;
 707         if (vif_priv->bss_index != WCN36XX_HAL_BSS_INVALID_IDX) {
 708                 /* Notify BSSID with null DATA packet */
 709                 msg_body.frame_type = 2;
 710                 msg_body.notify = 1;
 711                 msg_body.scan_entry.bss_index[0] = vif_priv->bss_index;
 712                 msg_body.scan_entry.active_bss_count = 1;
 713         }
 714
 715         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 716
 717         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal init scan mode %d\n", msg_body.mode);
 718
 719         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 720         if (ret) {
 721                 wcn36xx_err("Sending hal_init_scan failed\n");
 722                 goto out;
 723         }
 724         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 725         if (ret) {
 726                 wcn36xx_err("hal_init_scan response failed err=%d\n", ret);
 727                 goto out;
 728         }
 729         wcn->sw_scan_init = true;
 730 out:
 731         mutex_unlock(&wcn->hal_mutex);
 732         return ret;
 733 }
 734
 735 int wcn36xx_smd_start_scan(struct wcn36xx *wcn, u8 scan_channel)
 736 {
 737         struct wcn36xx_hal_start_scan_req_msg msg_body;
 738         int ret;
 739
 740         mutex_lock(&wcn->hal_mutex);
 741         INIT_HAL_MSG(msg_body, WCN36XX_HAL_START_SCAN_REQ);
 742
 743         msg_body.scan_channel = scan_channel;
 744
 745         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 746
 747         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal start scan channel %d\n",
 748                     msg_body.scan_channel);
 749
 750         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 751         if (ret) {
 752                 wcn36xx_err("Sending hal_start_scan failed\n");
 753                 goto out;
 754         }
 755         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 756         if (ret) {
 757                 wcn36xx_err("hal_start_scan response failed err=%d\n", ret);
 758                 goto out;
 759         }
 760         wcn->sw_scan_channel = scan_channel;
 761 out:
 762         mutex_unlock(&wcn->hal_mutex);
 763         return ret;
 764 }
 765
 766 int wcn36xx_smd_end_scan(struct wcn36xx *wcn, u8 scan_channel)
 767 {
 768         struct wcn36xx_hal_end_scan_req_msg msg_body;
 769         int ret;
 770
 771         mutex_lock(&wcn->hal_mutex);
 772         INIT_HAL_MSG(msg_body, WCN36XX_HAL_END_SCAN_REQ);
 773
 774         msg_body.scan_channel = scan_channel;
 775
 776         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 777
 778         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal end scan channel %d\n",
 779                     msg_body.scan_channel);
 780
 781         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 782         if (ret) {
 783                 wcn36xx_err("Sending hal_end_scan failed\n");
 784                 goto out;
 785         }
 786         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 787         if (ret) {
 788                 wcn36xx_err("hal_end_scan response failed err=%d\n", ret);
 789                 goto out;
 790         }
 791         wcn->sw_scan_channel = 0;
 792 out:
 793         mutex_unlock(&wcn->hal_mutex);
 794         return ret;
 795 }
 796
 797 int wcn36xx_smd_finish_scan(struct wcn36xx *wcn,
 798                             enum wcn36xx_hal_sys_mode mode,
 799                             struct ieee80211_vif *vif)
 800 {
 801         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
 802         struct wcn36xx_hal_finish_scan_req_msg msg_body;
 803         int ret;
 804
 805         mutex_lock(&wcn->hal_mutex);
 806         INIT_HAL_MSG(msg_body, WCN36XX_HAL_FINISH_SCAN_REQ);
 807
 808         msg_body.mode = mode;
 809         msg_body.oper_channel = WCN36XX_HW_CHANNEL(wcn);
 810         if (vif_priv->bss_index != WCN36XX_HAL_BSS_INVALID_IDX) {
 811                 /* Notify BSSID with null data packet */
 812                 msg_body.notify = 1;
 813                 msg_body.frame_type = 2;
 814                 msg_body.scan_entry.bss_index[0] = vif_priv->bss_index;
 815                 msg_body.scan_entry.active_bss_count = 1;
 816         }
 817
 818         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 819
 820         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal finish scan mode %d\n",
 821                     msg_body.mode);
 822
 823         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 824         if (ret) {
 825                 wcn36xx_err("Sending hal_finish_scan failed\n");
 826                 goto out;
 827         }
 828         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 829         if (ret) {
 830                 wcn36xx_err("hal_finish_scan response failed err=%d\n", ret);
 831                 goto out;
 832         }
 833         wcn->sw_scan_init = false;
 834 out:
 835         mutex_unlock(&wcn->hal_mutex);
 836         return ret;
 837 }
 838
 839 int wcn36xx_smd_start_hw_scan(struct wcn36xx *wcn, struct ieee80211_vif *vif,
 840                               struct cfg80211_scan_request *req)
 841 {
 842         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
 843         struct wcn36xx_hal_start_scan_offload_req_msg *msg_body;
 844         int ret, i;
 845
 846         if (req->ie_len > WCN36XX_MAX_SCAN_IE_LEN)
 847                 return -EINVAL;
 848
 849         mutex_lock(&wcn->hal_mutex);
 850         msg_body = kzalloc(sizeof(*msg_body), GFP_KERNEL);
 851         if (!msg_body) {
 852                 ret = -ENOMEM;
 853                 goto out;
 854         }
 855
 856         INIT_HAL_MSG((*msg_body), WCN36XX_HAL_START_SCAN_OFFLOAD_REQ);
 857
 858         msg_body->scan_type = WCN36XX_HAL_SCAN_TYPE_ACTIVE;
 859         msg_body->min_ch_time = 30;
 860         msg_body->max_ch_time = 100;
 861         msg_body->scan_hidden = 1;
 862         memcpy(msg_body->mac, vif->addr, ETH_ALEN);
 863         msg_body->bss_type = vif_priv->bss_type;
 864         msg_body->p2p_search = vif->p2p;
 865
 866         msg_body->num_ssid = min_t(u8, req->n_ssids, ARRAY_SIZE(msg_body->ssids));
 867         for (i = 0; i < msg_body->num_ssid; i++) {
 868                 msg_body->ssids[i].length = min_t(u8, req->ssids[i].ssid_len,
 869                                                 sizeof(msg_body->ssids[i].ssid));
 870                 memcpy(msg_body->ssids[i].ssid, req->ssids[i].ssid,
 871                        msg_body->ssids[i].length);
 872         }
 873
 874         msg_body->num_channel = min_t(u8, req->n_channels,
 875                                      sizeof(msg_body->channels));
 876         for (i = 0; i < msg_body->num_channel; i++) {
 877                 msg_body->channels[i] =
 878                         HW_VALUE_CHANNEL(req->channels[i]->hw_value);
 879         }
 880
 881         msg_body->header.len -= WCN36XX_MAX_SCAN_IE_LEN;
 882
 883         if (req->ie_len > 0) {
 884                 msg_body->ie_len = req->ie_len;
 885                 msg_body->header.len += req->ie_len;
 886                 memcpy(msg_body->ie, req->ie, req->ie_len);
 887         }
 888
 889         PREPARE_HAL_BUF(wcn->hal_buf, (*msg_body));
 890
 891         wcn36xx_dbg(WCN36XX_DBG_HAL,
 892                     "hal start hw-scan (channels: %u; ssids: %u; p2p: %s)\n",
 893                     msg_body->num_channel, msg_body->num_ssid,
 894                     msg_body->p2p_search ? "yes" : "no");
 895
 896         ret = wcn36xx_smd_send_and_wait(wcn, msg_body->header.len);
 897         if (ret) {
 898                 wcn36xx_err("Sending hal_start_scan_offload failed\n");
 899                 goto out;
 900         }
 901         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 902         if (ret) {
 903                 wcn36xx_err("hal_start_scan_offload response failed err=%d\n",
 904                             ret);
 905                 goto out;
 906         }
 907 out:
 908         kfree(msg_body);
 909         mutex_unlock(&wcn->hal_mutex);
 910         return ret;
 911 }
 912
 913 int wcn36xx_smd_stop_hw_scan(struct wcn36xx *wcn)
 914 {
 915         struct wcn36xx_hal_stop_scan_offload_req_msg msg_body;
 916         int ret;
 917
 918         mutex_lock(&wcn->hal_mutex);
 919         INIT_HAL_MSG(msg_body, WCN36XX_HAL_STOP_SCAN_OFFLOAD_REQ);
 920         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 921
 922         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal stop hw-scan\n");
 923
 924         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 925         if (ret) {
 926                 wcn36xx_err("Sending hal_stop_scan_offload failed\n");
 927                 goto out;
 928         }
 929         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 930         if (ret) {
 931                 wcn36xx_err("hal_stop_scan_offload response failed err=%d\n",
 932                             ret);
 933                 goto out;
 934         }
 935 out:
 936         mutex_unlock(&wcn->hal_mutex);
 937         return ret;
 938 }
 939
 940 int wcn36xx_smd_update_channel_list(struct wcn36xx *wcn, struct cfg80211_scan_request *req)
 941 {
 942         struct wcn36xx_hal_update_channel_list_req_msg *msg_body;
 943         int ret, i;
 944
 945         msg_body = kzalloc(sizeof(*msg_body), GFP_KERNEL);
 946         if (!msg_body)
 947                 return -ENOMEM;
 948
 949         INIT_HAL_MSG((*msg_body), WCN36XX_HAL_UPDATE_CHANNEL_LIST_REQ);
 950
 951         msg_body->num_channel = min_t(u8, req->n_channels, ARRAY_SIZE(msg_body->channels));
 952         for (i = 0; i < msg_body->num_channel; i++) {
 953                 struct wcn36xx_hal_channel_param *param = &msg_body->channels[i];
 954                 u32 min_power = WCN36XX_HAL_DEFAULT_MIN_POWER;
 955                 u32 ant_gain = WCN36XX_HAL_DEFAULT_ANT_GAIN;
 956
 957                 param->mhz = req->channels[i]->center_freq;
 958                 param->band_center_freq1 = req->channels[i]->center_freq;
 959                 param->band_center_freq2 = 0;
 960
 961                 if (req->channels[i]->flags & IEEE80211_CHAN_NO_IR)
 962                         param->channel_info |= WCN36XX_HAL_CHAN_INFO_FLAG_PASSIVE;
 963
 964                 if (req->channels[i]->flags & IEEE80211_CHAN_RADAR)
 965                         param->channel_info |= WCN36XX_HAL_CHAN_INFO_FLAG_DFS;
 966
 967                 if (req->channels[i]->band == NL80211_BAND_5GHZ) {
 968                         param->channel_info |= WCN36XX_HAL_CHAN_INFO_FLAG_HT;
 969                         param->channel_info |= WCN36XX_HAL_CHAN_INFO_FLAG_VHT;
 970                         param->channel_info |= WCN36XX_HAL_CHAN_INFO_PHY_11A;
 971                 } else {
 972                         param->channel_info |= WCN36XX_HAL_CHAN_INFO_PHY_11BG;
 973                 }
 974
 975                 if (min_power > req->channels[i]->max_power)
 976                         min_power = req->channels[i]->max_power;
 977
 978                 if (req->channels[i]->max_antenna_gain)
 979                         ant_gain = req->channels[i]->max_antenna_gain;
 980
 981                 u32p_replace_bits(&param->reg_info_1, min_power,
 982                                   WCN36XX_HAL_CHAN_REG1_MIN_PWR_MASK);
 983                 u32p_replace_bits(&param->reg_info_1, req->channels[i]->max_power,
 984                                   WCN36XX_HAL_CHAN_REG1_MAX_PWR_MASK);
 985                 u32p_replace_bits(&param->reg_info_1, req->channels[i]->max_reg_power,
 986                                   WCN36XX_HAL_CHAN_REG1_REG_PWR_MASK);
 987                 u32p_replace_bits(&param->reg_info_1, 0,
 988                                   WCN36XX_HAL_CHAN_REG1_CLASS_ID_MASK);
 989                 u32p_replace_bits(&param->reg_info_2, ant_gain,
 990                                   WCN36XX_HAL_CHAN_REG2_ANT_GAIN_MASK);
 991
 992                 wcn36xx_dbg(WCN36XX_DBG_HAL,
 993                             "%s: freq=%u, channel_info=%08x, reg_info1=%08x, reg_info2=%08x\n",
 994                             __func__, param->mhz, param->channel_info, param->reg_info_1,
 995                             param->reg_info_2);
 996         }
 997
 998         mutex_lock(&wcn->hal_mutex);
 999
1000         PREPARE_HAL_BUF(wcn->hal_buf, (*msg_body));
1001
1002         ret = wcn36xx_smd_send_and_wait(wcn, msg_body->header.len);
1003         if (ret) {
1004                 wcn36xx_err("Sending hal_update_channel_list failed\n");
1005                 goto out;
1006         }
1007
1008         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1009         if (ret) {
1010                 wcn36xx_err("hal_update_channel_list response failed err=%d\n", ret);
1011                 goto out;
1012         }
1013
1014 out:
1015         kfree(msg_body);
1016         mutex_unlock(&wcn->hal_mutex);
1017         return ret;
1018 }
1019
1020 static int wcn36xx_smd_switch_channel_rsp(void *buf, size_t len)
1021 {
1022         struct wcn36xx_hal_switch_channel_rsp_msg *rsp;
1023         int ret;
1024
1025         ret = wcn36xx_smd_rsp_status_check(buf, len);
1026         if (ret)
1027                 return ret;
1028         rsp = buf;
1029         wcn36xx_dbg(WCN36XX_DBG_HAL, "channel switched to: %d, status: %d\n",
1030                     rsp->channel_number, rsp->status);
1031         return ret;
1032 }
1033
1034 int wcn36xx_smd_switch_channel(struct wcn36xx *wcn,
1035                                struct ieee80211_vif *vif, int ch)
1036 {
1037         struct wcn36xx_hal_switch_channel_req_msg msg_body;
1038         int ret;
1039
1040         mutex_lock(&wcn->hal_mutex);
1041         INIT_HAL_MSG(msg_body, WCN36XX_HAL_CH_SWITCH_REQ);
1042
1043         msg_body.channel_number = (u8)ch;
1044         msg_body.tx_mgmt_power = 0xbf;
1045         msg_body.max_tx_power = 0xbf;
1046         memcpy(msg_body.self_sta_mac_addr, vif->addr, ETH_ALEN);
1047
1048         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1049
1050         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1051         if (ret) {
1052                 wcn36xx_err("Sending hal_switch_channel failed\n");
1053                 goto out;
1054         }
1055         ret = wcn36xx_smd_switch_channel_rsp(wcn->hal_buf, wcn->hal_rsp_len);
1056         if (ret) {
1057                 wcn36xx_err("hal_switch_channel response failed err=%d\n", ret);
1058                 goto out;
1059         }
1060 out:
1061         mutex_unlock(&wcn->hal_mutex);
1062         return ret;
1063 }
1064
1065 static int wcn36xx_smd_process_ptt_msg_rsp(void *buf, size_t len,
1066                                            void **p_ptt_rsp_msg)
1067 {
1068         struct wcn36xx_hal_process_ptt_msg_rsp_msg *rsp;
1069         int ret;
1070
1071         ret = wcn36xx_smd_rsp_status_check(buf, len);
1072         if (ret)
1073                 return ret;
1074
1075         rsp = buf;
1076
1077         wcn36xx_dbg(WCN36XX_DBG_HAL, "process ptt msg responded with length %d\n",
1078                     rsp->header.len);
1079         wcn36xx_dbg_dump(WCN36XX_DBG_HAL_DUMP, "HAL_PTT_MSG_RSP:", rsp->ptt_msg,
1080                          rsp->header.len - sizeof(rsp->ptt_msg_resp_status));
1081
1082         if (rsp->header.len > 0) {
1083                 *p_ptt_rsp_msg = kmemdup(rsp->ptt_msg, rsp->header.len,
1084                                          GFP_ATOMIC);
1085                 if (!*p_ptt_rsp_msg)
1086                         return -ENOMEM;
1087         }
1088         return ret;
1089 }
1090
1091 int wcn36xx_smd_process_ptt_msg(struct wcn36xx *wcn,
1092                                 struct ieee80211_vif *vif, void *ptt_msg, size_t len,
1093                 void **ptt_rsp_msg)
1094 {
1095         struct wcn36xx_hal_process_ptt_msg_req_msg *p_msg_body;
1096         int ret;
1097
1098         mutex_lock(&wcn->hal_mutex);
1099         p_msg_body = kmalloc(
1100                 sizeof(struct wcn36xx_hal_process_ptt_msg_req_msg) + len,
1101                 GFP_ATOMIC);
1102         if (!p_msg_body) {
1103                 ret = -ENOMEM;
1104                 goto out_nomem;
1105         }
1106         INIT_HAL_PTT_MSG(p_msg_body, len);
1107
1108         memcpy(&p_msg_body->ptt_msg, ptt_msg, len);
1109
1110         PREPARE_HAL_PTT_MSG_BUF(wcn->hal_buf, p_msg_body);
1111
1112         ret = wcn36xx_smd_send_and_wait(wcn, p_msg_body->header.len);
1113         if (ret) {
1114                 wcn36xx_err("Sending hal_process_ptt_msg failed\n");
1115                 goto out;
1116         }
1117         ret = wcn36xx_smd_process_ptt_msg_rsp(wcn->hal_buf, wcn->hal_rsp_len,
1118                                               ptt_rsp_msg);
1119         if (ret) {
1120                 wcn36xx_err("process_ptt_msg response failed err=%d\n", ret);
1121                 goto out;
1122         }
1123 out:
1124         kfree(p_msg_body);
1125 out_nomem:
1126         mutex_unlock(&wcn->hal_mutex);
1127         return ret;
1128 }
1129
1130 static int wcn36xx_smd_update_scan_params_rsp(void *buf, size_t len)
1131 {
1132         struct wcn36xx_hal_update_scan_params_resp *rsp;
1133
1134         rsp = buf;
1135
1136         /* Remove the PNO version bit */
1137         rsp->status &= (~(WCN36XX_FW_MSG_PNO_VERSION_MASK));
1138
1139         if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->status) {
1140                 wcn36xx_warn("error response from update scan\n");
1141                 return rsp->status;
1142         }
1143
1144         return 0;
1145 }
1146
1147 int wcn36xx_smd_update_scan_params(struct wcn36xx *wcn,
1148                                    u8 *channels, size_t channel_count)
1149 {
1150         struct wcn36xx_hal_update_scan_params_req_ex msg_body;
1151         int ret;
1152
1153         mutex_lock(&wcn->hal_mutex);
1154         INIT_HAL_MSG(msg_body, WCN36XX_HAL_UPDATE_SCAN_PARAM_REQ);
1155
1156         msg_body.dot11d_enabled = false;
1157         msg_body.dot11d_resolved = true;
1158
1159         msg_body.channel_count = channel_count;
1160         memcpy(msg_body.channels, channels, channel_count);
1161         msg_body.active_min_ch_time = 60;
1162         msg_body.active_max_ch_time = 120;
1163         msg_body.passive_min_ch_time = 60;
1164         msg_body.passive_max_ch_time = 110;
1165         msg_body.state = PHY_SINGLE_CHANNEL_CENTERED;
1166
1167         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1168
1169         wcn36xx_dbg(WCN36XX_DBG_HAL,
1170                     "hal update scan params channel_count %d\n",
1171                     msg_body.channel_count);
1172
1173         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1174         if (ret) {
1175                 wcn36xx_err("Sending hal_update_scan_params failed\n");
1176                 goto out;
1177         }
1178         ret = wcn36xx_smd_update_scan_params_rsp(wcn->hal_buf,
1179                                                  wcn->hal_rsp_len);
1180         if (ret) {
1181                 wcn36xx_err("hal_update_scan_params response failed err=%d\n",
1182                             ret);
1183                 goto out;
1184         }
1185 out:
1186         mutex_unlock(&wcn->hal_mutex);
1187         return ret;
1188 }
1189
1190 static int wcn36xx_smd_add_sta_self_rsp(struct wcn36xx *wcn,
1191                                         struct ieee80211_vif *vif,
1192                                         void *buf,
1193                                         size_t len)
1194 {
1195         struct wcn36xx_hal_add_sta_self_rsp_msg *rsp;
1196         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1197
1198         if (len < sizeof(*rsp))
1199                 return -EINVAL;
1200
1201         rsp = buf;
1202
1203         if (rsp->status != WCN36XX_FW_MSG_RESULT_SUCCESS) {
1204                 wcn36xx_warn("hal add sta self failure: %d\n",
1205                              rsp->status);
1206                 return rsp->status;
1207         }
1208
1209         wcn36xx_dbg(WCN36XX_DBG_HAL,
1210                     "hal add sta self status %d self_sta_index %d dpu_index %d\n",
1211                     rsp->status, rsp->self_sta_index, rsp->dpu_index);
1212
1213         vif_priv->self_sta_index = rsp->self_sta_index;
1214         vif_priv->self_dpu_desc_index = rsp->dpu_index;
1215
1216         return 0;
1217 }
1218
1219 int wcn36xx_smd_add_sta_self(struct wcn36xx *wcn, struct ieee80211_vif *vif)
1220 {
1221         struct wcn36xx_hal_add_sta_self_req msg_body;
1222         int ret;
1223
1224         mutex_lock(&wcn->hal_mutex);
1225         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_STA_SELF_REQ);
1226
1227         memcpy(&msg_body.self_addr, vif->addr, ETH_ALEN);
1228
1229         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1230
1231         wcn36xx_dbg(WCN36XX_DBG_HAL,
1232                     "hal add sta self self_addr %pM status %d\n",
1233                     msg_body.self_addr, msg_body.status);
1234
1235         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1236         if (ret) {
1237                 wcn36xx_err("Sending hal_add_sta_self failed\n");
1238                 goto out;
1239         }
1240         ret = wcn36xx_smd_add_sta_self_rsp(wcn,
1241                                            vif,
1242                                            wcn->hal_buf,
1243                                            wcn->hal_rsp_len);
1244         if (ret) {
1245                 wcn36xx_err("hal_add_sta_self response failed err=%d\n", ret);
1246                 goto out;
1247         }
1248 out:
1249         mutex_unlock(&wcn->hal_mutex);
1250         return ret;
1251 }
1252
1253 int wcn36xx_smd_delete_sta_self(struct wcn36xx *wcn, u8 *addr)
1254 {
1255         struct wcn36xx_hal_del_sta_self_req_msg msg_body;
1256         int ret;
1257
1258         mutex_lock(&wcn->hal_mutex);
1259         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DEL_STA_SELF_REQ);
1260
1261         memcpy(&msg_body.self_addr, addr, ETH_ALEN);
1262
1263         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1264
1265         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1266         if (ret) {
1267                 wcn36xx_err("Sending hal_delete_sta_self failed\n");
1268                 goto out;
1269         }
1270         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1271         if (ret) {
1272                 wcn36xx_err("hal_delete_sta_self response failed err=%d\n",
1273                             ret);
1274                 goto out;
1275         }
1276 out:
1277         mutex_unlock(&wcn->hal_mutex);
1278         return ret;
1279 }
1280
1281 int wcn36xx_smd_delete_sta(struct wcn36xx *wcn, u8 sta_index)
1282 {
1283         struct wcn36xx_hal_delete_sta_req_msg msg_body;
1284         int ret;
1285
1286         mutex_lock(&wcn->hal_mutex);
1287         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DELETE_STA_REQ);
1288
1289         msg_body.sta_index = sta_index;
1290
1291         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1292
1293         wcn36xx_dbg(WCN36XX_DBG_HAL,
1294                     "hal delete sta sta_index %d\n",
1295                     msg_body.sta_index);
1296
1297         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1298         if (ret) {
1299                 wcn36xx_err("Sending hal_delete_sta failed\n");
1300                 goto out;
1301         }
1302         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1303         if (ret) {
1304                 wcn36xx_err("hal_delete_sta response failed err=%d\n", ret);
1305                 goto out;
1306         }
1307 out:
1308         mutex_unlock(&wcn->hal_mutex);
1309         return ret;
1310 }
1311
1312 static int wcn36xx_smd_join_rsp(void *buf, size_t len)
1313 {
1314         struct wcn36xx_hal_join_rsp_msg *rsp;
1315
1316         if (wcn36xx_smd_rsp_status_check(buf, len))
1317                 return -EIO;
1318
1319         rsp = buf;
1320
1321         wcn36xx_dbg(WCN36XX_DBG_HAL,
1322                     "hal rsp join status %d tx_mgmt_power %d\n",
1323                     rsp->status, rsp->tx_mgmt_power);
1324
1325         return 0;
1326 }
1327
1328 int wcn36xx_smd_join(struct wcn36xx *wcn, const u8 *bssid, u8 *vif, u8 ch)
1329 {
1330         struct wcn36xx_hal_join_req_msg msg_body;
1331         int ret;
1332
1333         mutex_lock(&wcn->hal_mutex);
1334         INIT_HAL_MSG(msg_body, WCN36XX_HAL_JOIN_REQ);
1335
1336         memcpy(&msg_body.bssid, bssid, ETH_ALEN);
1337         memcpy(&msg_body.self_sta_mac_addr, vif, ETH_ALEN);
1338         msg_body.channel = ch;
1339
1340         if (conf_is_ht40_minus(&wcn->hw->conf))
1341                 msg_body.secondary_channel_offset =
1342                         PHY_DOUBLE_CHANNEL_HIGH_PRIMARY;
1343         else if (conf_is_ht40_plus(&wcn->hw->conf))
1344                 msg_body.secondary_channel_offset =
1345                         PHY_DOUBLE_CHANNEL_LOW_PRIMARY;
1346         else
1347                 msg_body.secondary_channel_offset =
1348                         PHY_SINGLE_CHANNEL_CENTERED;
1349
1350         msg_body.link_state = WCN36XX_HAL_LINK_PREASSOC_STATE;
1351
1352         msg_body.max_tx_power = 0xbf;
1353         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1354
1355         wcn36xx_dbg(WCN36XX_DBG_HAL,
1356                     "hal join req bssid %pM self_sta_mac_addr %pM channel %d link_state %d\n",
1357                     msg_body.bssid, msg_body.self_sta_mac_addr,
1358                     msg_body.channel, msg_body.link_state);
1359
1360         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1361         if (ret) {
1362                 wcn36xx_err("Sending hal_join failed\n");
1363                 goto out;
1364         }
1365         ret = wcn36xx_smd_join_rsp(wcn->hal_buf, wcn->hal_rsp_len);
1366         if (ret) {
1367                 wcn36xx_err("hal_join response failed err=%d\n", ret);
1368                 goto out;
1369         }
1370 out:
1371         mutex_unlock(&wcn->hal_mutex);
1372         return ret;
1373 }
1374
1375 int wcn36xx_smd_set_link_st(struct wcn36xx *wcn, const u8 *bssid,
1376                             const u8 *sta_mac,
1377                             enum wcn36xx_hal_link_state state)
1378 {
1379         struct wcn36xx_hal_set_link_state_req_msg msg_body;
1380         int ret;
1381
1382         mutex_lock(&wcn->hal_mutex);
1383         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_LINK_ST_REQ);
1384
1385         memcpy(&msg_body.bssid, bssid, ETH_ALEN);
1386         memcpy(&msg_body.self_mac_addr, sta_mac, ETH_ALEN);
1387         msg_body.state = state;
1388
1389         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1390
1391         wcn36xx_dbg(WCN36XX_DBG_HAL,
1392                     "hal set link state bssid %pM self_mac_addr %pM state %d\n",
1393                     msg_body.bssid, msg_body.self_mac_addr, msg_body.state);
1394
1395         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1396         if (ret) {
1397                 wcn36xx_err("Sending hal_set_link_st failed\n");
1398                 goto out;
1399         }
1400         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1401         if (ret) {
1402                 wcn36xx_err("hal_set_link_st response failed err=%d\n", ret);
1403                 goto out;
1404         }
1405 out:
1406         mutex_unlock(&wcn->hal_mutex);
1407         return ret;
1408 }
1409
1410 static void wcn36xx_smd_convert_sta_to_v1(struct wcn36xx *wcn,
1411                         const struct wcn36xx_hal_config_sta_params *orig,
1412                         struct wcn36xx_hal_config_sta_params_v1 *v1)
1413 {
1414         /* convert orig to v1 format */
1415         memcpy(&v1->bssid, orig->bssid, ETH_ALEN);
1416         memcpy(&v1->mac, orig->mac, ETH_ALEN);
1417         v1->aid = orig->aid;
1418         v1->type = orig->type;
1419         v1->short_preamble_supported = orig->short_preamble_supported;
1420         v1->listen_interval = orig->listen_interval;
1421         v1->wmm_enabled = orig->wmm_enabled;
1422         v1->ht_capable = orig->ht_capable;
1423         v1->tx_channel_width_set = orig->tx_channel_width_set;
1424         v1->rifs_mode = orig->rifs_mode;
1425         v1->lsig_txop_protection = orig->lsig_txop_protection;
1426         v1->max_ampdu_size = orig->max_ampdu_size;
1427         v1->max_ampdu_density = orig->max_ampdu_density;
1428         v1->sgi_40mhz = orig->sgi_40mhz;
1429         v1->sgi_20Mhz = orig->sgi_20Mhz;
1430         v1->rmf = orig->rmf;
1431         v1->encrypt_type = orig->encrypt_type;
1432         v1->action = orig->action;
1433         v1->uapsd = orig->uapsd;
1434         v1->max_sp_len = orig->max_sp_len;
1435         v1->green_field_capable = orig->green_field_capable;
1436         v1->mimo_ps = orig->mimo_ps;
1437         v1->delayed_ba_support = orig->delayed_ba_support;
1438         v1->max_ampdu_duration = orig->max_ampdu_duration;
1439         v1->dsss_cck_mode_40mhz = orig->dsss_cck_mode_40mhz;
1440         memcpy(&v1->supported_rates, &orig->supported_rates,
1441                sizeof(orig->supported_rates));
1442         v1->sta_index = orig->sta_index;
1443         v1->bssid_index = orig->bssid_index;
1444         v1->p2p = orig->p2p;
1445 }
1446
1447 static void
1448 wcn36xx_smd_set_sta_params_v1(struct wcn36xx *wcn,
1449                               struct ieee80211_vif *vif,
1450                               struct ieee80211_sta *sta,
1451                               struct wcn36xx_hal_config_sta_params_v1 *sta_par)
1452 {
1453         struct wcn36xx_sta *sta_priv = NULL;
1454         struct wcn36xx_hal_config_sta_params sta_par_v0;
1455
1456         wcn36xx_smd_set_sta_params(wcn, vif, sta, &sta_par_v0);
1457         wcn36xx_smd_convert_sta_to_v1(wcn, &sta_par_v0, sta_par);
1458
1459         if (sta) {
1460                 sta_priv = wcn36xx_sta_to_priv(sta);
1461                 wcn36xx_smd_set_sta_vht_params(wcn, sta, sta_par);
1462                 wcn36xx_smd_set_sta_ht_ldpc_params(sta, sta_par);
1463                 memcpy(&sta_par->supported_rates, &sta_priv->supported_rates,
1464                        sizeof(sta_par->supported_rates));
1465         } else {
1466                 wcn36xx_set_default_rates_v1(&sta_par->supported_rates);
1467                 wcn36xx_smd_set_sta_default_vht_params(wcn, sta_par);
1468                 wcn36xx_smd_set_sta_default_ht_ldpc_params(wcn, sta_par);
1469         }
1470 }
1471
1472 static int wcn36xx_smd_config_sta_rsp(struct wcn36xx *wcn,
1473                                       struct ieee80211_sta *sta,
1474                                       void *buf,
1475                                       size_t len)
1476 {
1477         struct wcn36xx_hal_config_sta_rsp_msg *rsp;
1478         struct config_sta_rsp_params *params;
1479         struct wcn36xx_sta *sta_priv = wcn36xx_sta_to_priv(sta);
1480
1481         if (len < sizeof(*rsp))
1482                 return -EINVAL;
1483
1484         rsp = buf;
1485         params = &rsp->params;
1486
1487         if (params->status != WCN36XX_FW_MSG_RESULT_SUCCESS) {
1488                 wcn36xx_warn("hal config sta response failure: %d\n",
1489                              params->status);
1490                 return -EIO;
1491         }
1492
1493         sta_priv->sta_index = params->sta_index;
1494         sta_priv->dpu_desc_index = params->dpu_index;
1495         sta_priv->ucast_dpu_sign = params->uc_ucast_sig;
1496
1497         wcn36xx_dbg(WCN36XX_DBG_HAL,
1498                     "hal config sta rsp status %d sta_index %d bssid_index %d uc_ucast_sig %d p2p %d\n",
1499                     params->status, params->sta_index, params->bssid_index,
1500                     params->uc_ucast_sig, params->p2p);
1501
1502         return 0;
1503 }
1504
1505 static int wcn36xx_smd_config_sta_v1(struct wcn36xx *wcn,
1506                                      struct ieee80211_vif *vif,
1507                                      struct ieee80211_sta *sta)
1508 {
1509         struct wcn36xx_hal_config_sta_req_msg_v1 msg_body;
1510         struct wcn36xx_hal_config_sta_params_v1 *sta_params;
1511
1512         if (wcn->rf_id == RF_IRIS_WCN3680) {
1513                 INIT_HAL_MSG_V1(msg_body, WCN36XX_HAL_CONFIG_STA_REQ);
1514         } else {
1515                 INIT_HAL_MSG(msg_body, WCN36XX_HAL_CONFIG_STA_REQ);
1516                 msg_body.header.len -= WCN36XX_DIFF_STA_PARAMS_V1_NOVHT;
1517         }
1518
1519         sta_params = &msg_body.sta_params;
1520
1521         wcn36xx_smd_set_sta_params_v1(wcn, vif, sta, sta_params);
1522
1523         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1524
1525         wcn36xx_dbg(WCN36XX_DBG_HAL,
1526                     "hal config sta v1 action %d sta_index %d bssid_index %d bssid %pM type %d mac %pM aid %d\n",
1527                     sta_params->action, sta_params->sta_index, sta_params->bssid_index,
1528                     sta_params->bssid, sta_params->type, sta_params->mac, sta_params->aid);
1529
1530         return wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1531 }
1532
1533 static int wcn36xx_smd_config_sta_v0(struct wcn36xx *wcn,
1534                                      struct ieee80211_vif *vif,
1535                                      struct ieee80211_sta *sta)
1536 {
1537         struct wcn36xx_hal_config_sta_req_msg msg;
1538         struct wcn36xx_hal_config_sta_params *sta_params;
1539
1540         INIT_HAL_MSG(msg, WCN36XX_HAL_CONFIG_STA_REQ);
1541
1542         sta_params = &msg.sta_params;
1543
1544         wcn36xx_smd_set_sta_params(wcn, vif, sta, sta_params);
1545
1546         PREPARE_HAL_BUF(wcn->hal_buf, msg);
1547
1548         wcn36xx_dbg(WCN36XX_DBG_HAL,
1549                     "hal config sta action %d sta_index %d bssid_index %d bssid %pM type %d mac %pM aid %d\n",
1550                     sta_params->action, sta_params->sta_index,
1551                     sta_params->bssid_index, sta_params->bssid,
1552                     sta_params->type, sta_params->mac, sta_params->aid);
1553
1554         return wcn36xx_smd_send_and_wait(wcn, msg.header.len);
1555 }
1556
1557 int wcn36xx_smd_config_sta(struct wcn36xx *wcn, struct ieee80211_vif *vif,
1558                            struct ieee80211_sta *sta)
1559 {
1560         int ret;
1561
1562         mutex_lock(&wcn->hal_mutex);
1563
1564         if (!wcn36xx_is_fw_version(wcn, 1, 2, 2, 24))
1565                 ret = wcn36xx_smd_config_sta_v1(wcn, vif, sta);
1566         else
1567                 ret = wcn36xx_smd_config_sta_v0(wcn, vif, sta);
1568
1569         if (ret) {
1570                 wcn36xx_err("Sending hal_config_sta failed\n");
1571                 goto out;
1572         }
1573         ret = wcn36xx_smd_config_sta_rsp(wcn,
1574                                          sta,
1575                                          wcn->hal_buf,
1576                                          wcn->hal_rsp_len);
1577         if (ret) {
1578                 wcn36xx_err("hal_config_sta response failed err=%d\n", ret);
1579                 goto out;
1580         }
1581 out:
1582         mutex_unlock(&wcn->hal_mutex);
1583         return ret;
1584 }
1585
1586 static void wcn36xx_smd_set_bss_params(struct wcn36xx *wcn,
1587                                        struct ieee80211_vif *vif,
1588                                        struct ieee80211_sta *sta,
1589                                        const u8 *bssid,
1590                                        bool update,
1591                                        struct wcn36xx_hal_config_bss_params *bss)
1592 {
1593         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1594
1595         WARN_ON(is_zero_ether_addr(bssid));
1596
1597         memcpy(&bss->bssid, bssid, ETH_ALEN);
1598
1599         memcpy(bss->self_mac_addr, vif->addr, ETH_ALEN);
1600
1601         if (vif->type == NL80211_IFTYPE_STATION) {
1602                 bss->bss_type = WCN36XX_HAL_INFRASTRUCTURE_MODE;
1603
1604                 /* STA */
1605                 bss->oper_mode = 1;
1606                 bss->wcn36xx_hal_persona = WCN36XX_HAL_STA_MODE;
1607         } else if (vif->type == NL80211_IFTYPE_AP ||
1608                    vif->type == NL80211_IFTYPE_MESH_POINT) {
1609                 bss->bss_type = WCN36XX_HAL_INFRA_AP_MODE;
1610
1611                 /* AP */
1612                 bss->oper_mode = 0;
1613                 bss->wcn36xx_hal_persona = WCN36XX_HAL_STA_SAP_MODE;
1614         } else if (vif->type == NL80211_IFTYPE_ADHOC) {
1615                 bss->bss_type = WCN36XX_HAL_IBSS_MODE;
1616
1617                 /* STA */
1618                 bss->oper_mode = 1;
1619         } else {
1620                 wcn36xx_warn("Unknown type for bss config: %d\n", vif->type);
1621         }
1622
1623         if (vif->type == NL80211_IFTYPE_STATION)
1624                 wcn36xx_smd_set_bss_nw_type(wcn, sta, bss);
1625         else
1626                 bss->nw_type = WCN36XX_HAL_11N_NW_TYPE;
1627
1628         bss->short_slot_time_supported = vif->bss_conf.use_short_slot;
1629         bss->lla_coexist = 0;
1630         bss->llb_coexist = 0;
1631         bss->llg_coexist = 0;
1632         bss->rifs_mode = 0;
1633         bss->beacon_interval = vif->bss_conf.beacon_int;
1634         bss->dtim_period = vif_priv->dtim_period;
1635
1636         wcn36xx_smd_set_bss_ht_params(vif, sta, bss);
1637
1638         bss->oper_channel = WCN36XX_HW_CHANNEL(wcn);
1639
1640         if (conf_is_ht40_minus(&wcn->hw->conf))
1641                 bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
1642         else if (conf_is_ht40_plus(&wcn->hw->conf))
1643                 bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
1644         else
1645                 bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_NONE;
1646
1647         bss->reserved = 0;
1648
1649         /* wcn->ssid is only valid in AP and IBSS mode */
1650         bss->ssid.length = vif_priv->ssid.length;
1651         memcpy(bss->ssid.ssid, vif_priv->ssid.ssid, vif_priv->ssid.length);
1652
1653         bss->obss_prot_enabled = 0;
1654         bss->rmf = 0;
1655         bss->max_probe_resp_retry_limit = 0;
1656         bss->hidden_ssid = vif->bss_conf.hidden_ssid;
1657         bss->proxy_probe_resp = 0;
1658         bss->edca_params_valid = 0;
1659
1660         /* FIXME: set acbe, acbk, acvi and acvo */
1661
1662         bss->ext_set_sta_key_param_valid = 0;
1663
1664         /* FIXME: set ext_set_sta_key_param */
1665
1666         bss->spectrum_mgt_enable = 0;
1667         bss->tx_mgmt_power = 0;
1668         bss->max_tx_power = WCN36XX_MAX_POWER(wcn);
1669         bss->action = update;
1670
1671         vif_priv->bss_type = bss->bss_type;
1672 }
1673
1674 static int wcn36xx_smd_config_bss_v1(struct wcn36xx *wcn,
1675                                      struct ieee80211_vif *vif,
1676                                      struct ieee80211_sta *sta_80211,
1677                                      const u8 *bssid,
1678                                      bool update)
1679 {
1680         struct wcn36xx_hal_config_bss_req_msg_v1 *msg_body;
1681         struct wcn36xx_hal_config_bss_params_v1 *bss;
1682         struct wcn36xx_hal_config_bss_params bss_v0;
1683         struct wcn36xx_hal_config_sta_params_v1 *sta;
1684         struct cfg80211_chan_def *chandef;
1685         int ret;
1686
1687         msg_body = kzalloc(sizeof(*msg_body), GFP_KERNEL);
1688         if (!msg_body)
1689                 return -ENOMEM;
1690
1691         if (wcn->rf_id == RF_IRIS_WCN3680) {
1692                 INIT_HAL_MSG_V1((*msg_body), WCN36XX_HAL_CONFIG_BSS_REQ);
1693         } else {
1694                 INIT_HAL_MSG((*msg_body), WCN36XX_HAL_CONFIG_BSS_REQ);
1695                 msg_body->header.len -= WCN36XX_DIFF_BSS_PARAMS_V1_NOVHT;
1696         }
1697
1698         bss = &msg_body->bss_params;
1699         sta = &bss->sta;
1700
1701         memset(&bss_v0, 0x00, sizeof(bss_v0));
1702         wcn36xx_smd_set_bss_params(wcn, vif, sta_80211, bssid, update, &bss_v0);
1703         wcn36xx_smd_set_sta_params_v1(wcn, vif, sta_80211, sta);
1704
1705         /* convert orig to v1 */
1706         memcpy(bss->bssid, &bss_v0.bssid, ETH_ALEN);
1707         memcpy(bss->self_mac_addr, &bss_v0.self_mac_addr, ETH_ALEN);
1708
1709         bss->bss_type = bss_v0.bss_type;
1710         bss->oper_mode = bss_v0.oper_mode;
1711         bss->nw_type = bss_v0.nw_type;
1712
1713         bss->short_slot_time_supported =
1714                 bss_v0.short_slot_time_supported;
1715         bss->lla_coexist = bss_v0.lla_coexist;
1716         bss->llb_coexist = bss_v0.llb_coexist;
1717         bss->llg_coexist = bss_v0.llg_coexist;
1718         bss->ht20_coexist = bss_v0.ht20_coexist;
1719         bss->lln_non_gf_coexist = bss_v0.lln_non_gf_coexist;
1720
1721         bss->lsig_tx_op_protection_full_support =
1722                 bss_v0.lsig_tx_op_protection_full_support;
1723         bss->rifs_mode = bss_v0.rifs_mode;
1724         bss->beacon_interval = bss_v0.beacon_interval;
1725         bss->dtim_period = bss_v0.dtim_period;
1726         bss->tx_channel_width_set = bss_v0.tx_channel_width_set;
1727         bss->oper_channel = bss_v0.oper_channel;
1728
1729         if (wcn->hw->conf.chandef.width == NL80211_CHAN_WIDTH_80) {
1730                 chandef = &wcn->hw->conf.chandef;
1731                 bss->ext_channel = HW_VALUE_PHY(chandef->chan->hw_value);
1732         } else {
1733                 bss->ext_channel = bss_v0.ext_channel;
1734         }
1735
1736         bss->reserved = bss_v0.reserved;
1737
1738         memcpy(&bss->ssid, &bss_v0.ssid,
1739                sizeof(bss_v0.ssid));
1740
1741         bss->action = bss_v0.action;
1742         bss->rateset = bss_v0.rateset;
1743         bss->ht = bss_v0.ht;
1744         bss->obss_prot_enabled = bss_v0.obss_prot_enabled;
1745         bss->rmf = bss_v0.rmf;
1746         bss->ht_oper_mode = bss_v0.ht_oper_mode;
1747         bss->dual_cts_protection = bss_v0.dual_cts_protection;
1748
1749         bss->max_probe_resp_retry_limit =
1750                 bss_v0.max_probe_resp_retry_limit;
1751         bss->hidden_ssid = bss_v0.hidden_ssid;
1752         bss->proxy_probe_resp = bss_v0.proxy_probe_resp;
1753         bss->edca_params_valid = bss_v0.edca_params_valid;
1754
1755         memcpy(&bss->acbe, &bss_v0.acbe,
1756                sizeof(bss_v0.acbe));
1757         memcpy(&bss->acbk, &bss_v0.acbk,
1758                sizeof(bss_v0.acbk));
1759         memcpy(&bss->acvi, &bss_v0.acvi,
1760                sizeof(bss_v0.acvi));
1761         memcpy(&bss->acvo, &bss_v0.acvo,
1762                sizeof(bss_v0.acvo));
1763
1764         bss->ext_set_sta_key_param_valid =
1765                 bss_v0.ext_set_sta_key_param_valid;
1766
1767         memcpy(&bss->ext_set_sta_key_param,
1768                &bss_v0.ext_set_sta_key_param,
1769                sizeof(bss_v0.acvo));
1770
1771         bss->wcn36xx_hal_persona = bss_v0.wcn36xx_hal_persona;
1772         bss->spectrum_mgt_enable = bss_v0.spectrum_mgt_enable;
1773         bss->tx_mgmt_power = bss_v0.tx_mgmt_power;
1774         bss->max_tx_power = bss_v0.max_tx_power;
1775
1776         wcn36xx_smd_set_bss_vht_params(vif, sta_80211, bss);
1777
1778         PREPARE_HAL_BUF(wcn->hal_buf, (*msg_body));
1779
1780         wcn36xx_dbg(WCN36XX_DBG_HAL,
1781                     "hal config bss v1 bssid %pM self_mac_addr %pM bss_type %d oper_mode %d nw_type %d\n",
1782                     bss->bssid, bss->self_mac_addr, bss->bss_type,
1783                     bss->oper_mode, bss->nw_type);
1784
1785         wcn36xx_dbg(WCN36XX_DBG_HAL,
1786                     "- sta bssid %pM action %d sta_index %d bssid_index %d aid %d type %d mac %pM\n",
1787                     sta->bssid, sta->action, sta->sta_index,
1788                     sta->bssid_index, sta->aid, sta->type, sta->mac);
1789
1790         ret = wcn36xx_smd_send_and_wait(wcn, msg_body->header.len);
1791         kfree(msg_body);
1792
1793         return ret;
1794 }
1795
1796 static int wcn36xx_smd_config_bss_v0(struct wcn36xx *wcn,
1797                                      struct ieee80211_vif *vif,
1798                                      struct ieee80211_sta *sta,
1799                                      const u8 *bssid,
1800                                      bool update)
1801 {
1802         struct wcn36xx_hal_config_bss_req_msg *msg;
1803         struct wcn36xx_hal_config_bss_params *bss;
1804         struct wcn36xx_hal_config_sta_params *sta_params;
1805         int ret;
1806
1807         msg = kzalloc(sizeof(*msg), GFP_KERNEL);
1808         if (!msg)
1809                 return -ENOMEM;
1810
1811         INIT_HAL_MSG((*msg), WCN36XX_HAL_CONFIG_BSS_REQ);
1812
1813         bss = &msg->bss_params;
1814         sta_params = &bss->sta;
1815
1816         wcn36xx_smd_set_bss_params(wcn, vif, sta, bssid, update, bss);
1817         wcn36xx_smd_set_sta_params(wcn, vif, sta, sta_params);
1818
1819         PREPARE_HAL_BUF(wcn->hal_buf, (*msg));
1820
1821         wcn36xx_dbg(WCN36XX_DBG_HAL,
1822                     "hal config bss bssid %pM self_mac_addr %pM bss_type %d oper_mode %d nw_type %d\n",
1823                     bss->bssid, bss->self_mac_addr, bss->bss_type,
1824                     bss->oper_mode, bss->nw_type);
1825
1826         wcn36xx_dbg(WCN36XX_DBG_HAL,
1827                     "- sta bssid %pM action %d sta_index %d bssid_index %d aid %d type %d mac %pM\n",
1828                     sta_params->bssid, sta_params->action,
1829                     sta_params->sta_index, sta_params->bssid_index,
1830                     sta_params->aid, sta_params->type,
1831                     sta_params->mac);
1832
1833         ret = wcn36xx_smd_send_and_wait(wcn, msg->header.len);
1834         kfree(msg);
1835
1836         return ret;
1837 }
1838
1839 static int wcn36xx_smd_config_bss_rsp(struct wcn36xx *wcn,
1840                                       struct ieee80211_vif *vif,
1841                                       struct ieee80211_sta *sta,
1842                                       void *buf,
1843                                       size_t len)
1844 {
1845         struct wcn36xx_hal_config_bss_rsp_msg *rsp;
1846         struct wcn36xx_hal_config_bss_rsp_params *params;
1847         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1848
1849         if (len < sizeof(*rsp))
1850                 return -EINVAL;
1851
1852         rsp = buf;
1853         params = &rsp->bss_rsp_params;
1854
1855         if (params->status != WCN36XX_FW_MSG_RESULT_SUCCESS) {
1856                 wcn36xx_warn("hal config bss response failure: %d\n",
1857                              params->status);
1858                 return -EIO;
1859         }
1860
1861         wcn36xx_dbg(WCN36XX_DBG_HAL,
1862                     "hal config bss rsp status %d bss_idx %d dpu_desc_index %d"
1863                     " sta_idx %d self_idx %d bcast_idx %d mac %pM"
1864                     " power %d ucast_dpu_signature %d\n",
1865                     params->status, params->bss_index, params->dpu_desc_index,
1866                     params->bss_sta_index, params->bss_self_sta_index,
1867                     params->bss_bcast_sta_idx, params->mac,
1868                     params->tx_mgmt_power, params->ucast_dpu_signature);
1869
1870         vif_priv->bss_index = params->bss_index;
1871
1872         if (sta) {
1873                 struct wcn36xx_sta *sta_priv = wcn36xx_sta_to_priv(sta);
1874                 sta_priv->bss_sta_index = params->bss_sta_index;
1875                 sta_priv->bss_dpu_desc_index = params->dpu_desc_index;
1876         }
1877
1878         vif_priv->self_ucast_dpu_sign = params->ucast_dpu_signature;
1879
1880         return 0;
1881 }
1882
1883 int wcn36xx_smd_config_bss(struct wcn36xx *wcn, struct ieee80211_vif *vif,
1884                            struct ieee80211_sta *sta, const u8 *bssid,
1885                            bool update)
1886 {
1887         int ret;
1888
1889         mutex_lock(&wcn->hal_mutex);
1890
1891         if (!wcn36xx_is_fw_version(wcn, 1, 2, 2, 24))
1892                 ret = wcn36xx_smd_config_bss_v1(wcn, vif, sta, bssid, update);
1893         else
1894                 ret = wcn36xx_smd_config_bss_v0(wcn, vif, sta, bssid, update);
1895
1896         if (ret) {
1897                 wcn36xx_err("Sending hal_config_bss failed\n");
1898                 goto out;
1899         }
1900         ret = wcn36xx_smd_config_bss_rsp(wcn,
1901                                          vif,
1902                                          sta,
1903                                          wcn->hal_buf,
1904                                          wcn->hal_rsp_len);
1905         if (ret)
1906                 wcn36xx_err("hal_config_bss response failed err=%d\n", ret);
1907
1908 out:
1909         mutex_unlock(&wcn->hal_mutex);
1910         return ret;
1911 }
1912
1913 int wcn36xx_smd_delete_bss(struct wcn36xx *wcn, struct ieee80211_vif *vif)
1914 {
1915         struct wcn36xx_hal_delete_bss_req_msg msg_body;
1916         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1917         int ret = 0;
1918
1919         mutex_lock(&wcn->hal_mutex);
1920
1921         if (vif_priv->bss_index == WCN36XX_HAL_BSS_INVALID_IDX)
1922                 goto out;
1923
1924         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DELETE_BSS_REQ);
1925
1926         msg_body.bss_index = vif_priv->bss_index;
1927
1928         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1929
1930         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal delete bss %d\n", msg_body.bss_index);
1931
1932         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1933         if (ret) {
1934                 wcn36xx_err("Sending hal_delete_bss failed\n");
1935                 goto out;
1936         }
1937         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1938         if (ret) {
1939                 wcn36xx_err("hal_delete_bss response failed err=%d\n", ret);
1940                 goto out;
1941         }
1942
1943         vif_priv->bss_index = WCN36XX_HAL_BSS_INVALID_IDX;
1944 out:
1945         mutex_unlock(&wcn->hal_mutex);
1946         return ret;
1947 }
1948
1949 int wcn36xx_smd_send_beacon(struct wcn36xx *wcn, struct ieee80211_vif *vif,
1950                             struct sk_buff *skb_beacon, u16 tim_off,
1951                             u16 p2p_off)
1952 {
1953         struct wcn36xx_hal_send_beacon_req_msg msg_body;
1954         int ret, pad, pvm_len;
1955
1956         mutex_lock(&wcn->hal_mutex);
1957         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SEND_BEACON_REQ);
1958
1959         pvm_len = skb_beacon->data[tim_off + 1] - 3;
1960         pad = TIM_MIN_PVM_SIZE - pvm_len;
1961
1962         /* Padding is irrelevant to mesh mode since tim_off is always 0. */
1963         if (vif->type == NL80211_IFTYPE_MESH_POINT)
1964                 pad = 0;
1965
1966         msg_body.beacon_length = skb_beacon->len + pad;
1967         /* TODO need to find out why + 6 is needed */
1968         msg_body.beacon_length6 = msg_body.beacon_length + 6;
1969
1970         if (msg_body.beacon_length > BEACON_TEMPLATE_SIZE) {
1971                 wcn36xx_err("Beacon is too big: beacon size=%d\n",
1972                               msg_body.beacon_length);
1973                 ret = -ENOMEM;
1974                 goto out;
1975         }
1976         memcpy(msg_body.beacon, skb_beacon->data, skb_beacon->len);
1977         memcpy(msg_body.bssid, vif->addr, ETH_ALEN);
1978
1979         if (pad > 0) {
1980                 /*
1981                  * The wcn36xx FW has a fixed size for the PVM in the TIM. If
1982                  * given the beacon template from mac80211 with a PVM shorter
1983                  * than the FW expectes it will overwrite the data after the
1984                  * TIM.
1985                  */
1986                 wcn36xx_dbg(WCN36XX_DBG_HAL, "Pad TIM PVM. %d bytes at %d\n",
1987                             pad, pvm_len);
1988                 memmove(&msg_body.beacon[tim_off + 5 + pvm_len + pad],
1989                         &msg_body.beacon[tim_off + 5 + pvm_len],
1990                         skb_beacon->len - (tim_off + 5 + pvm_len));
1991                 memset(&msg_body.beacon[tim_off + 5 + pvm_len], 0, pad);
1992                 msg_body.beacon[tim_off + 1] += pad;
1993         }
1994
1995         /* TODO need to find out why this is needed? */
1996         if (vif->type == NL80211_IFTYPE_MESH_POINT)
1997                 /* mesh beacon don't need this, so push further down */
1998                 msg_body.tim_ie_offset = 256;
1999         else
2000                 msg_body.tim_ie_offset = tim_off+4;
2001         msg_body.p2p_ie_offset = p2p_off;
2002         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2003
2004         wcn36xx_dbg(WCN36XX_DBG_HAL,
2005                     "hal send beacon beacon_length %d\n",
2006                     msg_body.beacon_length);
2007
2008         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2009         if (ret) {
2010                 wcn36xx_err("Sending hal_send_beacon failed\n");
2011                 goto out;
2012         }
2013         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2014         if (ret) {
2015                 wcn36xx_err("hal_send_beacon response failed err=%d\n", ret);
2016                 goto out;
2017         }
2018 out:
2019         mutex_unlock(&wcn->hal_mutex);
2020         return ret;
2021 }
2022
2023 int wcn36xx_smd_update_proberesp_tmpl(struct wcn36xx *wcn,
2024                                       struct ieee80211_vif *vif,
2025                                       struct sk_buff *skb)
2026 {
2027         struct wcn36xx_hal_send_probe_resp_req_msg msg;
2028         int ret;
2029
2030         mutex_lock(&wcn->hal_mutex);
2031         INIT_HAL_MSG(msg, WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_REQ);
2032
2033         if (skb->len > BEACON_TEMPLATE_SIZE) {
2034                 wcn36xx_warn("probe response template is too big: %d\n",
2035                              skb->len);
2036                 ret = -E2BIG;
2037                 goto out;
2038         }
2039
2040         msg.probe_resp_template_len = skb->len;
2041         memcpy(&msg.probe_resp_template, skb->data, skb->len);
2042
2043         memcpy(msg.bssid, vif->addr, ETH_ALEN);
2044
2045         PREPARE_HAL_BUF(wcn->hal_buf, msg);
2046
2047         wcn36xx_dbg(WCN36XX_DBG_HAL,
2048                     "hal update probe rsp len %d bssid %pM\n",
2049                     msg.probe_resp_template_len, msg.bssid);
2050
2051         ret = wcn36xx_smd_send_and_wait(wcn, msg.header.len);
2052         if (ret) {
2053                 wcn36xx_err("Sending hal_update_proberesp_tmpl failed\n");
2054                 goto out;
2055         }
2056         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2057         if (ret) {
2058                 wcn36xx_err("hal_update_proberesp_tmpl response failed err=%d\n",
2059                             ret);
2060                 goto out;
2061         }
2062 out:
2063         mutex_unlock(&wcn->hal_mutex);
2064         return ret;
2065 }
2066
2067 int wcn36xx_smd_set_stakey(struct wcn36xx *wcn,
2068                            enum ani_ed_type enc_type,
2069                            u8 keyidx,
2070                            u8 keylen,
2071                            u8 *key,
2072                            u8 sta_index)
2073 {
2074         struct wcn36xx_hal_set_sta_key_req_msg msg_body;
2075         int ret;
2076
2077         mutex_lock(&wcn->hal_mutex);
2078         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_STAKEY_REQ);
2079
2080         msg_body.set_sta_key_params.sta_index = sta_index;
2081         msg_body.set_sta_key_params.enc_type = enc_type;
2082
2083         if (enc_type == WCN36XX_HAL_ED_WEP104 ||
2084             enc_type == WCN36XX_HAL_ED_WEP40) {
2085                 /* Use bss key for wep (static) */
2086                 msg_body.set_sta_key_params.def_wep_idx = keyidx;
2087                 msg_body.set_sta_key_params.wep_type = 0;
2088         } else {
2089                 msg_body.set_sta_key_params.key[0].id = keyidx;
2090                 msg_body.set_sta_key_params.key[0].unicast = 1;
2091                 msg_body.set_sta_key_params.key[0].direction = WCN36XX_HAL_TX_RX;
2092                 msg_body.set_sta_key_params.key[0].pae_role = 0;
2093                 msg_body.set_sta_key_params.key[0].length = keylen;
2094                 memcpy(msg_body.set_sta_key_params.key[0].key, key, keylen);
2095         }
2096
2097         msg_body.set_sta_key_params.single_tid_rc = 1;
2098
2099         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2100
2101         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2102         if (ret) {
2103                 wcn36xx_err("Sending hal_set_stakey failed\n");
2104                 goto out;
2105         }
2106         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2107         if (ret) {
2108                 wcn36xx_err("hal_set_stakey response failed err=%d\n", ret);
2109                 goto out;
2110         }
2111 out:
2112         mutex_unlock(&wcn->hal_mutex);
2113         return ret;
2114 }
2115
2116 int wcn36xx_smd_set_bsskey(struct wcn36xx *wcn,
2117                            enum ani_ed_type enc_type,
2118                            u8 bssidx,
2119                            u8 keyidx,
2120                            u8 keylen,
2121                            u8 *key)
2122 {
2123         struct wcn36xx_hal_set_bss_key_req_msg msg_body;
2124         int ret;
2125
2126         mutex_lock(&wcn->hal_mutex);
2127         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_BSSKEY_REQ);
2128         msg_body.bss_idx = bssidx;
2129         msg_body.enc_type = enc_type;
2130         msg_body.num_keys = 1;
2131         msg_body.keys[0].id = keyidx;
2132         msg_body.keys[0].unicast = 0;
2133         msg_body.keys[0].direction = WCN36XX_HAL_RX_ONLY;
2134         msg_body.keys[0].pae_role = 0;
2135         msg_body.keys[0].length = keylen;
2136         memcpy(msg_body.keys[0].key, key, keylen);
2137
2138         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2139
2140         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2141         if (ret) {
2142                 wcn36xx_err("Sending hal_set_bsskey failed\n");
2143                 goto out;
2144         }
2145         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2146         if (ret) {
2147                 wcn36xx_err("hal_set_bsskey response failed err=%d\n", ret);
2148                 goto out;
2149         }
2150 out:
2151         mutex_unlock(&wcn->hal_mutex);
2152         return ret;
2153 }
2154
2155 int wcn36xx_smd_remove_stakey(struct wcn36xx *wcn,
2156                               enum ani_ed_type enc_type,
2157                               u8 keyidx,
2158                               u8 sta_index)
2159 {
2160         struct wcn36xx_hal_remove_sta_key_req_msg msg_body;
2161         int ret;
2162
2163         mutex_lock(&wcn->hal_mutex);
2164         INIT_HAL_MSG(msg_body, WCN36XX_HAL_RMV_STAKEY_REQ);
2165
2166         msg_body.sta_idx = sta_index;
2167         msg_body.enc_type = enc_type;
2168         msg_body.key_id = keyidx;
2169
2170         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2171
2172         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2173         if (ret) {
2174                 wcn36xx_err("Sending hal_remove_stakey failed\n");
2175                 goto out;
2176         }
2177         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2178         if (ret) {
2179                 wcn36xx_err("hal_remove_stakey response failed err=%d\n", ret);
2180                 goto out;
2181         }
2182 out:
2183         mutex_unlock(&wcn->hal_mutex);
2184         return ret;
2185 }
2186
2187 int wcn36xx_smd_remove_bsskey(struct wcn36xx *wcn,
2188                               enum ani_ed_type enc_type,
2189                               u8 bssidx,
2190                               u8 keyidx)
2191 {
2192         struct wcn36xx_hal_remove_bss_key_req_msg msg_body;
2193         int ret;
2194
2195         mutex_lock(&wcn->hal_mutex);
2196         INIT_HAL_MSG(msg_body, WCN36XX_HAL_RMV_BSSKEY_REQ);
2197         msg_body.bss_idx = bssidx;
2198         msg_body.enc_type = enc_type;
2199         msg_body.key_id = keyidx;
2200
2201         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2202
2203         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2204         if (ret) {
2205                 wcn36xx_err("Sending hal_remove_bsskey failed\n");
2206                 goto out;
2207         }
2208         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2209         if (ret) {
2210                 wcn36xx_err("hal_remove_bsskey response failed err=%d\n", ret);
2211                 goto out;
2212         }
2213 out:
2214         mutex_unlock(&wcn->hal_mutex);
2215         return ret;
2216 }
2217
2218 int wcn36xx_smd_enter_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif)
2219 {
2220         struct wcn36xx_hal_enter_bmps_req_msg msg_body;
2221         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2222         int ret;
2223
2224         mutex_lock(&wcn->hal_mutex);
2225         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ENTER_BMPS_REQ);
2226
2227         msg_body.bss_index = vif_priv->bss_index;
2228         msg_body.tbtt = vif->bss_conf.sync_tsf;
2229         msg_body.dtim_period = vif_priv->dtim_period;
2230
2231         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2232
2233         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2234         if (ret) {
2235                 wcn36xx_err("Sending hal_enter_bmps failed\n");
2236                 goto out;
2237         }
2238         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2239         if (ret) {
2240                 wcn36xx_err("hal_enter_bmps response failed err=%d\n", ret);
2241                 goto out;
2242         }
2243 out:
2244         mutex_unlock(&wcn->hal_mutex);
2245         return ret;
2246 }
2247
2248 int wcn36xx_smd_exit_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif)
2249 {
2250         struct wcn36xx_hal_exit_bmps_req_msg msg_body;
2251         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2252         int ret;
2253
2254         mutex_lock(&wcn->hal_mutex);
2255         INIT_HAL_MSG(msg_body, WCN36XX_HAL_EXIT_BMPS_REQ);
2256
2257         msg_body.bss_index = vif_priv->bss_index;
2258         msg_body.send_data_null = 1;
2259
2260         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2261
2262         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2263         if (ret) {
2264                 wcn36xx_err("Sending hal_exit_bmps failed\n");
2265                 goto out;
2266         }
2267         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2268         if (ret) {
2269                 wcn36xx_err("hal_exit_bmps response failed err=%d\n", ret);
2270                 goto out;
2271         }
2272 out:
2273         mutex_unlock(&wcn->hal_mutex);
2274         return ret;
2275 }
2276
2277 int wcn36xx_smd_enter_imps(struct wcn36xx *wcn)
2278 {
2279         struct wcn36xx_hal_enter_imps_req_msg msg_body;
2280         int ret;
2281
2282         mutex_lock(&wcn->hal_mutex);
2283         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ENTER_IMPS_REQ);
2284
2285         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2286
2287         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2288         if (ret) {
2289                 wcn36xx_err("Sending hal_enter_imps failed\n");
2290                 goto out;
2291         }
2292         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2293         if (ret) {
2294                 wcn36xx_err("hal_enter_imps response failed err=%d\n", ret);
2295                 goto out;
2296         }
2297
2298         wcn36xx_dbg(WCN36XX_DBG_HAL, "Entered idle mode\n");
2299 out:
2300         mutex_unlock(&wcn->hal_mutex);
2301         return ret;
2302 }
2303
2304 int wcn36xx_smd_exit_imps(struct wcn36xx *wcn)
2305 {
2306         struct wcn36xx_hal_exit_imps_req_msg msg_body;
2307         int ret;
2308
2309         mutex_lock(&wcn->hal_mutex);
2310         INIT_HAL_MSG(msg_body, WCN36XX_HAL_EXIT_IMPS_REQ);
2311
2312         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2313
2314         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2315         if (ret) {
2316                 wcn36xx_err("Sending hal_exit_imps failed\n");
2317                 goto out;
2318         }
2319         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2320         if (ret) {
2321                 wcn36xx_err("hal_exit_imps response failed err=%d\n", ret);
2322                 goto out;
2323         }
2324         wcn36xx_dbg(WCN36XX_DBG_HAL, "Exited idle mode\n");
2325 out:
2326         mutex_unlock(&wcn->hal_mutex);
2327         return ret;
2328 }
2329
2330 int wcn36xx_smd_set_power_params(struct wcn36xx *wcn, bool ignore_dtim)
2331 {
2332         struct wcn36xx_hal_set_power_params_req_msg msg_body;
2333         int ret;
2334
2335         mutex_lock(&wcn->hal_mutex);
2336         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_POWER_PARAMS_REQ);
2337
2338         /*
2339          * When host is down ignore every second dtim
2340          */
2341         if (ignore_dtim) {
2342                 msg_body.ignore_dtim = 1;
2343                 msg_body.dtim_period = 2;
2344         }
2345         msg_body.listen_interval = WCN36XX_LISTEN_INTERVAL(wcn);
2346
2347         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2348
2349         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2350         if (ret) {
2351                 wcn36xx_err("Sending hal_set_power_params failed\n");
2352                 goto out;
2353         }
2354
2355 out:
2356         mutex_unlock(&wcn->hal_mutex);
2357         return ret;
2358 }
2359
2360 /* Notice: This function should be called after associated, or else it
2361  * will be invalid
2362  */
2363 int wcn36xx_smd_keep_alive_req(struct wcn36xx *wcn,
2364                                struct ieee80211_vif *vif,
2365                                int packet_type)
2366 {
2367         struct wcn36xx_hal_keep_alive_req_msg msg_body;
2368         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2369         int ret;
2370
2371         mutex_lock(&wcn->hal_mutex);
2372         INIT_HAL_MSG(msg_body, WCN36XX_HAL_KEEP_ALIVE_REQ);
2373
2374         if (packet_type == WCN36XX_HAL_KEEP_ALIVE_NULL_PKT) {
2375                 msg_body.bss_index = vif_priv->bss_index;
2376                 msg_body.packet_type = WCN36XX_HAL_KEEP_ALIVE_NULL_PKT;
2377                 msg_body.time_period = WCN36XX_KEEP_ALIVE_TIME_PERIOD;
2378         } else if (packet_type == WCN36XX_HAL_KEEP_ALIVE_UNSOLICIT_ARP_RSP) {
2379                 /* TODO: it also support ARP response type */
2380         } else {
2381                 wcn36xx_warn("unknown keep alive packet type %d\n", packet_type);
2382                 ret = -EINVAL;
2383                 goto out;
2384         }
2385
2386         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2387
2388         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2389         if (ret) {
2390                 wcn36xx_err("Sending hal_keep_alive failed\n");
2391                 goto out;
2392         }
2393         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2394         if (ret) {
2395                 wcn36xx_err("hal_keep_alive response failed err=%d\n", ret);
2396                 goto out;
2397         }
2398 out:
2399         mutex_unlock(&wcn->hal_mutex);
2400         return ret;
2401 }
2402
2403 int wcn36xx_smd_dump_cmd_req(struct wcn36xx *wcn, u32 arg1, u32 arg2,
2404                              u32 arg3, u32 arg4, u32 arg5)
2405 {
2406         struct wcn36xx_hal_dump_cmd_req_msg msg_body;
2407         int ret;
2408
2409         mutex_lock(&wcn->hal_mutex);
2410         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DUMP_COMMAND_REQ);
2411
2412         msg_body.arg1 = arg1;
2413         msg_body.arg2 = arg2;
2414         msg_body.arg3 = arg3;
2415         msg_body.arg4 = arg4;
2416         msg_body.arg5 = arg5;
2417
2418         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2419
2420         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2421         if (ret) {
2422                 wcn36xx_err("Sending hal_dump_cmd failed\n");
2423                 goto out;
2424         }
2425         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2426         if (ret) {
2427                 wcn36xx_err("hal_dump_cmd response failed err=%d\n", ret);
2428                 goto out;
2429         }
2430 out:
2431         mutex_unlock(&wcn->hal_mutex);
2432         return ret;
2433 }
2434
2435 int wcn36xx_smd_feature_caps_exchange(struct wcn36xx *wcn)
2436 {
2437         struct wcn36xx_hal_feat_caps_msg msg_body, *rsp;
2438         int ret, i;
2439
2440         mutex_lock(&wcn->hal_mutex);
2441         INIT_HAL_MSG(msg_body, WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_REQ);
2442
2443         wcn36xx_firmware_set_feat_caps(msg_body.feat_caps, STA_POWERSAVE);
2444         if (wcn->rf_id == RF_IRIS_WCN3680) {
2445                 wcn36xx_firmware_set_feat_caps(msg_body.feat_caps, DOT11AC);
2446                 wcn36xx_firmware_set_feat_caps(msg_body.feat_caps, WLAN_CH144);
2447                 wcn36xx_firmware_set_feat_caps(msg_body.feat_caps,
2448                                                ANTENNA_DIVERSITY_SELECTION);
2449         }
2450
2451         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2452
2453         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2454         if (ret) {
2455                 wcn36xx_err("Sending hal_feature_caps_exchange failed\n");
2456                 goto out;
2457         }
2458         if (wcn->hal_rsp_len != sizeof(*rsp)) {
2459                 wcn36xx_err("Invalid hal_feature_caps_exchange response");
2460                 goto out;
2461         }
2462
2463         rsp = (struct wcn36xx_hal_feat_caps_msg *) wcn->hal_buf;
2464
2465         for (i = 0; i < WCN36XX_HAL_CAPS_SIZE; i++)
2466                 wcn->fw_feat_caps[i] = rsp->feat_caps[i];
2467 out:
2468         mutex_unlock(&wcn->hal_mutex);
2469         return ret;
2470 }
2471
2472 static int wcn36xx_smd_add_ba_session_rsp(void *buf, int len, u8 *session)
2473 {
2474         struct wcn36xx_hal_add_ba_session_rsp_msg *rsp;
2475
2476         if (len < sizeof(*rsp))
2477                 return -EINVAL;
2478
2479         rsp = buf;
2480         if (rsp->status != WCN36XX_FW_MSG_RESULT_SUCCESS)
2481                 return rsp->status;
2482
2483         *session = rsp->ba_session_id;
2484
2485         return 0;
2486 }
2487
2488 int wcn36xx_smd_add_ba_session(struct wcn36xx *wcn,
2489                 struct ieee80211_sta *sta,
2490                 u16 tid,
2491                 u16 *ssn,
2492                 u8 direction,
2493                 u8 sta_index)
2494 {
2495         struct wcn36xx_hal_add_ba_session_req_msg msg_body;
2496         u8 session_id;
2497         int ret;
2498
2499         mutex_lock(&wcn->hal_mutex);
2500         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BA_SESSION_REQ);
2501
2502         msg_body.sta_index = sta_index;
2503         memcpy(&msg_body.mac_addr, sta->addr, ETH_ALEN);
2504         msg_body.dialog_token = 0x10;
2505         msg_body.tid = tid;
2506
2507         /* Immediate BA because Delayed BA is not supported */
2508         msg_body.policy = 1;
2509         msg_body.buffer_size = WCN36XX_AGGR_BUFFER_SIZE;
2510         msg_body.timeout = 0;
2511         if (ssn)
2512                 msg_body.ssn = *ssn;
2513         msg_body.direction = direction;
2514
2515         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2516
2517         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2518         if (ret) {
2519                 wcn36xx_err("Sending hal_add_ba_session failed\n");
2520                 goto out;
2521         }
2522         ret = wcn36xx_smd_add_ba_session_rsp(wcn->hal_buf, wcn->hal_rsp_len,
2523                                              &session_id);
2524         if (ret) {
2525                 wcn36xx_err("hal_add_ba_session response failed err=%d\n", ret);
2526                 ret = -EINVAL;
2527                 goto out;
2528         }
2529
2530         ret = session_id;
2531 out:
2532         mutex_unlock(&wcn->hal_mutex);
2533         return ret;
2534 }
2535
2536 int wcn36xx_smd_add_ba(struct wcn36xx *wcn, u8 session_id)
2537 {
2538         struct wcn36xx_hal_add_ba_req_msg msg_body;
2539         int ret;
2540
2541         mutex_lock(&wcn->hal_mutex);
2542         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BA_REQ);
2543
2544         msg_body.session_id = session_id;
2545         msg_body.win_size = WCN36XX_AGGR_BUFFER_SIZE;
2546
2547         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2548
2549         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2550         if (ret) {
2551                 wcn36xx_err("Sending hal_add_ba failed\n");
2552                 goto out;
2553         }
2554         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2555         if (ret) {
2556                 wcn36xx_err("hal_add_ba response failed err=%d\n", ret);
2557                 goto out;
2558         }
2559 out:
2560         mutex_unlock(&wcn->hal_mutex);
2561         return ret;
2562 }
2563
2564 int wcn36xx_smd_del_ba(struct wcn36xx *wcn, u16 tid, u8 direction, u8 sta_index)
2565 {
2566         struct wcn36xx_hal_del_ba_req_msg msg_body;
2567         int ret;
2568
2569         mutex_lock(&wcn->hal_mutex);
2570         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DEL_BA_REQ);
2571
2572         msg_body.sta_index = sta_index;
2573         msg_body.tid = tid;
2574         msg_body.direction = direction;
2575         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2576
2577         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2578         if (ret) {
2579                 wcn36xx_err("Sending hal_del_ba failed\n");
2580                 goto out;
2581         }
2582         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2583         if (ret) {
2584                 wcn36xx_err("hal_del_ba response failed err=%d\n", ret);
2585                 goto out;
2586         }
2587 out:
2588         mutex_unlock(&wcn->hal_mutex);
2589         return ret;
2590 }
2591
2592 int wcn36xx_smd_get_stats(struct wcn36xx *wcn, u8 sta_index, u32 stats_mask,
2593                           struct station_info *sinfo)
2594 {
2595         struct wcn36xx_hal_stats_req_msg msg_body;
2596         struct wcn36xx_hal_stats_rsp_msg *rsp;
2597         void *rsp_body;
2598         int ret;
2599
2600         if (stats_mask & ~HAL_GLOBAL_CLASS_A_STATS_INFO) {
2601                 wcn36xx_err("stats_mask 0x%x contains unimplemented types\n",
2602                             stats_mask);
2603                 return -EINVAL;
2604         }
2605
2606         mutex_lock(&wcn->hal_mutex);
2607         INIT_HAL_MSG(msg_body, WCN36XX_HAL_GET_STATS_REQ);
2608
2609         msg_body.sta_id = sta_index;
2610         msg_body.stats_mask = stats_mask;
2611
2612         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2613
2614         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2615         if (ret) {
2616                 wcn36xx_err("sending hal_get_stats failed\n");
2617                 goto out;
2618         }
2619
2620         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2621         if (ret) {
2622                 wcn36xx_err("hal_get_stats response failed err=%d\n", ret);
2623                 goto out;
2624         }
2625
2626         rsp = (struct wcn36xx_hal_stats_rsp_msg *)wcn->hal_buf;
2627         rsp_body = (wcn->hal_buf + sizeof(struct wcn36xx_hal_stats_rsp_msg));
2628
2629         if (rsp->stats_mask != stats_mask) {
2630                 wcn36xx_err("stats_mask 0x%x differs from requested 0x%x\n",
2631                             rsp->stats_mask, stats_mask);
2632                 goto out;
2633         }
2634
2635         if (rsp->stats_mask & HAL_GLOBAL_CLASS_A_STATS_INFO) {
2636                 struct ani_global_class_a_stats_info *stats_info = rsp_body;
2637
2638                 wcn36xx_process_tx_rate(stats_info, &sinfo->txrate);
2639                 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
2640                 rsp_body += sizeof(struct ani_global_class_a_stats_info);
2641         }
2642 out:
2643         mutex_unlock(&wcn->hal_mutex);
2644
2645         return ret;
2646 }
2647
2648 static int wcn36xx_smd_trigger_ba_rsp(void *buf, int len, struct add_ba_info *ba_info)
2649 {
2650         struct wcn36xx_hal_trigger_ba_rsp_candidate *candidate;
2651         struct wcn36xx_hal_trigger_ba_rsp_msg *rsp;
2652         int i;
2653
2654         if (len < sizeof(*rsp))
2655                 return -EINVAL;
2656
2657         rsp = buf;
2658
2659         if (rsp->candidate_cnt < 1)
2660                 return rsp->status ? rsp->status : -EINVAL;
2661
2662         candidate = (struct wcn36xx_hal_trigger_ba_rsp_candidate *)(buf + sizeof(*rsp));
2663
2664         for (i = 0; i < STACFG_MAX_TC; i++) {
2665                 ba_info[i] = candidate->ba_info[i];
2666         }
2667
2668         return rsp->status;
2669 }
2670
2671 int wcn36xx_smd_trigger_ba(struct wcn36xx *wcn, u8 sta_index, u16 tid, u16 *ssn)
2672 {
2673         struct wcn36xx_hal_trigger_ba_req_msg msg_body;
2674         struct wcn36xx_hal_trigger_ba_req_candidate *candidate;
2675         struct add_ba_info ba_info[STACFG_MAX_TC];
2676         int ret;
2677
2678         if (tid >= STACFG_MAX_TC)
2679                 return -EINVAL;
2680
2681         mutex_lock(&wcn->hal_mutex);
2682         INIT_HAL_MSG(msg_body, WCN36XX_HAL_TRIGGER_BA_REQ);
2683
2684         msg_body.session_id = 0; /* not really used */
2685         msg_body.candidate_cnt = 1;
2686         msg_body.header.len += sizeof(*candidate);
2687         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2688
2689         candidate = (struct wcn36xx_hal_trigger_ba_req_candidate *)
2690                 (wcn->hal_buf + sizeof(msg_body));
2691         candidate->sta_index = sta_index;
2692         candidate->tid_bitmap = 1 << tid;
2693
2694         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2695         if (ret) {
2696                 wcn36xx_err("Sending hal_trigger_ba failed\n");
2697                 goto out;
2698         }
2699         ret = wcn36xx_smd_trigger_ba_rsp(wcn->hal_buf, wcn->hal_rsp_len, ba_info);
2700         if (ret) {
2701                 wcn36xx_err("hal_trigger_ba response failed err=%d\n", ret);
2702                 goto out;
2703         }
2704 out:
2705         mutex_unlock(&wcn->hal_mutex);
2706
2707         if (ssn)
2708                 *ssn = ba_info[tid].starting_seq_num;
2709
2710         return ret;
2711 }
2712
2713 static int wcn36xx_smd_tx_compl_ind(struct wcn36xx *wcn, void *buf, size_t len)
2714 {
2715         struct wcn36xx_hal_tx_compl_ind_msg *rsp = buf;
2716
2717         if (len != sizeof(*rsp)) {
2718                 wcn36xx_warn("Bad TX complete indication\n");
2719                 return -EIO;
2720         }
2721
2722         wcn36xx_dxe_tx_ack_ind(wcn, rsp->status);
2723
2724         return 0;
2725 }
2726
2727 static int wcn36xx_smd_hw_scan_ind(struct wcn36xx *wcn, void *buf, size_t len)
2728 {
2729         struct wcn36xx_hal_scan_offload_ind *rsp = buf;
2730         struct cfg80211_scan_info scan_info = {};
2731
2732         if (len != sizeof(*rsp)) {
2733                 wcn36xx_warn("Corrupted delete scan indication\n");
2734                 return -EIO;
2735         }
2736
2737         wcn36xx_dbg(WCN36XX_DBG_HAL, "scan indication (type %x)\n", rsp->type);
2738
2739         switch (rsp->type) {
2740         case WCN36XX_HAL_SCAN_IND_FAILED:
2741         case WCN36XX_HAL_SCAN_IND_DEQUEUED:
2742                 scan_info.aborted = true;
2743                 fallthrough;
2744         case WCN36XX_HAL_SCAN_IND_COMPLETED:
2745                 mutex_lock(&wcn->scan_lock);
2746                 wcn->scan_req = NULL;
2747                 if (wcn->scan_aborted)
2748                         scan_info.aborted = true;
2749                 mutex_unlock(&wcn->scan_lock);
2750                 ieee80211_scan_completed(wcn->hw, &scan_info);
2751                 break;
2752         case WCN36XX_HAL_SCAN_IND_STARTED:
2753         case WCN36XX_HAL_SCAN_IND_FOREIGN_CHANNEL:
2754         case WCN36XX_HAL_SCAN_IND_PREEMPTED:
2755         case WCN36XX_HAL_SCAN_IND_RESTARTED:
2756                 break;
2757         default:
2758                 wcn36xx_warn("Unknown scan indication type %x\n", rsp->type);
2759         }
2760
2761         return 0;
2762 }
2763
2764 static int wcn36xx_smd_missed_beacon_ind(struct wcn36xx *wcn,
2765                                          void *buf,
2766                                          size_t len)
2767 {
2768         struct wcn36xx_hal_missed_beacon_ind_msg *rsp = buf;
2769         struct ieee80211_vif *vif = NULL;
2770         struct wcn36xx_vif *tmp;
2771
2772         /* Old FW does not have bss index */
2773         if (wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) {
2774                 list_for_each_entry(tmp, &wcn->vif_list, list) {
2775                         wcn36xx_dbg(WCN36XX_DBG_HAL, "beacon missed bss_index %d\n",
2776                                     tmp->bss_index);
2777                         vif = wcn36xx_priv_to_vif(tmp);
2778                         ieee80211_beacon_loss(vif);
2779                 }
2780                 return 0;
2781         }
2782
2783         if (len != sizeof(*rsp)) {
2784                 wcn36xx_warn("Corrupted missed beacon indication\n");
2785                 return -EIO;
2786         }
2787
2788         list_for_each_entry(tmp, &wcn->vif_list, list) {
2789                 if (tmp->bss_index == rsp->bss_index) {
2790                         wcn36xx_dbg(WCN36XX_DBG_HAL, "beacon missed bss_index %d\n",
2791                                     rsp->bss_index);
2792                         vif = wcn36xx_priv_to_vif(tmp);
2793                         ieee80211_beacon_loss(vif);
2794                         return 0;
2795                 }
2796         }
2797
2798         wcn36xx_warn("BSS index %d not found\n", rsp->bss_index);
2799         return -ENOENT;
2800 }
2801
2802 static int wcn36xx_smd_delete_sta_context_ind(struct wcn36xx *wcn,
2803                                               void *buf,
2804                                               size_t len)
2805 {
2806         struct wcn36xx_hal_delete_sta_context_ind_msg *rsp = buf;
2807         struct wcn36xx_vif *vif_priv;
2808         struct ieee80211_vif *vif;
2809         struct ieee80211_bss_conf *bss_conf;
2810         struct ieee80211_sta *sta;
2811         bool found = false;
2812
2813         if (len != sizeof(*rsp)) {
2814                 wcn36xx_warn("Corrupted delete sta indication\n");
2815                 return -EIO;
2816         }
2817
2818         wcn36xx_dbg(WCN36XX_DBG_HAL,
2819                     "delete station indication %pM index %d reason %d\n",
2820                     rsp->addr2, rsp->sta_id, rsp->reason_code);
2821
2822         list_for_each_entry(vif_priv, &wcn->vif_list, list) {
2823                 rcu_read_lock();
2824                 vif = wcn36xx_priv_to_vif(vif_priv);
2825
2826                 if (vif->type == NL80211_IFTYPE_STATION) {
2827                         /* We could call ieee80211_find_sta too, but checking
2828                          * bss_conf is clearer.
2829                          */
2830                         bss_conf = &vif->bss_conf;
2831                         if (vif_priv->sta_assoc &&
2832                             !memcmp(bss_conf->bssid, rsp->addr2, ETH_ALEN)) {
2833                                 found = true;
2834                                 wcn36xx_dbg(WCN36XX_DBG_HAL,
2835                                             "connection loss bss_index %d\n",
2836                                             vif_priv->bss_index);
2837                                 ieee80211_connection_loss(vif);
2838                         }
2839                 } else {
2840                         sta = ieee80211_find_sta(vif, rsp->addr2);
2841                         if (sta) {
2842                                 found = true;
2843                                 ieee80211_report_low_ack(sta, 0);
2844                         }
2845                 }
2846
2847                 rcu_read_unlock();
2848                 if (found)
2849                         return 0;
2850         }
2851
2852         wcn36xx_warn("BSS or STA with addr %pM not found\n", rsp->addr2);
2853         return -ENOENT;
2854 }
2855
2856 static int wcn36xx_smd_print_reg_info_ind(struct wcn36xx *wcn,
2857                                           void *buf,
2858                                           size_t len)
2859 {
2860         struct wcn36xx_hal_print_reg_info_ind *rsp = buf;
2861         int i;
2862
2863         if (len < sizeof(*rsp)) {
2864                 wcn36xx_warn("Corrupted print reg info indication\n");
2865                 return -EIO;
2866         }
2867
2868         wcn36xx_dbg(WCN36XX_DBG_HAL,
2869                     "reginfo indication, scenario: 0x%x reason: 0x%x\n",
2870                     rsp->scenario, rsp->reason);
2871
2872         for (i = 0; i < rsp->count; i++) {
2873                 wcn36xx_dbg(WCN36XX_DBG_HAL, "\t0x%x: 0x%x\n",
2874                             rsp->regs[i].addr, rsp->regs[i].value);
2875         }
2876
2877         return 0;
2878 }
2879
2880 int wcn36xx_smd_update_cfg(struct wcn36xx *wcn, u32 cfg_id, u32 value)
2881 {
2882         struct wcn36xx_hal_update_cfg_req_msg msg_body, *body;
2883         size_t len;
2884         int ret;
2885
2886         mutex_lock(&wcn->hal_mutex);
2887         INIT_HAL_MSG(msg_body, WCN36XX_HAL_UPDATE_CFG_REQ);
2888
2889         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2890
2891         body = (struct wcn36xx_hal_update_cfg_req_msg *) wcn->hal_buf;
2892         len = msg_body.header.len;
2893
2894         put_cfg_tlv_u32(wcn, &len, cfg_id, value);
2895         body->header.len = len;
2896         body->len = len - sizeof(*body);
2897
2898         ret = wcn36xx_smd_send_and_wait(wcn, body->header.len);
2899         if (ret) {
2900                 wcn36xx_err("Sending hal_update_cfg failed\n");
2901                 goto out;
2902         }
2903         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2904         if (ret) {
2905                 wcn36xx_err("hal_update_cfg response failed err=%d\n", ret);
2906                 goto out;
2907         }
2908 out:
2909         mutex_unlock(&wcn->hal_mutex);
2910         return ret;
2911 }
2912
2913 int wcn36xx_smd_set_mc_list(struct wcn36xx *wcn,
2914                             struct ieee80211_vif *vif,
2915                             struct wcn36xx_hal_rcv_flt_mc_addr_list_type *fp)
2916 {
2917         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2918         struct wcn36xx_hal_rcv_flt_pkt_set_mc_list_req_msg *msg_body = NULL;
2919         int ret;
2920
2921         mutex_lock(&wcn->hal_mutex);
2922
2923         msg_body = (struct wcn36xx_hal_rcv_flt_pkt_set_mc_list_req_msg *)
2924                    wcn->hal_buf;
2925         INIT_HAL_MSG(*msg_body, WCN36XX_HAL_8023_MULTICAST_LIST_REQ);
2926
2927         /* An empty list means all mc traffic will be received */
2928         if (fp)
2929                 memcpy(&msg_body->mc_addr_list, fp,
2930                        sizeof(msg_body->mc_addr_list));
2931         else
2932                 msg_body->mc_addr_list.mc_addr_count = 0;
2933
2934         msg_body->mc_addr_list.bss_index = vif_priv->bss_index;
2935
2936         ret = wcn36xx_smd_send_and_wait(wcn, msg_body->header.len);
2937         if (ret) {
2938                 wcn36xx_err("Sending HAL_8023_MULTICAST_LIST failed\n");
2939                 goto out;
2940         }
2941         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2942         if (ret) {
2943                 wcn36xx_err("HAL_8023_MULTICAST_LIST rsp failed err=%d\n", ret);
2944                 goto out;
2945         }
2946 out:
2947         mutex_unlock(&wcn->hal_mutex);
2948         return ret;
2949 }
2950
2951 int wcn36xx_smd_arp_offload(struct wcn36xx *wcn, struct ieee80211_vif *vif,
2952                             bool enable)
2953 {
2954         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2955         struct wcn36xx_hal_host_offload_req_msg msg_body;
2956         int ret;
2957
2958         mutex_lock(&wcn->hal_mutex);
2959
2960         INIT_HAL_MSG(msg_body, WCN36XX_HAL_HOST_OFFLOAD_REQ);
2961         msg_body.host_offload_params.offload_type =
2962                 WCN36XX_HAL_IPV4_ARP_REPLY_OFFLOAD;
2963         if (enable) {
2964                 msg_body.host_offload_params.enable =
2965                         WCN36XX_HAL_OFFLOAD_ARP_AND_BCAST_FILTER_ENABLE;
2966                 memcpy(&msg_body.host_offload_params.u,
2967                        &vif->cfg.arp_addr_list[0], sizeof(__be32));
2968         }
2969         msg_body.ns_offload_params.bss_index = vif_priv->bss_index;
2970
2971         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2972
2973         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2974         if (ret) {
2975                 wcn36xx_err("Sending host_offload_arp failed\n");
2976                 goto out;
2977         }
2978         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2979         if (ret) {
2980                 wcn36xx_err("host_offload_arp failed err=%d\n", ret);
2981                 goto out;
2982         }
2983 out:
2984         mutex_unlock(&wcn->hal_mutex);
2985         return ret;
2986 }
2987
2988 #if IS_ENABLED(CONFIG_IPV6)
2989 int wcn36xx_smd_ipv6_ns_offload(struct wcn36xx *wcn, struct ieee80211_vif *vif,
2990                                 bool enable)
2991 {
2992         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2993         struct wcn36xx_hal_host_offload_req_msg msg_body;
2994         struct wcn36xx_hal_ns_offload_params *ns_params;
2995         struct wcn36xx_hal_host_offload_req *ho_params;
2996         int ret;
2997
2998         mutex_lock(&wcn->hal_mutex);
2999
3000         INIT_HAL_MSG(msg_body, WCN36XX_HAL_HOST_OFFLOAD_REQ);
3001         ho_params = &msg_body.host_offload_params;
3002         ns_params = &msg_body.ns_offload_params;
3003
3004         ho_params->offload_type = WCN36XX_HAL_IPV6_NS_OFFLOAD;
3005         if (enable) {
3006                 ho_params->enable =
3007                         WCN36XX_HAL_OFFLOAD_NS_AND_MCAST_FILTER_ENABLE;
3008                 if (vif_priv->num_target_ipv6_addrs) {
3009                         memcpy(&ho_params->u,
3010                                &vif_priv->target_ipv6_addrs[0].in6_u,
3011                                sizeof(struct in6_addr));
3012                         memcpy(&ns_params->target_ipv6_addr1,
3013                                &vif_priv->target_ipv6_addrs[0].in6_u,
3014                                sizeof(struct in6_addr));
3015                         ns_params->target_ipv6_addr1_valid = 1;
3016                 }
3017                 if (vif_priv->num_target_ipv6_addrs > 1) {
3018                         memcpy(&ns_params->target_ipv6_addr2,
3019                                &vif_priv->target_ipv6_addrs[1].in6_u,
3020                                sizeof(struct in6_addr));
3021                         ns_params->target_ipv6_addr2_valid = 1;
3022                 }
3023         }
3024         memcpy(&ns_params->self_addr, vif->addr, ETH_ALEN);
3025         ns_params->bss_index = vif_priv->bss_index;
3026
3027         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3028
3029         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
3030         if (ret) {
3031                 wcn36xx_err("Sending host_offload_arp failed\n");
3032                 goto out;
3033         }
3034         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
3035         if (ret) {
3036                 wcn36xx_err("host_offload_arp failed err=%d\n", ret);
3037                 goto out;
3038         }
3039 out:
3040         mutex_unlock(&wcn->hal_mutex);
3041         return ret;
3042 }
3043 #else
3044 int wcn36xx_smd_ipv6_ns_offload(struct wcn36xx *wcn, struct ieee80211_vif *vif,
3045                                 bool enable)
3046 {
3047         return 0;
3048 }
3049 #endif
3050
3051 int wcn36xx_smd_gtk_offload(struct wcn36xx *wcn, struct ieee80211_vif *vif,
3052                             bool enable)
3053 {
3054         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
3055         struct wcn36xx_hal_gtk_offload_req_msg msg_body;
3056         int ret;
3057
3058         mutex_lock(&wcn->hal_mutex);
3059
3060         INIT_HAL_MSG(msg_body, WCN36XX_HAL_GTK_OFFLOAD_REQ);
3061
3062         if (enable) {
3063                 memcpy(&msg_body.kek, vif_priv->rekey_data.kek, NL80211_KEK_LEN);
3064                 memcpy(&msg_body.kck, vif_priv->rekey_data.kck, NL80211_KCK_LEN);
3065                 msg_body.key_replay_counter =
3066                         le64_to_cpu(vif_priv->rekey_data.replay_ctr);
3067                 msg_body.bss_index = vif_priv->bss_index;
3068         } else {
3069                 msg_body.flags = WCN36XX_HAL_GTK_OFFLOAD_FLAGS_DISABLE;
3070         }
3071
3072         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3073
3074         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
3075         if (ret) {
3076                 wcn36xx_err("Sending host_offload_arp failed\n");
3077                 goto out;
3078         }
3079         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
3080         if (ret) {
3081                 wcn36xx_err("host_offload_arp failed err=%d\n", ret);
3082                 goto out;
3083         }
3084 out:
3085         mutex_unlock(&wcn->hal_mutex);
3086         return ret;
3087 }
3088
3089 static int wcn36xx_smd_gtk_offload_get_info_rsp(struct wcn36xx *wcn,
3090                                                 struct ieee80211_vif *vif)
3091 {
3092         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
3093         struct wcn36xx_hal_gtk_offload_get_info_rsp_msg *rsp;
3094         __be64 replay_ctr;
3095
3096         if (wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len))
3097                 return -EIO;
3098
3099         rsp = (struct wcn36xx_hal_gtk_offload_get_info_rsp_msg *)wcn->hal_buf;
3100
3101         if (rsp->bss_index != vif_priv->bss_index) {
3102                 wcn36xx_err("gtk_offload_info invalid response bss index %d\n",
3103                             rsp->bss_index);
3104                 return -ENOENT;
3105         }
3106
3107         if (vif_priv->rekey_data.replay_ctr != cpu_to_le64(rsp->key_replay_counter)) {
3108                 replay_ctr = cpu_to_be64(rsp->key_replay_counter);
3109                 vif_priv->rekey_data.replay_ctr =
3110                         cpu_to_le64(rsp->key_replay_counter);
3111                 ieee80211_gtk_rekey_notify(vif, vif->bss_conf.bssid,
3112                                            (void *)&replay_ctr, GFP_KERNEL);
3113                 wcn36xx_dbg(WCN36XX_DBG_HAL,
3114                             "GTK replay counter increment %llu\n",
3115                             rsp->key_replay_counter);
3116         }
3117
3118         wcn36xx_dbg(WCN36XX_DBG_HAL,
3119                     "gtk offload info status %d last_rekey_status %d "
3120                     "replay_counter %llu total_rekey_count %d gtk_rekey_count %d "
3121                     "igtk_rekey_count %d bss_index %d\n",
3122                     rsp->status, rsp->last_rekey_status,
3123                     rsp->key_replay_counter, rsp->total_rekey_count,
3124                     rsp->gtk_rekey_count, rsp->igtk_rekey_count,
3125                     rsp->bss_index);
3126
3127         return 0;
3128 }
3129
3130 int wcn36xx_smd_gtk_offload_get_info(struct wcn36xx *wcn,
3131                                      struct ieee80211_vif *vif)
3132 {
3133         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
3134         struct wcn36xx_hal_gtk_offload_get_info_req_msg msg_body;
3135         int ret;
3136
3137         mutex_lock(&wcn->hal_mutex);
3138
3139         INIT_HAL_MSG(msg_body, WCN36XX_HAL_GTK_OFFLOAD_GETINFO_REQ);
3140
3141         msg_body.bss_index = vif_priv->bss_index;
3142
3143         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3144
3145         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
3146         if (ret) {
3147                 wcn36xx_err("Sending gtk_offload_get_info failed\n");
3148                 goto out;
3149         }
3150         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
3151         if (ret) {
3152                 wcn36xx_err("gtk_offload_get_info failed err=%d\n", ret);
3153                 goto out;
3154         }
3155         ret = wcn36xx_smd_gtk_offload_get_info_rsp(wcn, vif);
3156 out:
3157         mutex_unlock(&wcn->hal_mutex);
3158         return ret;
3159 }
3160
3161 int wcn36xx_smd_wlan_host_suspend_ind(struct wcn36xx *wcn)
3162 {
3163         struct wcn36xx_hal_wlan_host_suspend_ind_msg msg_body;
3164         int ret;
3165
3166         mutex_lock(&wcn->hal_mutex);
3167
3168         INIT_HAL_MSG(msg_body, WCN36XX_HAL_HOST_SUSPEND_IND);
3169         msg_body.configured_mcst_bcst_filter_setting = 0;
3170         msg_body.active_session_count = 1;
3171         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3172
3173         ret = rpmsg_send(wcn->smd_channel, wcn->hal_buf, msg_body.header.len);
3174
3175         mutex_unlock(&wcn->hal_mutex);
3176
3177         return ret;
3178 }
3179
3180 int wcn36xx_smd_host_resume(struct wcn36xx *wcn)
3181 {
3182         struct wcn36xx_hal_wlan_host_resume_req_msg msg_body;
3183         struct wcn36xx_hal_host_resume_rsp_msg *rsp;
3184         int ret;
3185
3186         mutex_lock(&wcn->hal_mutex);
3187
3188         INIT_HAL_MSG(msg_body, WCN36XX_HAL_HOST_RESUME_REQ);
3189         msg_body.configured_mcst_bcst_filter_setting = 0;
3190
3191         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3192
3193         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
3194         if (ret) {
3195                 wcn36xx_err("Sending wlan_host_resume failed\n");
3196                 goto out;
3197         }
3198         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
3199         if (ret) {
3200                 wcn36xx_err("wlan_host_resume err=%d\n", ret);
3201                 goto out;
3202         }
3203
3204         rsp = (struct wcn36xx_hal_host_resume_rsp_msg *)wcn->hal_buf;
3205         if (rsp->status)
3206                 wcn36xx_warn("wlan_host_resume status=%d\n", rsp->status);
3207
3208 out:
3209         mutex_unlock(&wcn->hal_mutex);
3210
3211         return ret;
3212 }
3213
3214 #define BEACON_FILTER(eid, presence, offs, val, mask, ref_val) \
3215         {                                       \
3216                 .element_id = eid,              \
3217                 .check_ie_presence = presence,  \
3218                 .offset = offs,                 \
3219                 .value = val,                   \
3220                 .bitmask = mask,                \
3221                 .ref = ref_val,                 \
3222         }
3223
3224 static const struct beacon_filter_ie bcn_filter_ies[] = {
3225         BEACON_FILTER(WLAN_EID_DS_PARAMS, 0, 0, 0,
3226                       WCN36XX_FILTER_IE_DS_CHANNEL_MASK, 0),
3227         BEACON_FILTER(WLAN_EID_ERP_INFO, 0, 0, 0,
3228                       WCN36XX_FILTER_IE_ERP_FILTER_MASK, 0),
3229         BEACON_FILTER(WLAN_EID_EDCA_PARAM_SET, 0, 0, 0,
3230                       WCN36XX_FILTER_IE_EDCA_FILTER_MASK, 0),
3231         BEACON_FILTER(WLAN_EID_QOS_CAPA, 0, 0, 0,
3232                       WCN36XX_FILTER_IE_QOS_FILTER_MASK, 0),
3233         BEACON_FILTER(WLAN_EID_CHANNEL_SWITCH, 1, 0, 0,
3234                       WCN36XX_FILTER_IE_CHANNEL_SWITCH_MASK, 0),
3235         BEACON_FILTER(WLAN_EID_HT_OPERATION, 0, 0, 0,
3236                       WCN36XX_FILTER_IE_HT_BYTE0_FILTER_MASK, 0),
3237         BEACON_FILTER(WLAN_EID_HT_OPERATION, 0, 2, 0,
3238                       WCN36XX_FILTER_IE_HT_BYTE2_FILTER_MASK, 0),
3239         BEACON_FILTER(WLAN_EID_HT_OPERATION, 0, 5, 0,
3240                       WCN36XX_FILTER_IE_HT_BYTE5_FILTER_MASK, 0),
3241         BEACON_FILTER(WLAN_EID_PWR_CONSTRAINT, 0, 0, 0,
3242                       WCN36XX_FILTER_IE_PWR_CONSTRAINT_MASK, 0),
3243         BEACON_FILTER(WLAN_EID_OPMODE_NOTIF, 0, 0, 0,
3244                       WCN36XX_FILTER_IE_OPMODE_NOTIF_MASK, 0),
3245         BEACON_FILTER(WLAN_EID_VHT_OPERATION, 0, 0, 0,
3246                       WCN36XX_FILTER_IE_VHTOP_CHWIDTH_MASK, 0),
3247         BEACON_FILTER(WLAN_EID_RSN, 1, 0, 0,
3248                       WCN36XX_FILTER_IE_RSN_MASK, 0),
3249         BEACON_FILTER(WLAN_EID_VENDOR_SPECIFIC, 1, 0, 0,
3250                       WCN36XX_FILTER_IE_VENDOR_MASK, 0),
3251 };
3252
3253 int wcn36xx_smd_add_beacon_filter(struct wcn36xx *wcn,
3254                                   struct ieee80211_vif *vif)
3255 {
3256         struct wcn36xx_hal_add_bcn_filter_req_msg msg_body, *body;
3257         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
3258         u8 *payload;
3259         size_t payload_size;
3260         int ret;
3261
3262         if (!wcn36xx_firmware_get_feat_caps(wcn->fw_feat_caps, BCN_FILTER))
3263                 return -EOPNOTSUPP;
3264
3265         mutex_lock(&wcn->hal_mutex);
3266         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BCN_FILTER_REQ);
3267
3268         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
3269
3270         body = (struct wcn36xx_hal_add_bcn_filter_req_msg *)wcn->hal_buf;
3271         body->capability_info = vif->bss_conf.assoc_capability;
3272         body->capability_mask = WCN36XX_FILTER_CAPABILITY_MASK;
3273         body->beacon_interval = vif->bss_conf.beacon_int;
3274         body->ie_num = ARRAY_SIZE(bcn_filter_ies);
3275         body->bss_index = vif_priv->bss_index;
3276
3277         payload = ((u8 *)body) + body->header.len;
3278         payload_size = sizeof(bcn_filter_ies);
3279         memcpy(payload, &bcn_filter_ies, payload_size);
3280
3281         body->header.len += payload_size;
3282
3283         ret = wcn36xx_smd_send_and_wait(wcn, body->header.len);
3284         if (ret) {
3285                 wcn36xx_err("Sending add bcn_filter failed\n");
3286                 goto out;
3287         }
3288
3289         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
3290         if (ret) {
3291                 wcn36xx_err("add bcn filter response failed err=%d\n", ret);
3292                 goto out;
3293         }
3294 out:
3295         mutex_unlock(&wcn->hal_mutex);
3296         return ret;
3297 }
3298
3299 int wcn36xx_smd_rsp_process(struct rpmsg_device *rpdev,
3300                             void *buf, int len, void *priv, u32 addr)
3301 {
3302         const struct wcn36xx_hal_msg_header *msg_header = buf;
3303         struct ieee80211_hw *hw = priv;
3304         struct wcn36xx *wcn = hw->priv;
3305         struct wcn36xx_hal_ind_msg *msg_ind;
3306         wcn36xx_dbg_dump(WCN36XX_DBG_SMD_DUMP, "SMD <<< ", buf, len);
3307
3308         switch (msg_header->msg_type) {
3309         case WCN36XX_HAL_START_RSP:
3310         case WCN36XX_HAL_CONFIG_STA_RSP:
3311         case WCN36XX_HAL_CONFIG_BSS_RSP:
3312         case WCN36XX_HAL_ADD_STA_SELF_RSP:
3313         case WCN36XX_HAL_STOP_RSP:
3314         case WCN36XX_HAL_DEL_STA_SELF_RSP:
3315         case WCN36XX_HAL_DELETE_STA_RSP:
3316         case WCN36XX_HAL_INIT_SCAN_RSP:
3317         case WCN36XX_HAL_START_SCAN_RSP:
3318         case WCN36XX_HAL_END_SCAN_RSP:
3319         case WCN36XX_HAL_FINISH_SCAN_RSP:
3320         case WCN36XX_HAL_DOWNLOAD_NV_RSP:
3321         case WCN36XX_HAL_DELETE_BSS_RSP:
3322         case WCN36XX_HAL_SEND_BEACON_RSP:
3323         case WCN36XX_HAL_SET_LINK_ST_RSP:
3324         case WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_RSP:
3325         case WCN36XX_HAL_SET_BSSKEY_RSP:
3326         case WCN36XX_HAL_SET_STAKEY_RSP:
3327         case WCN36XX_HAL_RMV_STAKEY_RSP:
3328         case WCN36XX_HAL_RMV_BSSKEY_RSP:
3329         case WCN36XX_HAL_ENTER_BMPS_RSP:
3330         case WCN36XX_HAL_SET_POWER_PARAMS_RSP:
3331         case WCN36XX_HAL_EXIT_BMPS_RSP:
3332         case WCN36XX_HAL_KEEP_ALIVE_RSP:
3333         case WCN36XX_HAL_DUMP_COMMAND_RSP:
3334         case WCN36XX_HAL_ADD_BA_SESSION_RSP:
3335         case WCN36XX_HAL_ADD_BA_RSP:
3336         case WCN36XX_HAL_DEL_BA_RSP:
3337         case WCN36XX_HAL_GET_STATS_RSP:
3338         case WCN36XX_HAL_TRIGGER_BA_RSP:
3339         case WCN36XX_HAL_UPDATE_CFG_RSP:
3340         case WCN36XX_HAL_JOIN_RSP:
3341         case WCN36XX_HAL_UPDATE_SCAN_PARAM_RSP:
3342         case WCN36XX_HAL_CH_SWITCH_RSP:
3343         case WCN36XX_HAL_PROCESS_PTT_RSP:
3344         case WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_RSP:
3345         case WCN36XX_HAL_8023_MULTICAST_LIST_RSP:
3346         case WCN36XX_HAL_START_SCAN_OFFLOAD_RSP:
3347         case WCN36XX_HAL_STOP_SCAN_OFFLOAD_RSP:
3348         case WCN36XX_HAL_HOST_OFFLOAD_RSP:
3349         case WCN36XX_HAL_GTK_OFFLOAD_RSP:
3350         case WCN36XX_HAL_GTK_OFFLOAD_GETINFO_RSP:
3351         case WCN36XX_HAL_HOST_RESUME_RSP:
3352         case WCN36XX_HAL_ENTER_IMPS_RSP:
3353         case WCN36XX_HAL_EXIT_IMPS_RSP:
3354         case WCN36XX_HAL_UPDATE_CHANNEL_LIST_RSP:
3355         case WCN36XX_HAL_ADD_BCN_FILTER_RSP:
3356                 memcpy(wcn->hal_buf, buf, len);
3357                 wcn->hal_rsp_len = len;
3358                 complete(&wcn->hal_rsp_compl);
3359                 break;
3360
3361         case WCN36XX_HAL_COEX_IND:
3362         case WCN36XX_HAL_AVOID_FREQ_RANGE_IND:
3363         case WCN36XX_HAL_DEL_BA_IND:
3364         case WCN36XX_HAL_OTA_TX_COMPL_IND:
3365         case WCN36XX_HAL_MISSED_BEACON_IND:
3366         case WCN36XX_HAL_DELETE_STA_CONTEXT_IND:
3367         case WCN36XX_HAL_PRINT_REG_INFO_IND:
3368         case WCN36XX_HAL_SCAN_OFFLOAD_IND:
3369                 msg_ind = kmalloc(struct_size(msg_ind, msg, len), GFP_ATOMIC);
3370                 if (!msg_ind) {
3371                         wcn36xx_err("Run out of memory while handling SMD_EVENT (%d)\n",
3372                                     msg_header->msg_type);
3373                         return -ENOMEM;
3374                 }
3375
3376                 msg_ind->msg_len = len;
3377                 memcpy(msg_ind->msg, buf, len);
3378
3379                 spin_lock(&wcn->hal_ind_lock);
3380                 list_add_tail(&msg_ind->list, &wcn->hal_ind_queue);
3381                 queue_work(wcn->hal_ind_wq, &wcn->hal_ind_work);
3382                 spin_unlock(&wcn->hal_ind_lock);
3383                 wcn36xx_dbg(WCN36XX_DBG_HAL, "indication arrived\n");
3384                 break;
3385         default:
3386                 wcn36xx_err("SMD_EVENT (%d) not supported\n",
3387                               msg_header->msg_type);
3388         }
3389
3390         return 0;
3391 }
3392
3393 static void wcn36xx_ind_smd_work(struct work_struct *work)
3394 {
3395         struct wcn36xx *wcn =
3396                 container_of(work, struct wcn36xx, hal_ind_work);
3397
3398         for (;;) {
3399                 struct wcn36xx_hal_msg_header *msg_header;
3400                 struct wcn36xx_hal_ind_msg *hal_ind_msg;
3401                 unsigned long flags;
3402
3403                 spin_lock_irqsave(&wcn->hal_ind_lock, flags);
3404
3405                 if (list_empty(&wcn->hal_ind_queue)) {
3406                         spin_unlock_irqrestore(&wcn->hal_ind_lock, flags);
3407                         return;
3408                 }
3409
3410                 hal_ind_msg = list_first_entry(&wcn->hal_ind_queue,
3411                                                struct wcn36xx_hal_ind_msg,
3412                                                list);
3413                 list_del(&hal_ind_msg->list);
3414                 spin_unlock_irqrestore(&wcn->hal_ind_lock, flags);
3415
3416                 msg_header = (struct wcn36xx_hal_msg_header *)hal_ind_msg->msg;
3417
3418                 switch (msg_header->msg_type) {
3419                 case WCN36XX_HAL_COEX_IND:
3420                 case WCN36XX_HAL_DEL_BA_IND:
3421                 case WCN36XX_HAL_AVOID_FREQ_RANGE_IND:
3422                         break;
3423                 case WCN36XX_HAL_OTA_TX_COMPL_IND:
3424                         wcn36xx_smd_tx_compl_ind(wcn,
3425                                                  hal_ind_msg->msg,
3426                                                  hal_ind_msg->msg_len);
3427                         break;
3428                 case WCN36XX_HAL_MISSED_BEACON_IND:
3429                         wcn36xx_smd_missed_beacon_ind(wcn,
3430                                                       hal_ind_msg->msg,
3431                                                       hal_ind_msg->msg_len);
3432                         break;
3433                 case WCN36XX_HAL_DELETE_STA_CONTEXT_IND:
3434                         wcn36xx_smd_delete_sta_context_ind(wcn,
3435                                                            hal_ind_msg->msg,
3436                                                            hal_ind_msg->msg_len);
3437                         break;
3438                 case WCN36XX_HAL_PRINT_REG_INFO_IND:
3439                         wcn36xx_smd_print_reg_info_ind(wcn,
3440                                                        hal_ind_msg->msg,
3441                                                        hal_ind_msg->msg_len);
3442                         break;
3443                 case WCN36XX_HAL_SCAN_OFFLOAD_IND:
3444                         wcn36xx_smd_hw_scan_ind(wcn, hal_ind_msg->msg,
3445                                                 hal_ind_msg->msg_len);
3446                         break;
3447                 default:
3448                         wcn36xx_err("SMD_EVENT (%d) not supported\n",
3449                                     msg_header->msg_type);
3450                 }
3451
3452                 kfree(hal_ind_msg);
3453         }
3454 }
3455
3456 int wcn36xx_smd_open(struct wcn36xx *wcn)
3457 {
3458         wcn->hal_ind_wq = create_freezable_workqueue("wcn36xx_smd_ind");
3459         if (!wcn->hal_ind_wq)
3460                 return -ENOMEM;
3461
3462         INIT_WORK(&wcn->hal_ind_work, wcn36xx_ind_smd_work);
3463         INIT_LIST_HEAD(&wcn->hal_ind_queue);
3464         spin_lock_init(&wcn->hal_ind_lock);
3465
3466         return 0;
3467 }
3468
3469 void wcn36xx_smd_close(struct wcn36xx *wcn)
3470 {
3471         struct wcn36xx_hal_ind_msg *msg, *tmp;
3472
3473         cancel_work_sync(&wcn->hal_ind_work);
3474         destroy_workqueue(wcn->hal_ind_wq);
3475
3476         list_for_each_entry_safe(msg, tmp, &wcn->hal_ind_queue, list)
3477                 kfree(msg);
3478 }