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/etherdevice.h>
  20 #include <linux/firmware.h>
  21 #include <linux/bitops.h>
  22 #include "smd.h"
  23
  24 struct wcn36xx_cfg_val {
  25         u32 cfg_id;
  26         u32 value;
  27 };
  28
  29 #define WCN36XX_CFG_VAL(id, val) \
  30 { \
  31         .cfg_id = WCN36XX_HAL_CFG_ ## id, \
  32         .value = val \
  33 }
  34
  35 static struct wcn36xx_cfg_val wcn36xx_cfg_vals[] = {
  36         WCN36XX_CFG_VAL(CURRENT_TX_ANTENNA, 1),
  37         WCN36XX_CFG_VAL(CURRENT_RX_ANTENNA, 1),
  38         WCN36XX_CFG_VAL(LOW_GAIN_OVERRIDE, 0),
  39         WCN36XX_CFG_VAL(POWER_STATE_PER_CHAIN, 785),
  40         WCN36XX_CFG_VAL(CAL_PERIOD, 5),
  41         WCN36XX_CFG_VAL(CAL_CONTROL, 1),
  42         WCN36XX_CFG_VAL(PROXIMITY, 0),
  43         WCN36XX_CFG_VAL(NETWORK_DENSITY, 3),
  44         WCN36XX_CFG_VAL(MAX_MEDIUM_TIME, 6000),
  45         WCN36XX_CFG_VAL(MAX_MPDUS_IN_AMPDU, 64),
  46         WCN36XX_CFG_VAL(RTS_THRESHOLD, 2347),
  47         WCN36XX_CFG_VAL(SHORT_RETRY_LIMIT, 6),
  48         WCN36XX_CFG_VAL(LONG_RETRY_LIMIT, 6),
  49         WCN36XX_CFG_VAL(FRAGMENTATION_THRESHOLD, 8000),
  50         WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_ZERO, 5),
  51         WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_ONE, 10),
  52         WCN36XX_CFG_VAL(DYNAMIC_THRESHOLD_TWO, 15),
  53         WCN36XX_CFG_VAL(FIXED_RATE, 0),
  54         WCN36XX_CFG_VAL(RETRYRATE_POLICY, 4),
  55         WCN36XX_CFG_VAL(RETRYRATE_SECONDARY, 0),
  56         WCN36XX_CFG_VAL(RETRYRATE_TERTIARY, 0),
  57         WCN36XX_CFG_VAL(FORCE_POLICY_PROTECTION, 5),
  58         WCN36XX_CFG_VAL(FIXED_RATE_MULTICAST_24GHZ, 1),
  59         WCN36XX_CFG_VAL(FIXED_RATE_MULTICAST_5GHZ, 5),
  60         WCN36XX_CFG_VAL(DEFAULT_RATE_INDEX_5GHZ, 5),
  61         WCN36XX_CFG_VAL(MAX_BA_SESSIONS, 40),
  62         WCN36XX_CFG_VAL(PS_DATA_INACTIVITY_TIMEOUT, 200),
  63         WCN36XX_CFG_VAL(PS_ENABLE_BCN_FILTER, 1),
  64         WCN36XX_CFG_VAL(PS_ENABLE_RSSI_MONITOR, 1),
  65         WCN36XX_CFG_VAL(NUM_BEACON_PER_RSSI_AVERAGE, 20),
  66         WCN36XX_CFG_VAL(STATS_PERIOD, 10),
  67         WCN36XX_CFG_VAL(CFP_MAX_DURATION, 30000),
  68         WCN36XX_CFG_VAL(FRAME_TRANS_ENABLED, 0),
  69         WCN36XX_CFG_VAL(BA_THRESHOLD_HIGH, 128),
  70         WCN36XX_CFG_VAL(MAX_BA_BUFFERS, 2560),
  71         WCN36XX_CFG_VAL(DYNAMIC_PS_POLL_VALUE, 0),
  72         WCN36XX_CFG_VAL(TX_PWR_CTRL_ENABLE, 1),
  73         WCN36XX_CFG_VAL(ENABLE_CLOSE_LOOP, 1),
  74         WCN36XX_CFG_VAL(ENABLE_LPWR_IMG_TRANSITION, 0),
  75         WCN36XX_CFG_VAL(MAX_ASSOC_LIMIT, 10),
  76         WCN36XX_CFG_VAL(ENABLE_MCC_ADAPTIVE_SCHEDULER, 0),
  77 };
  78
  79 static int put_cfg_tlv_u32(struct wcn36xx *wcn, size_t *len, u32 id, u32 value)
  80 {
  81         struct wcn36xx_hal_cfg *entry;
  82         u32 *val;
  83
  84         if (*len + sizeof(*entry) + sizeof(u32) >= WCN36XX_HAL_BUF_SIZE) {
  85                 wcn36xx_err("Not enough room for TLV entry\n");
  86                 return -ENOMEM;
  87         }
  88
  89         entry = (struct wcn36xx_hal_cfg *) (wcn->hal_buf + *len);
  90         entry->id = id;
  91         entry->len = sizeof(u32);
  92         entry->pad_bytes = 0;
  93         entry->reserve = 0;
  94
  95         val = (u32 *) (entry + 1);
  96         *val = value;
  97
  98         *len += sizeof(*entry) + sizeof(u32);
  99
 100         return 0;
 101 }
 102
 103 static void wcn36xx_smd_set_bss_nw_type(struct wcn36xx *wcn,
 104                 struct ieee80211_sta *sta,
 105                 struct wcn36xx_hal_config_bss_params *bss_params)
 106 {
 107         if (NL80211_BAND_5GHZ == WCN36XX_BAND(wcn))
 108                 bss_params->nw_type = WCN36XX_HAL_11A_NW_TYPE;
 109         else if (sta && sta->ht_cap.ht_supported)
 110                 bss_params->nw_type = WCN36XX_HAL_11N_NW_TYPE;
 111         else if (sta && (sta->supp_rates[NL80211_BAND_2GHZ] & 0x7f))
 112                 bss_params->nw_type = WCN36XX_HAL_11G_NW_TYPE;
 113         else
 114                 bss_params->nw_type = WCN36XX_HAL_11B_NW_TYPE;
 115 }
 116
 117 static inline u8 is_cap_supported(unsigned long caps, unsigned long flag)
 118 {
 119         return caps & flag ? 1 : 0;
 120 }
 121 static void wcn36xx_smd_set_bss_ht_params(struct ieee80211_vif *vif,
 122                 struct ieee80211_sta *sta,
 123                 struct wcn36xx_hal_config_bss_params *bss_params)
 124 {
 125         if (sta && sta->ht_cap.ht_supported) {
 126                 unsigned long caps = sta->ht_cap.cap;
 127                 bss_params->ht = sta->ht_cap.ht_supported;
 128                 bss_params->tx_channel_width_set = is_cap_supported(caps,
 129                         IEEE80211_HT_CAP_SUP_WIDTH_20_40);
 130                 bss_params->lsig_tx_op_protection_full_support =
 131                         is_cap_supported(caps,
 132                                          IEEE80211_HT_CAP_LSIG_TXOP_PROT);
 133
 134                 bss_params->ht_oper_mode = vif->bss_conf.ht_operation_mode;
 135                 bss_params->lln_non_gf_coexist =
 136                         !!(vif->bss_conf.ht_operation_mode &
 137                            IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT);
 138                 /* IEEE80211_HT_STBC_PARAM_DUAL_CTS_PROT */
 139                 bss_params->dual_cts_protection = 0;
 140                 /* IEEE80211_HT_OP_MODE_PROTECTION_20MHZ */
 141                 bss_params->ht20_coexist = 0;
 142         }
 143 }
 144
 145 static void wcn36xx_smd_set_sta_ht_params(struct ieee80211_sta *sta,
 146                 struct wcn36xx_hal_config_sta_params *sta_params)
 147 {
 148         if (sta->ht_cap.ht_supported) {
 149                 unsigned long caps = sta->ht_cap.cap;
 150                 sta_params->ht_capable = sta->ht_cap.ht_supported;
 151                 sta_params->tx_channel_width_set = is_cap_supported(caps,
 152                         IEEE80211_HT_CAP_SUP_WIDTH_20_40);
 153                 sta_params->lsig_txop_protection = is_cap_supported(caps,
 154                         IEEE80211_HT_CAP_LSIG_TXOP_PROT);
 155
 156                 sta_params->max_ampdu_size = sta->ht_cap.ampdu_factor;
 157                 sta_params->max_ampdu_density = sta->ht_cap.ampdu_density;
 158                 sta_params->max_amsdu_size = is_cap_supported(caps,
 159                         IEEE80211_HT_CAP_MAX_AMSDU);
 160                 sta_params->sgi_20Mhz = is_cap_supported(caps,
 161                         IEEE80211_HT_CAP_SGI_20);
 162                 sta_params->sgi_40mhz = is_cap_supported(caps,
 163                         IEEE80211_HT_CAP_SGI_40);
 164                 sta_params->green_field_capable = is_cap_supported(caps,
 165                         IEEE80211_HT_CAP_GRN_FLD);
 166                 sta_params->delayed_ba_support = is_cap_supported(caps,
 167                         IEEE80211_HT_CAP_DELAY_BA);
 168                 sta_params->dsss_cck_mode_40mhz = is_cap_supported(caps,
 169                         IEEE80211_HT_CAP_DSSSCCK40);
 170         }
 171 }
 172
 173 static void wcn36xx_smd_set_sta_default_ht_params(
 174                 struct wcn36xx_hal_config_sta_params *sta_params)
 175 {
 176         sta_params->ht_capable = 1;
 177         sta_params->tx_channel_width_set = 1;
 178         sta_params->lsig_txop_protection = 1;
 179         sta_params->max_ampdu_size = 3;
 180         sta_params->max_ampdu_density = 5;
 181         sta_params->max_amsdu_size = 0;
 182         sta_params->sgi_20Mhz = 1;
 183         sta_params->sgi_40mhz = 1;
 184         sta_params->green_field_capable = 1;
 185         sta_params->delayed_ba_support = 0;
 186         sta_params->dsss_cck_mode_40mhz = 1;
 187 }
 188
 189 static void wcn36xx_smd_set_sta_params(struct wcn36xx *wcn,
 190                 struct ieee80211_vif *vif,
 191                 struct ieee80211_sta *sta,
 192                 struct wcn36xx_hal_config_sta_params *sta_params)
 193 {
 194         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
 195         struct wcn36xx_sta *sta_priv = NULL;
 196         if (vif->type == NL80211_IFTYPE_ADHOC ||
 197             vif->type == NL80211_IFTYPE_AP ||
 198             vif->type == NL80211_IFTYPE_MESH_POINT) {
 199                 sta_params->type = 1;
 200                 sta_params->sta_index = WCN36XX_HAL_STA_INVALID_IDX;
 201         } else {
 202                 sta_params->type = 0;
 203                 sta_params->sta_index = vif_priv->self_sta_index;
 204         }
 205
 206         sta_params->listen_interval = WCN36XX_LISTEN_INTERVAL(wcn);
 207
 208         /*
 209          * In STA mode ieee80211_sta contains bssid and ieee80211_vif
 210          * contains our mac address. In  AP mode we are bssid so vif
 211          * contains bssid and ieee80211_sta contains mac.
 212          */
 213         if (NL80211_IFTYPE_STATION == vif->type)
 214                 memcpy(&sta_params->mac, vif->addr, ETH_ALEN);
 215         else
 216                 memcpy(&sta_params->bssid, vif->addr, ETH_ALEN);
 217
 218         sta_params->encrypt_type = vif_priv->encrypt_type;
 219         sta_params->short_preamble_supported = true;
 220
 221         sta_params->rifs_mode = 0;
 222         sta_params->rmf = 0;
 223         sta_params->action = 0;
 224         sta_params->uapsd = 0;
 225         sta_params->mimo_ps = WCN36XX_HAL_HT_MIMO_PS_STATIC;
 226         sta_params->max_ampdu_duration = 0;
 227         sta_params->bssid_index = vif_priv->bss_index;
 228         sta_params->p2p = 0;
 229
 230         if (sta) {
 231                 sta_priv = wcn36xx_sta_to_priv(sta);
 232                 if (NL80211_IFTYPE_STATION == vif->type)
 233                         memcpy(&sta_params->bssid, sta->addr, ETH_ALEN);
 234                 else
 235                         memcpy(&sta_params->mac, sta->addr, ETH_ALEN);
 236                 sta_params->wmm_enabled = sta->wme;
 237                 sta_params->max_sp_len = sta->max_sp;
 238                 sta_params->aid = sta_priv->aid;
 239                 wcn36xx_smd_set_sta_ht_params(sta, sta_params);
 240                 memcpy(&sta_params->supported_rates, &sta_priv->supported_rates,
 241                         sizeof(sta_priv->supported_rates));
 242         } else {
 243                 wcn36xx_set_default_rates(&sta_params->supported_rates);
 244                 wcn36xx_smd_set_sta_default_ht_params(sta_params);
 245         }
 246 }
 247
 248 static int wcn36xx_smd_send_and_wait(struct wcn36xx *wcn, size_t len)
 249 {
 250         int ret = 0;
 251         unsigned long start;
 252         wcn36xx_dbg_dump(WCN36XX_DBG_SMD_DUMP, "HAL >>> ", wcn->hal_buf, len);
 253
 254         init_completion(&wcn->hal_rsp_compl);
 255         start = jiffies;
 256         ret = wcn->ctrl_ops->tx(wcn->hal_buf, len);
 257         if (ret) {
 258                 wcn36xx_err("HAL TX failed\n");
 259                 goto out;
 260         }
 261         if (wait_for_completion_timeout(&wcn->hal_rsp_compl,
 262                 msecs_to_jiffies(HAL_MSG_TIMEOUT)) <= 0) {
 263                 wcn36xx_err("Timeout! No SMD response in %dms\n",
 264                             HAL_MSG_TIMEOUT);
 265                 ret = -ETIME;
 266                 goto out;
 267         }
 268         wcn36xx_dbg(WCN36XX_DBG_SMD, "SMD command completed in %dms",
 269                     jiffies_to_msecs(jiffies - start));
 270 out:
 271         return ret;
 272 }
 273
 274 static void init_hal_msg(struct wcn36xx_hal_msg_header *hdr,
 275                          enum wcn36xx_hal_host_msg_type msg_type,
 276                          size_t msg_size)
 277 {
 278         memset(hdr, 0, msg_size + sizeof(*hdr));
 279         hdr->msg_type = msg_type;
 280         hdr->msg_version = WCN36XX_HAL_MSG_VERSION0;
 281         hdr->len = msg_size + sizeof(*hdr);
 282 }
 283
 284 #define INIT_HAL_MSG(msg_body, type) \
 285         do {                                                            \
 286                 memset(&msg_body, 0, sizeof(msg_body));                 \
 287                 msg_body.header.msg_type = type;                        \
 288                 msg_body.header.msg_version = WCN36XX_HAL_MSG_VERSION0; \
 289                 msg_body.header.len = sizeof(msg_body);                 \
 290         } while (0)                                                     \
 291
 292 #define PREPARE_HAL_BUF(send_buf, msg_body) \
 293         do {                                                    \
 294                 memset(send_buf, 0, msg_body.header.len);       \
 295                 memcpy(send_buf, &msg_body, sizeof(msg_body));  \
 296         } while (0)                                             \
 297
 298 static int wcn36xx_smd_rsp_status_check(void *buf, size_t len)
 299 {
 300         struct wcn36xx_fw_msg_status_rsp *rsp;
 301
 302         if (len < sizeof(struct wcn36xx_hal_msg_header) +
 303             sizeof(struct wcn36xx_fw_msg_status_rsp))
 304                 return -EIO;
 305
 306         rsp = (struct wcn36xx_fw_msg_status_rsp *)
 307                 (buf + sizeof(struct wcn36xx_hal_msg_header));
 308
 309         if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->status)
 310                 return rsp->status;
 311
 312         return 0;
 313 }
 314
 315 int wcn36xx_smd_load_nv(struct wcn36xx *wcn)
 316 {
 317         struct nv_data *nv_d;
 318         struct wcn36xx_hal_nv_img_download_req_msg msg_body;
 319         int fw_bytes_left;
 320         int ret;
 321         u16 fm_offset = 0;
 322
 323         if (!wcn->nv) {
 324                 ret = request_firmware(&wcn->nv, WLAN_NV_FILE, wcn->dev);
 325                 if (ret) {
 326                         wcn36xx_err("Failed to load nv file %s: %d\n",
 327                                       WLAN_NV_FILE, ret);
 328                         goto out;
 329                 }
 330         }
 331
 332         nv_d = (struct nv_data *)wcn->nv->data;
 333         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DOWNLOAD_NV_REQ);
 334
 335         msg_body.header.len += WCN36XX_NV_FRAGMENT_SIZE;
 336
 337         msg_body.frag_number = 0;
 338         /* hal_buf must be protected with  mutex */
 339         mutex_lock(&wcn->hal_mutex);
 340
 341         do {
 342                 fw_bytes_left = wcn->nv->size - fm_offset - 4;
 343                 if (fw_bytes_left > WCN36XX_NV_FRAGMENT_SIZE) {
 344                         msg_body.last_fragment = 0;
 345                         msg_body.nv_img_buffer_size = WCN36XX_NV_FRAGMENT_SIZE;
 346                 } else {
 347                         msg_body.last_fragment = 1;
 348                         msg_body.nv_img_buffer_size = fw_bytes_left;
 349
 350                         /* Do not forget update general message len */
 351                         msg_body.header.len = sizeof(msg_body) + fw_bytes_left;
 352
 353                 }
 354
 355                 /* Add load NV request message header */
 356                 memcpy(wcn->hal_buf, &msg_body, sizeof(msg_body));
 357
 358                 /* Add NV body itself */
 359                 memcpy(wcn->hal_buf + sizeof(msg_body),
 360                        &nv_d->table + fm_offset,
 361                        msg_body.nv_img_buffer_size);
 362
 363                 ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 364                 if (ret)
 365                         goto out_unlock;
 366                 ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf,
 367                                                    wcn->hal_rsp_len);
 368                 if (ret) {
 369                         wcn36xx_err("hal_load_nv response failed err=%d\n",
 370                                     ret);
 371                         goto out_unlock;
 372                 }
 373                 msg_body.frag_number++;
 374                 fm_offset += WCN36XX_NV_FRAGMENT_SIZE;
 375
 376         } while (msg_body.last_fragment != 1);
 377
 378 out_unlock:
 379         mutex_unlock(&wcn->hal_mutex);
 380 out:    return ret;
 381 }
 382
 383 static int wcn36xx_smd_start_rsp(struct wcn36xx *wcn, void *buf, size_t len)
 384 {
 385         struct wcn36xx_hal_mac_start_rsp_msg *rsp;
 386
 387         if (len < sizeof(*rsp))
 388                 return -EIO;
 389
 390         rsp = (struct wcn36xx_hal_mac_start_rsp_msg *)buf;
 391
 392         if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->start_rsp_params.status)
 393                 return -EIO;
 394
 395         memcpy(wcn->crm_version, rsp->start_rsp_params.crm_version,
 396                WCN36XX_HAL_VERSION_LENGTH);
 397         memcpy(wcn->wlan_version, rsp->start_rsp_params.wlan_version,
 398                WCN36XX_HAL_VERSION_LENGTH);
 399
 400         /* null terminate the strings, just in case */
 401         wcn->crm_version[WCN36XX_HAL_VERSION_LENGTH] = '\0';
 402         wcn->wlan_version[WCN36XX_HAL_VERSION_LENGTH] = '\0';
 403
 404         wcn->fw_revision = rsp->start_rsp_params.version.revision;
 405         wcn->fw_version = rsp->start_rsp_params.version.version;
 406         wcn->fw_minor = rsp->start_rsp_params.version.minor;
 407         wcn->fw_major = rsp->start_rsp_params.version.major;
 408
 409         wcn36xx_info("firmware WLAN version '%s' and CRM version '%s'\n",
 410                      wcn->wlan_version, wcn->crm_version);
 411
 412         wcn36xx_info("firmware API %u.%u.%u.%u, %u stations, %u bssids\n",
 413                      wcn->fw_major, wcn->fw_minor,
 414                      wcn->fw_version, wcn->fw_revision,
 415                      rsp->start_rsp_params.stations,
 416                      rsp->start_rsp_params.bssids);
 417
 418         return 0;
 419 }
 420
 421 int wcn36xx_smd_start(struct wcn36xx *wcn)
 422 {
 423         struct wcn36xx_hal_mac_start_req_msg msg_body, *body;
 424         int ret = 0;
 425         int i;
 426         size_t len;
 427
 428         mutex_lock(&wcn->hal_mutex);
 429         INIT_HAL_MSG(msg_body, WCN36XX_HAL_START_REQ);
 430
 431         msg_body.params.type = DRIVER_TYPE_PRODUCTION;
 432         msg_body.params.len = 0;
 433
 434         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 435
 436         body = (struct wcn36xx_hal_mac_start_req_msg *)wcn->hal_buf;
 437         len = body->header.len;
 438
 439         for (i = 0; i < ARRAY_SIZE(wcn36xx_cfg_vals); i++) {
 440                 ret = put_cfg_tlv_u32(wcn, &len, wcn36xx_cfg_vals[i].cfg_id,
 441                                       wcn36xx_cfg_vals[i].value);
 442                 if (ret)
 443                         goto out;
 444         }
 445         body->header.len = len;
 446         body->params.len = len - sizeof(*body);
 447
 448         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal start type %d\n",
 449                     msg_body.params.type);
 450
 451         ret = wcn36xx_smd_send_and_wait(wcn, body->header.len);
 452         if (ret) {
 453                 wcn36xx_err("Sending hal_start failed\n");
 454                 goto out;
 455         }
 456
 457         ret = wcn36xx_smd_start_rsp(wcn, wcn->hal_buf, wcn->hal_rsp_len);
 458         if (ret) {
 459                 wcn36xx_err("hal_start response failed err=%d\n", ret);
 460                 goto out;
 461         }
 462
 463 out:
 464         mutex_unlock(&wcn->hal_mutex);
 465         return ret;
 466 }
 467
 468 int wcn36xx_smd_stop(struct wcn36xx *wcn)
 469 {
 470         struct wcn36xx_hal_mac_stop_req_msg msg_body;
 471         int ret = 0;
 472
 473         mutex_lock(&wcn->hal_mutex);
 474         INIT_HAL_MSG(msg_body, WCN36XX_HAL_STOP_REQ);
 475
 476         msg_body.stop_req_params.reason = HAL_STOP_TYPE_RF_KILL;
 477
 478         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 479
 480         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 481         if (ret) {
 482                 wcn36xx_err("Sending hal_stop failed\n");
 483                 goto out;
 484         }
 485         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 486         if (ret) {
 487                 wcn36xx_err("hal_stop response failed err=%d\n", ret);
 488                 goto out;
 489         }
 490 out:
 491         mutex_unlock(&wcn->hal_mutex);
 492         return ret;
 493 }
 494
 495 int wcn36xx_smd_init_scan(struct wcn36xx *wcn, enum wcn36xx_hal_sys_mode mode)
 496 {
 497         struct wcn36xx_hal_init_scan_req_msg msg_body;
 498         int ret = 0;
 499
 500         mutex_lock(&wcn->hal_mutex);
 501         INIT_HAL_MSG(msg_body, WCN36XX_HAL_INIT_SCAN_REQ);
 502
 503         msg_body.mode = mode;
 504
 505         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 506
 507         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal init scan mode %d\n", msg_body.mode);
 508
 509         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 510         if (ret) {
 511                 wcn36xx_err("Sending hal_init_scan failed\n");
 512                 goto out;
 513         }
 514         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 515         if (ret) {
 516                 wcn36xx_err("hal_init_scan response failed err=%d\n", ret);
 517                 goto out;
 518         }
 519 out:
 520         mutex_unlock(&wcn->hal_mutex);
 521         return ret;
 522 }
 523
 524 int wcn36xx_smd_start_scan(struct wcn36xx *wcn)
 525 {
 526         struct wcn36xx_hal_start_scan_req_msg msg_body;
 527         int ret = 0;
 528
 529         mutex_lock(&wcn->hal_mutex);
 530         INIT_HAL_MSG(msg_body, WCN36XX_HAL_START_SCAN_REQ);
 531
 532         msg_body.scan_channel = WCN36XX_HW_CHANNEL(wcn);
 533
 534         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 535
 536         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal start scan channel %d\n",
 537                     msg_body.scan_channel);
 538
 539         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 540         if (ret) {
 541                 wcn36xx_err("Sending hal_start_scan failed\n");
 542                 goto out;
 543         }
 544         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 545         if (ret) {
 546                 wcn36xx_err("hal_start_scan response failed err=%d\n", ret);
 547                 goto out;
 548         }
 549 out:
 550         mutex_unlock(&wcn->hal_mutex);
 551         return ret;
 552 }
 553
 554 int wcn36xx_smd_end_scan(struct wcn36xx *wcn)
 555 {
 556         struct wcn36xx_hal_end_scan_req_msg msg_body;
 557         int ret = 0;
 558
 559         mutex_lock(&wcn->hal_mutex);
 560         INIT_HAL_MSG(msg_body, WCN36XX_HAL_END_SCAN_REQ);
 561
 562         msg_body.scan_channel = WCN36XX_HW_CHANNEL(wcn);
 563
 564         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 565
 566         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal end scan channel %d\n",
 567                     msg_body.scan_channel);
 568
 569         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 570         if (ret) {
 571                 wcn36xx_err("Sending hal_end_scan failed\n");
 572                 goto out;
 573         }
 574         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 575         if (ret) {
 576                 wcn36xx_err("hal_end_scan response failed err=%d\n", ret);
 577                 goto out;
 578         }
 579 out:
 580         mutex_unlock(&wcn->hal_mutex);
 581         return ret;
 582 }
 583
 584 int wcn36xx_smd_finish_scan(struct wcn36xx *wcn,
 585                             enum wcn36xx_hal_sys_mode mode)
 586 {
 587         struct wcn36xx_hal_finish_scan_req_msg msg_body;
 588         int ret = 0;
 589
 590         mutex_lock(&wcn->hal_mutex);
 591         INIT_HAL_MSG(msg_body, WCN36XX_HAL_FINISH_SCAN_REQ);
 592
 593         msg_body.mode = mode;
 594
 595         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 596
 597         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal finish scan mode %d\n",
 598                     msg_body.mode);
 599
 600         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 601         if (ret) {
 602                 wcn36xx_err("Sending hal_finish_scan failed\n");
 603                 goto out;
 604         }
 605         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 606         if (ret) {
 607                 wcn36xx_err("hal_finish_scan response failed err=%d\n", ret);
 608                 goto out;
 609         }
 610 out:
 611         mutex_unlock(&wcn->hal_mutex);
 612         return ret;
 613 }
 614
 615 static int wcn36xx_smd_switch_channel_rsp(void *buf, size_t len)
 616 {
 617         struct wcn36xx_hal_switch_channel_rsp_msg *rsp;
 618         int ret = 0;
 619
 620         ret = wcn36xx_smd_rsp_status_check(buf, len);
 621         if (ret)
 622                 return ret;
 623         rsp = (struct wcn36xx_hal_switch_channel_rsp_msg *)buf;
 624         wcn36xx_dbg(WCN36XX_DBG_HAL, "channel switched to: %d, status: %d\n",
 625                     rsp->channel_number, rsp->status);
 626         return ret;
 627 }
 628
 629 int wcn36xx_smd_switch_channel(struct wcn36xx *wcn,
 630                                struct ieee80211_vif *vif, int ch)
 631 {
 632         struct wcn36xx_hal_switch_channel_req_msg msg_body;
 633         int ret = 0;
 634
 635         mutex_lock(&wcn->hal_mutex);
 636         INIT_HAL_MSG(msg_body, WCN36XX_HAL_CH_SWITCH_REQ);
 637
 638         msg_body.channel_number = (u8)ch;
 639         msg_body.tx_mgmt_power = 0xbf;
 640         msg_body.max_tx_power = 0xbf;
 641         memcpy(msg_body.self_sta_mac_addr, vif->addr, ETH_ALEN);
 642
 643         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 644
 645         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 646         if (ret) {
 647                 wcn36xx_err("Sending hal_switch_channel failed\n");
 648                 goto out;
 649         }
 650         ret = wcn36xx_smd_switch_channel_rsp(wcn->hal_buf, wcn->hal_rsp_len);
 651         if (ret) {
 652                 wcn36xx_err("hal_switch_channel response failed err=%d\n", ret);
 653                 goto out;
 654         }
 655 out:
 656         mutex_unlock(&wcn->hal_mutex);
 657         return ret;
 658 }
 659
 660 static int wcn36xx_smd_update_scan_params_rsp(void *buf, size_t len)
 661 {
 662         struct wcn36xx_hal_update_scan_params_resp *rsp;
 663
 664         rsp = (struct wcn36xx_hal_update_scan_params_resp *)buf;
 665
 666         /* Remove the PNO version bit */
 667         rsp->status &= (~(WCN36XX_FW_MSG_PNO_VERSION_MASK));
 668
 669         if (WCN36XX_FW_MSG_RESULT_SUCCESS != rsp->status) {
 670                 wcn36xx_warn("error response from update scan\n");
 671                 return rsp->status;
 672         }
 673
 674         return 0;
 675 }
 676
 677 int wcn36xx_smd_update_scan_params(struct wcn36xx *wcn)
 678 {
 679         struct wcn36xx_hal_update_scan_params_req msg_body;
 680         int ret = 0;
 681
 682         mutex_lock(&wcn->hal_mutex);
 683         INIT_HAL_MSG(msg_body, WCN36XX_HAL_UPDATE_SCAN_PARAM_REQ);
 684
 685         msg_body.dot11d_enabled = 0;
 686         msg_body.dot11d_resolved = 0;
 687         msg_body.channel_count = 26;
 688         msg_body.active_min_ch_time = 60;
 689         msg_body.active_max_ch_time = 120;
 690         msg_body.passive_min_ch_time = 60;
 691         msg_body.passive_max_ch_time = 110;
 692         msg_body.state = 0;
 693
 694         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 695
 696         wcn36xx_dbg(WCN36XX_DBG_HAL,
 697                     "hal update scan params channel_count %d\n",
 698                     msg_body.channel_count);
 699
 700         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 701         if (ret) {
 702                 wcn36xx_err("Sending hal_update_scan_params failed\n");
 703                 goto out;
 704         }
 705         ret = wcn36xx_smd_update_scan_params_rsp(wcn->hal_buf,
 706                                                  wcn->hal_rsp_len);
 707         if (ret) {
 708                 wcn36xx_err("hal_update_scan_params response failed err=%d\n",
 709                             ret);
 710                 goto out;
 711         }
 712 out:
 713         mutex_unlock(&wcn->hal_mutex);
 714         return ret;
 715 }
 716
 717 static int wcn36xx_smd_add_sta_self_rsp(struct wcn36xx *wcn,
 718                                         struct ieee80211_vif *vif,
 719                                         void *buf,
 720                                         size_t len)
 721 {
 722         struct wcn36xx_hal_add_sta_self_rsp_msg *rsp;
 723         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
 724
 725         if (len < sizeof(*rsp))
 726                 return -EINVAL;
 727
 728         rsp = (struct wcn36xx_hal_add_sta_self_rsp_msg *)buf;
 729
 730         if (rsp->status != WCN36XX_FW_MSG_RESULT_SUCCESS) {
 731                 wcn36xx_warn("hal add sta self failure: %d\n",
 732                              rsp->status);
 733                 return rsp->status;
 734         }
 735
 736         wcn36xx_dbg(WCN36XX_DBG_HAL,
 737                     "hal add sta self status %d self_sta_index %d dpu_index %d\n",
 738                     rsp->status, rsp->self_sta_index, rsp->dpu_index);
 739
 740         vif_priv->self_sta_index = rsp->self_sta_index;
 741         vif_priv->self_dpu_desc_index = rsp->dpu_index;
 742
 743         return 0;
 744 }
 745
 746 int wcn36xx_smd_add_sta_self(struct wcn36xx *wcn, struct ieee80211_vif *vif)
 747 {
 748         struct wcn36xx_hal_add_sta_self_req msg_body;
 749         int ret = 0;
 750
 751         mutex_lock(&wcn->hal_mutex);
 752         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_STA_SELF_REQ);
 753
 754         memcpy(&msg_body.self_addr, vif->addr, ETH_ALEN);
 755
 756         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 757
 758         wcn36xx_dbg(WCN36XX_DBG_HAL,
 759                     "hal add sta self self_addr %pM status %d\n",
 760                     msg_body.self_addr, msg_body.status);
 761
 762         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 763         if (ret) {
 764                 wcn36xx_err("Sending hal_add_sta_self failed\n");
 765                 goto out;
 766         }
 767         ret = wcn36xx_smd_add_sta_self_rsp(wcn,
 768                                            vif,
 769                                            wcn->hal_buf,
 770                                            wcn->hal_rsp_len);
 771         if (ret) {
 772                 wcn36xx_err("hal_add_sta_self response failed err=%d\n", ret);
 773                 goto out;
 774         }
 775 out:
 776         mutex_unlock(&wcn->hal_mutex);
 777         return ret;
 778 }
 779
 780 int wcn36xx_smd_delete_sta_self(struct wcn36xx *wcn, u8 *addr)
 781 {
 782         struct wcn36xx_hal_del_sta_self_req_msg msg_body;
 783         int ret = 0;
 784
 785         mutex_lock(&wcn->hal_mutex);
 786         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DEL_STA_SELF_REQ);
 787
 788         memcpy(&msg_body.self_addr, addr, ETH_ALEN);
 789
 790         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 791
 792         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 793         if (ret) {
 794                 wcn36xx_err("Sending hal_delete_sta_self failed\n");
 795                 goto out;
 796         }
 797         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 798         if (ret) {
 799                 wcn36xx_err("hal_delete_sta_self response failed err=%d\n",
 800                             ret);
 801                 goto out;
 802         }
 803 out:
 804         mutex_unlock(&wcn->hal_mutex);
 805         return ret;
 806 }
 807
 808 int wcn36xx_smd_delete_sta(struct wcn36xx *wcn, u8 sta_index)
 809 {
 810         struct wcn36xx_hal_delete_sta_req_msg msg_body;
 811         int ret = 0;
 812
 813         mutex_lock(&wcn->hal_mutex);
 814         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DELETE_STA_REQ);
 815
 816         msg_body.sta_index = sta_index;
 817
 818         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 819
 820         wcn36xx_dbg(WCN36XX_DBG_HAL,
 821                     "hal delete sta sta_index %d\n",
 822                     msg_body.sta_index);
 823
 824         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 825         if (ret) {
 826                 wcn36xx_err("Sending hal_delete_sta failed\n");
 827                 goto out;
 828         }
 829         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 830         if (ret) {
 831                 wcn36xx_err("hal_delete_sta response failed err=%d\n", ret);
 832                 goto out;
 833         }
 834 out:
 835         mutex_unlock(&wcn->hal_mutex);
 836         return ret;
 837 }
 838
 839 static int wcn36xx_smd_join_rsp(void *buf, size_t len)
 840 {
 841         struct wcn36xx_hal_join_rsp_msg *rsp;
 842
 843         if (wcn36xx_smd_rsp_status_check(buf, len))
 844                 return -EIO;
 845
 846         rsp = (struct wcn36xx_hal_join_rsp_msg *)buf;
 847
 848         wcn36xx_dbg(WCN36XX_DBG_HAL,
 849                     "hal rsp join status %d tx_mgmt_power %d\n",
 850                     rsp->status, rsp->tx_mgmt_power);
 851
 852         return 0;
 853 }
 854
 855 int wcn36xx_smd_join(struct wcn36xx *wcn, const u8 *bssid, u8 *vif, u8 ch)
 856 {
 857         struct wcn36xx_hal_join_req_msg msg_body;
 858         int ret = 0;
 859
 860         mutex_lock(&wcn->hal_mutex);
 861         INIT_HAL_MSG(msg_body, WCN36XX_HAL_JOIN_REQ);
 862
 863         memcpy(&msg_body.bssid, bssid, ETH_ALEN);
 864         memcpy(&msg_body.self_sta_mac_addr, vif, ETH_ALEN);
 865         msg_body.channel = ch;
 866
 867         if (conf_is_ht40_minus(&wcn->hw->conf))
 868                 msg_body.secondary_channel_offset =
 869                         PHY_DOUBLE_CHANNEL_HIGH_PRIMARY;
 870         else if (conf_is_ht40_plus(&wcn->hw->conf))
 871                 msg_body.secondary_channel_offset =
 872                         PHY_DOUBLE_CHANNEL_LOW_PRIMARY;
 873         else
 874                 msg_body.secondary_channel_offset =
 875                         PHY_SINGLE_CHANNEL_CENTERED;
 876
 877         msg_body.link_state = WCN36XX_HAL_LINK_PREASSOC_STATE;
 878
 879         msg_body.max_tx_power = 0xbf;
 880         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 881
 882         wcn36xx_dbg(WCN36XX_DBG_HAL,
 883                     "hal join req bssid %pM self_sta_mac_addr %pM channel %d link_state %d\n",
 884                     msg_body.bssid, msg_body.self_sta_mac_addr,
 885                     msg_body.channel, msg_body.link_state);
 886
 887         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 888         if (ret) {
 889                 wcn36xx_err("Sending hal_join failed\n");
 890                 goto out;
 891         }
 892         ret = wcn36xx_smd_join_rsp(wcn->hal_buf, wcn->hal_rsp_len);
 893         if (ret) {
 894                 wcn36xx_err("hal_join response failed err=%d\n", ret);
 895                 goto out;
 896         }
 897 out:
 898         mutex_unlock(&wcn->hal_mutex);
 899         return ret;
 900 }
 901
 902 int wcn36xx_smd_set_link_st(struct wcn36xx *wcn, const u8 *bssid,
 903                             const u8 *sta_mac,
 904                             enum wcn36xx_hal_link_state state)
 905 {
 906         struct wcn36xx_hal_set_link_state_req_msg msg_body;
 907         int ret = 0;
 908
 909         mutex_lock(&wcn->hal_mutex);
 910         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_LINK_ST_REQ);
 911
 912         memcpy(&msg_body.bssid, bssid, ETH_ALEN);
 913         memcpy(&msg_body.self_mac_addr, sta_mac, ETH_ALEN);
 914         msg_body.state = state;
 915
 916         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
 917
 918         wcn36xx_dbg(WCN36XX_DBG_HAL,
 919                     "hal set link state bssid %pM self_mac_addr %pM state %d\n",
 920                     msg_body.bssid, msg_body.self_mac_addr, msg_body.state);
 921
 922         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
 923         if (ret) {
 924                 wcn36xx_err("Sending hal_set_link_st failed\n");
 925                 goto out;
 926         }
 927         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
 928         if (ret) {
 929                 wcn36xx_err("hal_set_link_st response failed err=%d\n", ret);
 930                 goto out;
 931         }
 932 out:
 933         mutex_unlock(&wcn->hal_mutex);
 934         return ret;
 935 }
 936
 937 static void wcn36xx_smd_convert_sta_to_v1(struct wcn36xx *wcn,
 938                         const struct wcn36xx_hal_config_sta_params *orig,
 939                         struct wcn36xx_hal_config_sta_params_v1 *v1)
 940 {
 941         /* convert orig to v1 format */
 942         memcpy(&v1->bssid, orig->bssid, ETH_ALEN);
 943         memcpy(&v1->mac, orig->mac, ETH_ALEN);
 944         v1->aid = orig->aid;
 945         v1->type = orig->type;
 946         v1->short_preamble_supported = orig->short_preamble_supported;
 947         v1->listen_interval = orig->listen_interval;
 948         v1->wmm_enabled = orig->wmm_enabled;
 949         v1->ht_capable = orig->ht_capable;
 950         v1->tx_channel_width_set = orig->tx_channel_width_set;
 951         v1->rifs_mode = orig->rifs_mode;
 952         v1->lsig_txop_protection = orig->lsig_txop_protection;
 953         v1->max_ampdu_size = orig->max_ampdu_size;
 954         v1->max_ampdu_density = orig->max_ampdu_density;
 955         v1->sgi_40mhz = orig->sgi_40mhz;
 956         v1->sgi_20Mhz = orig->sgi_20Mhz;
 957         v1->rmf = orig->rmf;
 958         v1->encrypt_type = orig->encrypt_type;
 959         v1->action = orig->action;
 960         v1->uapsd = orig->uapsd;
 961         v1->max_sp_len = orig->max_sp_len;
 962         v1->green_field_capable = orig->green_field_capable;
 963         v1->mimo_ps = orig->mimo_ps;
 964         v1->delayed_ba_support = orig->delayed_ba_support;
 965         v1->max_ampdu_duration = orig->max_ampdu_duration;
 966         v1->dsss_cck_mode_40mhz = orig->dsss_cck_mode_40mhz;
 967         memcpy(&v1->supported_rates, &orig->supported_rates,
 968                sizeof(orig->supported_rates));
 969         v1->sta_index = orig->sta_index;
 970         v1->bssid_index = orig->bssid_index;
 971         v1->p2p = orig->p2p;
 972 }
 973
 974 static int wcn36xx_smd_config_sta_rsp(struct wcn36xx *wcn,
 975                                       struct ieee80211_sta *sta,
 976                                       void *buf,
 977                                       size_t len)
 978 {
 979         struct wcn36xx_hal_config_sta_rsp_msg *rsp;
 980         struct config_sta_rsp_params *params;
 981         struct wcn36xx_sta *sta_priv = wcn36xx_sta_to_priv(sta);
 982
 983         if (len < sizeof(*rsp))
 984                 return -EINVAL;
 985
 986         rsp = (struct wcn36xx_hal_config_sta_rsp_msg *)buf;
 987         params = &rsp->params;
 988
 989         if (params->status != WCN36XX_FW_MSG_RESULT_SUCCESS) {
 990                 wcn36xx_warn("hal config sta response failure: %d\n",
 991                              params->status);
 992                 return -EIO;
 993         }
 994
 995         sta_priv->sta_index = params->sta_index;
 996         sta_priv->dpu_desc_index = params->dpu_index;
 997         sta_priv->ucast_dpu_sign = params->uc_ucast_sig;
 998
 999         wcn36xx_dbg(WCN36XX_DBG_HAL,
1000                     "hal config sta rsp status %d sta_index %d bssid_index %d uc_ucast_sig %d p2p %d\n",
1001                     params->status, params->sta_index, params->bssid_index,
1002                     params->uc_ucast_sig, params->p2p);
1003
1004         return 0;
1005 }
1006
1007 static int wcn36xx_smd_config_sta_v1(struct wcn36xx *wcn,
1008                      const struct wcn36xx_hal_config_sta_req_msg *orig)
1009 {
1010         struct wcn36xx_hal_config_sta_req_msg_v1 msg_body;
1011         struct wcn36xx_hal_config_sta_params_v1 *sta = &msg_body.sta_params;
1012
1013         INIT_HAL_MSG(msg_body, WCN36XX_HAL_CONFIG_STA_REQ);
1014
1015         wcn36xx_smd_convert_sta_to_v1(wcn, &orig->sta_params,
1016                                       &msg_body.sta_params);
1017
1018         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1019
1020         wcn36xx_dbg(WCN36XX_DBG_HAL,
1021                     "hal config sta v1 action %d sta_index %d bssid_index %d bssid %pM type %d mac %pM aid %d\n",
1022                     sta->action, sta->sta_index, sta->bssid_index,
1023                     sta->bssid, sta->type, sta->mac, sta->aid);
1024
1025         return wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1026 }
1027
1028 int wcn36xx_smd_config_sta(struct wcn36xx *wcn, struct ieee80211_vif *vif,
1029                            struct ieee80211_sta *sta)
1030 {
1031         struct wcn36xx_hal_config_sta_req_msg msg;
1032         struct wcn36xx_hal_config_sta_params *sta_params;
1033         int ret = 0;
1034
1035         mutex_lock(&wcn->hal_mutex);
1036         INIT_HAL_MSG(msg, WCN36XX_HAL_CONFIG_STA_REQ);
1037
1038         sta_params = &msg.sta_params;
1039
1040         wcn36xx_smd_set_sta_params(wcn, vif, sta, sta_params);
1041
1042         if (!wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) {
1043                 ret = wcn36xx_smd_config_sta_v1(wcn, &msg);
1044         } else {
1045                 PREPARE_HAL_BUF(wcn->hal_buf, msg);
1046
1047                 wcn36xx_dbg(WCN36XX_DBG_HAL,
1048                             "hal config sta action %d sta_index %d bssid_index %d bssid %pM type %d mac %pM aid %d\n",
1049                             sta_params->action, sta_params->sta_index,
1050                             sta_params->bssid_index, sta_params->bssid,
1051                             sta_params->type, sta_params->mac, sta_params->aid);
1052
1053                 ret = wcn36xx_smd_send_and_wait(wcn, msg.header.len);
1054         }
1055         if (ret) {
1056                 wcn36xx_err("Sending hal_config_sta failed\n");
1057                 goto out;
1058         }
1059         ret = wcn36xx_smd_config_sta_rsp(wcn,
1060                                          sta,
1061                                          wcn->hal_buf,
1062                                          wcn->hal_rsp_len);
1063         if (ret) {
1064                 wcn36xx_err("hal_config_sta response failed err=%d\n", ret);
1065                 goto out;
1066         }
1067 out:
1068         mutex_unlock(&wcn->hal_mutex);
1069         return ret;
1070 }
1071
1072 static int wcn36xx_smd_config_bss_v1(struct wcn36xx *wcn,
1073                         const struct wcn36xx_hal_config_bss_req_msg *orig)
1074 {
1075         struct wcn36xx_hal_config_bss_req_msg_v1 msg_body;
1076         struct wcn36xx_hal_config_bss_params_v1 *bss = &msg_body.bss_params;
1077         struct wcn36xx_hal_config_sta_params_v1 *sta = &bss->sta;
1078
1079         INIT_HAL_MSG(msg_body, WCN36XX_HAL_CONFIG_BSS_REQ);
1080
1081         /* convert orig to v1 */
1082         memcpy(&msg_body.bss_params.bssid,
1083                &orig->bss_params.bssid, ETH_ALEN);
1084         memcpy(&msg_body.bss_params.self_mac_addr,
1085                &orig->bss_params.self_mac_addr, ETH_ALEN);
1086
1087         msg_body.bss_params.bss_type = orig->bss_params.bss_type;
1088         msg_body.bss_params.oper_mode = orig->bss_params.oper_mode;
1089         msg_body.bss_params.nw_type = orig->bss_params.nw_type;
1090
1091         msg_body.bss_params.short_slot_time_supported =
1092                 orig->bss_params.short_slot_time_supported;
1093         msg_body.bss_params.lla_coexist = orig->bss_params.lla_coexist;
1094         msg_body.bss_params.llb_coexist = orig->bss_params.llb_coexist;
1095         msg_body.bss_params.llg_coexist = orig->bss_params.llg_coexist;
1096         msg_body.bss_params.ht20_coexist = orig->bss_params.ht20_coexist;
1097         msg_body.bss_params.lln_non_gf_coexist =
1098                 orig->bss_params.lln_non_gf_coexist;
1099
1100         msg_body.bss_params.lsig_tx_op_protection_full_support =
1101                 orig->bss_params.lsig_tx_op_protection_full_support;
1102         msg_body.bss_params.rifs_mode = orig->bss_params.rifs_mode;
1103         msg_body.bss_params.beacon_interval = orig->bss_params.beacon_interval;
1104         msg_body.bss_params.dtim_period = orig->bss_params.dtim_period;
1105         msg_body.bss_params.tx_channel_width_set =
1106                 orig->bss_params.tx_channel_width_set;
1107         msg_body.bss_params.oper_channel = orig->bss_params.oper_channel;
1108         msg_body.bss_params.ext_channel = orig->bss_params.ext_channel;
1109
1110         msg_body.bss_params.reserved = orig->bss_params.reserved;
1111
1112         memcpy(&msg_body.bss_params.ssid,
1113                &orig->bss_params.ssid,
1114                sizeof(orig->bss_params.ssid));
1115
1116         msg_body.bss_params.action = orig->bss_params.action;
1117         msg_body.bss_params.rateset = orig->bss_params.rateset;
1118         msg_body.bss_params.ht = orig->bss_params.ht;
1119         msg_body.bss_params.obss_prot_enabled =
1120                 orig->bss_params.obss_prot_enabled;
1121         msg_body.bss_params.rmf = orig->bss_params.rmf;
1122         msg_body.bss_params.ht_oper_mode = orig->bss_params.ht_oper_mode;
1123         msg_body.bss_params.dual_cts_protection =
1124                 orig->bss_params.dual_cts_protection;
1125
1126         msg_body.bss_params.max_probe_resp_retry_limit =
1127                 orig->bss_params.max_probe_resp_retry_limit;
1128         msg_body.bss_params.hidden_ssid = orig->bss_params.hidden_ssid;
1129         msg_body.bss_params.proxy_probe_resp =
1130                 orig->bss_params.proxy_probe_resp;
1131         msg_body.bss_params.edca_params_valid =
1132                 orig->bss_params.edca_params_valid;
1133
1134         memcpy(&msg_body.bss_params.acbe,
1135                &orig->bss_params.acbe,
1136                sizeof(orig->bss_params.acbe));
1137         memcpy(&msg_body.bss_params.acbk,
1138                &orig->bss_params.acbk,
1139                sizeof(orig->bss_params.acbk));
1140         memcpy(&msg_body.bss_params.acvi,
1141                &orig->bss_params.acvi,
1142                sizeof(orig->bss_params.acvi));
1143         memcpy(&msg_body.bss_params.acvo,
1144                &orig->bss_params.acvo,
1145                sizeof(orig->bss_params.acvo));
1146
1147         msg_body.bss_params.ext_set_sta_key_param_valid =
1148                 orig->bss_params.ext_set_sta_key_param_valid;
1149
1150         memcpy(&msg_body.bss_params.ext_set_sta_key_param,
1151                &orig->bss_params.ext_set_sta_key_param,
1152                sizeof(orig->bss_params.acvo));
1153
1154         msg_body.bss_params.wcn36xx_hal_persona =
1155                 orig->bss_params.wcn36xx_hal_persona;
1156         msg_body.bss_params.spectrum_mgt_enable =
1157                 orig->bss_params.spectrum_mgt_enable;
1158         msg_body.bss_params.tx_mgmt_power = orig->bss_params.tx_mgmt_power;
1159         msg_body.bss_params.max_tx_power = orig->bss_params.max_tx_power;
1160
1161         wcn36xx_smd_convert_sta_to_v1(wcn, &orig->bss_params.sta,
1162                                       &msg_body.bss_params.sta);
1163
1164         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1165
1166         wcn36xx_dbg(WCN36XX_DBG_HAL,
1167                     "hal config bss v1 bssid %pM self_mac_addr %pM bss_type %d oper_mode %d nw_type %d\n",
1168                     bss->bssid, bss->self_mac_addr, bss->bss_type,
1169                     bss->oper_mode, bss->nw_type);
1170
1171         wcn36xx_dbg(WCN36XX_DBG_HAL,
1172                     "- sta bssid %pM action %d sta_index %d bssid_index %d aid %d type %d mac %pM\n",
1173                     sta->bssid, sta->action, sta->sta_index,
1174                     sta->bssid_index, sta->aid, sta->type, sta->mac);
1175
1176         return wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1177 }
1178
1179
1180 static int wcn36xx_smd_config_bss_rsp(struct wcn36xx *wcn,
1181                                       struct ieee80211_vif *vif,
1182                                       struct ieee80211_sta *sta,
1183                                       void *buf,
1184                                       size_t len)
1185 {
1186         struct wcn36xx_hal_config_bss_rsp_msg *rsp;
1187         struct wcn36xx_hal_config_bss_rsp_params *params;
1188         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1189
1190         if (len < sizeof(*rsp))
1191                 return -EINVAL;
1192
1193         rsp = (struct wcn36xx_hal_config_bss_rsp_msg *)buf;
1194         params = &rsp->bss_rsp_params;
1195
1196         if (params->status != WCN36XX_FW_MSG_RESULT_SUCCESS) {
1197                 wcn36xx_warn("hal config bss response failure: %d\n",
1198                              params->status);
1199                 return -EIO;
1200         }
1201
1202         wcn36xx_dbg(WCN36XX_DBG_HAL,
1203                     "hal config bss rsp status %d bss_idx %d dpu_desc_index %d"
1204                     " sta_idx %d self_idx %d bcast_idx %d mac %pM"
1205                     " power %d ucast_dpu_signature %d\n",
1206                     params->status, params->bss_index, params->dpu_desc_index,
1207                     params->bss_sta_index, params->bss_self_sta_index,
1208                     params->bss_bcast_sta_idx, params->mac,
1209                     params->tx_mgmt_power, params->ucast_dpu_signature);
1210
1211         vif_priv->bss_index = params->bss_index;
1212
1213         if (sta) {
1214                 struct wcn36xx_sta *sta_priv = wcn36xx_sta_to_priv(sta);
1215                 sta_priv->bss_sta_index = params->bss_sta_index;
1216                 sta_priv->bss_dpu_desc_index = params->dpu_desc_index;
1217         }
1218
1219         vif_priv->self_ucast_dpu_sign = params->ucast_dpu_signature;
1220
1221         return 0;
1222 }
1223
1224 int wcn36xx_smd_config_bss(struct wcn36xx *wcn, struct ieee80211_vif *vif,
1225                            struct ieee80211_sta *sta, const u8 *bssid,
1226                            bool update)
1227 {
1228         struct wcn36xx_hal_config_bss_req_msg msg;
1229         struct wcn36xx_hal_config_bss_params *bss;
1230         struct wcn36xx_hal_config_sta_params *sta_params;
1231         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1232         int ret = 0;
1233
1234         mutex_lock(&wcn->hal_mutex);
1235         INIT_HAL_MSG(msg, WCN36XX_HAL_CONFIG_BSS_REQ);
1236
1237         bss = &msg.bss_params;
1238         sta_params = &bss->sta;
1239
1240         WARN_ON(is_zero_ether_addr(bssid));
1241
1242         memcpy(&bss->bssid, bssid, ETH_ALEN);
1243
1244         memcpy(bss->self_mac_addr, vif->addr, ETH_ALEN);
1245
1246         if (vif->type == NL80211_IFTYPE_STATION) {
1247                 bss->bss_type = WCN36XX_HAL_INFRASTRUCTURE_MODE;
1248
1249                 /* STA */
1250                 bss->oper_mode = 1;
1251                 bss->wcn36xx_hal_persona = WCN36XX_HAL_STA_MODE;
1252         } else if (vif->type == NL80211_IFTYPE_AP ||
1253                    vif->type == NL80211_IFTYPE_MESH_POINT) {
1254                 bss->bss_type = WCN36XX_HAL_INFRA_AP_MODE;
1255
1256                 /* AP */
1257                 bss->oper_mode = 0;
1258                 bss->wcn36xx_hal_persona = WCN36XX_HAL_STA_SAP_MODE;
1259         } else if (vif->type == NL80211_IFTYPE_ADHOC) {
1260                 bss->bss_type = WCN36XX_HAL_IBSS_MODE;
1261
1262                 /* STA */
1263                 bss->oper_mode = 1;
1264         } else {
1265                 wcn36xx_warn("Unknown type for bss config: %d\n", vif->type);
1266         }
1267
1268         if (vif->type == NL80211_IFTYPE_STATION)
1269                 wcn36xx_smd_set_bss_nw_type(wcn, sta, bss);
1270         else
1271                 bss->nw_type = WCN36XX_HAL_11N_NW_TYPE;
1272
1273         bss->short_slot_time_supported = vif->bss_conf.use_short_slot;
1274         bss->lla_coexist = 0;
1275         bss->llb_coexist = 0;
1276         bss->llg_coexist = 0;
1277         bss->rifs_mode = 0;
1278         bss->beacon_interval = vif->bss_conf.beacon_int;
1279         bss->dtim_period = vif_priv->dtim_period;
1280
1281         wcn36xx_smd_set_bss_ht_params(vif, sta, bss);
1282
1283         bss->oper_channel = WCN36XX_HW_CHANNEL(wcn);
1284
1285         if (conf_is_ht40_minus(&wcn->hw->conf))
1286                 bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
1287         else if (conf_is_ht40_plus(&wcn->hw->conf))
1288                 bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
1289         else
1290                 bss->ext_channel = IEEE80211_HT_PARAM_CHA_SEC_NONE;
1291
1292         bss->reserved = 0;
1293         wcn36xx_smd_set_sta_params(wcn, vif, sta, sta_params);
1294
1295         /* wcn->ssid is only valid in AP and IBSS mode */
1296         bss->ssid.length = vif_priv->ssid.length;
1297         memcpy(bss->ssid.ssid, vif_priv->ssid.ssid, vif_priv->ssid.length);
1298
1299         bss->obss_prot_enabled = 0;
1300         bss->rmf = 0;
1301         bss->max_probe_resp_retry_limit = 0;
1302         bss->hidden_ssid = vif->bss_conf.hidden_ssid;
1303         bss->proxy_probe_resp = 0;
1304         bss->edca_params_valid = 0;
1305
1306         /* FIXME: set acbe, acbk, acvi and acvo */
1307
1308         bss->ext_set_sta_key_param_valid = 0;
1309
1310         /* FIXME: set ext_set_sta_key_param */
1311
1312         bss->spectrum_mgt_enable = 0;
1313         bss->tx_mgmt_power = 0;
1314         bss->max_tx_power = WCN36XX_MAX_POWER(wcn);
1315
1316         bss->action = update;
1317
1318         wcn36xx_dbg(WCN36XX_DBG_HAL,
1319                     "hal config bss bssid %pM self_mac_addr %pM bss_type %d oper_mode %d nw_type %d\n",
1320                     bss->bssid, bss->self_mac_addr, bss->bss_type,
1321                     bss->oper_mode, bss->nw_type);
1322
1323         wcn36xx_dbg(WCN36XX_DBG_HAL,
1324                     "- sta bssid %pM action %d sta_index %d bssid_index %d aid %d type %d mac %pM\n",
1325                     sta_params->bssid, sta_params->action,
1326                     sta_params->sta_index, sta_params->bssid_index,
1327                     sta_params->aid, sta_params->type,
1328                     sta_params->mac);
1329
1330         if (!wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) {
1331                 ret = wcn36xx_smd_config_bss_v1(wcn, &msg);
1332         } else {
1333                 PREPARE_HAL_BUF(wcn->hal_buf, msg);
1334
1335                 ret = wcn36xx_smd_send_and_wait(wcn, msg.header.len);
1336         }
1337         if (ret) {
1338                 wcn36xx_err("Sending hal_config_bss failed\n");
1339                 goto out;
1340         }
1341         ret = wcn36xx_smd_config_bss_rsp(wcn,
1342                                          vif,
1343                                          sta,
1344                                          wcn->hal_buf,
1345                                          wcn->hal_rsp_len);
1346         if (ret) {
1347                 wcn36xx_err("hal_config_bss response failed err=%d\n", ret);
1348                 goto out;
1349         }
1350 out:
1351         mutex_unlock(&wcn->hal_mutex);
1352         return ret;
1353 }
1354
1355 int wcn36xx_smd_delete_bss(struct wcn36xx *wcn, struct ieee80211_vif *vif)
1356 {
1357         struct wcn36xx_hal_delete_bss_req_msg msg_body;
1358         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1359         int ret = 0;
1360
1361         mutex_lock(&wcn->hal_mutex);
1362         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DELETE_BSS_REQ);
1363
1364         msg_body.bss_index = vif_priv->bss_index;
1365
1366         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1367
1368         wcn36xx_dbg(WCN36XX_DBG_HAL, "hal delete bss %d\n", msg_body.bss_index);
1369
1370         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1371         if (ret) {
1372                 wcn36xx_err("Sending hal_delete_bss failed\n");
1373                 goto out;
1374         }
1375         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1376         if (ret) {
1377                 wcn36xx_err("hal_delete_bss response failed err=%d\n", ret);
1378                 goto out;
1379         }
1380 out:
1381         mutex_unlock(&wcn->hal_mutex);
1382         return ret;
1383 }
1384
1385 int wcn36xx_smd_send_beacon(struct wcn36xx *wcn, struct ieee80211_vif *vif,
1386                             struct sk_buff *skb_beacon, u16 tim_off,
1387                             u16 p2p_off)
1388 {
1389         struct wcn36xx_hal_send_beacon_req_msg msg_body;
1390         int ret = 0, pad, pvm_len;
1391
1392         mutex_lock(&wcn->hal_mutex);
1393         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SEND_BEACON_REQ);
1394
1395         pvm_len = skb_beacon->data[tim_off + 1] - 3;
1396         pad = TIM_MIN_PVM_SIZE - pvm_len;
1397
1398         /* Padding is irrelevant to mesh mode since tim_off is always 0. */
1399         if (vif->type == NL80211_IFTYPE_MESH_POINT)
1400                 pad = 0;
1401
1402         msg_body.beacon_length = skb_beacon->len + pad;
1403         /* TODO need to find out why + 6 is needed */
1404         msg_body.beacon_length6 = msg_body.beacon_length + 6;
1405
1406         if (msg_body.beacon_length > BEACON_TEMPLATE_SIZE) {
1407                 wcn36xx_err("Beacon is to big: beacon size=%d\n",
1408                               msg_body.beacon_length);
1409                 ret = -ENOMEM;
1410                 goto out;
1411         }
1412         memcpy(msg_body.beacon, skb_beacon->data, skb_beacon->len);
1413         memcpy(msg_body.bssid, vif->addr, ETH_ALEN);
1414
1415         if (pad > 0) {
1416                 /*
1417                  * The wcn36xx FW has a fixed size for the PVM in the TIM. If
1418                  * given the beacon template from mac80211 with a PVM shorter
1419                  * than the FW expectes it will overwrite the data after the
1420                  * TIM.
1421                  */
1422                 wcn36xx_dbg(WCN36XX_DBG_HAL, "Pad TIM PVM. %d bytes at %d\n",
1423                             pad, pvm_len);
1424                 memmove(&msg_body.beacon[tim_off + 5 + pvm_len + pad],
1425                         &msg_body.beacon[tim_off + 5 + pvm_len],
1426                         skb_beacon->len - (tim_off + 5 + pvm_len));
1427                 memset(&msg_body.beacon[tim_off + 5 + pvm_len], 0, pad);
1428                 msg_body.beacon[tim_off + 1] += pad;
1429         }
1430
1431         /* TODO need to find out why this is needed? */
1432         if (vif->type == NL80211_IFTYPE_MESH_POINT)
1433                 /* mesh beacon don't need this, so push further down */
1434                 msg_body.tim_ie_offset = 256;
1435         else
1436                 msg_body.tim_ie_offset = tim_off+4;
1437         msg_body.p2p_ie_offset = p2p_off;
1438         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1439
1440         wcn36xx_dbg(WCN36XX_DBG_HAL,
1441                     "hal send beacon beacon_length %d\n",
1442                     msg_body.beacon_length);
1443
1444         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1445         if (ret) {
1446                 wcn36xx_err("Sending hal_send_beacon failed\n");
1447                 goto out;
1448         }
1449         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1450         if (ret) {
1451                 wcn36xx_err("hal_send_beacon response failed err=%d\n", ret);
1452                 goto out;
1453         }
1454 out:
1455         mutex_unlock(&wcn->hal_mutex);
1456         return ret;
1457 }
1458
1459 int wcn36xx_smd_update_proberesp_tmpl(struct wcn36xx *wcn,
1460                                       struct ieee80211_vif *vif,
1461                                       struct sk_buff *skb)
1462 {
1463         struct wcn36xx_hal_send_probe_resp_req_msg msg;
1464         int ret = 0;
1465
1466         mutex_lock(&wcn->hal_mutex);
1467         INIT_HAL_MSG(msg, WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_REQ);
1468
1469         if (skb->len > BEACON_TEMPLATE_SIZE) {
1470                 wcn36xx_warn("probe response template is too big: %d\n",
1471                              skb->len);
1472                 ret = -E2BIG;
1473                 goto out;
1474         }
1475
1476         msg.probe_resp_template_len = skb->len;
1477         memcpy(&msg.probe_resp_template, skb->data, skb->len);
1478
1479         memcpy(msg.bssid, vif->addr, ETH_ALEN);
1480
1481         PREPARE_HAL_BUF(wcn->hal_buf, msg);
1482
1483         wcn36xx_dbg(WCN36XX_DBG_HAL,
1484                     "hal update probe rsp len %d bssid %pM\n",
1485                     msg.probe_resp_template_len, msg.bssid);
1486
1487         ret = wcn36xx_smd_send_and_wait(wcn, msg.header.len);
1488         if (ret) {
1489                 wcn36xx_err("Sending hal_update_proberesp_tmpl failed\n");
1490                 goto out;
1491         }
1492         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1493         if (ret) {
1494                 wcn36xx_err("hal_update_proberesp_tmpl response failed err=%d\n",
1495                             ret);
1496                 goto out;
1497         }
1498 out:
1499         mutex_unlock(&wcn->hal_mutex);
1500         return ret;
1501 }
1502
1503 int wcn36xx_smd_set_stakey(struct wcn36xx *wcn,
1504                            enum ani_ed_type enc_type,
1505                            u8 keyidx,
1506                            u8 keylen,
1507                            u8 *key,
1508                            u8 sta_index)
1509 {
1510         struct wcn36xx_hal_set_sta_key_req_msg msg_body;
1511         int ret = 0;
1512
1513         mutex_lock(&wcn->hal_mutex);
1514         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_STAKEY_REQ);
1515
1516         msg_body.set_sta_key_params.sta_index = sta_index;
1517         msg_body.set_sta_key_params.enc_type = enc_type;
1518
1519         msg_body.set_sta_key_params.key[0].id = keyidx;
1520         msg_body.set_sta_key_params.key[0].unicast = 1;
1521         msg_body.set_sta_key_params.key[0].direction = WCN36XX_HAL_TX_RX;
1522         msg_body.set_sta_key_params.key[0].pae_role = 0;
1523         msg_body.set_sta_key_params.key[0].length = keylen;
1524         memcpy(msg_body.set_sta_key_params.key[0].key, key, keylen);
1525         msg_body.set_sta_key_params.single_tid_rc = 1;
1526
1527         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1528
1529         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1530         if (ret) {
1531                 wcn36xx_err("Sending hal_set_stakey failed\n");
1532                 goto out;
1533         }
1534         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1535         if (ret) {
1536                 wcn36xx_err("hal_set_stakey response failed err=%d\n", ret);
1537                 goto out;
1538         }
1539 out:
1540         mutex_unlock(&wcn->hal_mutex);
1541         return ret;
1542 }
1543
1544 int wcn36xx_smd_set_bsskey(struct wcn36xx *wcn,
1545                            enum ani_ed_type enc_type,
1546                            u8 keyidx,
1547                            u8 keylen,
1548                            u8 *key)
1549 {
1550         struct wcn36xx_hal_set_bss_key_req_msg msg_body;
1551         int ret = 0;
1552
1553         mutex_lock(&wcn->hal_mutex);
1554         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_BSSKEY_REQ);
1555         msg_body.bss_idx = 0;
1556         msg_body.enc_type = enc_type;
1557         msg_body.num_keys = 1;
1558         msg_body.keys[0].id = keyidx;
1559         msg_body.keys[0].unicast = 0;
1560         msg_body.keys[0].direction = WCN36XX_HAL_RX_ONLY;
1561         msg_body.keys[0].pae_role = 0;
1562         msg_body.keys[0].length = keylen;
1563         memcpy(msg_body.keys[0].key, key, keylen);
1564
1565         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1566
1567         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1568         if (ret) {
1569                 wcn36xx_err("Sending hal_set_bsskey failed\n");
1570                 goto out;
1571         }
1572         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1573         if (ret) {
1574                 wcn36xx_err("hal_set_bsskey response failed err=%d\n", ret);
1575                 goto out;
1576         }
1577 out:
1578         mutex_unlock(&wcn->hal_mutex);
1579         return ret;
1580 }
1581
1582 int wcn36xx_smd_remove_stakey(struct wcn36xx *wcn,
1583                               enum ani_ed_type enc_type,
1584                               u8 keyidx,
1585                               u8 sta_index)
1586 {
1587         struct wcn36xx_hal_remove_sta_key_req_msg msg_body;
1588         int ret = 0;
1589
1590         mutex_lock(&wcn->hal_mutex);
1591         INIT_HAL_MSG(msg_body, WCN36XX_HAL_RMV_STAKEY_REQ);
1592
1593         msg_body.sta_idx = sta_index;
1594         msg_body.enc_type = enc_type;
1595         msg_body.key_id = keyidx;
1596
1597         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1598
1599         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1600         if (ret) {
1601                 wcn36xx_err("Sending hal_remove_stakey failed\n");
1602                 goto out;
1603         }
1604         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1605         if (ret) {
1606                 wcn36xx_err("hal_remove_stakey response failed err=%d\n", ret);
1607                 goto out;
1608         }
1609 out:
1610         mutex_unlock(&wcn->hal_mutex);
1611         return ret;
1612 }
1613
1614 int wcn36xx_smd_remove_bsskey(struct wcn36xx *wcn,
1615                               enum ani_ed_type enc_type,
1616                               u8 keyidx)
1617 {
1618         struct wcn36xx_hal_remove_bss_key_req_msg msg_body;
1619         int ret = 0;
1620
1621         mutex_lock(&wcn->hal_mutex);
1622         INIT_HAL_MSG(msg_body, WCN36XX_HAL_RMV_BSSKEY_REQ);
1623         msg_body.bss_idx = 0;
1624         msg_body.enc_type = enc_type;
1625         msg_body.key_id = keyidx;
1626
1627         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1628
1629         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1630         if (ret) {
1631                 wcn36xx_err("Sending hal_remove_bsskey failed\n");
1632                 goto out;
1633         }
1634         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1635         if (ret) {
1636                 wcn36xx_err("hal_remove_bsskey response failed err=%d\n", ret);
1637                 goto out;
1638         }
1639 out:
1640         mutex_unlock(&wcn->hal_mutex);
1641         return ret;
1642 }
1643
1644 int wcn36xx_smd_enter_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif)
1645 {
1646         struct wcn36xx_hal_enter_bmps_req_msg msg_body;
1647         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1648         int ret = 0;
1649
1650         mutex_lock(&wcn->hal_mutex);
1651         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ENTER_BMPS_REQ);
1652
1653         msg_body.bss_index = vif_priv->bss_index;
1654         msg_body.tbtt = vif->bss_conf.sync_tsf;
1655         msg_body.dtim_period = vif_priv->dtim_period;
1656
1657         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1658
1659         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1660         if (ret) {
1661                 wcn36xx_err("Sending hal_enter_bmps failed\n");
1662                 goto out;
1663         }
1664         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1665         if (ret) {
1666                 wcn36xx_err("hal_enter_bmps response failed err=%d\n", ret);
1667                 goto out;
1668         }
1669 out:
1670         mutex_unlock(&wcn->hal_mutex);
1671         return ret;
1672 }
1673
1674 int wcn36xx_smd_exit_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif)
1675 {
1676         struct wcn36xx_hal_exit_bmps_req_msg msg_body;
1677         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1678         int ret = 0;
1679
1680         mutex_lock(&wcn->hal_mutex);
1681         INIT_HAL_MSG(msg_body, WCN36XX_HAL_EXIT_BMPS_REQ);
1682
1683         msg_body.bss_index = vif_priv->bss_index;
1684
1685         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1686
1687         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1688         if (ret) {
1689                 wcn36xx_err("Sending hal_exit_bmps failed\n");
1690                 goto out;
1691         }
1692         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1693         if (ret) {
1694                 wcn36xx_err("hal_exit_bmps response failed err=%d\n", ret);
1695                 goto out;
1696         }
1697 out:
1698         mutex_unlock(&wcn->hal_mutex);
1699         return ret;
1700 }
1701 int wcn36xx_smd_set_power_params(struct wcn36xx *wcn, bool ignore_dtim)
1702 {
1703         struct wcn36xx_hal_set_power_params_req_msg msg_body;
1704         int ret = 0;
1705
1706         mutex_lock(&wcn->hal_mutex);
1707         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_POWER_PARAMS_REQ);
1708
1709         /*
1710          * When host is down ignore every second dtim
1711          */
1712         if (ignore_dtim) {
1713                 msg_body.ignore_dtim = 1;
1714                 msg_body.dtim_period = 2;
1715         }
1716         msg_body.listen_interval = WCN36XX_LISTEN_INTERVAL(wcn);
1717
1718         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1719
1720         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1721         if (ret) {
1722                 wcn36xx_err("Sending hal_set_power_params failed\n");
1723                 goto out;
1724         }
1725
1726 out:
1727         mutex_unlock(&wcn->hal_mutex);
1728         return ret;
1729 }
1730 /* Notice: This function should be called after associated, or else it
1731  * will be invalid
1732  */
1733 int wcn36xx_smd_keep_alive_req(struct wcn36xx *wcn,
1734                                struct ieee80211_vif *vif,
1735                                int packet_type)
1736 {
1737         struct wcn36xx_hal_keep_alive_req_msg msg_body;
1738         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1739         int ret = 0;
1740
1741         mutex_lock(&wcn->hal_mutex);
1742         INIT_HAL_MSG(msg_body, WCN36XX_HAL_KEEP_ALIVE_REQ);
1743
1744         if (packet_type == WCN36XX_HAL_KEEP_ALIVE_NULL_PKT) {
1745                 msg_body.bss_index = vif_priv->bss_index;
1746                 msg_body.packet_type = WCN36XX_HAL_KEEP_ALIVE_NULL_PKT;
1747                 msg_body.time_period = WCN36XX_KEEP_ALIVE_TIME_PERIOD;
1748         } else if (packet_type == WCN36XX_HAL_KEEP_ALIVE_UNSOLICIT_ARP_RSP) {
1749                 /* TODO: it also support ARP response type */
1750         } else {
1751                 wcn36xx_warn("unknown keep alive packet type %d\n", packet_type);
1752                 ret = -EINVAL;
1753                 goto out;
1754         }
1755
1756         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1757
1758         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1759         if (ret) {
1760                 wcn36xx_err("Sending hal_keep_alive failed\n");
1761                 goto out;
1762         }
1763         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1764         if (ret) {
1765                 wcn36xx_err("hal_keep_alive response failed err=%d\n", ret);
1766                 goto out;
1767         }
1768 out:
1769         mutex_unlock(&wcn->hal_mutex);
1770         return ret;
1771 }
1772
1773 int wcn36xx_smd_dump_cmd_req(struct wcn36xx *wcn, u32 arg1, u32 arg2,
1774                              u32 arg3, u32 arg4, u32 arg5)
1775 {
1776         struct wcn36xx_hal_dump_cmd_req_msg msg_body;
1777         int ret = 0;
1778
1779         mutex_lock(&wcn->hal_mutex);
1780         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DUMP_COMMAND_REQ);
1781
1782         msg_body.arg1 = arg1;
1783         msg_body.arg2 = arg2;
1784         msg_body.arg3 = arg3;
1785         msg_body.arg4 = arg4;
1786         msg_body.arg5 = arg5;
1787
1788         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1789
1790         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1791         if (ret) {
1792                 wcn36xx_err("Sending hal_dump_cmd failed\n");
1793                 goto out;
1794         }
1795         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1796         if (ret) {
1797                 wcn36xx_err("hal_dump_cmd response failed err=%d\n", ret);
1798                 goto out;
1799         }
1800 out:
1801         mutex_unlock(&wcn->hal_mutex);
1802         return ret;
1803 }
1804
1805 void set_feat_caps(u32 *bitmap, enum place_holder_in_cap_bitmap cap)
1806 {
1807         int arr_idx, bit_idx;
1808
1809         if (cap < 0 || cap > 127) {
1810                 wcn36xx_warn("error cap idx %d\n", cap);
1811                 return;
1812         }
1813
1814         arr_idx = cap / 32;
1815         bit_idx = cap % 32;
1816         bitmap[arr_idx] |= (1 << bit_idx);
1817 }
1818
1819 int get_feat_caps(u32 *bitmap, enum place_holder_in_cap_bitmap cap)
1820 {
1821         int arr_idx, bit_idx;
1822         int ret = 0;
1823
1824         if (cap < 0 || cap > 127) {
1825                 wcn36xx_warn("error cap idx %d\n", cap);
1826                 return -EINVAL;
1827         }
1828
1829         arr_idx = cap / 32;
1830         bit_idx = cap % 32;
1831         ret = (bitmap[arr_idx] & (1 << bit_idx)) ? 1 : 0;
1832         return ret;
1833 }
1834
1835 void clear_feat_caps(u32 *bitmap, enum place_holder_in_cap_bitmap cap)
1836 {
1837         int arr_idx, bit_idx;
1838
1839         if (cap < 0 || cap > 127) {
1840                 wcn36xx_warn("error cap idx %d\n", cap);
1841                 return;
1842         }
1843
1844         arr_idx = cap / 32;
1845         bit_idx = cap % 32;
1846         bitmap[arr_idx] &= ~(1 << bit_idx);
1847 }
1848
1849 int wcn36xx_smd_feature_caps_exchange(struct wcn36xx *wcn)
1850 {
1851         struct wcn36xx_hal_feat_caps_msg msg_body, *rsp;
1852         int ret = 0, i;
1853
1854         mutex_lock(&wcn->hal_mutex);
1855         INIT_HAL_MSG(msg_body, WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_REQ);
1856
1857         set_feat_caps(msg_body.feat_caps, STA_POWERSAVE);
1858
1859         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1860
1861         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1862         if (ret) {
1863                 wcn36xx_err("Sending hal_feature_caps_exchange failed\n");
1864                 goto out;
1865         }
1866         if (wcn->hal_rsp_len != sizeof(*rsp)) {
1867                 wcn36xx_err("Invalid hal_feature_caps_exchange response");
1868                 goto out;
1869         }
1870
1871         rsp = (struct wcn36xx_hal_feat_caps_msg *) wcn->hal_buf;
1872
1873         for (i = 0; i < WCN36XX_HAL_CAPS_SIZE; i++)
1874                 wcn->fw_feat_caps[i] = rsp->feat_caps[i];
1875 out:
1876         mutex_unlock(&wcn->hal_mutex);
1877         return ret;
1878 }
1879
1880 int wcn36xx_smd_add_ba_session(struct wcn36xx *wcn,
1881                 struct ieee80211_sta *sta,
1882                 u16 tid,
1883                 u16 *ssn,
1884                 u8 direction,
1885                 u8 sta_index)
1886 {
1887         struct wcn36xx_hal_add_ba_session_req_msg msg_body;
1888         int ret = 0;
1889
1890         mutex_lock(&wcn->hal_mutex);
1891         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BA_SESSION_REQ);
1892
1893         msg_body.sta_index = sta_index;
1894         memcpy(&msg_body.mac_addr, sta->addr, ETH_ALEN);
1895         msg_body.dialog_token = 0x10;
1896         msg_body.tid = tid;
1897
1898         /* Immediate BA because Delayed BA is not supported */
1899         msg_body.policy = 1;
1900         msg_body.buffer_size = WCN36XX_AGGR_BUFFER_SIZE;
1901         msg_body.timeout = 0;
1902         if (ssn)
1903                 msg_body.ssn = *ssn;
1904         msg_body.direction = direction;
1905
1906         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1907
1908         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1909         if (ret) {
1910                 wcn36xx_err("Sending hal_add_ba_session failed\n");
1911                 goto out;
1912         }
1913         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1914         if (ret) {
1915                 wcn36xx_err("hal_add_ba_session response failed err=%d\n", ret);
1916                 goto out;
1917         }
1918 out:
1919         mutex_unlock(&wcn->hal_mutex);
1920         return ret;
1921 }
1922
1923 int wcn36xx_smd_add_ba(struct wcn36xx *wcn)
1924 {
1925         struct wcn36xx_hal_add_ba_req_msg msg_body;
1926         int ret = 0;
1927
1928         mutex_lock(&wcn->hal_mutex);
1929         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BA_REQ);
1930
1931         msg_body.session_id = 0;
1932         msg_body.win_size = WCN36XX_AGGR_BUFFER_SIZE;
1933
1934         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1935
1936         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1937         if (ret) {
1938                 wcn36xx_err("Sending hal_add_ba failed\n");
1939                 goto out;
1940         }
1941         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1942         if (ret) {
1943                 wcn36xx_err("hal_add_ba response failed err=%d\n", ret);
1944                 goto out;
1945         }
1946 out:
1947         mutex_unlock(&wcn->hal_mutex);
1948         return ret;
1949 }
1950
1951 int wcn36xx_smd_del_ba(struct wcn36xx *wcn, u16 tid, u8 sta_index)
1952 {
1953         struct wcn36xx_hal_del_ba_req_msg msg_body;
1954         int ret = 0;
1955
1956         mutex_lock(&wcn->hal_mutex);
1957         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DEL_BA_REQ);
1958
1959         msg_body.sta_index = sta_index;
1960         msg_body.tid = tid;
1961         msg_body.direction = 0;
1962         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1963
1964         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1965         if (ret) {
1966                 wcn36xx_err("Sending hal_del_ba failed\n");
1967                 goto out;
1968         }
1969         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1970         if (ret) {
1971                 wcn36xx_err("hal_del_ba response failed err=%d\n", ret);
1972                 goto out;
1973         }
1974 out:
1975         mutex_unlock(&wcn->hal_mutex);
1976         return ret;
1977 }
1978
1979 static int wcn36xx_smd_trigger_ba_rsp(void *buf, int len)
1980 {
1981         struct wcn36xx_hal_trigger_ba_rsp_msg *rsp;
1982
1983         if (len < sizeof(*rsp))
1984                 return -EINVAL;
1985
1986         rsp = (struct wcn36xx_hal_trigger_ba_rsp_msg *) buf;
1987         return rsp->status;
1988 }
1989
1990 int wcn36xx_smd_trigger_ba(struct wcn36xx *wcn, u8 sta_index)
1991 {
1992         struct wcn36xx_hal_trigger_ba_req_msg msg_body;
1993         struct wcn36xx_hal_trigger_ba_req_candidate *candidate;
1994         int ret = 0;
1995
1996         mutex_lock(&wcn->hal_mutex);
1997         INIT_HAL_MSG(msg_body, WCN36XX_HAL_TRIGGER_BA_REQ);
1998
1999         msg_body.session_id = 0;
2000         msg_body.candidate_cnt = 1;
2001         msg_body.header.len += sizeof(*candidate);
2002         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2003
2004         candidate = (struct wcn36xx_hal_trigger_ba_req_candidate *)
2005                 (wcn->hal_buf + sizeof(msg_body));
2006         candidate->sta_index = sta_index;
2007         candidate->tid_bitmap = 1;
2008
2009         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2010         if (ret) {
2011                 wcn36xx_err("Sending hal_trigger_ba failed\n");
2012                 goto out;
2013         }
2014         ret = wcn36xx_smd_trigger_ba_rsp(wcn->hal_buf, wcn->hal_rsp_len);
2015         if (ret) {
2016                 wcn36xx_err("hal_trigger_ba response failed err=%d\n", ret);
2017                 goto out;
2018         }
2019 out:
2020         mutex_unlock(&wcn->hal_mutex);
2021         return ret;
2022 }
2023
2024 static int wcn36xx_smd_tx_compl_ind(struct wcn36xx *wcn, void *buf, size_t len)
2025 {
2026         struct wcn36xx_hal_tx_compl_ind_msg *rsp = buf;
2027
2028         if (len != sizeof(*rsp)) {
2029                 wcn36xx_warn("Bad TX complete indication\n");
2030                 return -EIO;
2031         }
2032
2033         wcn36xx_dxe_tx_ack_ind(wcn, rsp->status);
2034
2035         return 0;
2036 }
2037
2038 static int wcn36xx_smd_missed_beacon_ind(struct wcn36xx *wcn,
2039                                          void *buf,
2040                                          size_t len)
2041 {
2042         struct wcn36xx_hal_missed_beacon_ind_msg *rsp = buf;
2043         struct ieee80211_vif *vif = NULL;
2044         struct wcn36xx_vif *tmp;
2045
2046         /* Old FW does not have bss index */
2047         if (wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) {
2048                 list_for_each_entry(tmp, &wcn->vif_list, list) {
2049                         wcn36xx_dbg(WCN36XX_DBG_HAL, "beacon missed bss_index %d\n",
2050                                     tmp->bss_index);
2051                         vif = wcn36xx_priv_to_vif(tmp);
2052                         ieee80211_connection_loss(vif);
2053                 }
2054                 return 0;
2055         }
2056
2057         if (len != sizeof(*rsp)) {
2058                 wcn36xx_warn("Corrupted missed beacon indication\n");
2059                 return -EIO;
2060         }
2061
2062         list_for_each_entry(tmp, &wcn->vif_list, list) {
2063                 if (tmp->bss_index == rsp->bss_index) {
2064                         wcn36xx_dbg(WCN36XX_DBG_HAL, "beacon missed bss_index %d\n",
2065                                     rsp->bss_index);
2066                         vif = wcn36xx_priv_to_vif(tmp);
2067                         ieee80211_connection_loss(vif);
2068                         return 0;
2069                 }
2070         }
2071
2072         wcn36xx_warn("BSS index %d not found\n", rsp->bss_index);
2073         return -ENOENT;
2074 }
2075
2076 static int wcn36xx_smd_delete_sta_context_ind(struct wcn36xx *wcn,
2077                                               void *buf,
2078                                               size_t len)
2079 {
2080         struct wcn36xx_hal_delete_sta_context_ind_msg *rsp = buf;
2081         struct wcn36xx_vif *tmp;
2082         struct ieee80211_sta *sta;
2083
2084         if (len != sizeof(*rsp)) {
2085                 wcn36xx_warn("Corrupted delete sta indication\n");
2086                 return -EIO;
2087         }
2088
2089         wcn36xx_dbg(WCN36XX_DBG_HAL, "delete station indication %pM index %d\n",
2090                     rsp->addr2, rsp->sta_id);
2091
2092         list_for_each_entry(tmp, &wcn->vif_list, list) {
2093                 rcu_read_lock();
2094                 sta = ieee80211_find_sta(wcn36xx_priv_to_vif(tmp), rsp->addr2);
2095                 if (sta)
2096                         ieee80211_report_low_ack(sta, 0);
2097                 rcu_read_unlock();
2098                 if (sta)
2099                         return 0;
2100         }
2101
2102         wcn36xx_warn("STA with addr %pM and index %d not found\n",
2103                      rsp->addr2,
2104                      rsp->sta_id);
2105         return -ENOENT;
2106 }
2107
2108 int wcn36xx_smd_update_cfg(struct wcn36xx *wcn, u32 cfg_id, u32 value)
2109 {
2110         struct wcn36xx_hal_update_cfg_req_msg msg_body, *body;
2111         size_t len;
2112         int ret = 0;
2113
2114         mutex_lock(&wcn->hal_mutex);
2115         INIT_HAL_MSG(msg_body, WCN36XX_HAL_UPDATE_CFG_REQ);
2116
2117         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2118
2119         body = (struct wcn36xx_hal_update_cfg_req_msg *) wcn->hal_buf;
2120         len = msg_body.header.len;
2121
2122         put_cfg_tlv_u32(wcn, &len, cfg_id, value);
2123         body->header.len = len;
2124         body->len = len - sizeof(*body);
2125
2126         ret = wcn36xx_smd_send_and_wait(wcn, body->header.len);
2127         if (ret) {
2128                 wcn36xx_err("Sending hal_update_cfg failed\n");
2129                 goto out;
2130         }
2131         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2132         if (ret) {
2133                 wcn36xx_err("hal_update_cfg response failed err=%d\n", ret);
2134                 goto out;
2135         }
2136 out:
2137         mutex_unlock(&wcn->hal_mutex);
2138         return ret;
2139 }
2140
2141 int wcn36xx_smd_set_mc_list(struct wcn36xx *wcn,
2142                             struct ieee80211_vif *vif,
2143                             struct wcn36xx_hal_rcv_flt_mc_addr_list_type *fp)
2144 {
2145         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2146         struct wcn36xx_hal_rcv_flt_pkt_set_mc_list_req_msg *msg_body = NULL;
2147         int ret = 0;
2148
2149         mutex_lock(&wcn->hal_mutex);
2150
2151         msg_body = (struct wcn36xx_hal_rcv_flt_pkt_set_mc_list_req_msg *)
2152                    wcn->hal_buf;
2153         init_hal_msg(&msg_body->header, WCN36XX_HAL_8023_MULTICAST_LIST_REQ,
2154                      sizeof(msg_body->mc_addr_list));
2155
2156         /* An empty list means all mc traffic will be received */
2157         if (fp)
2158                 memcpy(&msg_body->mc_addr_list, fp,
2159                        sizeof(msg_body->mc_addr_list));
2160         else
2161                 msg_body->mc_addr_list.mc_addr_count = 0;
2162
2163         msg_body->mc_addr_list.bss_index = vif_priv->bss_index;
2164
2165         ret = wcn36xx_smd_send_and_wait(wcn, msg_body->header.len);
2166         if (ret) {
2167                 wcn36xx_err("Sending HAL_8023_MULTICAST_LIST failed\n");
2168                 goto out;
2169         }
2170         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2171         if (ret) {
2172                 wcn36xx_err("HAL_8023_MULTICAST_LIST rsp failed err=%d\n", ret);
2173                 goto out;
2174         }
2175 out:
2176         mutex_unlock(&wcn->hal_mutex);
2177         return ret;
2178 }
2179
2180 static void wcn36xx_smd_rsp_process(struct wcn36xx *wcn, void *buf, size_t len)
2181 {
2182         struct wcn36xx_hal_msg_header *msg_header = buf;
2183         struct wcn36xx_hal_ind_msg *msg_ind;
2184         wcn36xx_dbg_dump(WCN36XX_DBG_SMD_DUMP, "SMD <<< ", buf, len);
2185
2186         switch (msg_header->msg_type) {
2187         case WCN36XX_HAL_START_RSP:
2188         case WCN36XX_HAL_CONFIG_STA_RSP:
2189         case WCN36XX_HAL_CONFIG_BSS_RSP:
2190         case WCN36XX_HAL_ADD_STA_SELF_RSP:
2191         case WCN36XX_HAL_STOP_RSP:
2192         case WCN36XX_HAL_DEL_STA_SELF_RSP:
2193         case WCN36XX_HAL_DELETE_STA_RSP:
2194         case WCN36XX_HAL_INIT_SCAN_RSP:
2195         case WCN36XX_HAL_START_SCAN_RSP:
2196         case WCN36XX_HAL_END_SCAN_RSP:
2197         case WCN36XX_HAL_FINISH_SCAN_RSP:
2198         case WCN36XX_HAL_DOWNLOAD_NV_RSP:
2199         case WCN36XX_HAL_DELETE_BSS_RSP:
2200         case WCN36XX_HAL_SEND_BEACON_RSP:
2201         case WCN36XX_HAL_SET_LINK_ST_RSP:
2202         case WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_RSP:
2203         case WCN36XX_HAL_SET_BSSKEY_RSP:
2204         case WCN36XX_HAL_SET_STAKEY_RSP:
2205         case WCN36XX_HAL_RMV_STAKEY_RSP:
2206         case WCN36XX_HAL_RMV_BSSKEY_RSP:
2207         case WCN36XX_HAL_ENTER_BMPS_RSP:
2208         case WCN36XX_HAL_SET_POWER_PARAMS_RSP:
2209         case WCN36XX_HAL_EXIT_BMPS_RSP:
2210         case WCN36XX_HAL_KEEP_ALIVE_RSP:
2211         case WCN36XX_HAL_DUMP_COMMAND_RSP:
2212         case WCN36XX_HAL_ADD_BA_SESSION_RSP:
2213         case WCN36XX_HAL_ADD_BA_RSP:
2214         case WCN36XX_HAL_DEL_BA_RSP:
2215         case WCN36XX_HAL_TRIGGER_BA_RSP:
2216         case WCN36XX_HAL_UPDATE_CFG_RSP:
2217         case WCN36XX_HAL_JOIN_RSP:
2218         case WCN36XX_HAL_UPDATE_SCAN_PARAM_RSP:
2219         case WCN36XX_HAL_CH_SWITCH_RSP:
2220         case WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_RSP:
2221         case WCN36XX_HAL_8023_MULTICAST_LIST_RSP:
2222                 memcpy(wcn->hal_buf, buf, len);
2223                 wcn->hal_rsp_len = len;
2224                 complete(&wcn->hal_rsp_compl);
2225                 break;
2226
2227         case WCN36XX_HAL_COEX_IND:
2228         case WCN36XX_HAL_AVOID_FREQ_RANGE_IND:
2229         case WCN36XX_HAL_OTA_TX_COMPL_IND:
2230         case WCN36XX_HAL_MISSED_BEACON_IND:
2231         case WCN36XX_HAL_DELETE_STA_CONTEXT_IND:
2232                 msg_ind = kmalloc(sizeof(*msg_ind), GFP_KERNEL);
2233                 if (!msg_ind)
2234                         goto nomem;
2235                 msg_ind->msg_len = len;
2236                 msg_ind->msg = kmemdup(buf, len, GFP_KERNEL);
2237                 if (!msg_ind->msg) {
2238                         kfree(msg_ind);
2239 nomem:
2240                         /*
2241                          * FIXME: Do something smarter then just
2242                          * printing an error.
2243                          */
2244                         wcn36xx_err("Run out of memory while handling SMD_EVENT (%d)\n",
2245                                     msg_header->msg_type);
2246                         break;
2247                 }
2248                 mutex_lock(&wcn->hal_ind_mutex);
2249                 list_add_tail(&msg_ind->list, &wcn->hal_ind_queue);
2250                 queue_work(wcn->hal_ind_wq, &wcn->hal_ind_work);
2251                 mutex_unlock(&wcn->hal_ind_mutex);
2252                 wcn36xx_dbg(WCN36XX_DBG_HAL, "indication arrived\n");
2253                 break;
2254         default:
2255                 wcn36xx_err("SMD_EVENT (%d) not supported\n",
2256                               msg_header->msg_type);
2257         }
2258 }
2259 static void wcn36xx_ind_smd_work(struct work_struct *work)
2260 {
2261         struct wcn36xx *wcn =
2262                 container_of(work, struct wcn36xx, hal_ind_work);
2263         struct wcn36xx_hal_msg_header *msg_header;
2264         struct wcn36xx_hal_ind_msg *hal_ind_msg;
2265
2266         mutex_lock(&wcn->hal_ind_mutex);
2267
2268         hal_ind_msg = list_first_entry(&wcn->hal_ind_queue,
2269                                        struct wcn36xx_hal_ind_msg,
2270                                        list);
2271
2272         msg_header = (struct wcn36xx_hal_msg_header *)hal_ind_msg->msg;
2273
2274         switch (msg_header->msg_type) {
2275         case WCN36XX_HAL_COEX_IND:
2276         case WCN36XX_HAL_AVOID_FREQ_RANGE_IND:
2277                 break;
2278         case WCN36XX_HAL_OTA_TX_COMPL_IND:
2279                 wcn36xx_smd_tx_compl_ind(wcn,
2280                                          hal_ind_msg->msg,
2281                                          hal_ind_msg->msg_len);
2282                 break;
2283         case WCN36XX_HAL_MISSED_BEACON_IND:
2284                 wcn36xx_smd_missed_beacon_ind(wcn,
2285                                               hal_ind_msg->msg,
2286                                               hal_ind_msg->msg_len);
2287                 break;
2288         case WCN36XX_HAL_DELETE_STA_CONTEXT_IND:
2289                 wcn36xx_smd_delete_sta_context_ind(wcn,
2290                                                    hal_ind_msg->msg,
2291                                                    hal_ind_msg->msg_len);
2292                 break;
2293         default:
2294                 wcn36xx_err("SMD_EVENT (%d) not supported\n",
2295                               msg_header->msg_type);
2296         }
2297         list_del(wcn->hal_ind_queue.next);
2298         kfree(hal_ind_msg->msg);
2299         kfree(hal_ind_msg);
2300         mutex_unlock(&wcn->hal_ind_mutex);
2301 }
2302 int wcn36xx_smd_open(struct wcn36xx *wcn)
2303 {
2304         int ret = 0;
2305         wcn->hal_ind_wq = create_freezable_workqueue("wcn36xx_smd_ind");
2306         if (!wcn->hal_ind_wq) {
2307                 wcn36xx_err("failed to allocate wq\n");
2308                 ret = -ENOMEM;
2309                 goto out;
2310         }
2311         INIT_WORK(&wcn->hal_ind_work, wcn36xx_ind_smd_work);
2312         INIT_LIST_HEAD(&wcn->hal_ind_queue);
2313         mutex_init(&wcn->hal_ind_mutex);
2314
2315         ret = wcn->ctrl_ops->open(wcn, wcn36xx_smd_rsp_process);
2316         if (ret) {
2317                 wcn36xx_err("failed to open control channel\n");
2318                 goto free_wq;
2319         }
2320
2321         return ret;
2322
2323 free_wq:
2324         destroy_workqueue(wcn->hal_ind_wq);
2325 out:
2326         return ret;
2327 }
2328
2329 void wcn36xx_smd_close(struct wcn36xx *wcn)
2330 {
2331         wcn->ctrl_ops->close();
2332         destroy_workqueue(wcn->hal_ind_wq);
2333         mutex_destroy(&wcn->hal_ind_mutex);
2334 }