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