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