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 (IEEE80211_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[IEEE80211_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, 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         u32 beacon_length;
1392
1393         mutex_lock(&wcn->hal_mutex);
1394         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SEND_BEACON_REQ);
1395
1396         pvm_len = skb_beacon->data[tim_off + 1] - 3;
1397         pad = TIM_MIN_PVM_SIZE - pvm_len;
1398
1399         /* Padding is irrelevant to mesh mode since tim_off is always 0. */
1400         if (vif->type == NL80211_IFTYPE_MESH_POINT)
1401                 pad = 0;
1402
1403         beacon_length = skb_beacon->len + pad;
1404         msg_body.template_length = beacon_length + sizeof(beacon_length);
1405
1406         if (msg_body.template_length > BEACON_TEMPLATE_SIZE) {
1407                 wcn36xx_err("Beacon is to big: beacon size=%d\n",
1408                               msg_body.template_length);
1409                 ret = -ENOMEM;
1410                 goto out;
1411         }
1412         msg_body.beacon_length = beacon_length;
1413         memcpy(msg_body.beacon, skb_beacon->data, skb_beacon->len);
1414         memcpy(msg_body.bssid, vif->addr, ETH_ALEN);
1415
1416         if (pad > 0) {
1417                 /*
1418                  * The wcn36xx FW has a fixed size for the PVM in the TIM. If
1419                  * given the beacon template from mac80211 with a PVM shorter
1420                  * than the FW expectes it will overwrite the data after the
1421                  * TIM.
1422                  */
1423                 wcn36xx_dbg(WCN36XX_DBG_HAL, "Pad TIM PVM. %d bytes at %d\n",
1424                             pad, pvm_len);
1425                 memmove(&msg_body.beacon[tim_off + 5 + pvm_len + pad],
1426                         &msg_body.beacon[tim_off + 5 + pvm_len],
1427                         skb_beacon->len - (tim_off + 5 + pvm_len));
1428                 memset(&msg_body.beacon[tim_off + 5 + pvm_len], 0, pad);
1429                 msg_body.beacon[tim_off + 1] += pad;
1430         }
1431
1432         /* TODO need to find out why this is needed? */
1433         if (vif->type == NL80211_IFTYPE_MESH_POINT)
1434                 /* mesh beacon don't need this, so push further down */
1435                 msg_body.tim_ie_offset = 256;
1436         else
1437                 msg_body.tim_ie_offset = tim_off+4;
1438         msg_body.p2p_ie_offset = p2p_off;
1439         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1440
1441         wcn36xx_dbg(WCN36XX_DBG_HAL,
1442                     "hal send beacon beacon_length %d\n",
1443                     msg_body.beacon_length);
1444
1445         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1446         if (ret) {
1447                 wcn36xx_err("Sending hal_send_beacon failed\n");
1448                 goto out;
1449         }
1450         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1451         if (ret) {
1452                 wcn36xx_err("hal_send_beacon response failed err=%d\n", ret);
1453                 goto out;
1454         }
1455 out:
1456         mutex_unlock(&wcn->hal_mutex);
1457         return ret;
1458 }
1459
1460 int wcn36xx_smd_update_proberesp_tmpl(struct wcn36xx *wcn,
1461                                       struct ieee80211_vif *vif,
1462                                       struct sk_buff *skb)
1463 {
1464         struct wcn36xx_hal_send_probe_resp_req_msg msg;
1465         int ret = 0;
1466
1467         mutex_lock(&wcn->hal_mutex);
1468         INIT_HAL_MSG(msg, WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_REQ);
1469
1470         if (skb->len > BEACON_TEMPLATE_SIZE) {
1471                 wcn36xx_warn("probe response template is too big: %d\n",
1472                              skb->len);
1473                 ret = -E2BIG;
1474                 goto out;
1475         }
1476
1477         msg.probe_resp_template_len = skb->len;
1478         memcpy(&msg.probe_resp_template, skb->data, skb->len);
1479
1480         memcpy(msg.bssid, vif->addr, ETH_ALEN);
1481
1482         PREPARE_HAL_BUF(wcn->hal_buf, msg);
1483
1484         wcn36xx_dbg(WCN36XX_DBG_HAL,
1485                     "hal update probe rsp len %d bssid %pM\n",
1486                     msg.probe_resp_template_len, msg.bssid);
1487
1488         ret = wcn36xx_smd_send_and_wait(wcn, msg.header.len);
1489         if (ret) {
1490                 wcn36xx_err("Sending hal_update_proberesp_tmpl failed\n");
1491                 goto out;
1492         }
1493         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1494         if (ret) {
1495                 wcn36xx_err("hal_update_proberesp_tmpl response failed err=%d\n",
1496                             ret);
1497                 goto out;
1498         }
1499 out:
1500         mutex_unlock(&wcn->hal_mutex);
1501         return ret;
1502 }
1503
1504 int wcn36xx_smd_set_stakey(struct wcn36xx *wcn,
1505                            enum ani_ed_type enc_type,
1506                            u8 keyidx,
1507                            u8 keylen,
1508                            u8 *key,
1509                            u8 sta_index)
1510 {
1511         struct wcn36xx_hal_set_sta_key_req_msg msg_body;
1512         int ret = 0;
1513
1514         mutex_lock(&wcn->hal_mutex);
1515         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_STAKEY_REQ);
1516
1517         msg_body.set_sta_key_params.sta_index = sta_index;
1518         msg_body.set_sta_key_params.enc_type = enc_type;
1519
1520         msg_body.set_sta_key_params.key[0].id = keyidx;
1521         msg_body.set_sta_key_params.key[0].unicast = 1;
1522         msg_body.set_sta_key_params.key[0].direction = WCN36XX_HAL_TX_RX;
1523         msg_body.set_sta_key_params.key[0].pae_role = 0;
1524         msg_body.set_sta_key_params.key[0].length = keylen;
1525         memcpy(msg_body.set_sta_key_params.key[0].key, key, keylen);
1526         msg_body.set_sta_key_params.single_tid_rc = 1;
1527
1528         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1529
1530         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1531         if (ret) {
1532                 wcn36xx_err("Sending hal_set_stakey failed\n");
1533                 goto out;
1534         }
1535         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1536         if (ret) {
1537                 wcn36xx_err("hal_set_stakey response failed err=%d\n", ret);
1538                 goto out;
1539         }
1540 out:
1541         mutex_unlock(&wcn->hal_mutex);
1542         return ret;
1543 }
1544
1545 int wcn36xx_smd_set_bsskey(struct wcn36xx *wcn,
1546                            enum ani_ed_type enc_type,
1547                            u8 keyidx,
1548                            u8 keylen,
1549                            u8 *key)
1550 {
1551         struct wcn36xx_hal_set_bss_key_req_msg msg_body;
1552         int ret = 0;
1553
1554         mutex_lock(&wcn->hal_mutex);
1555         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_BSSKEY_REQ);
1556         msg_body.bss_idx = 0;
1557         msg_body.enc_type = enc_type;
1558         msg_body.num_keys = 1;
1559         msg_body.keys[0].id = keyidx;
1560         msg_body.keys[0].unicast = 0;
1561         msg_body.keys[0].direction = WCN36XX_HAL_RX_ONLY;
1562         msg_body.keys[0].pae_role = 0;
1563         msg_body.keys[0].length = keylen;
1564         memcpy(msg_body.keys[0].key, key, keylen);
1565
1566         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1567
1568         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1569         if (ret) {
1570                 wcn36xx_err("Sending hal_set_bsskey failed\n");
1571                 goto out;
1572         }
1573         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1574         if (ret) {
1575                 wcn36xx_err("hal_set_bsskey response failed err=%d\n", ret);
1576                 goto out;
1577         }
1578 out:
1579         mutex_unlock(&wcn->hal_mutex);
1580         return ret;
1581 }
1582
1583 int wcn36xx_smd_remove_stakey(struct wcn36xx *wcn,
1584                               enum ani_ed_type enc_type,
1585                               u8 keyidx,
1586                               u8 sta_index)
1587 {
1588         struct wcn36xx_hal_remove_sta_key_req_msg msg_body;
1589         int ret = 0;
1590
1591         mutex_lock(&wcn->hal_mutex);
1592         INIT_HAL_MSG(msg_body, WCN36XX_HAL_RMV_STAKEY_REQ);
1593
1594         msg_body.sta_idx = sta_index;
1595         msg_body.enc_type = enc_type;
1596         msg_body.key_id = keyidx;
1597
1598         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1599
1600         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1601         if (ret) {
1602                 wcn36xx_err("Sending hal_remove_stakey failed\n");
1603                 goto out;
1604         }
1605         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1606         if (ret) {
1607                 wcn36xx_err("hal_remove_stakey response failed err=%d\n", ret);
1608                 goto out;
1609         }
1610 out:
1611         mutex_unlock(&wcn->hal_mutex);
1612         return ret;
1613 }
1614
1615 int wcn36xx_smd_remove_bsskey(struct wcn36xx *wcn,
1616                               enum ani_ed_type enc_type,
1617                               u8 keyidx)
1618 {
1619         struct wcn36xx_hal_remove_bss_key_req_msg msg_body;
1620         int ret = 0;
1621
1622         mutex_lock(&wcn->hal_mutex);
1623         INIT_HAL_MSG(msg_body, WCN36XX_HAL_RMV_BSSKEY_REQ);
1624         msg_body.bss_idx = 0;
1625         msg_body.enc_type = enc_type;
1626         msg_body.key_id = keyidx;
1627
1628         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1629
1630         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1631         if (ret) {
1632                 wcn36xx_err("Sending hal_remove_bsskey failed\n");
1633                 goto out;
1634         }
1635         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1636         if (ret) {
1637                 wcn36xx_err("hal_remove_bsskey response failed err=%d\n", ret);
1638                 goto out;
1639         }
1640 out:
1641         mutex_unlock(&wcn->hal_mutex);
1642         return ret;
1643 }
1644
1645 int wcn36xx_smd_enter_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif)
1646 {
1647         struct wcn36xx_hal_enter_bmps_req_msg msg_body;
1648         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1649         int ret = 0;
1650
1651         mutex_lock(&wcn->hal_mutex);
1652         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ENTER_BMPS_REQ);
1653
1654         msg_body.bss_index = vif_priv->bss_index;
1655         msg_body.tbtt = vif->bss_conf.sync_tsf;
1656         msg_body.dtim_period = vif_priv->dtim_period;
1657
1658         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1659
1660         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1661         if (ret) {
1662                 wcn36xx_err("Sending hal_enter_bmps failed\n");
1663                 goto out;
1664         }
1665         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1666         if (ret) {
1667                 wcn36xx_err("hal_enter_bmps response failed err=%d\n", ret);
1668                 goto out;
1669         }
1670 out:
1671         mutex_unlock(&wcn->hal_mutex);
1672         return ret;
1673 }
1674
1675 int wcn36xx_smd_exit_bmps(struct wcn36xx *wcn, struct ieee80211_vif *vif)
1676 {
1677         struct wcn36xx_hal_exit_bmps_req_msg msg_body;
1678         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1679         int ret = 0;
1680
1681         mutex_lock(&wcn->hal_mutex);
1682         INIT_HAL_MSG(msg_body, WCN36XX_HAL_EXIT_BMPS_REQ);
1683
1684         msg_body.bss_index = vif_priv->bss_index;
1685
1686         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1687
1688         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1689         if (ret) {
1690                 wcn36xx_err("Sending hal_exit_bmps failed\n");
1691                 goto out;
1692         }
1693         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1694         if (ret) {
1695                 wcn36xx_err("hal_exit_bmps response failed err=%d\n", ret);
1696                 goto out;
1697         }
1698 out:
1699         mutex_unlock(&wcn->hal_mutex);
1700         return ret;
1701 }
1702 int wcn36xx_smd_set_power_params(struct wcn36xx *wcn, bool ignore_dtim)
1703 {
1704         struct wcn36xx_hal_set_power_params_req_msg msg_body;
1705         int ret = 0;
1706
1707         mutex_lock(&wcn->hal_mutex);
1708         INIT_HAL_MSG(msg_body, WCN36XX_HAL_SET_POWER_PARAMS_REQ);
1709
1710         /*
1711          * When host is down ignore every second dtim
1712          */
1713         if (ignore_dtim) {
1714                 msg_body.ignore_dtim = 1;
1715                 msg_body.dtim_period = 2;
1716         }
1717         msg_body.listen_interval = WCN36XX_LISTEN_INTERVAL(wcn);
1718
1719         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1720
1721         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1722         if (ret) {
1723                 wcn36xx_err("Sending hal_set_power_params failed\n");
1724                 goto out;
1725         }
1726
1727 out:
1728         mutex_unlock(&wcn->hal_mutex);
1729         return ret;
1730 }
1731 /* Notice: This function should be called after associated, or else it
1732  * will be invalid
1733  */
1734 int wcn36xx_smd_keep_alive_req(struct wcn36xx *wcn,
1735                                struct ieee80211_vif *vif,
1736                                int packet_type)
1737 {
1738         struct wcn36xx_hal_keep_alive_req_msg msg_body;
1739         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
1740         int ret = 0;
1741
1742         mutex_lock(&wcn->hal_mutex);
1743         INIT_HAL_MSG(msg_body, WCN36XX_HAL_KEEP_ALIVE_REQ);
1744
1745         if (packet_type == WCN36XX_HAL_KEEP_ALIVE_NULL_PKT) {
1746                 msg_body.bss_index = vif_priv->bss_index;
1747                 msg_body.packet_type = WCN36XX_HAL_KEEP_ALIVE_NULL_PKT;
1748                 msg_body.time_period = WCN36XX_KEEP_ALIVE_TIME_PERIOD;
1749         } else if (packet_type == WCN36XX_HAL_KEEP_ALIVE_UNSOLICIT_ARP_RSP) {
1750                 /* TODO: it also support ARP response type */
1751         } else {
1752                 wcn36xx_warn("unknown keep alive packet type %d\n", packet_type);
1753                 ret = -EINVAL;
1754                 goto out;
1755         }
1756
1757         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1758
1759         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1760         if (ret) {
1761                 wcn36xx_err("Sending hal_keep_alive failed\n");
1762                 goto out;
1763         }
1764         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1765         if (ret) {
1766                 wcn36xx_err("hal_keep_alive response failed err=%d\n", ret);
1767                 goto out;
1768         }
1769 out:
1770         mutex_unlock(&wcn->hal_mutex);
1771         return ret;
1772 }
1773
1774 int wcn36xx_smd_dump_cmd_req(struct wcn36xx *wcn, u32 arg1, u32 arg2,
1775                              u32 arg3, u32 arg4, u32 arg5)
1776 {
1777         struct wcn36xx_hal_dump_cmd_req_msg msg_body;
1778         int ret = 0;
1779
1780         mutex_lock(&wcn->hal_mutex);
1781         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DUMP_COMMAND_REQ);
1782
1783         msg_body.arg1 = arg1;
1784         msg_body.arg2 = arg2;
1785         msg_body.arg3 = arg3;
1786         msg_body.arg4 = arg4;
1787         msg_body.arg5 = arg5;
1788
1789         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1790
1791         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1792         if (ret) {
1793                 wcn36xx_err("Sending hal_dump_cmd failed\n");
1794                 goto out;
1795         }
1796         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1797         if (ret) {
1798                 wcn36xx_err("hal_dump_cmd response failed err=%d\n", ret);
1799                 goto out;
1800         }
1801 out:
1802         mutex_unlock(&wcn->hal_mutex);
1803         return ret;
1804 }
1805
1806 void set_feat_caps(u32 *bitmap, enum place_holder_in_cap_bitmap cap)
1807 {
1808         int arr_idx, bit_idx;
1809
1810         if (cap < 0 || cap > 127) {
1811                 wcn36xx_warn("error cap idx %d\n", cap);
1812                 return;
1813         }
1814
1815         arr_idx = cap / 32;
1816         bit_idx = cap % 32;
1817         bitmap[arr_idx] |= (1 << bit_idx);
1818 }
1819
1820 int get_feat_caps(u32 *bitmap, enum place_holder_in_cap_bitmap cap)
1821 {
1822         int arr_idx, bit_idx;
1823         int ret = 0;
1824
1825         if (cap < 0 || cap > 127) {
1826                 wcn36xx_warn("error cap idx %d\n", cap);
1827                 return -EINVAL;
1828         }
1829
1830         arr_idx = cap / 32;
1831         bit_idx = cap % 32;
1832         ret = (bitmap[arr_idx] & (1 << bit_idx)) ? 1 : 0;
1833         return ret;
1834 }
1835
1836 void clear_feat_caps(u32 *bitmap, enum place_holder_in_cap_bitmap cap)
1837 {
1838         int arr_idx, bit_idx;
1839
1840         if (cap < 0 || cap > 127) {
1841                 wcn36xx_warn("error cap idx %d\n", cap);
1842                 return;
1843         }
1844
1845         arr_idx = cap / 32;
1846         bit_idx = cap % 32;
1847         bitmap[arr_idx] &= ~(1 << bit_idx);
1848 }
1849
1850 int wcn36xx_smd_feature_caps_exchange(struct wcn36xx *wcn)
1851 {
1852         struct wcn36xx_hal_feat_caps_msg msg_body, *rsp;
1853         int ret = 0, i;
1854
1855         mutex_lock(&wcn->hal_mutex);
1856         INIT_HAL_MSG(msg_body, WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_REQ);
1857
1858         set_feat_caps(msg_body.feat_caps, STA_POWERSAVE);
1859
1860         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1861
1862         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1863         if (ret) {
1864                 wcn36xx_err("Sending hal_feature_caps_exchange failed\n");
1865                 goto out;
1866         }
1867         if (wcn->hal_rsp_len != sizeof(*rsp)) {
1868                 wcn36xx_err("Invalid hal_feature_caps_exchange response");
1869                 goto out;
1870         }
1871
1872         rsp = (struct wcn36xx_hal_feat_caps_msg *) wcn->hal_buf;
1873
1874         for (i = 0; i < WCN36XX_HAL_CAPS_SIZE; i++)
1875                 wcn->fw_feat_caps[i] = rsp->feat_caps[i];
1876 out:
1877         mutex_unlock(&wcn->hal_mutex);
1878         return ret;
1879 }
1880
1881 int wcn36xx_smd_add_ba_session(struct wcn36xx *wcn,
1882                 struct ieee80211_sta *sta,
1883                 u16 tid,
1884                 u16 *ssn,
1885                 u8 direction,
1886                 u8 sta_index)
1887 {
1888         struct wcn36xx_hal_add_ba_session_req_msg msg_body;
1889         int ret = 0;
1890
1891         mutex_lock(&wcn->hal_mutex);
1892         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BA_SESSION_REQ);
1893
1894         msg_body.sta_index = sta_index;
1895         memcpy(&msg_body.mac_addr, sta->addr, ETH_ALEN);
1896         msg_body.dialog_token = 0x10;
1897         msg_body.tid = tid;
1898
1899         /* Immediate BA because Delayed BA is not supported */
1900         msg_body.policy = 1;
1901         msg_body.buffer_size = WCN36XX_AGGR_BUFFER_SIZE;
1902         msg_body.timeout = 0;
1903         if (ssn)
1904                 msg_body.ssn = *ssn;
1905         msg_body.direction = direction;
1906
1907         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1908
1909         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1910         if (ret) {
1911                 wcn36xx_err("Sending hal_add_ba_session failed\n");
1912                 goto out;
1913         }
1914         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1915         if (ret) {
1916                 wcn36xx_err("hal_add_ba_session response failed err=%d\n", ret);
1917                 goto out;
1918         }
1919 out:
1920         mutex_unlock(&wcn->hal_mutex);
1921         return ret;
1922 }
1923
1924 int wcn36xx_smd_add_ba(struct wcn36xx *wcn)
1925 {
1926         struct wcn36xx_hal_add_ba_req_msg msg_body;
1927         int ret = 0;
1928
1929         mutex_lock(&wcn->hal_mutex);
1930         INIT_HAL_MSG(msg_body, WCN36XX_HAL_ADD_BA_REQ);
1931
1932         msg_body.session_id = 0;
1933         msg_body.win_size = WCN36XX_AGGR_BUFFER_SIZE;
1934
1935         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1936
1937         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1938         if (ret) {
1939                 wcn36xx_err("Sending hal_add_ba failed\n");
1940                 goto out;
1941         }
1942         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1943         if (ret) {
1944                 wcn36xx_err("hal_add_ba response failed err=%d\n", ret);
1945                 goto out;
1946         }
1947 out:
1948         mutex_unlock(&wcn->hal_mutex);
1949         return ret;
1950 }
1951
1952 int wcn36xx_smd_del_ba(struct wcn36xx *wcn, u16 tid, u8 sta_index)
1953 {
1954         struct wcn36xx_hal_del_ba_req_msg msg_body;
1955         int ret = 0;
1956
1957         mutex_lock(&wcn->hal_mutex);
1958         INIT_HAL_MSG(msg_body, WCN36XX_HAL_DEL_BA_REQ);
1959
1960         msg_body.sta_index = sta_index;
1961         msg_body.tid = tid;
1962         msg_body.direction = 0;
1963         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
1964
1965         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
1966         if (ret) {
1967                 wcn36xx_err("Sending hal_del_ba failed\n");
1968                 goto out;
1969         }
1970         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
1971         if (ret) {
1972                 wcn36xx_err("hal_del_ba response failed err=%d\n", ret);
1973                 goto out;
1974         }
1975 out:
1976         mutex_unlock(&wcn->hal_mutex);
1977         return ret;
1978 }
1979
1980 static int wcn36xx_smd_trigger_ba_rsp(void *buf, int len)
1981 {
1982         struct wcn36xx_hal_trigger_ba_rsp_msg *rsp;
1983
1984         if (len < sizeof(*rsp))
1985                 return -EINVAL;
1986
1987         rsp = (struct wcn36xx_hal_trigger_ba_rsp_msg *) buf;
1988         return rsp->status;
1989 }
1990
1991 int wcn36xx_smd_trigger_ba(struct wcn36xx *wcn, u8 sta_index)
1992 {
1993         struct wcn36xx_hal_trigger_ba_req_msg msg_body;
1994         struct wcn36xx_hal_trigger_ba_req_candidate *candidate;
1995         int ret = 0;
1996
1997         mutex_lock(&wcn->hal_mutex);
1998         INIT_HAL_MSG(msg_body, WCN36XX_HAL_TRIGGER_BA_REQ);
1999
2000         msg_body.session_id = 0;
2001         msg_body.candidate_cnt = 1;
2002         msg_body.header.len += sizeof(*candidate);
2003         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2004
2005         candidate = (struct wcn36xx_hal_trigger_ba_req_candidate *)
2006                 (wcn->hal_buf + sizeof(msg_body));
2007         candidate->sta_index = sta_index;
2008         candidate->tid_bitmap = 1;
2009
2010         ret = wcn36xx_smd_send_and_wait(wcn, msg_body.header.len);
2011         if (ret) {
2012                 wcn36xx_err("Sending hal_trigger_ba failed\n");
2013                 goto out;
2014         }
2015         ret = wcn36xx_smd_trigger_ba_rsp(wcn->hal_buf, wcn->hal_rsp_len);
2016         if (ret) {
2017                 wcn36xx_err("hal_trigger_ba response failed err=%d\n", ret);
2018                 goto out;
2019         }
2020 out:
2021         mutex_unlock(&wcn->hal_mutex);
2022         return ret;
2023 }
2024
2025 static int wcn36xx_smd_tx_compl_ind(struct wcn36xx *wcn, void *buf, size_t len)
2026 {
2027         struct wcn36xx_hal_tx_compl_ind_msg *rsp = buf;
2028
2029         if (len != sizeof(*rsp)) {
2030                 wcn36xx_warn("Bad TX complete indication\n");
2031                 return -EIO;
2032         }
2033
2034         wcn36xx_dxe_tx_ack_ind(wcn, rsp->status);
2035
2036         return 0;
2037 }
2038
2039 static int wcn36xx_smd_missed_beacon_ind(struct wcn36xx *wcn,
2040                                          void *buf,
2041                                          size_t len)
2042 {
2043         struct wcn36xx_hal_missed_beacon_ind_msg *rsp = buf;
2044         struct ieee80211_vif *vif = NULL;
2045         struct wcn36xx_vif *tmp;
2046
2047         /* Old FW does not have bss index */
2048         if (wcn36xx_is_fw_version(wcn, 1, 2, 2, 24)) {
2049                 list_for_each_entry(tmp, &wcn->vif_list, list) {
2050                         wcn36xx_dbg(WCN36XX_DBG_HAL, "beacon missed bss_index %d\n",
2051                                     tmp->bss_index);
2052                         vif = wcn36xx_priv_to_vif(tmp);
2053                         ieee80211_connection_loss(vif);
2054                 }
2055                 return 0;
2056         }
2057
2058         if (len != sizeof(*rsp)) {
2059                 wcn36xx_warn("Corrupted missed beacon indication\n");
2060                 return -EIO;
2061         }
2062
2063         list_for_each_entry(tmp, &wcn->vif_list, list) {
2064                 if (tmp->bss_index == rsp->bss_index) {
2065                         wcn36xx_dbg(WCN36XX_DBG_HAL, "beacon missed bss_index %d\n",
2066                                     rsp->bss_index);
2067                         vif = wcn36xx_priv_to_vif(tmp);
2068                         ieee80211_connection_loss(vif);
2069                         return 0;
2070                 }
2071         }
2072
2073         wcn36xx_warn("BSS index %d not found\n", rsp->bss_index);
2074         return -ENOENT;
2075 }
2076
2077 static int wcn36xx_smd_delete_sta_context_ind(struct wcn36xx *wcn,
2078                                               void *buf,
2079                                               size_t len)
2080 {
2081         struct wcn36xx_hal_delete_sta_context_ind_msg *rsp = buf;
2082         struct wcn36xx_vif *tmp;
2083         struct ieee80211_sta *sta;
2084
2085         if (len != sizeof(*rsp)) {
2086                 wcn36xx_warn("Corrupted delete sta indication\n");
2087                 return -EIO;
2088         }
2089
2090         wcn36xx_dbg(WCN36XX_DBG_HAL, "delete station indication %pM index %d\n",
2091                     rsp->addr2, rsp->sta_id);
2092
2093         list_for_each_entry(tmp, &wcn->vif_list, list) {
2094                 rcu_read_lock();
2095                 sta = ieee80211_find_sta(wcn36xx_priv_to_vif(tmp), rsp->addr2);
2096                 if (sta)
2097                         ieee80211_report_low_ack(sta, 0);
2098                 rcu_read_unlock();
2099                 if (sta)
2100                         return 0;
2101         }
2102
2103         wcn36xx_warn("STA with addr %pM and index %d not found\n",
2104                      rsp->addr2,
2105                      rsp->sta_id);
2106         return -ENOENT;
2107 }
2108
2109 int wcn36xx_smd_update_cfg(struct wcn36xx *wcn, u32 cfg_id, u32 value)
2110 {
2111         struct wcn36xx_hal_update_cfg_req_msg msg_body, *body;
2112         size_t len;
2113         int ret = 0;
2114
2115         mutex_lock(&wcn->hal_mutex);
2116         INIT_HAL_MSG(msg_body, WCN36XX_HAL_UPDATE_CFG_REQ);
2117
2118         PREPARE_HAL_BUF(wcn->hal_buf, msg_body);
2119
2120         body = (struct wcn36xx_hal_update_cfg_req_msg *) wcn->hal_buf;
2121         len = msg_body.header.len;
2122
2123         put_cfg_tlv_u32(wcn, &len, cfg_id, value);
2124         body->header.len = len;
2125         body->len = len - sizeof(*body);
2126
2127         ret = wcn36xx_smd_send_and_wait(wcn, body->header.len);
2128         if (ret) {
2129                 wcn36xx_err("Sending hal_update_cfg failed\n");
2130                 goto out;
2131         }
2132         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2133         if (ret) {
2134                 wcn36xx_err("hal_update_cfg response failed err=%d\n", ret);
2135                 goto out;
2136         }
2137 out:
2138         mutex_unlock(&wcn->hal_mutex);
2139         return ret;
2140 }
2141
2142 int wcn36xx_smd_set_mc_list(struct wcn36xx *wcn,
2143                             struct ieee80211_vif *vif,
2144                             struct wcn36xx_hal_rcv_flt_mc_addr_list_type *fp)
2145 {
2146         struct wcn36xx_vif *vif_priv = wcn36xx_vif_to_priv(vif);
2147         struct wcn36xx_hal_rcv_flt_pkt_set_mc_list_req_msg *msg_body = NULL;
2148         int ret = 0;
2149
2150         mutex_lock(&wcn->hal_mutex);
2151
2152         msg_body = (struct wcn36xx_hal_rcv_flt_pkt_set_mc_list_req_msg *)
2153                    wcn->hal_buf;
2154         init_hal_msg(&msg_body->header, WCN36XX_HAL_8023_MULTICAST_LIST_REQ,
2155                      sizeof(msg_body->mc_addr_list));
2156
2157         /* An empty list means all mc traffic will be received */
2158         if (fp)
2159                 memcpy(&msg_body->mc_addr_list, fp,
2160                        sizeof(msg_body->mc_addr_list));
2161         else
2162                 msg_body->mc_addr_list.mc_addr_count = 0;
2163
2164         msg_body->mc_addr_list.bss_index = vif_priv->bss_index;
2165
2166         ret = wcn36xx_smd_send_and_wait(wcn, msg_body->header.len);
2167         if (ret) {
2168                 wcn36xx_err("Sending HAL_8023_MULTICAST_LIST failed\n");
2169                 goto out;
2170         }
2171         ret = wcn36xx_smd_rsp_status_check(wcn->hal_buf, wcn->hal_rsp_len);
2172         if (ret) {
2173                 wcn36xx_err("HAL_8023_MULTICAST_LIST rsp failed err=%d\n", ret);
2174                 goto out;
2175         }
2176 out:
2177         mutex_unlock(&wcn->hal_mutex);
2178         return ret;
2179 }
2180
2181 static void wcn36xx_smd_rsp_process(struct wcn36xx *wcn, void *buf, size_t len)
2182 {
2183         struct wcn36xx_hal_msg_header *msg_header = buf;
2184         struct wcn36xx_hal_ind_msg *msg_ind;
2185         wcn36xx_dbg_dump(WCN36XX_DBG_SMD_DUMP, "SMD <<< ", buf, len);
2186
2187         switch (msg_header->msg_type) {
2188         case WCN36XX_HAL_START_RSP:
2189         case WCN36XX_HAL_CONFIG_STA_RSP:
2190         case WCN36XX_HAL_CONFIG_BSS_RSP:
2191         case WCN36XX_HAL_ADD_STA_SELF_RSP:
2192         case WCN36XX_HAL_STOP_RSP:
2193         case WCN36XX_HAL_DEL_STA_SELF_RSP:
2194         case WCN36XX_HAL_DELETE_STA_RSP:
2195         case WCN36XX_HAL_INIT_SCAN_RSP:
2196         case WCN36XX_HAL_START_SCAN_RSP:
2197         case WCN36XX_HAL_END_SCAN_RSP:
2198         case WCN36XX_HAL_FINISH_SCAN_RSP:
2199         case WCN36XX_HAL_DOWNLOAD_NV_RSP:
2200         case WCN36XX_HAL_DELETE_BSS_RSP:
2201         case WCN36XX_HAL_SEND_BEACON_RSP:
2202         case WCN36XX_HAL_SET_LINK_ST_RSP:
2203         case WCN36XX_HAL_UPDATE_PROBE_RSP_TEMPLATE_RSP:
2204         case WCN36XX_HAL_SET_BSSKEY_RSP:
2205         case WCN36XX_HAL_SET_STAKEY_RSP:
2206         case WCN36XX_HAL_RMV_STAKEY_RSP:
2207         case WCN36XX_HAL_RMV_BSSKEY_RSP:
2208         case WCN36XX_HAL_ENTER_BMPS_RSP:
2209         case WCN36XX_HAL_SET_POWER_PARAMS_RSP:
2210         case WCN36XX_HAL_EXIT_BMPS_RSP:
2211         case WCN36XX_HAL_KEEP_ALIVE_RSP:
2212         case WCN36XX_HAL_DUMP_COMMAND_RSP:
2213         case WCN36XX_HAL_ADD_BA_SESSION_RSP:
2214         case WCN36XX_HAL_ADD_BA_RSP:
2215         case WCN36XX_HAL_DEL_BA_RSP:
2216         case WCN36XX_HAL_TRIGGER_BA_RSP:
2217         case WCN36XX_HAL_UPDATE_CFG_RSP:
2218         case WCN36XX_HAL_JOIN_RSP:
2219         case WCN36XX_HAL_UPDATE_SCAN_PARAM_RSP:
2220         case WCN36XX_HAL_CH_SWITCH_RSP:
2221         case WCN36XX_HAL_FEATURE_CAPS_EXCHANGE_RSP:
2222         case WCN36XX_HAL_8023_MULTICAST_LIST_RSP:
2223                 memcpy(wcn->hal_buf, buf, len);
2224                 wcn->hal_rsp_len = len;
2225                 complete(&wcn->hal_rsp_compl);
2226                 break;
2227
2228         case WCN36XX_HAL_DEL_BA_IND:
2229         case WCN36XX_HAL_PRINT_REG_INFO_IND:
2230         case WCN36XX_HAL_COEX_IND:
2231         case WCN36XX_HAL_AVOID_FREQ_RANGE_IND:
2232         case WCN36XX_HAL_OTA_TX_COMPL_IND:
2233         case WCN36XX_HAL_MISSED_BEACON_IND:
2234         case WCN36XX_HAL_DELETE_STA_CONTEXT_IND:
2235                 msg_ind = kmalloc(sizeof(*msg_ind), GFP_KERNEL);
2236                 if (!msg_ind)
2237                         goto nomem;
2238                 msg_ind->msg_len = len;
2239                 msg_ind->msg = kmemdup(buf, len, GFP_KERNEL);
2240                 if (!msg_ind->msg) {
2241                         kfree(msg_ind);
2242 nomem:
2243                         /*
2244                          * FIXME: Do something smarter then just
2245                          * printing an error.
2246                          */
2247                         wcn36xx_err("Run out of memory while handling SMD_EVENT (%d)\n",
2248                                     msg_header->msg_type);
2249                         break;
2250                 }
2251                 mutex_lock(&wcn->hal_ind_mutex);
2252                 list_add_tail(&msg_ind->list, &wcn->hal_ind_queue);
2253                 queue_work(wcn->hal_ind_wq, &wcn->hal_ind_work);
2254                 mutex_unlock(&wcn->hal_ind_mutex);
2255                 wcn36xx_dbg(WCN36XX_DBG_HAL, "indication arrived\n");
2256                 break;
2257         default:
2258                 wcn36xx_err("SMD_EVENT (%d) not supported\n",
2259                               msg_header->msg_type);
2260         }
2261 }
2262 static void wcn36xx_ind_smd_work(struct work_struct *work)
2263 {
2264         struct wcn36xx *wcn =
2265                 container_of(work, struct wcn36xx, hal_ind_work);
2266         struct wcn36xx_hal_msg_header *msg_header;
2267         struct wcn36xx_hal_ind_msg *hal_ind_msg;
2268
2269         mutex_lock(&wcn->hal_ind_mutex);
2270
2271         hal_ind_msg = list_first_entry(&wcn->hal_ind_queue,
2272                                        struct wcn36xx_hal_ind_msg,
2273                                        list);
2274
2275         msg_header = (struct wcn36xx_hal_msg_header *)hal_ind_msg->msg;
2276
2277         switch (msg_header->msg_type) {
2278         case WCN36XX_HAL_DEL_BA_IND:
2279         case WCN36XX_HAL_PRINT_REG_INFO_IND:
2280         case WCN36XX_HAL_COEX_IND:
2281         case WCN36XX_HAL_AVOID_FREQ_RANGE_IND:
2282                 break;
2283         case WCN36XX_HAL_OTA_TX_COMPL_IND:
2284                 wcn36xx_smd_tx_compl_ind(wcn,
2285                                          hal_ind_msg->msg,
2286                                          hal_ind_msg->msg_len);
2287                 break;
2288         case WCN36XX_HAL_MISSED_BEACON_IND:
2289                 wcn36xx_smd_missed_beacon_ind(wcn,
2290                                               hal_ind_msg->msg,
2291                                               hal_ind_msg->msg_len);
2292                 break;
2293         case WCN36XX_HAL_DELETE_STA_CONTEXT_IND:
2294                 wcn36xx_smd_delete_sta_context_ind(wcn,
2295                                                    hal_ind_msg->msg,
2296                                                    hal_ind_msg->msg_len);
2297                 break;
2298         default:
2299                 wcn36xx_err("SMD_EVENT (%d) not supported\n",
2300                               msg_header->msg_type);
2301         }
2302         list_del(wcn->hal_ind_queue.next);
2303         kfree(hal_ind_msg->msg);
2304         kfree(hal_ind_msg);
2305         mutex_unlock(&wcn->hal_ind_mutex);
2306 }
2307 int wcn36xx_smd_open(struct wcn36xx *wcn)
2308 {
2309         int ret = 0;
2310         wcn->hal_ind_wq = create_freezable_workqueue("wcn36xx_smd_ind");
2311         if (!wcn->hal_ind_wq) {
2312                 wcn36xx_err("failed to allocate wq\n");
2313                 ret = -ENOMEM;
2314                 goto out;
2315         }
2316         INIT_WORK(&wcn->hal_ind_work, wcn36xx_ind_smd_work);
2317         INIT_LIST_HEAD(&wcn->hal_ind_queue);
2318         mutex_init(&wcn->hal_ind_mutex);
2319
2320         ret = wcn->ctrl_ops->open(wcn, wcn36xx_smd_rsp_process);
2321         if (ret) {
2322                 wcn36xx_err("failed to open control channel\n");
2323                 goto free_wq;
2324         }
2325
2326         return ret;
2327
2328 free_wq:
2329         destroy_workqueue(wcn->hal_ind_wq);
2330 out:
2331         return ret;
2332 }
2333
2334 void wcn36xx_smd_close(struct wcn36xx *wcn)
2335 {
2336         wcn->ctrl_ops->close(wcn);
2337         destroy_workqueue(wcn->hal_ind_wq);
2338         mutex_destroy(&wcn->hal_ind_mutex);
2339 }