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

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