ath10k: fix hw roc expiration notifcation
[firefly-linux-kernel-4.4.55.git] / drivers / net / wireless / ath / ath10k / mac.c
1 /*
2  * Copyright (c) 2005-2011 Atheros Communications Inc.
3  * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
4  *
5  * Permission to use, copy, modify, and/or distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17
18 #include "mac.h"
19
20 #include <net/mac80211.h>
21 #include <linux/etherdevice.h>
22
23 #include "hif.h"
24 #include "core.h"
25 #include "debug.h"
26 #include "wmi.h"
27 #include "htt.h"
28 #include "txrx.h"
29 #include "testmode.h"
30 #include "wmi.h"
31 #include "wmi-tlv.h"
32 #include "wmi-ops.h"
33 #include "wow.h"
34
35 /*********/
36 /* Rates */
37 /*********/
38
39 static struct ieee80211_rate ath10k_rates[] = {
40         { .bitrate = 10,
41           .hw_value = ATH10K_HW_RATE_CCK_LP_1M },
42         { .bitrate = 20,
43           .hw_value = ATH10K_HW_RATE_CCK_LP_2M,
44           .hw_value_short = ATH10K_HW_RATE_CCK_SP_2M,
45           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
46         { .bitrate = 55,
47           .hw_value = ATH10K_HW_RATE_CCK_LP_5_5M,
48           .hw_value_short = ATH10K_HW_RATE_CCK_SP_5_5M,
49           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
50         { .bitrate = 110,
51           .hw_value = ATH10K_HW_RATE_CCK_LP_11M,
52           .hw_value_short = ATH10K_HW_RATE_CCK_SP_11M,
53           .flags = IEEE80211_RATE_SHORT_PREAMBLE },
54
55         { .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M },
56         { .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M },
57         { .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M },
58         { .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M },
59         { .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M },
60         { .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M },
61         { .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M },
62         { .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M },
63 };
64
65 #define ATH10K_MAC_FIRST_OFDM_RATE_IDX 4
66
67 #define ath10k_a_rates (ath10k_rates + ATH10K_MAC_FIRST_OFDM_RATE_IDX)
68 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - \
69                              ATH10K_MAC_FIRST_OFDM_RATE_IDX)
70 #define ath10k_g_rates (ath10k_rates + 0)
71 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
72
73 static bool ath10k_mac_bitrate_is_cck(int bitrate)
74 {
75         switch (bitrate) {
76         case 10:
77         case 20:
78         case 55:
79         case 110:
80                 return true;
81         }
82
83         return false;
84 }
85
86 static u8 ath10k_mac_bitrate_to_rate(int bitrate)
87 {
88         return DIV_ROUND_UP(bitrate, 5) |
89                (ath10k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);
90 }
91
92 u8 ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,
93                              u8 hw_rate)
94 {
95         const struct ieee80211_rate *rate;
96         int i;
97
98         for (i = 0; i < sband->n_bitrates; i++) {
99                 rate = &sband->bitrates[i];
100
101                 if (rate->hw_value == hw_rate)
102                         return i;
103                 else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
104                          rate->hw_value_short == hw_rate)
105                         return i;
106         }
107
108         return 0;
109 }
110
111 u8 ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
112                              u32 bitrate)
113 {
114         int i;
115
116         for (i = 0; i < sband->n_bitrates; i++)
117                 if (sband->bitrates[i].bitrate == bitrate)
118                         return i;
119
120         return 0;
121 }
122
123 static int ath10k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
124 {
125         switch ((mcs_map >> (2 * nss)) & 0x3) {
126         case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
127         case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
128         case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
129         }
130         return 0;
131 }
132
133 static u32
134 ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
135 {
136         int nss;
137
138         for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
139                 if (ht_mcs_mask[nss])
140                         return nss + 1;
141
142         return 1;
143 }
144
145 static u32
146 ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
147 {
148         int nss;
149
150         for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
151                 if (vht_mcs_mask[nss])
152                         return nss + 1;
153
154         return 1;
155 }
156
157 /**********/
158 /* Crypto */
159 /**********/
160
161 static int ath10k_send_key(struct ath10k_vif *arvif,
162                            struct ieee80211_key_conf *key,
163                            enum set_key_cmd cmd,
164                            const u8 *macaddr, u32 flags)
165 {
166         struct ath10k *ar = arvif->ar;
167         struct wmi_vdev_install_key_arg arg = {
168                 .vdev_id = arvif->vdev_id,
169                 .key_idx = key->keyidx,
170                 .key_len = key->keylen,
171                 .key_data = key->key,
172                 .key_flags = flags,
173                 .macaddr = macaddr,
174         };
175
176         lockdep_assert_held(&arvif->ar->conf_mutex);
177
178         switch (key->cipher) {
179         case WLAN_CIPHER_SUITE_CCMP:
180                 arg.key_cipher = WMI_CIPHER_AES_CCM;
181                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
182                 break;
183         case WLAN_CIPHER_SUITE_TKIP:
184                 arg.key_cipher = WMI_CIPHER_TKIP;
185                 arg.key_txmic_len = 8;
186                 arg.key_rxmic_len = 8;
187                 break;
188         case WLAN_CIPHER_SUITE_WEP40:
189         case WLAN_CIPHER_SUITE_WEP104:
190                 arg.key_cipher = WMI_CIPHER_WEP;
191                 break;
192         case WLAN_CIPHER_SUITE_AES_CMAC:
193                 WARN_ON(1);
194                 return -EINVAL;
195         default:
196                 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
197                 return -EOPNOTSUPP;
198         }
199
200         if (cmd == DISABLE_KEY) {
201                 arg.key_cipher = WMI_CIPHER_NONE;
202                 arg.key_data = NULL;
203         }
204
205         return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
206 }
207
208 static int ath10k_install_key(struct ath10k_vif *arvif,
209                               struct ieee80211_key_conf *key,
210                               enum set_key_cmd cmd,
211                               const u8 *macaddr, u32 flags)
212 {
213         struct ath10k *ar = arvif->ar;
214         int ret;
215         unsigned long time_left;
216
217         lockdep_assert_held(&ar->conf_mutex);
218
219         reinit_completion(&ar->install_key_done);
220
221         ret = ath10k_send_key(arvif, key, cmd, macaddr, flags);
222         if (ret)
223                 return ret;
224
225         time_left = wait_for_completion_timeout(&ar->install_key_done, 3 * HZ);
226         if (time_left == 0)
227                 return -ETIMEDOUT;
228
229         return 0;
230 }
231
232 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
233                                         const u8 *addr)
234 {
235         struct ath10k *ar = arvif->ar;
236         struct ath10k_peer *peer;
237         int ret;
238         int i;
239         u32 flags;
240
241         lockdep_assert_held(&ar->conf_mutex);
242
243         spin_lock_bh(&ar->data_lock);
244         peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
245         spin_unlock_bh(&ar->data_lock);
246
247         if (!peer)
248                 return -ENOENT;
249
250         for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
251                 if (arvif->wep_keys[i] == NULL)
252                         continue;
253
254                 flags = 0;
255                 flags |= WMI_KEY_PAIRWISE;
256
257                 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
258                                          addr, flags);
259                 if (ret)
260                         return ret;
261
262                 flags = 0;
263                 flags |= WMI_KEY_GROUP;
264
265                 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
266                                          addr, flags);
267                 if (ret)
268                         return ret;
269
270                 spin_lock_bh(&ar->data_lock);
271                 peer->keys[i] = arvif->wep_keys[i];
272                 spin_unlock_bh(&ar->data_lock);
273         }
274
275         /* In some cases (notably with static WEP IBSS with multiple keys)
276          * multicast Tx becomes broken. Both pairwise and groupwise keys are
277          * installed already. Using WMI_KEY_TX_USAGE in different combinations
278          * didn't seem help. Using def_keyid vdev parameter seems to be
279          * effective so use that.
280          *
281          * FIXME: Revisit. Perhaps this can be done in a less hacky way.
282          */
283         if (arvif->def_wep_key_idx == -1)
284                 return 0;
285
286         ret = ath10k_wmi_vdev_set_param(arvif->ar,
287                                         arvif->vdev_id,
288                                         arvif->ar->wmi.vdev_param->def_keyid,
289                                         arvif->def_wep_key_idx);
290         if (ret) {
291                 ath10k_warn(ar, "failed to re-set def wpa key idxon vdev %i: %d\n",
292                             arvif->vdev_id, ret);
293                 return ret;
294         }
295
296         return 0;
297 }
298
299 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
300                                   const u8 *addr)
301 {
302         struct ath10k *ar = arvif->ar;
303         struct ath10k_peer *peer;
304         int first_errno = 0;
305         int ret;
306         int i;
307         u32 flags = 0;
308
309         lockdep_assert_held(&ar->conf_mutex);
310
311         spin_lock_bh(&ar->data_lock);
312         peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
313         spin_unlock_bh(&ar->data_lock);
314
315         if (!peer)
316                 return -ENOENT;
317
318         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
319                 if (peer->keys[i] == NULL)
320                         continue;
321
322                 /* key flags are not required to delete the key */
323                 ret = ath10k_install_key(arvif, peer->keys[i],
324                                          DISABLE_KEY, addr, flags);
325                 if (ret && first_errno == 0)
326                         first_errno = ret;
327
328                 if (ret)
329                         ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
330                                     i, ret);
331
332                 spin_lock_bh(&ar->data_lock);
333                 peer->keys[i] = NULL;
334                 spin_unlock_bh(&ar->data_lock);
335         }
336
337         return first_errno;
338 }
339
340 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr,
341                                     u8 keyidx)
342 {
343         struct ath10k_peer *peer;
344         int i;
345
346         lockdep_assert_held(&ar->data_lock);
347
348         /* We don't know which vdev this peer belongs to,
349          * since WMI doesn't give us that information.
350          *
351          * FIXME: multi-bss needs to be handled.
352          */
353         peer = ath10k_peer_find(ar, 0, addr);
354         if (!peer)
355                 return false;
356
357         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
358                 if (peer->keys[i] && peer->keys[i]->keyidx == keyidx)
359                         return true;
360         }
361
362         return false;
363 }
364
365 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
366                                  struct ieee80211_key_conf *key)
367 {
368         struct ath10k *ar = arvif->ar;
369         struct ath10k_peer *peer;
370         u8 addr[ETH_ALEN];
371         int first_errno = 0;
372         int ret;
373         int i;
374         u32 flags = 0;
375
376         lockdep_assert_held(&ar->conf_mutex);
377
378         for (;;) {
379                 /* since ath10k_install_key we can't hold data_lock all the
380                  * time, so we try to remove the keys incrementally */
381                 spin_lock_bh(&ar->data_lock);
382                 i = 0;
383                 list_for_each_entry(peer, &ar->peers, list) {
384                         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
385                                 if (peer->keys[i] == key) {
386                                         ether_addr_copy(addr, peer->addr);
387                                         peer->keys[i] = NULL;
388                                         break;
389                                 }
390                         }
391
392                         if (i < ARRAY_SIZE(peer->keys))
393                                 break;
394                 }
395                 spin_unlock_bh(&ar->data_lock);
396
397                 if (i == ARRAY_SIZE(peer->keys))
398                         break;
399                 /* key flags are not required to delete the key */
400                 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, flags);
401                 if (ret && first_errno == 0)
402                         first_errno = ret;
403
404                 if (ret)
405                         ath10k_warn(ar, "failed to remove key for %pM: %d\n",
406                                     addr, ret);
407         }
408
409         return first_errno;
410 }
411
412 static int ath10k_mac_vif_update_wep_key(struct ath10k_vif *arvif,
413                                          struct ieee80211_key_conf *key)
414 {
415         struct ath10k *ar = arvif->ar;
416         struct ath10k_peer *peer;
417         int ret;
418
419         lockdep_assert_held(&ar->conf_mutex);
420
421         list_for_each_entry(peer, &ar->peers, list) {
422                 if (!memcmp(peer->addr, arvif->vif->addr, ETH_ALEN))
423                         continue;
424
425                 if (!memcmp(peer->addr, arvif->bssid, ETH_ALEN))
426                         continue;
427
428                 if (peer->keys[key->keyidx] == key)
429                         continue;
430
431                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vif vdev %i update key %i needs update\n",
432                            arvif->vdev_id, key->keyidx);
433
434                 ret = ath10k_install_peer_wep_keys(arvif, peer->addr);
435                 if (ret) {
436                         ath10k_warn(ar, "failed to update wep keys on vdev %i for peer %pM: %d\n",
437                                     arvif->vdev_id, peer->addr, ret);
438                         return ret;
439                 }
440         }
441
442         return 0;
443 }
444
445 /*********************/
446 /* General utilities */
447 /*********************/
448
449 static inline enum wmi_phy_mode
450 chan_to_phymode(const struct cfg80211_chan_def *chandef)
451 {
452         enum wmi_phy_mode phymode = MODE_UNKNOWN;
453
454         switch (chandef->chan->band) {
455         case IEEE80211_BAND_2GHZ:
456                 switch (chandef->width) {
457                 case NL80211_CHAN_WIDTH_20_NOHT:
458                         if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM)
459                                 phymode = MODE_11B;
460                         else
461                                 phymode = MODE_11G;
462                         break;
463                 case NL80211_CHAN_WIDTH_20:
464                         phymode = MODE_11NG_HT20;
465                         break;
466                 case NL80211_CHAN_WIDTH_40:
467                         phymode = MODE_11NG_HT40;
468                         break;
469                 case NL80211_CHAN_WIDTH_5:
470                 case NL80211_CHAN_WIDTH_10:
471                 case NL80211_CHAN_WIDTH_80:
472                 case NL80211_CHAN_WIDTH_80P80:
473                 case NL80211_CHAN_WIDTH_160:
474                         phymode = MODE_UNKNOWN;
475                         break;
476                 }
477                 break;
478         case IEEE80211_BAND_5GHZ:
479                 switch (chandef->width) {
480                 case NL80211_CHAN_WIDTH_20_NOHT:
481                         phymode = MODE_11A;
482                         break;
483                 case NL80211_CHAN_WIDTH_20:
484                         phymode = MODE_11NA_HT20;
485                         break;
486                 case NL80211_CHAN_WIDTH_40:
487                         phymode = MODE_11NA_HT40;
488                         break;
489                 case NL80211_CHAN_WIDTH_80:
490                         phymode = MODE_11AC_VHT80;
491                         break;
492                 case NL80211_CHAN_WIDTH_5:
493                 case NL80211_CHAN_WIDTH_10:
494                 case NL80211_CHAN_WIDTH_80P80:
495                 case NL80211_CHAN_WIDTH_160:
496                         phymode = MODE_UNKNOWN;
497                         break;
498                 }
499                 break;
500         default:
501                 break;
502         }
503
504         WARN_ON(phymode == MODE_UNKNOWN);
505         return phymode;
506 }
507
508 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
509 {
510 /*
511  * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
512  *   0 for no restriction
513  *   1 for 1/4 us
514  *   2 for 1/2 us
515  *   3 for 1 us
516  *   4 for 2 us
517  *   5 for 4 us
518  *   6 for 8 us
519  *   7 for 16 us
520  */
521         switch (mpdudensity) {
522         case 0:
523                 return 0;
524         case 1:
525         case 2:
526         case 3:
527         /* Our lower layer calculations limit our precision to
528            1 microsecond */
529                 return 1;
530         case 4:
531                 return 2;
532         case 5:
533                 return 4;
534         case 6:
535                 return 8;
536         case 7:
537                 return 16;
538         default:
539                 return 0;
540         }
541 }
542
543 int ath10k_mac_vif_chan(struct ieee80211_vif *vif,
544                         struct cfg80211_chan_def *def)
545 {
546         struct ieee80211_chanctx_conf *conf;
547
548         rcu_read_lock();
549         conf = rcu_dereference(vif->chanctx_conf);
550         if (!conf) {
551                 rcu_read_unlock();
552                 return -ENOENT;
553         }
554
555         *def = conf->def;
556         rcu_read_unlock();
557
558         return 0;
559 }
560
561 static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw *hw,
562                                          struct ieee80211_chanctx_conf *conf,
563                                          void *data)
564 {
565         int *num = data;
566
567         (*num)++;
568 }
569
570 static int ath10k_mac_num_chanctxs(struct ath10k *ar)
571 {
572         int num = 0;
573
574         ieee80211_iter_chan_contexts_atomic(ar->hw,
575                                             ath10k_mac_num_chanctxs_iter,
576                                             &num);
577
578         return num;
579 }
580
581 static void
582 ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
583                                 struct ieee80211_chanctx_conf *conf,
584                                 void *data)
585 {
586         struct cfg80211_chan_def **def = data;
587
588         *def = &conf->def;
589 }
590
591 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr,
592                               enum wmi_peer_type peer_type)
593 {
594         int ret;
595
596         lockdep_assert_held(&ar->conf_mutex);
597
598         if (ar->num_peers >= ar->max_num_peers)
599                 return -ENOBUFS;
600
601         ret = ath10k_wmi_peer_create(ar, vdev_id, addr, peer_type);
602         if (ret) {
603                 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
604                             addr, vdev_id, ret);
605                 return ret;
606         }
607
608         ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
609         if (ret) {
610                 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
611                             addr, vdev_id, ret);
612                 return ret;
613         }
614
615         ar->num_peers++;
616
617         return 0;
618 }
619
620 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
621 {
622         struct ath10k *ar = arvif->ar;
623         u32 param;
624         int ret;
625
626         param = ar->wmi.pdev_param->sta_kickout_th;
627         ret = ath10k_wmi_pdev_set_param(ar, param,
628                                         ATH10K_KICKOUT_THRESHOLD);
629         if (ret) {
630                 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
631                             arvif->vdev_id, ret);
632                 return ret;
633         }
634
635         param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
636         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
637                                         ATH10K_KEEPALIVE_MIN_IDLE);
638         if (ret) {
639                 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
640                             arvif->vdev_id, ret);
641                 return ret;
642         }
643
644         param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
645         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
646                                         ATH10K_KEEPALIVE_MAX_IDLE);
647         if (ret) {
648                 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
649                             arvif->vdev_id, ret);
650                 return ret;
651         }
652
653         param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
654         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
655                                         ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
656         if (ret) {
657                 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
658                             arvif->vdev_id, ret);
659                 return ret;
660         }
661
662         return 0;
663 }
664
665 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
666 {
667         struct ath10k *ar = arvif->ar;
668         u32 vdev_param;
669
670         vdev_param = ar->wmi.vdev_param->rts_threshold;
671         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
672 }
673
674 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
675 {
676         struct ath10k *ar = arvif->ar;
677         u32 vdev_param;
678
679         if (value != 0xFFFFFFFF)
680                 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
681                                 ATH10K_FRAGMT_THRESHOLD_MIN,
682                                 ATH10K_FRAGMT_THRESHOLD_MAX);
683
684         vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
685         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
686 }
687
688 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
689 {
690         int ret;
691
692         lockdep_assert_held(&ar->conf_mutex);
693
694         ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
695         if (ret)
696                 return ret;
697
698         ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
699         if (ret)
700                 return ret;
701
702         ar->num_peers--;
703
704         return 0;
705 }
706
707 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
708 {
709         struct ath10k_peer *peer, *tmp;
710
711         lockdep_assert_held(&ar->conf_mutex);
712
713         spin_lock_bh(&ar->data_lock);
714         list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
715                 if (peer->vdev_id != vdev_id)
716                         continue;
717
718                 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
719                             peer->addr, vdev_id);
720
721                 list_del(&peer->list);
722                 kfree(peer);
723                 ar->num_peers--;
724         }
725         spin_unlock_bh(&ar->data_lock);
726 }
727
728 static void ath10k_peer_cleanup_all(struct ath10k *ar)
729 {
730         struct ath10k_peer *peer, *tmp;
731
732         lockdep_assert_held(&ar->conf_mutex);
733
734         spin_lock_bh(&ar->data_lock);
735         list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
736                 list_del(&peer->list);
737                 kfree(peer);
738         }
739         spin_unlock_bh(&ar->data_lock);
740
741         ar->num_peers = 0;
742         ar->num_stations = 0;
743 }
744
745 static int ath10k_mac_tdls_peer_update(struct ath10k *ar, u32 vdev_id,
746                                        struct ieee80211_sta *sta,
747                                        enum wmi_tdls_peer_state state)
748 {
749         int ret;
750         struct wmi_tdls_peer_update_cmd_arg arg = {};
751         struct wmi_tdls_peer_capab_arg cap = {};
752         struct wmi_channel_arg chan_arg = {};
753
754         lockdep_assert_held(&ar->conf_mutex);
755
756         arg.vdev_id = vdev_id;
757         arg.peer_state = state;
758         ether_addr_copy(arg.addr, sta->addr);
759
760         cap.peer_max_sp = sta->max_sp;
761         cap.peer_uapsd_queues = sta->uapsd_queues;
762
763         if (state == WMI_TDLS_PEER_STATE_CONNECTED &&
764             !sta->tdls_initiator)
765                 cap.is_peer_responder = 1;
766
767         ret = ath10k_wmi_tdls_peer_update(ar, &arg, &cap, &chan_arg);
768         if (ret) {
769                 ath10k_warn(ar, "failed to update tdls peer %pM on vdev %i: %i\n",
770                             arg.addr, vdev_id, ret);
771                 return ret;
772         }
773
774         return 0;
775 }
776
777 /************************/
778 /* Interface management */
779 /************************/
780
781 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
782 {
783         struct ath10k *ar = arvif->ar;
784
785         lockdep_assert_held(&ar->data_lock);
786
787         if (!arvif->beacon)
788                 return;
789
790         if (!arvif->beacon_buf)
791                 dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
792                                  arvif->beacon->len, DMA_TO_DEVICE);
793
794         if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED &&
795                     arvif->beacon_state != ATH10K_BEACON_SENT))
796                 return;
797
798         dev_kfree_skb_any(arvif->beacon);
799
800         arvif->beacon = NULL;
801         arvif->beacon_state = ATH10K_BEACON_SCHEDULED;
802 }
803
804 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
805 {
806         struct ath10k *ar = arvif->ar;
807
808         lockdep_assert_held(&ar->data_lock);
809
810         ath10k_mac_vif_beacon_free(arvif);
811
812         if (arvif->beacon_buf) {
813                 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
814                                   arvif->beacon_buf, arvif->beacon_paddr);
815                 arvif->beacon_buf = NULL;
816         }
817 }
818
819 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
820 {
821         unsigned long time_left;
822
823         lockdep_assert_held(&ar->conf_mutex);
824
825         if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
826                 return -ESHUTDOWN;
827
828         time_left = wait_for_completion_timeout(&ar->vdev_setup_done,
829                                                 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
830         if (time_left == 0)
831                 return -ETIMEDOUT;
832
833         return 0;
834 }
835
836 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
837 {
838         struct cfg80211_chan_def *chandef = NULL;
839         struct ieee80211_channel *channel = chandef->chan;
840         struct wmi_vdev_start_request_arg arg = {};
841         int ret = 0;
842
843         lockdep_assert_held(&ar->conf_mutex);
844
845         ieee80211_iter_chan_contexts_atomic(ar->hw,
846                                             ath10k_mac_get_any_chandef_iter,
847                                             &chandef);
848         if (WARN_ON_ONCE(!chandef))
849                 return -ENOENT;
850
851         channel = chandef->chan;
852
853         arg.vdev_id = vdev_id;
854         arg.channel.freq = channel->center_freq;
855         arg.channel.band_center_freq1 = chandef->center_freq1;
856
857         /* TODO setup this dynamically, what in case we
858            don't have any vifs? */
859         arg.channel.mode = chan_to_phymode(chandef);
860         arg.channel.chan_radar =
861                         !!(channel->flags & IEEE80211_CHAN_RADAR);
862
863         arg.channel.min_power = 0;
864         arg.channel.max_power = channel->max_power * 2;
865         arg.channel.max_reg_power = channel->max_reg_power * 2;
866         arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
867
868         reinit_completion(&ar->vdev_setup_done);
869
870         ret = ath10k_wmi_vdev_start(ar, &arg);
871         if (ret) {
872                 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
873                             vdev_id, ret);
874                 return ret;
875         }
876
877         ret = ath10k_vdev_setup_sync(ar);
878         if (ret) {
879                 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i start: %d\n",
880                             vdev_id, ret);
881                 return ret;
882         }
883
884         ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
885         if (ret) {
886                 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
887                             vdev_id, ret);
888                 goto vdev_stop;
889         }
890
891         ar->monitor_vdev_id = vdev_id;
892
893         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
894                    ar->monitor_vdev_id);
895         return 0;
896
897 vdev_stop:
898         ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
899         if (ret)
900                 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
901                             ar->monitor_vdev_id, ret);
902
903         return ret;
904 }
905
906 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
907 {
908         int ret = 0;
909
910         lockdep_assert_held(&ar->conf_mutex);
911
912         ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
913         if (ret)
914                 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
915                             ar->monitor_vdev_id, ret);
916
917         reinit_completion(&ar->vdev_setup_done);
918
919         ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
920         if (ret)
921                 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n",
922                             ar->monitor_vdev_id, ret);
923
924         ret = ath10k_vdev_setup_sync(ar);
925         if (ret)
926                 ath10k_warn(ar, "failed to synchronize monitor vdev %i stop: %d\n",
927                             ar->monitor_vdev_id, ret);
928
929         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
930                    ar->monitor_vdev_id);
931         return ret;
932 }
933
934 static int ath10k_monitor_vdev_create(struct ath10k *ar)
935 {
936         int bit, ret = 0;
937
938         lockdep_assert_held(&ar->conf_mutex);
939
940         if (ar->free_vdev_map == 0) {
941                 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
942                 return -ENOMEM;
943         }
944
945         bit = __ffs64(ar->free_vdev_map);
946
947         ar->monitor_vdev_id = bit;
948
949         ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
950                                      WMI_VDEV_TYPE_MONITOR,
951                                      0, ar->mac_addr);
952         if (ret) {
953                 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
954                             ar->monitor_vdev_id, ret);
955                 return ret;
956         }
957
958         ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
959         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
960                    ar->monitor_vdev_id);
961
962         return 0;
963 }
964
965 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
966 {
967         int ret = 0;
968
969         lockdep_assert_held(&ar->conf_mutex);
970
971         ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
972         if (ret) {
973                 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
974                             ar->monitor_vdev_id, ret);
975                 return ret;
976         }
977
978         ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
979
980         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
981                    ar->monitor_vdev_id);
982         return ret;
983 }
984
985 static int ath10k_monitor_start(struct ath10k *ar)
986 {
987         int ret;
988
989         lockdep_assert_held(&ar->conf_mutex);
990
991         ret = ath10k_monitor_vdev_create(ar);
992         if (ret) {
993                 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
994                 return ret;
995         }
996
997         ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
998         if (ret) {
999                 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
1000                 ath10k_monitor_vdev_delete(ar);
1001                 return ret;
1002         }
1003
1004         ar->monitor_started = true;
1005         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
1006
1007         return 0;
1008 }
1009
1010 static int ath10k_monitor_stop(struct ath10k *ar)
1011 {
1012         int ret;
1013
1014         lockdep_assert_held(&ar->conf_mutex);
1015
1016         ret = ath10k_monitor_vdev_stop(ar);
1017         if (ret) {
1018                 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
1019                 return ret;
1020         }
1021
1022         ret = ath10k_monitor_vdev_delete(ar);
1023         if (ret) {
1024                 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
1025                 return ret;
1026         }
1027
1028         ar->monitor_started = false;
1029         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
1030
1031         return 0;
1032 }
1033
1034 static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k *ar)
1035 {
1036         int num_ctx;
1037
1038         /* At least one chanctx is required to derive a channel to start
1039          * monitor vdev on.
1040          */
1041         num_ctx = ath10k_mac_num_chanctxs(ar);
1042         if (num_ctx == 0)
1043                 return false;
1044
1045         /* If there's already an existing special monitor interface then don't
1046          * bother creating another monitor vdev.
1047          */
1048         if (ar->monitor_arvif)
1049                 return false;
1050
1051         return ar->monitor ||
1052                test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1053 }
1054
1055 static bool ath10k_mac_monitor_vdev_is_allowed(struct ath10k *ar)
1056 {
1057         int num_ctx;
1058
1059         num_ctx = ath10k_mac_num_chanctxs(ar);
1060
1061         /* FIXME: Current interface combinations and cfg80211/mac80211 code
1062          * shouldn't allow this but make sure to prevent handling the following
1063          * case anyway since multi-channel DFS hasn't been tested at all.
1064          */
1065         if (test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags) && num_ctx > 1)
1066                 return false;
1067
1068         return true;
1069 }
1070
1071 static int ath10k_monitor_recalc(struct ath10k *ar)
1072 {
1073         bool needed;
1074         bool allowed;
1075         int ret;
1076
1077         lockdep_assert_held(&ar->conf_mutex);
1078
1079         needed = ath10k_mac_monitor_vdev_is_needed(ar);
1080         allowed = ath10k_mac_monitor_vdev_is_allowed(ar);
1081
1082         ath10k_dbg(ar, ATH10K_DBG_MAC,
1083                    "mac monitor recalc started? %d needed? %d allowed? %d\n",
1084                    ar->monitor_started, needed, allowed);
1085
1086         if (WARN_ON(needed && !allowed)) {
1087                 if (ar->monitor_started) {
1088                         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopping disallowed monitor\n");
1089
1090                         ret = ath10k_monitor_stop(ar);
1091                         if (ret)
1092                                 ath10k_warn(ar, "failed to stop disallowed monitor: %d\n", ret);
1093                                 /* not serious */
1094                 }
1095
1096                 return -EPERM;
1097         }
1098
1099         if (needed == ar->monitor_started)
1100                 return 0;
1101
1102         if (needed)
1103                 return ath10k_monitor_start(ar);
1104         else
1105                 return ath10k_monitor_stop(ar);
1106 }
1107
1108 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
1109 {
1110         struct ath10k *ar = arvif->ar;
1111         u32 vdev_param, rts_cts = 0;
1112
1113         lockdep_assert_held(&ar->conf_mutex);
1114
1115         vdev_param = ar->wmi.vdev_param->enable_rtscts;
1116
1117         rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
1118
1119         if (arvif->num_legacy_stations > 0)
1120                 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
1121                               WMI_RTSCTS_PROFILE);
1122         else
1123                 rts_cts |= SM(WMI_RTSCTS_FOR_SECOND_RATESERIES,
1124                               WMI_RTSCTS_PROFILE);
1125
1126         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
1127                                          rts_cts);
1128 }
1129
1130 static int ath10k_start_cac(struct ath10k *ar)
1131 {
1132         int ret;
1133
1134         lockdep_assert_held(&ar->conf_mutex);
1135
1136         set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1137
1138         ret = ath10k_monitor_recalc(ar);
1139         if (ret) {
1140                 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
1141                 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1142                 return ret;
1143         }
1144
1145         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
1146                    ar->monitor_vdev_id);
1147
1148         return 0;
1149 }
1150
1151 static int ath10k_stop_cac(struct ath10k *ar)
1152 {
1153         lockdep_assert_held(&ar->conf_mutex);
1154
1155         /* CAC is not running - do nothing */
1156         if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
1157                 return 0;
1158
1159         clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1160         ath10k_monitor_stop(ar);
1161
1162         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
1163
1164         return 0;
1165 }
1166
1167 static void ath10k_mac_has_radar_iter(struct ieee80211_hw *hw,
1168                                       struct ieee80211_chanctx_conf *conf,
1169                                       void *data)
1170 {
1171         bool *ret = data;
1172
1173         if (!*ret && conf->radar_enabled)
1174                 *ret = true;
1175 }
1176
1177 static bool ath10k_mac_has_radar_enabled(struct ath10k *ar)
1178 {
1179         bool has_radar = false;
1180
1181         ieee80211_iter_chan_contexts_atomic(ar->hw,
1182                                             ath10k_mac_has_radar_iter,
1183                                             &has_radar);
1184
1185         return has_radar;
1186 }
1187
1188 static void ath10k_recalc_radar_detection(struct ath10k *ar)
1189 {
1190         int ret;
1191
1192         lockdep_assert_held(&ar->conf_mutex);
1193
1194         ath10k_stop_cac(ar);
1195
1196         if (!ath10k_mac_has_radar_enabled(ar))
1197                 return;
1198
1199         if (ar->num_started_vdevs > 0)
1200                 return;
1201
1202         ret = ath10k_start_cac(ar);
1203         if (ret) {
1204                 /*
1205                  * Not possible to start CAC on current channel so starting
1206                  * radiation is not allowed, make this channel DFS_UNAVAILABLE
1207                  * by indicating that radar was detected.
1208                  */
1209                 ath10k_warn(ar, "failed to start CAC: %d\n", ret);
1210                 ieee80211_radar_detected(ar->hw);
1211         }
1212 }
1213
1214 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
1215 {
1216         struct ath10k *ar = arvif->ar;
1217         int ret;
1218
1219         lockdep_assert_held(&ar->conf_mutex);
1220
1221         reinit_completion(&ar->vdev_setup_done);
1222
1223         ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
1224         if (ret) {
1225                 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
1226                             arvif->vdev_id, ret);
1227                 return ret;
1228         }
1229
1230         ret = ath10k_vdev_setup_sync(ar);
1231         if (ret) {
1232                 ath10k_warn(ar, "failed to syncronise setup for vdev %i: %d\n",
1233                             arvif->vdev_id, ret);
1234                 return ret;
1235         }
1236
1237         WARN_ON(ar->num_started_vdevs == 0);
1238
1239         if (ar->num_started_vdevs != 0) {
1240                 ar->num_started_vdevs--;
1241                 ath10k_recalc_radar_detection(ar);
1242         }
1243
1244         return ret;
1245 }
1246
1247 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif,
1248                                      const struct cfg80211_chan_def *chandef,
1249                                      bool restart)
1250 {
1251         struct ath10k *ar = arvif->ar;
1252         struct wmi_vdev_start_request_arg arg = {};
1253         int ret = 0;
1254
1255         lockdep_assert_held(&ar->conf_mutex);
1256
1257         reinit_completion(&ar->vdev_setup_done);
1258
1259         arg.vdev_id = arvif->vdev_id;
1260         arg.dtim_period = arvif->dtim_period;
1261         arg.bcn_intval = arvif->beacon_interval;
1262
1263         arg.channel.freq = chandef->chan->center_freq;
1264         arg.channel.band_center_freq1 = chandef->center_freq1;
1265         arg.channel.mode = chan_to_phymode(chandef);
1266
1267         arg.channel.min_power = 0;
1268         arg.channel.max_power = chandef->chan->max_power * 2;
1269         arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
1270         arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
1271
1272         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
1273                 arg.ssid = arvif->u.ap.ssid;
1274                 arg.ssid_len = arvif->u.ap.ssid_len;
1275                 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
1276
1277                 /* For now allow DFS for AP mode */
1278                 arg.channel.chan_radar =
1279                         !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
1280         } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
1281                 arg.ssid = arvif->vif->bss_conf.ssid;
1282                 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
1283         }
1284
1285         ath10k_dbg(ar, ATH10K_DBG_MAC,
1286                    "mac vdev %d start center_freq %d phymode %s\n",
1287                    arg.vdev_id, arg.channel.freq,
1288                    ath10k_wmi_phymode_str(arg.channel.mode));
1289
1290         if (restart)
1291                 ret = ath10k_wmi_vdev_restart(ar, &arg);
1292         else
1293                 ret = ath10k_wmi_vdev_start(ar, &arg);
1294
1295         if (ret) {
1296                 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
1297                             arg.vdev_id, ret);
1298                 return ret;
1299         }
1300
1301         ret = ath10k_vdev_setup_sync(ar);
1302         if (ret) {
1303                 ath10k_warn(ar,
1304                             "failed to synchronize setup for vdev %i restart %d: %d\n",
1305                             arg.vdev_id, restart, ret);
1306                 return ret;
1307         }
1308
1309         ar->num_started_vdevs++;
1310         ath10k_recalc_radar_detection(ar);
1311
1312         return ret;
1313 }
1314
1315 static int ath10k_vdev_start(struct ath10k_vif *arvif,
1316                              const struct cfg80211_chan_def *def)
1317 {
1318         return ath10k_vdev_start_restart(arvif, def, false);
1319 }
1320
1321 static int ath10k_vdev_restart(struct ath10k_vif *arvif,
1322                                const struct cfg80211_chan_def *def)
1323 {
1324         return ath10k_vdev_start_restart(arvif, def, true);
1325 }
1326
1327 static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif *arvif,
1328                                        struct sk_buff *bcn)
1329 {
1330         struct ath10k *ar = arvif->ar;
1331         struct ieee80211_mgmt *mgmt;
1332         const u8 *p2p_ie;
1333         int ret;
1334
1335         if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1336                 return 0;
1337
1338         if (arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1339                 return 0;
1340
1341         mgmt = (void *)bcn->data;
1342         p2p_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1343                                          mgmt->u.beacon.variable,
1344                                          bcn->len - (mgmt->u.beacon.variable -
1345                                                      bcn->data));
1346         if (!p2p_ie)
1347                 return -ENOENT;
1348
1349         ret = ath10k_wmi_p2p_go_bcn_ie(ar, arvif->vdev_id, p2p_ie);
1350         if (ret) {
1351                 ath10k_warn(ar, "failed to submit p2p go bcn ie for vdev %i: %d\n",
1352                             arvif->vdev_id, ret);
1353                 return ret;
1354         }
1355
1356         return 0;
1357 }
1358
1359 static int ath10k_mac_remove_vendor_ie(struct sk_buff *skb, unsigned int oui,
1360                                        u8 oui_type, size_t ie_offset)
1361 {
1362         size_t len;
1363         const u8 *next;
1364         const u8 *end;
1365         u8 *ie;
1366
1367         if (WARN_ON(skb->len < ie_offset))
1368                 return -EINVAL;
1369
1370         ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
1371                                            skb->data + ie_offset,
1372                                            skb->len - ie_offset);
1373         if (!ie)
1374                 return -ENOENT;
1375
1376         len = ie[1] + 2;
1377         end = skb->data + skb->len;
1378         next = ie + len;
1379
1380         if (WARN_ON(next > end))
1381                 return -EINVAL;
1382
1383         memmove(ie, next, end - next);
1384         skb_trim(skb, skb->len - len);
1385
1386         return 0;
1387 }
1388
1389 static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif *arvif)
1390 {
1391         struct ath10k *ar = arvif->ar;
1392         struct ieee80211_hw *hw = ar->hw;
1393         struct ieee80211_vif *vif = arvif->vif;
1394         struct ieee80211_mutable_offsets offs = {};
1395         struct sk_buff *bcn;
1396         int ret;
1397
1398         if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1399                 return 0;
1400
1401         if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
1402             arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
1403                 return 0;
1404
1405         bcn = ieee80211_beacon_get_template(hw, vif, &offs);
1406         if (!bcn) {
1407                 ath10k_warn(ar, "failed to get beacon template from mac80211\n");
1408                 return -EPERM;
1409         }
1410
1411         ret = ath10k_mac_setup_bcn_p2p_ie(arvif, bcn);
1412         if (ret) {
1413                 ath10k_warn(ar, "failed to setup p2p go bcn ie: %d\n", ret);
1414                 kfree_skb(bcn);
1415                 return ret;
1416         }
1417
1418         /* P2P IE is inserted by firmware automatically (as configured above)
1419          * so remove it from the base beacon template to avoid duplicate P2P
1420          * IEs in beacon frames.
1421          */
1422         ath10k_mac_remove_vendor_ie(bcn, WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1423                                     offsetof(struct ieee80211_mgmt,
1424                                              u.beacon.variable));
1425
1426         ret = ath10k_wmi_bcn_tmpl(ar, arvif->vdev_id, offs.tim_offset, bcn, 0,
1427                                   0, NULL, 0);
1428         kfree_skb(bcn);
1429
1430         if (ret) {
1431                 ath10k_warn(ar, "failed to submit beacon template command: %d\n",
1432                             ret);
1433                 return ret;
1434         }
1435
1436         return 0;
1437 }
1438
1439 static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif *arvif)
1440 {
1441         struct ath10k *ar = arvif->ar;
1442         struct ieee80211_hw *hw = ar->hw;
1443         struct ieee80211_vif *vif = arvif->vif;
1444         struct sk_buff *prb;
1445         int ret;
1446
1447         if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1448                 return 0;
1449
1450         if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1451                 return 0;
1452
1453         prb = ieee80211_proberesp_get(hw, vif);
1454         if (!prb) {
1455                 ath10k_warn(ar, "failed to get probe resp template from mac80211\n");
1456                 return -EPERM;
1457         }
1458
1459         ret = ath10k_wmi_prb_tmpl(ar, arvif->vdev_id, prb);
1460         kfree_skb(prb);
1461
1462         if (ret) {
1463                 ath10k_warn(ar, "failed to submit probe resp template command: %d\n",
1464                             ret);
1465                 return ret;
1466         }
1467
1468         return 0;
1469 }
1470
1471 static int ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif *arvif)
1472 {
1473         struct ath10k *ar = arvif->ar;
1474         struct cfg80211_chan_def def;
1475         int ret;
1476
1477         /* When originally vdev is started during assign_vif_chanctx() some
1478          * information is missing, notably SSID. Firmware revisions with beacon
1479          * offloading require the SSID to be provided during vdev (re)start to
1480          * handle hidden SSID properly.
1481          *
1482          * Vdev restart must be done after vdev has been both started and
1483          * upped. Otherwise some firmware revisions (at least 10.2) fail to
1484          * deliver vdev restart response event causing timeouts during vdev
1485          * syncing in ath10k.
1486          *
1487          * Note: The vdev down/up and template reinstallation could be skipped
1488          * since only wmi-tlv firmware are known to have beacon offload and
1489          * wmi-tlv doesn't seem to misbehave like 10.2 wrt vdev restart
1490          * response delivery. It's probably more robust to keep it as is.
1491          */
1492         if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1493                 return 0;
1494
1495         if (WARN_ON(!arvif->is_started))
1496                 return -EINVAL;
1497
1498         if (WARN_ON(!arvif->is_up))
1499                 return -EINVAL;
1500
1501         if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
1502                 return -EINVAL;
1503
1504         ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1505         if (ret) {
1506                 ath10k_warn(ar, "failed to bring down ap vdev %i: %d\n",
1507                             arvif->vdev_id, ret);
1508                 return ret;
1509         }
1510
1511         /* Vdev down reset beacon & presp templates. Reinstall them. Otherwise
1512          * firmware will crash upon vdev up.
1513          */
1514
1515         ret = ath10k_mac_setup_bcn_tmpl(arvif);
1516         if (ret) {
1517                 ath10k_warn(ar, "failed to update beacon template: %d\n", ret);
1518                 return ret;
1519         }
1520
1521         ret = ath10k_mac_setup_prb_tmpl(arvif);
1522         if (ret) {
1523                 ath10k_warn(ar, "failed to update presp template: %d\n", ret);
1524                 return ret;
1525         }
1526
1527         ret = ath10k_vdev_restart(arvif, &def);
1528         if (ret) {
1529                 ath10k_warn(ar, "failed to restart ap vdev %i: %d\n",
1530                             arvif->vdev_id, ret);
1531                 return ret;
1532         }
1533
1534         ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1535                                  arvif->bssid);
1536         if (ret) {
1537                 ath10k_warn(ar, "failed to bring up ap vdev %i: %d\n",
1538                             arvif->vdev_id, ret);
1539                 return ret;
1540         }
1541
1542         return 0;
1543 }
1544
1545 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
1546                                      struct ieee80211_bss_conf *info)
1547 {
1548         struct ath10k *ar = arvif->ar;
1549         int ret = 0;
1550
1551         lockdep_assert_held(&arvif->ar->conf_mutex);
1552
1553         if (!info->enable_beacon) {
1554                 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1555                 if (ret)
1556                         ath10k_warn(ar, "failed to down vdev_id %i: %d\n",
1557                                     arvif->vdev_id, ret);
1558
1559                 arvif->is_up = false;
1560
1561                 spin_lock_bh(&arvif->ar->data_lock);
1562                 ath10k_mac_vif_beacon_free(arvif);
1563                 spin_unlock_bh(&arvif->ar->data_lock);
1564
1565                 return;
1566         }
1567
1568         arvif->tx_seq_no = 0x1000;
1569
1570         arvif->aid = 0;
1571         ether_addr_copy(arvif->bssid, info->bssid);
1572
1573         ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1574                                  arvif->bssid);
1575         if (ret) {
1576                 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
1577                             arvif->vdev_id, ret);
1578                 return;
1579         }
1580
1581         arvif->is_up = true;
1582
1583         ret = ath10k_mac_vif_fix_hidden_ssid(arvif);
1584         if (ret) {
1585                 ath10k_warn(ar, "failed to fix hidden ssid for vdev %i, expect trouble: %d\n",
1586                             arvif->vdev_id, ret);
1587                 return;
1588         }
1589
1590         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
1591 }
1592
1593 static void ath10k_control_ibss(struct ath10k_vif *arvif,
1594                                 struct ieee80211_bss_conf *info,
1595                                 const u8 self_peer[ETH_ALEN])
1596 {
1597         struct ath10k *ar = arvif->ar;
1598         u32 vdev_param;
1599         int ret = 0;
1600
1601         lockdep_assert_held(&arvif->ar->conf_mutex);
1602
1603         if (!info->ibss_joined) {
1604                 if (is_zero_ether_addr(arvif->bssid))
1605                         return;
1606
1607                 eth_zero_addr(arvif->bssid);
1608
1609                 return;
1610         }
1611
1612         vdev_param = arvif->ar->wmi.vdev_param->atim_window;
1613         ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
1614                                         ATH10K_DEFAULT_ATIM);
1615         if (ret)
1616                 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
1617                             arvif->vdev_id, ret);
1618 }
1619
1620 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif)
1621 {
1622         struct ath10k *ar = arvif->ar;
1623         u32 param;
1624         u32 value;
1625         int ret;
1626
1627         lockdep_assert_held(&arvif->ar->conf_mutex);
1628
1629         if (arvif->u.sta.uapsd)
1630                 value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER;
1631         else
1632                 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
1633
1634         param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
1635         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value);
1636         if (ret) {
1637                 ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n",
1638                             value, arvif->vdev_id, ret);
1639                 return ret;
1640         }
1641
1642         return 0;
1643 }
1644
1645 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif)
1646 {
1647         struct ath10k *ar = arvif->ar;
1648         u32 param;
1649         u32 value;
1650         int ret;
1651
1652         lockdep_assert_held(&arvif->ar->conf_mutex);
1653
1654         if (arvif->u.sta.uapsd)
1655                 value = WMI_STA_PS_PSPOLL_COUNT_UAPSD;
1656         else
1657                 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
1658
1659         param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
1660         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1661                                           param, value);
1662         if (ret) {
1663                 ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n",
1664                             value, arvif->vdev_id, ret);
1665                 return ret;
1666         }
1667
1668         return 0;
1669 }
1670
1671 static int ath10k_mac_num_vifs_started(struct ath10k *ar)
1672 {
1673         struct ath10k_vif *arvif;
1674         int num = 0;
1675
1676         lockdep_assert_held(&ar->conf_mutex);
1677
1678         list_for_each_entry(arvif, &ar->arvifs, list)
1679                 if (arvif->is_started)
1680                         num++;
1681
1682         return num;
1683 }
1684
1685 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1686 {
1687         struct ath10k *ar = arvif->ar;
1688         struct ieee80211_vif *vif = arvif->vif;
1689         struct ieee80211_conf *conf = &ar->hw->conf;
1690         enum wmi_sta_powersave_param param;
1691         enum wmi_sta_ps_mode psmode;
1692         int ret;
1693         int ps_timeout;
1694         bool enable_ps;
1695
1696         lockdep_assert_held(&arvif->ar->conf_mutex);
1697
1698         if (arvif->vif->type != NL80211_IFTYPE_STATION)
1699                 return 0;
1700
1701         enable_ps = arvif->ps;
1702
1703         if (enable_ps && ath10k_mac_num_vifs_started(ar) > 1 &&
1704             !test_bit(ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT,
1705                       ar->fw_features)) {
1706                 ath10k_warn(ar, "refusing to enable ps on vdev %i: not supported by fw\n",
1707                             arvif->vdev_id);
1708                 enable_ps = false;
1709         }
1710
1711         if (!arvif->is_started) {
1712                 /* mac80211 can update vif powersave state while disconnected.
1713                  * Firmware doesn't behave nicely and consumes more power than
1714                  * necessary if PS is disabled on a non-started vdev. Hence
1715                  * force-enable PS for non-running vdevs.
1716                  */
1717                 psmode = WMI_STA_PS_MODE_ENABLED;
1718         } else if (enable_ps) {
1719                 psmode = WMI_STA_PS_MODE_ENABLED;
1720                 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1721
1722                 ps_timeout = conf->dynamic_ps_timeout;
1723                 if (ps_timeout == 0) {
1724                         /* Firmware doesn't like 0 */
1725                         ps_timeout = ieee80211_tu_to_usec(
1726                                 vif->bss_conf.beacon_int) / 1000;
1727                 }
1728
1729                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1730                                                   ps_timeout);
1731                 if (ret) {
1732                         ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
1733                                     arvif->vdev_id, ret);
1734                         return ret;
1735                 }
1736         } else {
1737                 psmode = WMI_STA_PS_MODE_DISABLED;
1738         }
1739
1740         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1741                    arvif->vdev_id, psmode ? "enable" : "disable");
1742
1743         ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1744         if (ret) {
1745                 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
1746                             psmode, arvif->vdev_id, ret);
1747                 return ret;
1748         }
1749
1750         return 0;
1751 }
1752
1753 static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif *arvif)
1754 {
1755         struct ath10k *ar = arvif->ar;
1756         struct wmi_sta_keepalive_arg arg = {};
1757         int ret;
1758
1759         lockdep_assert_held(&arvif->ar->conf_mutex);
1760
1761         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
1762                 return 0;
1763
1764         if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE, ar->wmi.svc_map))
1765                 return 0;
1766
1767         /* Some firmware revisions have a bug and ignore the `enabled` field.
1768          * Instead use the interval to disable the keepalive.
1769          */
1770         arg.vdev_id = arvif->vdev_id;
1771         arg.enabled = 1;
1772         arg.method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;
1773         arg.interval = WMI_STA_KEEPALIVE_INTERVAL_DISABLE;
1774
1775         ret = ath10k_wmi_sta_keepalive(ar, &arg);
1776         if (ret) {
1777                 ath10k_warn(ar, "failed to submit keepalive on vdev %i: %d\n",
1778                             arvif->vdev_id, ret);
1779                 return ret;
1780         }
1781
1782         return 0;
1783 }
1784
1785 static void ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif *arvif)
1786 {
1787         struct ath10k *ar = arvif->ar;
1788         struct ieee80211_vif *vif = arvif->vif;
1789         int ret;
1790
1791         lockdep_assert_held(&arvif->ar->conf_mutex);
1792
1793         if (WARN_ON(!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)))
1794                 return;
1795
1796         if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1797                 return;
1798
1799         if (!vif->csa_active)
1800                 return;
1801
1802         if (!arvif->is_up)
1803                 return;
1804
1805         if (!ieee80211_csa_is_complete(vif)) {
1806                 ieee80211_csa_update_counter(vif);
1807
1808                 ret = ath10k_mac_setup_bcn_tmpl(arvif);
1809                 if (ret)
1810                         ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
1811                                     ret);
1812
1813                 ret = ath10k_mac_setup_prb_tmpl(arvif);
1814                 if (ret)
1815                         ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
1816                                     ret);
1817         } else {
1818                 ieee80211_csa_finish(vif);
1819         }
1820 }
1821
1822 static void ath10k_mac_vif_ap_csa_work(struct work_struct *work)
1823 {
1824         struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1825                                                 ap_csa_work);
1826         struct ath10k *ar = arvif->ar;
1827
1828         mutex_lock(&ar->conf_mutex);
1829         ath10k_mac_vif_ap_csa_count_down(arvif);
1830         mutex_unlock(&ar->conf_mutex);
1831 }
1832
1833 static void ath10k_mac_handle_beacon_iter(void *data, u8 *mac,
1834                                           struct ieee80211_vif *vif)
1835 {
1836         struct sk_buff *skb = data;
1837         struct ieee80211_mgmt *mgmt = (void *)skb->data;
1838         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1839
1840         if (vif->type != NL80211_IFTYPE_STATION)
1841                 return;
1842
1843         if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))
1844                 return;
1845
1846         cancel_delayed_work(&arvif->connection_loss_work);
1847 }
1848
1849 void ath10k_mac_handle_beacon(struct ath10k *ar, struct sk_buff *skb)
1850 {
1851         ieee80211_iterate_active_interfaces_atomic(ar->hw,
1852                                                    IEEE80211_IFACE_ITER_NORMAL,
1853                                                    ath10k_mac_handle_beacon_iter,
1854                                                    skb);
1855 }
1856
1857 static void ath10k_mac_handle_beacon_miss_iter(void *data, u8 *mac,
1858                                                struct ieee80211_vif *vif)
1859 {
1860         u32 *vdev_id = data;
1861         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1862         struct ath10k *ar = arvif->ar;
1863         struct ieee80211_hw *hw = ar->hw;
1864
1865         if (arvif->vdev_id != *vdev_id)
1866                 return;
1867
1868         if (!arvif->is_up)
1869                 return;
1870
1871         ieee80211_beacon_loss(vif);
1872
1873         /* Firmware doesn't report beacon loss events repeatedly. If AP probe
1874          * (done by mac80211) succeeds but beacons do not resume then it
1875          * doesn't make sense to continue operation. Queue connection loss work
1876          * which can be cancelled when beacon is received.
1877          */
1878         ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,
1879                                      ATH10K_CONNECTION_LOSS_HZ);
1880 }
1881
1882 void ath10k_mac_handle_beacon_miss(struct ath10k *ar, u32 vdev_id)
1883 {
1884         ieee80211_iterate_active_interfaces_atomic(ar->hw,
1885                                                    IEEE80211_IFACE_ITER_NORMAL,
1886                                                    ath10k_mac_handle_beacon_miss_iter,
1887                                                    &vdev_id);
1888 }
1889
1890 static void ath10k_mac_vif_sta_connection_loss_work(struct work_struct *work)
1891 {
1892         struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1893                                                 connection_loss_work.work);
1894         struct ieee80211_vif *vif = arvif->vif;
1895
1896         if (!arvif->is_up)
1897                 return;
1898
1899         ieee80211_connection_loss(vif);
1900 }
1901
1902 /**********************/
1903 /* Station management */
1904 /**********************/
1905
1906 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,
1907                                              struct ieee80211_vif *vif)
1908 {
1909         /* Some firmware revisions have unstable STA powersave when listen
1910          * interval is set too high (e.g. 5). The symptoms are firmware doesn't
1911          * generate NullFunc frames properly even if buffered frames have been
1912          * indicated in Beacon TIM. Firmware would seldom wake up to pull
1913          * buffered frames. Often pinging the device from AP would simply fail.
1914          *
1915          * As a workaround set it to 1.
1916          */
1917         if (vif->type == NL80211_IFTYPE_STATION)
1918                 return 1;
1919
1920         return ar->hw->conf.listen_interval;
1921 }
1922
1923 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1924                                       struct ieee80211_vif *vif,
1925                                       struct ieee80211_sta *sta,
1926                                       struct wmi_peer_assoc_complete_arg *arg)
1927 {
1928         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1929         u32 aid;
1930
1931         lockdep_assert_held(&ar->conf_mutex);
1932
1933         if (vif->type == NL80211_IFTYPE_STATION)
1934                 aid = vif->bss_conf.aid;
1935         else
1936                 aid = sta->aid;
1937
1938         ether_addr_copy(arg->addr, sta->addr);
1939         arg->vdev_id = arvif->vdev_id;
1940         arg->peer_aid = aid;
1941         arg->peer_flags |= WMI_PEER_AUTH;
1942         arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);
1943         arg->peer_num_spatial_streams = 1;
1944         arg->peer_caps = vif->bss_conf.assoc_capability;
1945 }
1946
1947 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1948                                        struct ieee80211_vif *vif,
1949                                        struct wmi_peer_assoc_complete_arg *arg)
1950 {
1951         struct ieee80211_bss_conf *info = &vif->bss_conf;
1952         struct cfg80211_chan_def def;
1953         struct cfg80211_bss *bss;
1954         const u8 *rsnie = NULL;
1955         const u8 *wpaie = NULL;
1956
1957         lockdep_assert_held(&ar->conf_mutex);
1958
1959         if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
1960                 return;
1961
1962         bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid, NULL, 0,
1963                                IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
1964         if (bss) {
1965                 const struct cfg80211_bss_ies *ies;
1966
1967                 rcu_read_lock();
1968                 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1969
1970                 ies = rcu_dereference(bss->ies);
1971
1972                 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1973                                                 WLAN_OUI_TYPE_MICROSOFT_WPA,
1974                                                 ies->data,
1975                                                 ies->len);
1976                 rcu_read_unlock();
1977                 cfg80211_put_bss(ar->hw->wiphy, bss);
1978         }
1979
1980         /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1981         if (rsnie || wpaie) {
1982                 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
1983                 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1984         }
1985
1986         if (wpaie) {
1987                 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
1988                 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1989         }
1990 }
1991
1992 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
1993                                       struct ieee80211_vif *vif,
1994                                       struct ieee80211_sta *sta,
1995                                       struct wmi_peer_assoc_complete_arg *arg)
1996 {
1997         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1998         struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1999         struct cfg80211_chan_def def;
2000         const struct ieee80211_supported_band *sband;
2001         const struct ieee80211_rate *rates;
2002         enum ieee80211_band band;
2003         u32 ratemask;
2004         u8 rate;
2005         int i;
2006
2007         lockdep_assert_held(&ar->conf_mutex);
2008
2009         if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2010                 return;
2011
2012         band = def.chan->band;
2013         sband = ar->hw->wiphy->bands[band];
2014         ratemask = sta->supp_rates[band];
2015         ratemask &= arvif->bitrate_mask.control[band].legacy;
2016         rates = sband->bitrates;
2017
2018         rateset->num_rates = 0;
2019
2020         for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
2021                 if (!(ratemask & 1))
2022                         continue;
2023
2024                 rate = ath10k_mac_bitrate_to_rate(rates->bitrate);
2025                 rateset->rates[rateset->num_rates] = rate;
2026                 rateset->num_rates++;
2027         }
2028 }
2029
2030 static bool
2031 ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
2032 {
2033         int nss;
2034
2035         for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
2036                 if (ht_mcs_mask[nss])
2037                         return false;
2038
2039         return true;
2040 }
2041
2042 static bool
2043 ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
2044 {
2045         int nss;
2046
2047         for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
2048                 if (vht_mcs_mask[nss])
2049                         return false;
2050
2051         return true;
2052 }
2053
2054 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
2055                                    struct ieee80211_vif *vif,
2056                                    struct ieee80211_sta *sta,
2057                                    struct wmi_peer_assoc_complete_arg *arg)
2058 {
2059         const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
2060         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2061         struct cfg80211_chan_def def;
2062         enum ieee80211_band band;
2063         const u8 *ht_mcs_mask;
2064         const u16 *vht_mcs_mask;
2065         int i, n, max_nss;
2066         u32 stbc;
2067
2068         lockdep_assert_held(&ar->conf_mutex);
2069
2070         if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2071                 return;
2072
2073         if (!ht_cap->ht_supported)
2074                 return;
2075
2076         band = def.chan->band;
2077         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2078         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2079
2080         if (ath10k_peer_assoc_h_ht_masked(ht_mcs_mask) &&
2081             ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2082                 return;
2083
2084         arg->peer_flags |= WMI_PEER_HT;
2085         arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2086                                     ht_cap->ampdu_factor)) - 1;
2087
2088         arg->peer_mpdu_density =
2089                 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
2090
2091         arg->peer_ht_caps = ht_cap->cap;
2092         arg->peer_rate_caps |= WMI_RC_HT_FLAG;
2093
2094         if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
2095                 arg->peer_flags |= WMI_PEER_LDPC;
2096
2097         if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
2098                 arg->peer_flags |= WMI_PEER_40MHZ;
2099                 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
2100         }
2101
2102         if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
2103                 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
2104                         arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2105
2106                 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
2107                         arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2108         }
2109
2110         if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
2111                 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
2112                 arg->peer_flags |= WMI_PEER_STBC;
2113         }
2114
2115         if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
2116                 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
2117                 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
2118                 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
2119                 arg->peer_rate_caps |= stbc;
2120                 arg->peer_flags |= WMI_PEER_STBC;
2121         }
2122
2123         if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
2124                 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
2125         else if (ht_cap->mcs.rx_mask[1])
2126                 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
2127
2128         for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
2129                 if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
2130                     (ht_mcs_mask[i / 8] & BIT(i % 8))) {
2131                         max_nss = (i / 8) + 1;
2132                         arg->peer_ht_rates.rates[n++] = i;
2133                 }
2134
2135         /*
2136          * This is a workaround for HT-enabled STAs which break the spec
2137          * and have no HT capabilities RX mask (no HT RX MCS map).
2138          *
2139          * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
2140          * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
2141          *
2142          * Firmware asserts if such situation occurs.
2143          */
2144         if (n == 0) {
2145                 arg->peer_ht_rates.num_rates = 8;
2146                 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
2147                         arg->peer_ht_rates.rates[i] = i;
2148         } else {
2149                 arg->peer_ht_rates.num_rates = n;
2150                 arg->peer_num_spatial_streams = max_nss;
2151         }
2152
2153         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
2154                    arg->addr,
2155                    arg->peer_ht_rates.num_rates,
2156                    arg->peer_num_spatial_streams);
2157 }
2158
2159 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
2160                                     struct ath10k_vif *arvif,
2161                                     struct ieee80211_sta *sta)
2162 {
2163         u32 uapsd = 0;
2164         u32 max_sp = 0;
2165         int ret = 0;
2166
2167         lockdep_assert_held(&ar->conf_mutex);
2168
2169         if (sta->wme && sta->uapsd_queues) {
2170                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
2171                            sta->uapsd_queues, sta->max_sp);
2172
2173                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2174                         uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2175                                  WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2176                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2177                         uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2178                                  WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2179                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2180                         uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2181                                  WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2182                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2183                         uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2184                                  WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2185
2186                 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2187                         max_sp = sta->max_sp;
2188
2189                 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2190                                                  sta->addr,
2191                                                  WMI_AP_PS_PEER_PARAM_UAPSD,
2192                                                  uapsd);
2193                 if (ret) {
2194                         ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
2195                                     arvif->vdev_id, ret);
2196                         return ret;
2197                 }
2198
2199                 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2200                                                  sta->addr,
2201                                                  WMI_AP_PS_PEER_PARAM_MAX_SP,
2202                                                  max_sp);
2203                 if (ret) {
2204                         ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
2205                                     arvif->vdev_id, ret);
2206                         return ret;
2207                 }
2208
2209                 /* TODO setup this based on STA listen interval and
2210                    beacon interval. Currently we don't know
2211                    sta->listen_interval - mac80211 patch required.
2212                    Currently use 10 seconds */
2213                 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
2214                                                  WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
2215                                                  10);
2216                 if (ret) {
2217                         ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
2218                                     arvif->vdev_id, ret);
2219                         return ret;
2220                 }
2221         }
2222
2223         return 0;
2224 }
2225
2226 static u16
2227 ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
2228                               const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
2229 {
2230         int idx_limit;
2231         int nss;
2232         u16 mcs_map;
2233         u16 mcs;
2234
2235         for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
2236                 mcs_map = ath10k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
2237                           vht_mcs_limit[nss];
2238
2239                 if (mcs_map)
2240                         idx_limit = fls(mcs_map) - 1;
2241                 else
2242                         idx_limit = -1;
2243
2244                 switch (idx_limit) {
2245                 case 0: /* fall through */
2246                 case 1: /* fall through */
2247                 case 2: /* fall through */
2248                 case 3: /* fall through */
2249                 case 4: /* fall through */
2250                 case 5: /* fall through */
2251                 case 6: /* fall through */
2252                 default:
2253                         /* see ath10k_mac_can_set_bitrate_mask() */
2254                         WARN_ON(1);
2255                         /* fall through */
2256                 case -1:
2257                         mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
2258                         break;
2259                 case 7:
2260                         mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
2261                         break;
2262                 case 8:
2263                         mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
2264                         break;
2265                 case 9:
2266                         mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
2267                         break;
2268                 }
2269
2270                 tx_mcs_set &= ~(0x3 << (nss * 2));
2271                 tx_mcs_set |= mcs << (nss * 2);
2272         }
2273
2274         return tx_mcs_set;
2275 }
2276
2277 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
2278                                     struct ieee80211_vif *vif,
2279                                     struct ieee80211_sta *sta,
2280                                     struct wmi_peer_assoc_complete_arg *arg)
2281 {
2282         const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
2283         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2284         struct cfg80211_chan_def def;
2285         enum ieee80211_band band;
2286         const u16 *vht_mcs_mask;
2287         u8 ampdu_factor;
2288
2289         if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2290                 return;
2291
2292         if (!vht_cap->vht_supported)
2293                 return;
2294
2295         band = def.chan->band;
2296         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2297
2298         if (ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2299                 return;
2300
2301         arg->peer_flags |= WMI_PEER_VHT;
2302
2303         if (def.chan->band == IEEE80211_BAND_2GHZ)
2304                 arg->peer_flags |= WMI_PEER_VHT_2G;
2305
2306         arg->peer_vht_caps = vht_cap->cap;
2307
2308         ampdu_factor = (vht_cap->cap &
2309                         IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
2310                        IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
2311
2312         /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
2313          * zero in VHT IE. Using it would result in degraded throughput.
2314          * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
2315          * it if VHT max_mpdu is smaller. */
2316         arg->peer_max_mpdu = max(arg->peer_max_mpdu,
2317                                  (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2318                                         ampdu_factor)) - 1);
2319
2320         if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2321                 arg->peer_flags |= WMI_PEER_80MHZ;
2322
2323         arg->peer_vht_rates.rx_max_rate =
2324                 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
2325         arg->peer_vht_rates.rx_mcs_set =
2326                 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
2327         arg->peer_vht_rates.tx_max_rate =
2328                 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
2329         arg->peer_vht_rates.tx_mcs_set = ath10k_peer_assoc_h_vht_limit(
2330                 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);
2331
2332         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
2333                    sta->addr, arg->peer_max_mpdu, arg->peer_flags);
2334 }
2335
2336 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
2337                                     struct ieee80211_vif *vif,
2338                                     struct ieee80211_sta *sta,
2339                                     struct wmi_peer_assoc_complete_arg *arg)
2340 {
2341         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2342
2343         switch (arvif->vdev_type) {
2344         case WMI_VDEV_TYPE_AP:
2345                 if (sta->wme)
2346                         arg->peer_flags |= WMI_PEER_QOS;
2347
2348                 if (sta->wme && sta->uapsd_queues) {
2349                         arg->peer_flags |= WMI_PEER_APSD;
2350                         arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
2351                 }
2352                 break;
2353         case WMI_VDEV_TYPE_STA:
2354                 if (vif->bss_conf.qos)
2355                         arg->peer_flags |= WMI_PEER_QOS;
2356                 break;
2357         case WMI_VDEV_TYPE_IBSS:
2358                 if (sta->wme)
2359                         arg->peer_flags |= WMI_PEER_QOS;
2360                 break;
2361         default:
2362                 break;
2363         }
2364
2365         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM qos %d\n",
2366                    sta->addr, !!(arg->peer_flags & WMI_PEER_QOS));
2367 }
2368
2369 static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2370 {
2371         return sta->supp_rates[IEEE80211_BAND_2GHZ] >>
2372                ATH10K_MAC_FIRST_OFDM_RATE_IDX;
2373 }
2374
2375 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
2376                                         struct ieee80211_vif *vif,
2377                                         struct ieee80211_sta *sta,
2378                                         struct wmi_peer_assoc_complete_arg *arg)
2379 {
2380         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2381         struct cfg80211_chan_def def;
2382         enum ieee80211_band band;
2383         const u8 *ht_mcs_mask;
2384         const u16 *vht_mcs_mask;
2385         enum wmi_phy_mode phymode = MODE_UNKNOWN;
2386
2387         if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2388                 return;
2389
2390         band = def.chan->band;
2391         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2392         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2393
2394         switch (band) {
2395         case IEEE80211_BAND_2GHZ:
2396                 if (sta->vht_cap.vht_supported &&
2397                     !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2398                         if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2399                                 phymode = MODE_11AC_VHT40;
2400                         else
2401                                 phymode = MODE_11AC_VHT20;
2402                 } else if (sta->ht_cap.ht_supported &&
2403                            !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2404                         if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2405                                 phymode = MODE_11NG_HT40;
2406                         else
2407                                 phymode = MODE_11NG_HT20;
2408                 } else if (ath10k_mac_sta_has_ofdm_only(sta)) {
2409                         phymode = MODE_11G;
2410                 } else {
2411                         phymode = MODE_11B;
2412                 }
2413
2414                 break;
2415         case IEEE80211_BAND_5GHZ:
2416                 /*
2417                  * Check VHT first.
2418                  */
2419                 if (sta->vht_cap.vht_supported &&
2420                     !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2421                         if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
2422                                 phymode = MODE_11AC_VHT80;
2423                         else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
2424                                 phymode = MODE_11AC_VHT40;
2425                         else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
2426                                 phymode = MODE_11AC_VHT20;
2427                 } else if (sta->ht_cap.ht_supported &&
2428                            !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2429                         if (sta->bandwidth >= IEEE80211_STA_RX_BW_40)
2430                                 phymode = MODE_11NA_HT40;
2431                         else
2432                                 phymode = MODE_11NA_HT20;
2433                 } else {
2434                         phymode = MODE_11A;
2435                 }
2436
2437                 break;
2438         default:
2439                 break;
2440         }
2441
2442         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
2443                    sta->addr, ath10k_wmi_phymode_str(phymode));
2444
2445         arg->peer_phymode = phymode;
2446         WARN_ON(phymode == MODE_UNKNOWN);
2447 }
2448
2449 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
2450                                      struct ieee80211_vif *vif,
2451                                      struct ieee80211_sta *sta,
2452                                      struct wmi_peer_assoc_complete_arg *arg)
2453 {
2454         lockdep_assert_held(&ar->conf_mutex);
2455
2456         memset(arg, 0, sizeof(*arg));
2457
2458         ath10k_peer_assoc_h_basic(ar, vif, sta, arg);
2459         ath10k_peer_assoc_h_crypto(ar, vif, arg);
2460         ath10k_peer_assoc_h_rates(ar, vif, sta, arg);
2461         ath10k_peer_assoc_h_ht(ar, vif, sta, arg);
2462         ath10k_peer_assoc_h_vht(ar, vif, sta, arg);
2463         ath10k_peer_assoc_h_qos(ar, vif, sta, arg);
2464         ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);
2465
2466         return 0;
2467 }
2468
2469 static const u32 ath10k_smps_map[] = {
2470         [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
2471         [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
2472         [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
2473         [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
2474 };
2475
2476 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
2477                                   const u8 *addr,
2478                                   const struct ieee80211_sta_ht_cap *ht_cap)
2479 {
2480         int smps;
2481
2482         if (!ht_cap->ht_supported)
2483                 return 0;
2484
2485         smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2486         smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2487
2488         if (smps >= ARRAY_SIZE(ath10k_smps_map))
2489                 return -EINVAL;
2490
2491         return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
2492                                          WMI_PEER_SMPS_STATE,
2493                                          ath10k_smps_map[smps]);
2494 }
2495
2496 static int ath10k_mac_vif_recalc_txbf(struct ath10k *ar,
2497                                       struct ieee80211_vif *vif,
2498                                       struct ieee80211_sta_vht_cap vht_cap)
2499 {
2500         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2501         int ret;
2502         u32 param;
2503         u32 value;
2504
2505         if (!(ar->vht_cap_info &
2506               (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2507                IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE |
2508                IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2509                IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)))
2510                 return 0;
2511
2512         param = ar->wmi.vdev_param->txbf;
2513         value = 0;
2514
2515         if (WARN_ON(param == WMI_VDEV_PARAM_UNSUPPORTED))
2516                 return 0;
2517
2518         /* The following logic is correct. If a remote STA advertises support
2519          * for being a beamformer then we should enable us being a beamformee.
2520          */
2521
2522         if (ar->vht_cap_info &
2523             (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2524              IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
2525                 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
2526                         value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2527
2528                 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
2529                         value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
2530         }
2531
2532         if (ar->vht_cap_info &
2533             (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2534              IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
2535                 if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
2536                         value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2537
2538                 if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
2539                         value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
2540         }
2541
2542         if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFEE)
2543                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2544
2545         if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFER)
2546                 value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2547
2548         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, value);
2549         if (ret) {
2550                 ath10k_warn(ar, "failed to submit vdev param txbf 0x%x: %d\n",
2551                             value, ret);
2552                 return ret;
2553         }
2554
2555         return 0;
2556 }
2557
2558 /* can be called only in mac80211 callbacks due to `key_count` usage */
2559 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
2560                              struct ieee80211_vif *vif,
2561                              struct ieee80211_bss_conf *bss_conf)
2562 {
2563         struct ath10k *ar = hw->priv;
2564         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2565         struct ieee80211_sta_ht_cap ht_cap;
2566         struct ieee80211_sta_vht_cap vht_cap;
2567         struct wmi_peer_assoc_complete_arg peer_arg;
2568         struct ieee80211_sta *ap_sta;
2569         int ret;
2570
2571         lockdep_assert_held(&ar->conf_mutex);
2572
2573         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
2574                    arvif->vdev_id, arvif->bssid, arvif->aid);
2575
2576         rcu_read_lock();
2577
2578         ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
2579         if (!ap_sta) {
2580                 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
2581                             bss_conf->bssid, arvif->vdev_id);
2582                 rcu_read_unlock();
2583                 return;
2584         }
2585
2586         /* ap_sta must be accessed only within rcu section which must be left
2587          * before calling ath10k_setup_peer_smps() which might sleep. */
2588         ht_cap = ap_sta->ht_cap;
2589         vht_cap = ap_sta->vht_cap;
2590
2591         ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);
2592         if (ret) {
2593                 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
2594                             bss_conf->bssid, arvif->vdev_id, ret);
2595                 rcu_read_unlock();
2596                 return;
2597         }
2598
2599         rcu_read_unlock();
2600
2601         ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
2602         if (ret) {
2603                 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
2604                             bss_conf->bssid, arvif->vdev_id, ret);
2605                 return;
2606         }
2607
2608         ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
2609         if (ret) {
2610                 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
2611                             arvif->vdev_id, ret);
2612                 return;
2613         }
2614
2615         ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
2616         if (ret) {
2617                 ath10k_warn(ar, "failed to recalc txbf for vdev %i on bss %pM: %d\n",
2618                             arvif->vdev_id, bss_conf->bssid, ret);
2619                 return;
2620         }
2621
2622         ath10k_dbg(ar, ATH10K_DBG_MAC,
2623                    "mac vdev %d up (associated) bssid %pM aid %d\n",
2624                    arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
2625
2626         WARN_ON(arvif->is_up);
2627
2628         arvif->aid = bss_conf->aid;
2629         ether_addr_copy(arvif->bssid, bss_conf->bssid);
2630
2631         ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
2632         if (ret) {
2633                 ath10k_warn(ar, "failed to set vdev %d up: %d\n",
2634                             arvif->vdev_id, ret);
2635                 return;
2636         }
2637
2638         arvif->is_up = true;
2639
2640         /* Workaround: Some firmware revisions (tested with qca6174
2641          * WLAN.RM.2.0-00073) have buggy powersave state machine and must be
2642          * poked with peer param command.
2643          */
2644         ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, arvif->bssid,
2645                                         WMI_PEER_DUMMY_VAR, 1);
2646         if (ret) {
2647                 ath10k_warn(ar, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n",
2648                             arvif->bssid, arvif->vdev_id, ret);
2649                 return;
2650         }
2651 }
2652
2653 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
2654                                 struct ieee80211_vif *vif)
2655 {
2656         struct ath10k *ar = hw->priv;
2657         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2658         struct ieee80211_sta_vht_cap vht_cap = {};
2659         int ret;
2660
2661         lockdep_assert_held(&ar->conf_mutex);
2662
2663         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
2664                    arvif->vdev_id, arvif->bssid);
2665
2666         ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
2667         if (ret)
2668                 ath10k_warn(ar, "faield to down vdev %i: %d\n",
2669                             arvif->vdev_id, ret);
2670
2671         arvif->def_wep_key_idx = -1;
2672
2673         ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
2674         if (ret) {
2675                 ath10k_warn(ar, "failed to recalc txbf for vdev %i: %d\n",
2676                             arvif->vdev_id, ret);
2677                 return;
2678         }
2679
2680         arvif->is_up = false;
2681
2682         cancel_delayed_work_sync(&arvif->connection_loss_work);
2683 }
2684
2685 static int ath10k_station_assoc(struct ath10k *ar,
2686                                 struct ieee80211_vif *vif,
2687                                 struct ieee80211_sta *sta,
2688                                 bool reassoc)
2689 {
2690         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2691         struct wmi_peer_assoc_complete_arg peer_arg;
2692         int ret = 0;
2693
2694         lockdep_assert_held(&ar->conf_mutex);
2695
2696         ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);
2697         if (ret) {
2698                 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
2699                             sta->addr, arvif->vdev_id, ret);
2700                 return ret;
2701         }
2702
2703         ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
2704         if (ret) {
2705                 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
2706                             sta->addr, arvif->vdev_id, ret);
2707                 return ret;
2708         }
2709
2710         /* Re-assoc is run only to update supported rates for given station. It
2711          * doesn't make much sense to reconfigure the peer completely.
2712          */
2713         if (!reassoc) {
2714                 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,
2715                                              &sta->ht_cap);
2716                 if (ret) {
2717                         ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
2718                                     arvif->vdev_id, ret);
2719                         return ret;
2720                 }
2721
2722                 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
2723                 if (ret) {
2724                         ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
2725                                     sta->addr, arvif->vdev_id, ret);
2726                         return ret;
2727                 }
2728
2729                 if (!sta->wme) {
2730                         arvif->num_legacy_stations++;
2731                         ret  = ath10k_recalc_rtscts_prot(arvif);
2732                         if (ret) {
2733                                 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
2734                                             arvif->vdev_id, ret);
2735                                 return ret;
2736                         }
2737                 }
2738
2739                 /* Plumb cached keys only for static WEP */
2740                 if (arvif->def_wep_key_idx != -1) {
2741                         ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
2742                         if (ret) {
2743                                 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
2744                                             arvif->vdev_id, ret);
2745                                 return ret;
2746                         }
2747                 }
2748         }
2749
2750         return ret;
2751 }
2752
2753 static int ath10k_station_disassoc(struct ath10k *ar,
2754                                    struct ieee80211_vif *vif,
2755                                    struct ieee80211_sta *sta)
2756 {
2757         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2758         int ret = 0;
2759
2760         lockdep_assert_held(&ar->conf_mutex);
2761
2762         if (!sta->wme) {
2763                 arvif->num_legacy_stations--;
2764                 ret = ath10k_recalc_rtscts_prot(arvif);
2765                 if (ret) {
2766                         ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
2767                                     arvif->vdev_id, ret);
2768                         return ret;
2769                 }
2770         }
2771
2772         ret = ath10k_clear_peer_keys(arvif, sta->addr);
2773         if (ret) {
2774                 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
2775                             arvif->vdev_id, ret);
2776                 return ret;
2777         }
2778
2779         return ret;
2780 }
2781
2782 /**************/
2783 /* Regulatory */
2784 /**************/
2785
2786 static int ath10k_update_channel_list(struct ath10k *ar)
2787 {
2788         struct ieee80211_hw *hw = ar->hw;
2789         struct ieee80211_supported_band **bands;
2790         enum ieee80211_band band;
2791         struct ieee80211_channel *channel;
2792         struct wmi_scan_chan_list_arg arg = {0};
2793         struct wmi_channel_arg *ch;
2794         bool passive;
2795         int len;
2796         int ret;
2797         int i;
2798
2799         lockdep_assert_held(&ar->conf_mutex);
2800
2801         bands = hw->wiphy->bands;
2802         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2803                 if (!bands[band])
2804                         continue;
2805
2806                 for (i = 0; i < bands[band]->n_channels; i++) {
2807                         if (bands[band]->channels[i].flags &
2808                             IEEE80211_CHAN_DISABLED)
2809                                 continue;
2810
2811                         arg.n_channels++;
2812                 }
2813         }
2814
2815         len = sizeof(struct wmi_channel_arg) * arg.n_channels;
2816         arg.channels = kzalloc(len, GFP_KERNEL);
2817         if (!arg.channels)
2818                 return -ENOMEM;
2819
2820         ch = arg.channels;
2821         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
2822                 if (!bands[band])
2823                         continue;
2824
2825                 for (i = 0; i < bands[band]->n_channels; i++) {
2826                         channel = &bands[band]->channels[i];
2827
2828                         if (channel->flags & IEEE80211_CHAN_DISABLED)
2829                                 continue;
2830
2831                         ch->allow_ht   = true;
2832
2833                         /* FIXME: when should we really allow VHT? */
2834                         ch->allow_vht = true;
2835
2836                         ch->allow_ibss =
2837                                 !(channel->flags & IEEE80211_CHAN_NO_IR);
2838
2839                         ch->ht40plus =
2840                                 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
2841
2842                         ch->chan_radar =
2843                                 !!(channel->flags & IEEE80211_CHAN_RADAR);
2844
2845                         passive = channel->flags & IEEE80211_CHAN_NO_IR;
2846                         ch->passive = passive;
2847
2848                         ch->freq = channel->center_freq;
2849                         ch->band_center_freq1 = channel->center_freq;
2850                         ch->min_power = 0;
2851                         ch->max_power = channel->max_power * 2;
2852                         ch->max_reg_power = channel->max_reg_power * 2;
2853                         ch->max_antenna_gain = channel->max_antenna_gain * 2;
2854                         ch->reg_class_id = 0; /* FIXME */
2855
2856                         /* FIXME: why use only legacy modes, why not any
2857                          * HT/VHT modes? Would that even make any
2858                          * difference? */
2859                         if (channel->band == IEEE80211_BAND_2GHZ)
2860                                 ch->mode = MODE_11G;
2861                         else
2862                                 ch->mode = MODE_11A;
2863
2864                         if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
2865                                 continue;
2866
2867                         ath10k_dbg(ar, ATH10K_DBG_WMI,
2868                                    "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
2869                                     ch - arg.channels, arg.n_channels,
2870                                    ch->freq, ch->max_power, ch->max_reg_power,
2871                                    ch->max_antenna_gain, ch->mode);
2872
2873                         ch++;
2874                 }
2875         }
2876
2877         ret = ath10k_wmi_scan_chan_list(ar, &arg);
2878         kfree(arg.channels);
2879
2880         return ret;
2881 }
2882
2883 static enum wmi_dfs_region
2884 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
2885 {
2886         switch (dfs_region) {
2887         case NL80211_DFS_UNSET:
2888                 return WMI_UNINIT_DFS_DOMAIN;
2889         case NL80211_DFS_FCC:
2890                 return WMI_FCC_DFS_DOMAIN;
2891         case NL80211_DFS_ETSI:
2892                 return WMI_ETSI_DFS_DOMAIN;
2893         case NL80211_DFS_JP:
2894                 return WMI_MKK4_DFS_DOMAIN;
2895         }
2896         return WMI_UNINIT_DFS_DOMAIN;
2897 }
2898
2899 static void ath10k_regd_update(struct ath10k *ar)
2900 {
2901         struct reg_dmn_pair_mapping *regpair;
2902         int ret;
2903         enum wmi_dfs_region wmi_dfs_reg;
2904         enum nl80211_dfs_regions nl_dfs_reg;
2905
2906         lockdep_assert_held(&ar->conf_mutex);
2907
2908         ret = ath10k_update_channel_list(ar);
2909         if (ret)
2910                 ath10k_warn(ar, "failed to update channel list: %d\n", ret);
2911
2912         regpair = ar->ath_common.regulatory.regpair;
2913
2914         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
2915                 nl_dfs_reg = ar->dfs_detector->region;
2916                 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
2917         } else {
2918                 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
2919         }
2920
2921         /* Target allows setting up per-band regdomain but ath_common provides
2922          * a combined one only */
2923         ret = ath10k_wmi_pdev_set_regdomain(ar,
2924                                             regpair->reg_domain,
2925                                             regpair->reg_domain, /* 2ghz */
2926                                             regpair->reg_domain, /* 5ghz */
2927                                             regpair->reg_2ghz_ctl,
2928                                             regpair->reg_5ghz_ctl,
2929                                             wmi_dfs_reg);
2930         if (ret)
2931                 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
2932 }
2933
2934 static void ath10k_reg_notifier(struct wiphy *wiphy,
2935                                 struct regulatory_request *request)
2936 {
2937         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
2938         struct ath10k *ar = hw->priv;
2939         bool result;
2940
2941         ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
2942
2943         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
2944                 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
2945                            request->dfs_region);
2946                 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
2947                                                           request->dfs_region);
2948                 if (!result)
2949                         ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
2950                                     request->dfs_region);
2951         }
2952
2953         mutex_lock(&ar->conf_mutex);
2954         if (ar->state == ATH10K_STATE_ON)
2955                 ath10k_regd_update(ar);
2956         mutex_unlock(&ar->conf_mutex);
2957 }
2958
2959 /***************/
2960 /* TX handlers */
2961 /***************/
2962
2963 void ath10k_mac_tx_lock(struct ath10k *ar, int reason)
2964 {
2965         lockdep_assert_held(&ar->htt.tx_lock);
2966
2967         WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
2968         ar->tx_paused |= BIT(reason);
2969         ieee80211_stop_queues(ar->hw);
2970 }
2971
2972 static void ath10k_mac_tx_unlock_iter(void *data, u8 *mac,
2973                                       struct ieee80211_vif *vif)
2974 {
2975         struct ath10k *ar = data;
2976         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2977
2978         if (arvif->tx_paused)
2979                 return;
2980
2981         ieee80211_wake_queue(ar->hw, arvif->vdev_id);
2982 }
2983
2984 void ath10k_mac_tx_unlock(struct ath10k *ar, int reason)
2985 {
2986         lockdep_assert_held(&ar->htt.tx_lock);
2987
2988         WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
2989         ar->tx_paused &= ~BIT(reason);
2990
2991         if (ar->tx_paused)
2992                 return;
2993
2994         ieee80211_iterate_active_interfaces_atomic(ar->hw,
2995                                                    IEEE80211_IFACE_ITER_RESUME_ALL,
2996                                                    ath10k_mac_tx_unlock_iter,
2997                                                    ar);
2998 }
2999
3000 void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason)
3001 {
3002         struct ath10k *ar = arvif->ar;
3003
3004         lockdep_assert_held(&ar->htt.tx_lock);
3005
3006         WARN_ON(reason >= BITS_PER_LONG);
3007         arvif->tx_paused |= BIT(reason);
3008         ieee80211_stop_queue(ar->hw, arvif->vdev_id);
3009 }
3010
3011 void ath10k_mac_vif_tx_unlock(struct ath10k_vif *arvif, int reason)
3012 {
3013         struct ath10k *ar = arvif->ar;
3014
3015         lockdep_assert_held(&ar->htt.tx_lock);
3016
3017         WARN_ON(reason >= BITS_PER_LONG);
3018         arvif->tx_paused &= ~BIT(reason);
3019
3020         if (ar->tx_paused)
3021                 return;
3022
3023         if (arvif->tx_paused)
3024                 return;
3025
3026         ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3027 }
3028
3029 static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif *arvif,
3030                                            enum wmi_tlv_tx_pause_id pause_id,
3031                                            enum wmi_tlv_tx_pause_action action)
3032 {
3033         struct ath10k *ar = arvif->ar;
3034
3035         lockdep_assert_held(&ar->htt.tx_lock);
3036
3037         switch (pause_id) {
3038         case WMI_TLV_TX_PAUSE_ID_MCC:
3039         case WMI_TLV_TX_PAUSE_ID_P2P_CLI_NOA:
3040         case WMI_TLV_TX_PAUSE_ID_P2P_GO_PS:
3041         case WMI_TLV_TX_PAUSE_ID_AP_PS:
3042         case WMI_TLV_TX_PAUSE_ID_IBSS_PS:
3043                 switch (action) {
3044                 case WMI_TLV_TX_PAUSE_ACTION_STOP:
3045                         ath10k_mac_vif_tx_lock(arvif, pause_id);
3046                         break;
3047                 case WMI_TLV_TX_PAUSE_ACTION_WAKE:
3048                         ath10k_mac_vif_tx_unlock(arvif, pause_id);
3049                         break;
3050                 default:
3051                         ath10k_warn(ar, "received unknown tx pause action %d on vdev %i, ignoring\n",
3052                                     action, arvif->vdev_id);
3053                         break;
3054                 }
3055                 break;
3056         case WMI_TLV_TX_PAUSE_ID_AP_PEER_PS:
3057         case WMI_TLV_TX_PAUSE_ID_AP_PEER_UAPSD:
3058         case WMI_TLV_TX_PAUSE_ID_STA_ADD_BA:
3059         case WMI_TLV_TX_PAUSE_ID_HOST:
3060         default:
3061                 /* FIXME: Some pause_ids aren't vdev specific. Instead they
3062                  * target peer_id and tid. Implementing these could improve
3063                  * traffic scheduling fairness across multiple connected
3064                  * stations in AP/IBSS modes.
3065                  */
3066                 ath10k_dbg(ar, ATH10K_DBG_MAC,
3067                            "mac ignoring unsupported tx pause vdev %i id %d\n",
3068                            arvif->vdev_id, pause_id);
3069                 break;
3070         }
3071 }
3072
3073 struct ath10k_mac_tx_pause {
3074         u32 vdev_id;
3075         enum wmi_tlv_tx_pause_id pause_id;
3076         enum wmi_tlv_tx_pause_action action;
3077 };
3078
3079 static void ath10k_mac_handle_tx_pause_iter(void *data, u8 *mac,
3080                                             struct ieee80211_vif *vif)
3081 {
3082         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3083         struct ath10k_mac_tx_pause *arg = data;
3084
3085         ath10k_mac_vif_handle_tx_pause(arvif, arg->pause_id, arg->action);
3086 }
3087
3088 void ath10k_mac_handle_tx_pause(struct ath10k *ar, u32 vdev_id,
3089                                 enum wmi_tlv_tx_pause_id pause_id,
3090                                 enum wmi_tlv_tx_pause_action action)
3091 {
3092         struct ath10k_mac_tx_pause arg = {
3093                 .vdev_id = vdev_id,
3094                 .pause_id = pause_id,
3095                 .action = action,
3096         };
3097
3098         spin_lock_bh(&ar->htt.tx_lock);
3099         ieee80211_iterate_active_interfaces_atomic(ar->hw,
3100                                                    IEEE80211_IFACE_ITER_RESUME_ALL,
3101                                                    ath10k_mac_handle_tx_pause_iter,
3102                                                    &arg);
3103         spin_unlock_bh(&ar->htt.tx_lock);
3104 }
3105
3106 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
3107 {
3108         if (ieee80211_is_mgmt(hdr->frame_control))
3109                 return HTT_DATA_TX_EXT_TID_MGMT;
3110
3111         if (!ieee80211_is_data_qos(hdr->frame_control))
3112                 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
3113
3114         if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
3115                 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
3116
3117         return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
3118 }
3119
3120 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar, struct ieee80211_vif *vif)
3121 {
3122         if (vif)
3123                 return ath10k_vif_to_arvif(vif)->vdev_id;
3124
3125         if (ar->monitor_started)
3126                 return ar->monitor_vdev_id;
3127
3128         ath10k_warn(ar, "failed to resolve vdev id\n");
3129         return 0;
3130 }
3131
3132 static enum ath10k_hw_txrx_mode
3133 ath10k_tx_h_get_txmode(struct ath10k *ar, struct ieee80211_vif *vif,
3134                        struct ieee80211_sta *sta, struct sk_buff *skb)
3135 {
3136         const struct ieee80211_hdr *hdr = (void *)skb->data;
3137         __le16 fc = hdr->frame_control;
3138
3139         if (!vif || vif->type == NL80211_IFTYPE_MONITOR)
3140                 return ATH10K_HW_TXRX_RAW;
3141
3142         if (ieee80211_is_mgmt(fc))
3143                 return ATH10K_HW_TXRX_MGMT;
3144
3145         /* Workaround:
3146          *
3147          * NullFunc frames are mostly used to ping if a client or AP are still
3148          * reachable and responsive. This implies tx status reports must be
3149          * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can
3150          * come to a conclusion that the other end disappeared and tear down
3151          * BSS connection or it can never disconnect from BSS/client (which is
3152          * the case).
3153          *
3154          * Firmware with HTT older than 3.0 delivers incorrect tx status for
3155          * NullFunc frames to driver. However there's a HTT Mgmt Tx command
3156          * which seems to deliver correct tx reports for NullFunc frames. The
3157          * downside of using it is it ignores client powersave state so it can
3158          * end up disconnecting sleeping clients in AP mode. It should fix STA
3159          * mode though because AP don't sleep.
3160          */
3161         if (ar->htt.target_version_major < 3 &&
3162             (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) &&
3163             !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX, ar->fw_features))
3164                 return ATH10K_HW_TXRX_MGMT;
3165
3166         /* Workaround:
3167          *
3168          * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for
3169          * NativeWifi txmode - it selects AP key instead of peer key. It seems
3170          * to work with Ethernet txmode so use it.
3171          */
3172         if (ieee80211_is_data_present(fc) && sta && sta->tdls)
3173                 return ATH10K_HW_TXRX_ETHERNET;
3174
3175         return ATH10K_HW_TXRX_NATIVE_WIFI;
3176 }
3177
3178 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
3179  * Control in the header.
3180  */
3181 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
3182 {
3183         struct ieee80211_hdr *hdr = (void *)skb->data;
3184         struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3185         u8 *qos_ctl;
3186
3187         if (!ieee80211_is_data_qos(hdr->frame_control))
3188                 return;
3189
3190         qos_ctl = ieee80211_get_qos_ctl(hdr);
3191         memmove(skb->data + IEEE80211_QOS_CTL_LEN,
3192                 skb->data, (void *)qos_ctl - (void *)skb->data);
3193         skb_pull(skb, IEEE80211_QOS_CTL_LEN);
3194
3195         /* Some firmware revisions don't handle sending QoS NullFunc well.
3196          * These frames are mainly used for CQM purposes so it doesn't really
3197          * matter whether QoS NullFunc or NullFunc are sent.
3198          */
3199         hdr = (void *)skb->data;
3200         if (ieee80211_is_qos_nullfunc(hdr->frame_control))
3201                 cb->htt.tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
3202
3203         hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
3204 }
3205
3206 static void ath10k_tx_h_8023(struct sk_buff *skb)
3207 {
3208         struct ieee80211_hdr *hdr;
3209         struct rfc1042_hdr *rfc1042;
3210         struct ethhdr *eth;
3211         size_t hdrlen;
3212         u8 da[ETH_ALEN];
3213         u8 sa[ETH_ALEN];
3214         __be16 type;
3215
3216         hdr = (void *)skb->data;
3217         hdrlen = ieee80211_hdrlen(hdr->frame_control);
3218         rfc1042 = (void *)skb->data + hdrlen;
3219
3220         ether_addr_copy(da, ieee80211_get_DA(hdr));
3221         ether_addr_copy(sa, ieee80211_get_SA(hdr));
3222         type = rfc1042->snap_type;
3223
3224         skb_pull(skb, hdrlen + sizeof(*rfc1042));
3225         skb_push(skb, sizeof(*eth));
3226
3227         eth = (void *)skb->data;
3228         ether_addr_copy(eth->h_dest, da);
3229         ether_addr_copy(eth->h_source, sa);
3230         eth->h_proto = type;
3231 }
3232
3233 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
3234                                        struct ieee80211_vif *vif,
3235                                        struct sk_buff *skb)
3236 {
3237         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3238         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3239
3240         /* This is case only for P2P_GO */
3241         if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
3242             arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
3243                 return;
3244
3245         if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
3246                 spin_lock_bh(&ar->data_lock);
3247                 if (arvif->u.ap.noa_data)
3248                         if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
3249                                               GFP_ATOMIC))
3250                                 memcpy(skb_put(skb, arvif->u.ap.noa_len),
3251                                        arvif->u.ap.noa_data,
3252                                        arvif->u.ap.noa_len);
3253                 spin_unlock_bh(&ar->data_lock);
3254         }
3255 }
3256
3257 static bool ath10k_mac_need_offchan_tx_work(struct ath10k *ar)
3258 {
3259         /* FIXME: Not really sure since when the behaviour changed. At some
3260          * point new firmware stopped requiring creation of peer entries for
3261          * offchannel tx (and actually creating them causes issues with wmi-htc
3262          * tx credit replenishment and reliability). Assuming it's at least 3.4
3263          * because that's when the `freq` was introduced to TX_FRM HTT command.
3264          */
3265         return !(ar->htt.target_version_major >= 3 &&
3266                  ar->htt.target_version_minor >= 4);
3267 }
3268
3269 static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb)
3270 {
3271         struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
3272         int ret = 0;
3273
3274         spin_lock_bh(&ar->data_lock);
3275
3276         if (skb_queue_len(q) == ATH10K_MAX_NUM_MGMT_PENDING) {
3277                 ath10k_warn(ar, "wmi mgmt tx queue is full\n");
3278                 ret = -ENOSPC;
3279                 goto unlock;
3280         }
3281
3282         __skb_queue_tail(q, skb);
3283         ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
3284
3285 unlock:
3286         spin_unlock_bh(&ar->data_lock);
3287
3288         return ret;
3289 }
3290
3291 static void ath10k_mac_tx(struct ath10k *ar, struct sk_buff *skb)
3292 {
3293         struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3294         struct ath10k_htt *htt = &ar->htt;
3295         int ret = 0;
3296
3297         switch (cb->txmode) {
3298         case ATH10K_HW_TXRX_RAW:
3299         case ATH10K_HW_TXRX_NATIVE_WIFI:
3300         case ATH10K_HW_TXRX_ETHERNET:
3301                 ret = ath10k_htt_tx(htt, skb);
3302                 break;
3303         case ATH10K_HW_TXRX_MGMT:
3304                 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
3305                              ar->fw_features))
3306                         ret = ath10k_mac_tx_wmi_mgmt(ar, skb);
3307                 else if (ar->htt.target_version_major >= 3)
3308                         ret = ath10k_htt_tx(htt, skb);
3309                 else
3310                         ret = ath10k_htt_mgmt_tx(htt, skb);
3311                 break;
3312         }
3313
3314         if (ret) {
3315                 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
3316                             ret);
3317                 ieee80211_free_txskb(ar->hw, skb);
3318         }
3319 }
3320
3321 void ath10k_offchan_tx_purge(struct ath10k *ar)
3322 {
3323         struct sk_buff *skb;
3324
3325         for (;;) {
3326                 skb = skb_dequeue(&ar->offchan_tx_queue);
3327                 if (!skb)
3328                         break;
3329
3330                 ieee80211_free_txskb(ar->hw, skb);
3331         }
3332 }
3333
3334 void ath10k_offchan_tx_work(struct work_struct *work)
3335 {
3336         struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
3337         struct ath10k_peer *peer;
3338         struct ieee80211_hdr *hdr;
3339         struct sk_buff *skb;
3340         const u8 *peer_addr;
3341         int vdev_id;
3342         int ret;
3343         unsigned long time_left;
3344
3345         /* FW requirement: We must create a peer before FW will send out
3346          * an offchannel frame. Otherwise the frame will be stuck and
3347          * never transmitted. We delete the peer upon tx completion.
3348          * It is unlikely that a peer for offchannel tx will already be
3349          * present. However it may be in some rare cases so account for that.
3350          * Otherwise we might remove a legitimate peer and break stuff. */
3351
3352         for (;;) {
3353                 skb = skb_dequeue(&ar->offchan_tx_queue);
3354                 if (!skb)
3355                         break;
3356
3357                 mutex_lock(&ar->conf_mutex);
3358
3359                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %p\n",
3360                            skb);
3361
3362                 hdr = (struct ieee80211_hdr *)skb->data;
3363                 peer_addr = ieee80211_get_DA(hdr);
3364                 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
3365
3366                 spin_lock_bh(&ar->data_lock);
3367                 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
3368                 spin_unlock_bh(&ar->data_lock);
3369
3370                 if (peer)
3371                         /* FIXME: should this use ath10k_warn()? */
3372                         ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
3373                                    peer_addr, vdev_id);
3374
3375                 if (!peer) {
3376                         ret = ath10k_peer_create(ar, vdev_id, peer_addr,
3377                                                  WMI_PEER_TYPE_DEFAULT);
3378                         if (ret)
3379                                 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
3380                                             peer_addr, vdev_id, ret);
3381                 }
3382
3383                 spin_lock_bh(&ar->data_lock);
3384                 reinit_completion(&ar->offchan_tx_completed);
3385                 ar->offchan_tx_skb = skb;
3386                 spin_unlock_bh(&ar->data_lock);
3387
3388                 ath10k_mac_tx(ar, skb);
3389
3390                 time_left =
3391                 wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ);
3392                 if (time_left == 0)
3393                         ath10k_warn(ar, "timed out waiting for offchannel skb %p\n",
3394                                     skb);
3395
3396                 if (!peer) {
3397                         ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
3398                         if (ret)
3399                                 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
3400                                             peer_addr, vdev_id, ret);
3401                 }
3402
3403                 mutex_unlock(&ar->conf_mutex);
3404         }
3405 }
3406
3407 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
3408 {
3409         struct sk_buff *skb;
3410
3411         for (;;) {
3412                 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
3413                 if (!skb)
3414                         break;
3415
3416                 ieee80211_free_txskb(ar->hw, skb);
3417         }
3418 }
3419
3420 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
3421 {
3422         struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
3423         struct sk_buff *skb;
3424         int ret;
3425
3426         for (;;) {
3427                 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
3428                 if (!skb)
3429                         break;
3430
3431                 ret = ath10k_wmi_mgmt_tx(ar, skb);
3432                 if (ret) {
3433                         ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
3434                                     ret);
3435                         ieee80211_free_txskb(ar->hw, skb);
3436                 }
3437         }
3438 }
3439
3440 /************/
3441 /* Scanning */
3442 /************/
3443
3444 void __ath10k_scan_finish(struct ath10k *ar)
3445 {
3446         lockdep_assert_held(&ar->data_lock);
3447
3448         switch (ar->scan.state) {
3449         case ATH10K_SCAN_IDLE:
3450                 break;
3451         case ATH10K_SCAN_RUNNING:
3452         case ATH10K_SCAN_ABORTING:
3453                 if (!ar->scan.is_roc)
3454                         ieee80211_scan_completed(ar->hw,
3455                                                  (ar->scan.state ==
3456                                                   ATH10K_SCAN_ABORTING));
3457                 else if (ar->scan.roc_notify)
3458                         ieee80211_remain_on_channel_expired(ar->hw);
3459                 /* fall through */
3460         case ATH10K_SCAN_STARTING:
3461                 ar->scan.state = ATH10K_SCAN_IDLE;
3462                 ar->scan_channel = NULL;
3463                 ath10k_offchan_tx_purge(ar);
3464                 cancel_delayed_work(&ar->scan.timeout);
3465                 complete_all(&ar->scan.completed);
3466                 break;
3467         }
3468 }
3469
3470 void ath10k_scan_finish(struct ath10k *ar)
3471 {
3472         spin_lock_bh(&ar->data_lock);
3473         __ath10k_scan_finish(ar);
3474         spin_unlock_bh(&ar->data_lock);
3475 }
3476
3477 static int ath10k_scan_stop(struct ath10k *ar)
3478 {
3479         struct wmi_stop_scan_arg arg = {
3480                 .req_id = 1, /* FIXME */
3481                 .req_type = WMI_SCAN_STOP_ONE,
3482                 .u.scan_id = ATH10K_SCAN_ID,
3483         };
3484         int ret;
3485
3486         lockdep_assert_held(&ar->conf_mutex);
3487
3488         ret = ath10k_wmi_stop_scan(ar, &arg);
3489         if (ret) {
3490                 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
3491                 goto out;
3492         }
3493
3494         ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
3495         if (ret == 0) {
3496                 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
3497                 ret = -ETIMEDOUT;
3498         } else if (ret > 0) {
3499                 ret = 0;
3500         }
3501
3502 out:
3503         /* Scan state should be updated upon scan completion but in case
3504          * firmware fails to deliver the event (for whatever reason) it is
3505          * desired to clean up scan state anyway. Firmware may have just
3506          * dropped the scan completion event delivery due to transport pipe
3507          * being overflown with data and/or it can recover on its own before
3508          * next scan request is submitted.
3509          */
3510         spin_lock_bh(&ar->data_lock);
3511         if (ar->scan.state != ATH10K_SCAN_IDLE)
3512                 __ath10k_scan_finish(ar);
3513         spin_unlock_bh(&ar->data_lock);
3514
3515         return ret;
3516 }
3517
3518 static void ath10k_scan_abort(struct ath10k *ar)
3519 {
3520         int ret;
3521
3522         lockdep_assert_held(&ar->conf_mutex);
3523
3524         spin_lock_bh(&ar->data_lock);
3525
3526         switch (ar->scan.state) {
3527         case ATH10K_SCAN_IDLE:
3528                 /* This can happen if timeout worker kicked in and called
3529                  * abortion while scan completion was being processed.
3530                  */
3531                 break;
3532         case ATH10K_SCAN_STARTING:
3533         case ATH10K_SCAN_ABORTING:
3534                 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
3535                             ath10k_scan_state_str(ar->scan.state),
3536                             ar->scan.state);
3537                 break;
3538         case ATH10K_SCAN_RUNNING:
3539                 ar->scan.state = ATH10K_SCAN_ABORTING;
3540                 spin_unlock_bh(&ar->data_lock);
3541
3542                 ret = ath10k_scan_stop(ar);
3543                 if (ret)
3544                         ath10k_warn(ar, "failed to abort scan: %d\n", ret);
3545
3546                 spin_lock_bh(&ar->data_lock);
3547                 break;
3548         }
3549
3550         spin_unlock_bh(&ar->data_lock);
3551 }
3552
3553 void ath10k_scan_timeout_work(struct work_struct *work)
3554 {
3555         struct ath10k *ar = container_of(work, struct ath10k,
3556                                          scan.timeout.work);
3557
3558         mutex_lock(&ar->conf_mutex);
3559         ath10k_scan_abort(ar);
3560         mutex_unlock(&ar->conf_mutex);
3561 }
3562
3563 static int ath10k_start_scan(struct ath10k *ar,
3564                              const struct wmi_start_scan_arg *arg)
3565 {
3566         int ret;
3567
3568         lockdep_assert_held(&ar->conf_mutex);
3569
3570         ret = ath10k_wmi_start_scan(ar, arg);
3571         if (ret)
3572                 return ret;
3573
3574         ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
3575         if (ret == 0) {
3576                 ret = ath10k_scan_stop(ar);
3577                 if (ret)
3578                         ath10k_warn(ar, "failed to stop scan: %d\n", ret);
3579
3580                 return -ETIMEDOUT;
3581         }
3582
3583         /* If we failed to start the scan, return error code at
3584          * this point.  This is probably due to some issue in the
3585          * firmware, but no need to wedge the driver due to that...
3586          */
3587         spin_lock_bh(&ar->data_lock);
3588         if (ar->scan.state == ATH10K_SCAN_IDLE) {
3589                 spin_unlock_bh(&ar->data_lock);
3590                 return -EINVAL;
3591         }
3592         spin_unlock_bh(&ar->data_lock);
3593
3594         /* Add a 200ms margin to account for event/command processing */
3595         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
3596                                      msecs_to_jiffies(arg->max_scan_time+200));
3597         return 0;
3598 }
3599
3600 /**********************/
3601 /* mac80211 callbacks */
3602 /**********************/
3603
3604 static void ath10k_tx(struct ieee80211_hw *hw,
3605                       struct ieee80211_tx_control *control,
3606                       struct sk_buff *skb)
3607 {
3608         struct ath10k *ar = hw->priv;
3609         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3610         struct ieee80211_vif *vif = info->control.vif;
3611         struct ieee80211_sta *sta = control->sta;
3612         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3613         __le16 fc = hdr->frame_control;
3614
3615         /* We should disable CCK RATE due to P2P */
3616         if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
3617                 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
3618
3619         ATH10K_SKB_CB(skb)->htt.is_offchan = false;
3620         ATH10K_SKB_CB(skb)->htt.freq = 0;
3621         ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr);
3622         ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, vif);
3623         ATH10K_SKB_CB(skb)->txmode = ath10k_tx_h_get_txmode(ar, vif, sta, skb);
3624         ATH10K_SKB_CB(skb)->is_protected = ieee80211_has_protected(fc);
3625
3626         switch (ATH10K_SKB_CB(skb)->txmode) {
3627         case ATH10K_HW_TXRX_MGMT:
3628         case ATH10K_HW_TXRX_NATIVE_WIFI:
3629                 ath10k_tx_h_nwifi(hw, skb);
3630                 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
3631                 ath10k_tx_h_seq_no(vif, skb);
3632                 break;
3633         case ATH10K_HW_TXRX_ETHERNET:
3634                 ath10k_tx_h_8023(skb);
3635                 break;
3636         case ATH10K_HW_TXRX_RAW:
3637                 /* FIXME: Packet injection isn't implemented. It should be
3638                  * doable with firmware 10.2 on qca988x.
3639                  */
3640                 WARN_ON_ONCE(1);
3641                 ieee80211_free_txskb(hw, skb);
3642                 return;
3643         }
3644
3645         if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
3646                 spin_lock_bh(&ar->data_lock);
3647                 ATH10K_SKB_CB(skb)->htt.freq = ar->scan.roc_freq;
3648                 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
3649                 spin_unlock_bh(&ar->data_lock);
3650
3651                 if (ath10k_mac_need_offchan_tx_work(ar)) {
3652                         ATH10K_SKB_CB(skb)->htt.freq = 0;
3653                         ATH10K_SKB_CB(skb)->htt.is_offchan = true;
3654
3655                         ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
3656                                    skb);
3657
3658                         skb_queue_tail(&ar->offchan_tx_queue, skb);
3659                         ieee80211_queue_work(hw, &ar->offchan_tx_work);
3660                         return;
3661                 }
3662         }
3663
3664         ath10k_mac_tx(ar, skb);
3665 }
3666
3667 /* Must not be called with conf_mutex held as workers can use that also. */
3668 void ath10k_drain_tx(struct ath10k *ar)
3669 {
3670         /* make sure rcu-protected mac80211 tx path itself is drained */
3671         synchronize_net();
3672
3673         ath10k_offchan_tx_purge(ar);
3674         ath10k_mgmt_over_wmi_tx_purge(ar);
3675
3676         cancel_work_sync(&ar->offchan_tx_work);
3677         cancel_work_sync(&ar->wmi_mgmt_tx_work);
3678 }
3679
3680 void ath10k_halt(struct ath10k *ar)
3681 {
3682         struct ath10k_vif *arvif;
3683
3684         lockdep_assert_held(&ar->conf_mutex);
3685
3686         clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
3687         ar->filter_flags = 0;
3688         ar->monitor = false;
3689         ar->monitor_arvif = NULL;
3690
3691         if (ar->monitor_started)
3692                 ath10k_monitor_stop(ar);
3693
3694         ar->monitor_started = false;
3695         ar->tx_paused = 0;
3696
3697         ath10k_scan_finish(ar);
3698         ath10k_peer_cleanup_all(ar);
3699         ath10k_core_stop(ar);
3700         ath10k_hif_power_down(ar);
3701
3702         spin_lock_bh(&ar->data_lock);
3703         list_for_each_entry(arvif, &ar->arvifs, list)
3704                 ath10k_mac_vif_beacon_cleanup(arvif);
3705         spin_unlock_bh(&ar->data_lock);
3706 }
3707
3708 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
3709 {
3710         struct ath10k *ar = hw->priv;
3711
3712         mutex_lock(&ar->conf_mutex);
3713
3714         if (ar->cfg_tx_chainmask) {
3715                 *tx_ant = ar->cfg_tx_chainmask;
3716                 *rx_ant = ar->cfg_rx_chainmask;
3717         } else {
3718                 *tx_ant = ar->supp_tx_chainmask;
3719                 *rx_ant = ar->supp_rx_chainmask;
3720         }
3721
3722         mutex_unlock(&ar->conf_mutex);
3723
3724         return 0;
3725 }
3726
3727 static void ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
3728 {
3729         /* It is not clear that allowing gaps in chainmask
3730          * is helpful.  Probably it will not do what user
3731          * is hoping for, so warn in that case.
3732          */
3733         if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
3734                 return;
3735
3736         ath10k_warn(ar, "mac %s antenna chainmask may be invalid: 0x%x.  Suggested values: 15, 7, 3, 1 or 0.\n",
3737                     dbg, cm);
3738 }
3739
3740 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
3741 {
3742         int ret;
3743
3744         lockdep_assert_held(&ar->conf_mutex);
3745
3746         ath10k_check_chain_mask(ar, tx_ant, "tx");
3747         ath10k_check_chain_mask(ar, rx_ant, "rx");
3748
3749         ar->cfg_tx_chainmask = tx_ant;
3750         ar->cfg_rx_chainmask = rx_ant;
3751
3752         if ((ar->state != ATH10K_STATE_ON) &&
3753             (ar->state != ATH10K_STATE_RESTARTED))
3754                 return 0;
3755
3756         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
3757                                         tx_ant);
3758         if (ret) {
3759                 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
3760                             ret, tx_ant);
3761                 return ret;
3762         }
3763
3764         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
3765                                         rx_ant);
3766         if (ret) {
3767                 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
3768                             ret, rx_ant);
3769                 return ret;
3770         }
3771
3772         return 0;
3773 }
3774
3775 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
3776 {
3777         struct ath10k *ar = hw->priv;
3778         int ret;
3779
3780         mutex_lock(&ar->conf_mutex);
3781         ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
3782         mutex_unlock(&ar->conf_mutex);
3783         return ret;
3784 }
3785
3786 static int ath10k_start(struct ieee80211_hw *hw)
3787 {
3788         struct ath10k *ar = hw->priv;
3789         u32 burst_enable;
3790         int ret = 0;
3791
3792         /*
3793          * This makes sense only when restarting hw. It is harmless to call
3794          * uncoditionally. This is necessary to make sure no HTT/WMI tx
3795          * commands will be submitted while restarting.
3796          */
3797         ath10k_drain_tx(ar);
3798
3799         mutex_lock(&ar->conf_mutex);
3800
3801         switch (ar->state) {
3802         case ATH10K_STATE_OFF:
3803                 ar->state = ATH10K_STATE_ON;
3804                 break;
3805         case ATH10K_STATE_RESTARTING:
3806                 ath10k_halt(ar);
3807                 ar->state = ATH10K_STATE_RESTARTED;
3808                 break;
3809         case ATH10K_STATE_ON:
3810         case ATH10K_STATE_RESTARTED:
3811         case ATH10K_STATE_WEDGED:
3812                 WARN_ON(1);
3813                 ret = -EINVAL;
3814                 goto err;
3815         case ATH10K_STATE_UTF:
3816                 ret = -EBUSY;
3817                 goto err;
3818         }
3819
3820         ret = ath10k_hif_power_up(ar);
3821         if (ret) {
3822                 ath10k_err(ar, "Could not init hif: %d\n", ret);
3823                 goto err_off;
3824         }
3825
3826         ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
3827         if (ret) {
3828                 ath10k_err(ar, "Could not init core: %d\n", ret);
3829                 goto err_power_down;
3830         }
3831
3832         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
3833         if (ret) {
3834                 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
3835                 goto err_core_stop;
3836         }
3837
3838         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
3839         if (ret) {
3840                 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
3841                 goto err_core_stop;
3842         }
3843
3844         if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
3845                 ret = ath10k_wmi_adaptive_qcs(ar, true);
3846                 if (ret) {
3847                         ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",
3848                                     ret);
3849                         goto err_core_stop;
3850                 }
3851         }
3852
3853         if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {
3854                 burst_enable = ar->wmi.pdev_param->burst_enable;
3855                 ret = ath10k_wmi_pdev_set_param(ar, burst_enable, 0);
3856                 if (ret) {
3857                         ath10k_warn(ar, "failed to disable burst: %d\n", ret);
3858                         goto err_core_stop;
3859                 }
3860         }
3861
3862         if (ar->cfg_tx_chainmask)
3863                 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
3864                                      ar->cfg_rx_chainmask);
3865
3866         /*
3867          * By default FW set ARP frames ac to voice (6). In that case ARP
3868          * exchange is not working properly for UAPSD enabled AP. ARP requests
3869          * which arrives with access category 0 are processed by network stack
3870          * and send back with access category 0, but FW changes access category
3871          * to 6. Set ARP frames access category to best effort (0) solves
3872          * this problem.
3873          */
3874
3875         ret = ath10k_wmi_pdev_set_param(ar,
3876                                         ar->wmi.pdev_param->arp_ac_override, 0);
3877         if (ret) {
3878                 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
3879                             ret);
3880                 goto err_core_stop;
3881         }
3882
3883         ret = ath10k_wmi_pdev_set_param(ar,
3884                                         ar->wmi.pdev_param->ani_enable, 1);
3885         if (ret) {
3886                 ath10k_warn(ar, "failed to enable ani by default: %d\n",
3887                             ret);
3888                 goto err_core_stop;
3889         }
3890
3891         ar->ani_enabled = true;
3892
3893         ar->num_started_vdevs = 0;
3894         ath10k_regd_update(ar);
3895
3896         ath10k_spectral_start(ar);
3897         ath10k_thermal_set_throttling(ar);
3898
3899         mutex_unlock(&ar->conf_mutex);
3900         return 0;
3901
3902 err_core_stop:
3903         ath10k_core_stop(ar);
3904
3905 err_power_down:
3906         ath10k_hif_power_down(ar);
3907
3908 err_off:
3909         ar->state = ATH10K_STATE_OFF;
3910
3911 err:
3912         mutex_unlock(&ar->conf_mutex);
3913         return ret;
3914 }
3915
3916 static void ath10k_stop(struct ieee80211_hw *hw)
3917 {
3918         struct ath10k *ar = hw->priv;
3919
3920         ath10k_drain_tx(ar);
3921
3922         mutex_lock(&ar->conf_mutex);
3923         if (ar->state != ATH10K_STATE_OFF) {
3924                 ath10k_halt(ar);
3925                 ar->state = ATH10K_STATE_OFF;
3926         }
3927         mutex_unlock(&ar->conf_mutex);
3928
3929         cancel_delayed_work_sync(&ar->scan.timeout);
3930         cancel_work_sync(&ar->restart_work);
3931 }
3932
3933 static int ath10k_config_ps(struct ath10k *ar)
3934 {
3935         struct ath10k_vif *arvif;
3936         int ret = 0;
3937
3938         lockdep_assert_held(&ar->conf_mutex);
3939
3940         list_for_each_entry(arvif, &ar->arvifs, list) {
3941                 ret = ath10k_mac_vif_setup_ps(arvif);
3942                 if (ret) {
3943                         ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
3944                         break;
3945                 }
3946         }
3947
3948         return ret;
3949 }
3950
3951 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
3952 {
3953         int ret;
3954         u32 param;
3955
3956         lockdep_assert_held(&ar->conf_mutex);
3957
3958         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower %d\n", txpower);
3959
3960         param = ar->wmi.pdev_param->txpower_limit2g;
3961         ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
3962         if (ret) {
3963                 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
3964                             txpower, ret);
3965                 return ret;
3966         }
3967
3968         param = ar->wmi.pdev_param->txpower_limit5g;
3969         ret = ath10k_wmi_pdev_set_param(ar, param, txpower * 2);
3970         if (ret) {
3971                 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
3972                             txpower, ret);
3973                 return ret;
3974         }
3975
3976         return 0;
3977 }
3978
3979 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
3980 {
3981         struct ath10k_vif *arvif;
3982         int ret, txpower = -1;
3983
3984         lockdep_assert_held(&ar->conf_mutex);
3985
3986         list_for_each_entry(arvif, &ar->arvifs, list) {
3987                 WARN_ON(arvif->txpower < 0);
3988
3989                 if (txpower == -1)
3990                         txpower = arvif->txpower;
3991                 else
3992                         txpower = min(txpower, arvif->txpower);
3993         }
3994
3995         if (WARN_ON(txpower == -1))
3996                 return -EINVAL;
3997
3998         ret = ath10k_mac_txpower_setup(ar, txpower);
3999         if (ret) {
4000                 ath10k_warn(ar, "failed to setup tx power %d: %d\n",
4001                             txpower, ret);
4002                 return ret;
4003         }
4004
4005         return 0;
4006 }
4007
4008 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
4009 {
4010         struct ath10k *ar = hw->priv;
4011         struct ieee80211_conf *conf = &hw->conf;
4012         int ret = 0;
4013
4014         mutex_lock(&ar->conf_mutex);
4015
4016         if (changed & IEEE80211_CONF_CHANGE_PS)
4017                 ath10k_config_ps(ar);
4018
4019         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
4020                 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
4021                 ret = ath10k_monitor_recalc(ar);
4022                 if (ret)
4023                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4024         }
4025
4026         mutex_unlock(&ar->conf_mutex);
4027         return ret;
4028 }
4029
4030 static u32 get_nss_from_chainmask(u16 chain_mask)
4031 {
4032         if ((chain_mask & 0x15) == 0x15)
4033                 return 4;
4034         else if ((chain_mask & 0x7) == 0x7)
4035                 return 3;
4036         else if ((chain_mask & 0x3) == 0x3)
4037                 return 2;
4038         return 1;
4039 }
4040
4041 /*
4042  * TODO:
4043  * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
4044  * because we will send mgmt frames without CCK. This requirement
4045  * for P2P_FIND/GO_NEG should be handled by checking CCK flag
4046  * in the TX packet.
4047  */
4048 static int ath10k_add_interface(struct ieee80211_hw *hw,
4049                                 struct ieee80211_vif *vif)
4050 {
4051         struct ath10k *ar = hw->priv;
4052         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4053         enum wmi_sta_powersave_param param;
4054         int ret = 0;
4055         u32 value;
4056         int bit;
4057         int i;
4058         u32 vdev_param;
4059
4060         vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
4061
4062         mutex_lock(&ar->conf_mutex);
4063
4064         memset(arvif, 0, sizeof(*arvif));
4065
4066         arvif->ar = ar;
4067         arvif->vif = vif;
4068
4069         INIT_LIST_HEAD(&arvif->list);
4070         INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);
4071         INIT_DELAYED_WORK(&arvif->connection_loss_work,
4072                           ath10k_mac_vif_sta_connection_loss_work);
4073
4074         for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
4075                 arvif->bitrate_mask.control[i].legacy = 0xffffffff;
4076                 memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
4077                        sizeof(arvif->bitrate_mask.control[i].ht_mcs));
4078                 memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
4079                        sizeof(arvif->bitrate_mask.control[i].vht_mcs));
4080         }
4081
4082         if (ar->free_vdev_map == 0) {
4083                 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
4084                 ret = -EBUSY;
4085                 goto err;
4086         }
4087         bit = __ffs64(ar->free_vdev_map);
4088
4089         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
4090                    bit, ar->free_vdev_map);
4091
4092         arvif->vdev_id = bit;
4093         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
4094
4095         switch (vif->type) {
4096         case NL80211_IFTYPE_P2P_DEVICE:
4097                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4098                 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
4099                 break;
4100         case NL80211_IFTYPE_UNSPECIFIED:
4101         case NL80211_IFTYPE_STATION:
4102                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
4103                 if (vif->p2p)
4104                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
4105                 break;
4106         case NL80211_IFTYPE_ADHOC:
4107                 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
4108                 break;
4109         case NL80211_IFTYPE_AP:
4110                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
4111
4112                 if (vif->p2p)
4113                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
4114                 break;
4115         case NL80211_IFTYPE_MONITOR:
4116                 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
4117                 break;
4118         default:
4119                 WARN_ON(1);
4120                 break;
4121         }
4122
4123         /* Using vdev_id as queue number will make it very easy to do per-vif
4124          * tx queue locking. This shouldn't wrap due to interface combinations
4125          * but do a modulo for correctness sake and prevent using offchannel tx
4126          * queues for regular vif tx.
4127          */
4128         vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4129         for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
4130                 vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
4131
4132         /* Some firmware revisions don't wait for beacon tx completion before
4133          * sending another SWBA event. This could lead to hardware using old
4134          * (freed) beacon data in some cases, e.g. tx credit starvation
4135          * combined with missed TBTT. This is very very rare.
4136          *
4137          * On non-IOMMU-enabled hosts this could be a possible security issue
4138          * because hw could beacon some random data on the air.  On
4139          * IOMMU-enabled hosts DMAR faults would occur in most cases and target
4140          * device would crash.
4141          *
4142          * Since there are no beacon tx completions (implicit nor explicit)
4143          * propagated to host the only workaround for this is to allocate a
4144          * DMA-coherent buffer for a lifetime of a vif and use it for all
4145          * beacon tx commands. Worst case for this approach is some beacons may
4146          * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
4147          */
4148         if (vif->type == NL80211_IFTYPE_ADHOC ||
4149             vif->type == NL80211_IFTYPE_AP) {
4150                 arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
4151                                                         IEEE80211_MAX_FRAME_LEN,
4152                                                         &arvif->beacon_paddr,
4153                                                         GFP_ATOMIC);
4154                 if (!arvif->beacon_buf) {
4155                         ret = -ENOMEM;
4156                         ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
4157                                     ret);
4158                         goto err;
4159                 }
4160         }
4161
4162         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
4163                    arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
4164                    arvif->beacon_buf ? "single-buf" : "per-skb");
4165
4166         ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
4167                                      arvif->vdev_subtype, vif->addr);
4168         if (ret) {
4169                 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
4170                             arvif->vdev_id, ret);
4171                 goto err;
4172         }
4173
4174         ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
4175         list_add(&arvif->list, &ar->arvifs);
4176
4177         /* It makes no sense to have firmware do keepalives. mac80211 already
4178          * takes care of this with idle connection polling.
4179          */
4180         ret = ath10k_mac_vif_disable_keepalive(arvif);
4181         if (ret) {
4182                 ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
4183                             arvif->vdev_id, ret);
4184                 goto err_vdev_delete;
4185         }
4186
4187         arvif->def_wep_key_idx = -1;
4188
4189         vdev_param = ar->wmi.vdev_param->tx_encap_type;
4190         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4191                                         ATH10K_HW_TXRX_NATIVE_WIFI);
4192         /* 10.X firmware does not support this VDEV parameter. Do not warn */
4193         if (ret && ret != -EOPNOTSUPP) {
4194                 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
4195                             arvif->vdev_id, ret);
4196                 goto err_vdev_delete;
4197         }
4198
4199         if (ar->cfg_tx_chainmask) {
4200                 u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
4201
4202                 vdev_param = ar->wmi.vdev_param->nss;
4203                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4204                                                 nss);
4205                 if (ret) {
4206                         ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
4207                                     arvif->vdev_id, ar->cfg_tx_chainmask, nss,
4208                                     ret);
4209                         goto err_vdev_delete;
4210                 }
4211         }
4212
4213         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4214             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4215                 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr,
4216                                          WMI_PEER_TYPE_DEFAULT);
4217                 if (ret) {
4218                         ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
4219                                     arvif->vdev_id, ret);
4220                         goto err_vdev_delete;
4221                 }
4222         }
4223
4224         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
4225                 ret = ath10k_mac_set_kickout(arvif);
4226                 if (ret) {
4227                         ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
4228                                     arvif->vdev_id, ret);
4229                         goto err_peer_delete;
4230                 }
4231         }
4232
4233         if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
4234                 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
4235                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
4236                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
4237                                                   param, value);
4238                 if (ret) {
4239                         ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
4240                                     arvif->vdev_id, ret);
4241                         goto err_peer_delete;
4242                 }
4243
4244                 ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
4245                 if (ret) {
4246                         ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
4247                                     arvif->vdev_id, ret);
4248                         goto err_peer_delete;
4249                 }
4250
4251                 ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
4252                 if (ret) {
4253                         ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
4254                                     arvif->vdev_id, ret);
4255                         goto err_peer_delete;
4256                 }
4257         }
4258
4259         ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
4260         if (ret) {
4261                 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
4262                             arvif->vdev_id, ret);
4263                 goto err_peer_delete;
4264         }
4265
4266         ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
4267         if (ret) {
4268                 ath10k_warn(ar, "failed to set frag threshold for vdev %d: %d\n",
4269                             arvif->vdev_id, ret);
4270                 goto err_peer_delete;
4271         }
4272
4273         arvif->txpower = vif->bss_conf.txpower;
4274         ret = ath10k_mac_txpower_recalc(ar);
4275         if (ret) {
4276                 ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4277                 goto err_peer_delete;
4278         }
4279
4280         if (vif->type == NL80211_IFTYPE_MONITOR) {
4281                 ar->monitor_arvif = arvif;
4282                 ret = ath10k_monitor_recalc(ar);
4283                 if (ret) {
4284                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4285                         goto err_peer_delete;
4286                 }
4287         }
4288
4289         mutex_unlock(&ar->conf_mutex);
4290         return 0;
4291
4292 err_peer_delete:
4293         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4294             arvif->vdev_type == WMI_VDEV_TYPE_IBSS)
4295                 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
4296
4297 err_vdev_delete:
4298         ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4299         ar->free_vdev_map |= 1LL << arvif->vdev_id;
4300         list_del(&arvif->list);
4301
4302 err:
4303         if (arvif->beacon_buf) {
4304                 dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
4305                                   arvif->beacon_buf, arvif->beacon_paddr);
4306                 arvif->beacon_buf = NULL;
4307         }
4308
4309         mutex_unlock(&ar->conf_mutex);
4310
4311         return ret;
4312 }
4313
4314 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
4315 {
4316         int i;
4317
4318         for (i = 0; i < BITS_PER_LONG; i++)
4319                 ath10k_mac_vif_tx_unlock(arvif, i);
4320 }
4321
4322 static void ath10k_remove_interface(struct ieee80211_hw *hw,
4323                                     struct ieee80211_vif *vif)
4324 {
4325         struct ath10k *ar = hw->priv;
4326         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4327         int ret;
4328
4329         cancel_work_sync(&arvif->ap_csa_work);
4330         cancel_delayed_work_sync(&arvif->connection_loss_work);
4331
4332         mutex_lock(&ar->conf_mutex);
4333
4334         spin_lock_bh(&ar->data_lock);
4335         ath10k_mac_vif_beacon_cleanup(arvif);
4336         spin_unlock_bh(&ar->data_lock);
4337
4338         ret = ath10k_spectral_vif_stop(arvif);
4339         if (ret)
4340                 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
4341                             arvif->vdev_id, ret);
4342
4343         ar->free_vdev_map |= 1LL << arvif->vdev_id;
4344         list_del(&arvif->list);
4345
4346         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4347             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4348                 ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
4349                                              vif->addr);
4350                 if (ret)
4351                         ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
4352                                     arvif->vdev_id, ret);
4353
4354                 kfree(arvif->u.ap.noa_data);
4355         }
4356
4357         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
4358                    arvif->vdev_id);
4359
4360         ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
4361         if (ret)
4362                 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
4363                             arvif->vdev_id, ret);
4364
4365         /* Some firmware revisions don't notify host about self-peer removal
4366          * until after associated vdev is deleted.
4367          */
4368         if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
4369             arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
4370                 ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
4371                                                    vif->addr);
4372                 if (ret)
4373                         ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
4374                                     arvif->vdev_id, ret);
4375
4376                 spin_lock_bh(&ar->data_lock);
4377                 ar->num_peers--;
4378                 spin_unlock_bh(&ar->data_lock);
4379         }
4380
4381         ath10k_peer_cleanup(ar, arvif->vdev_id);
4382
4383         if (vif->type == NL80211_IFTYPE_MONITOR) {
4384                 ar->monitor_arvif = NULL;
4385                 ret = ath10k_monitor_recalc(ar);
4386                 if (ret)
4387                         ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
4388         }
4389
4390         spin_lock_bh(&ar->htt.tx_lock);
4391         ath10k_mac_vif_tx_unlock_all(arvif);
4392         spin_unlock_bh(&ar->htt.tx_lock);
4393
4394         mutex_unlock(&ar->conf_mutex);
4395 }
4396
4397 /*
4398  * FIXME: Has to be verified.
4399  */
4400 #define SUPPORTED_FILTERS                       \
4401         (FIF_ALLMULTI |                         \
4402         FIF_CONTROL |                           \
4403         FIF_PSPOLL |                            \
4404         FIF_OTHER_BSS |                         \
4405         FIF_BCN_PRBRESP_PROMISC |               \
4406         FIF_PROBE_REQ |                         \
4407         FIF_FCSFAIL)
4408
4409 static void ath10k_configure_filter(struct ieee80211_hw *hw,
4410                                     unsigned int changed_flags,
4411                                     unsigned int *total_flags,
4412                                     u64 multicast)
4413 {
4414         struct ath10k *ar = hw->priv;
4415         int ret;
4416
4417         mutex_lock(&ar->conf_mutex);
4418
4419         changed_flags &= SUPPORTED_FILTERS;
4420         *total_flags &= SUPPORTED_FILTERS;
4421         ar->filter_flags = *total_flags;
4422
4423         ret = ath10k_monitor_recalc(ar);
4424         if (ret)
4425                 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
4426
4427         mutex_unlock(&ar->conf_mutex);
4428 }
4429
4430 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
4431                                     struct ieee80211_vif *vif,
4432                                     struct ieee80211_bss_conf *info,
4433                                     u32 changed)
4434 {
4435         struct ath10k *ar = hw->priv;
4436         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4437         int ret = 0;
4438         u32 vdev_param, pdev_param, slottime, preamble;
4439
4440         mutex_lock(&ar->conf_mutex);
4441
4442         if (changed & BSS_CHANGED_IBSS)
4443                 ath10k_control_ibss(arvif, info, vif->addr);
4444
4445         if (changed & BSS_CHANGED_BEACON_INT) {
4446                 arvif->beacon_interval = info->beacon_int;
4447                 vdev_param = ar->wmi.vdev_param->beacon_interval;
4448                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4449                                                 arvif->beacon_interval);
4450                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4451                            "mac vdev %d beacon_interval %d\n",
4452                            arvif->vdev_id, arvif->beacon_interval);
4453
4454                 if (ret)
4455                         ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
4456                                     arvif->vdev_id, ret);
4457         }
4458
4459         if (changed & BSS_CHANGED_BEACON) {
4460                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4461                            "vdev %d set beacon tx mode to staggered\n",
4462                            arvif->vdev_id);
4463
4464                 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
4465                 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
4466                                                 WMI_BEACON_STAGGERED_MODE);
4467                 if (ret)
4468                         ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
4469                                     arvif->vdev_id, ret);
4470
4471                 ret = ath10k_mac_setup_bcn_tmpl(arvif);
4472                 if (ret)
4473                         ath10k_warn(ar, "failed to update beacon template: %d\n",
4474                                     ret);
4475         }
4476
4477         if (changed & BSS_CHANGED_AP_PROBE_RESP) {
4478                 ret = ath10k_mac_setup_prb_tmpl(arvif);
4479                 if (ret)
4480                         ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
4481                                     arvif->vdev_id, ret);
4482         }
4483
4484         if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
4485                 arvif->dtim_period = info->dtim_period;
4486
4487                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4488                            "mac vdev %d dtim_period %d\n",
4489                            arvif->vdev_id, arvif->dtim_period);
4490
4491                 vdev_param = ar->wmi.vdev_param->dtim_period;
4492                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4493                                                 arvif->dtim_period);
4494                 if (ret)
4495                         ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
4496                                     arvif->vdev_id, ret);
4497         }
4498
4499         if (changed & BSS_CHANGED_SSID &&
4500             vif->type == NL80211_IFTYPE_AP) {
4501                 arvif->u.ap.ssid_len = info->ssid_len;
4502                 if (info->ssid_len)
4503                         memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
4504                 arvif->u.ap.hidden_ssid = info->hidden_ssid;
4505         }
4506
4507         if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
4508                 ether_addr_copy(arvif->bssid, info->bssid);
4509
4510         if (changed & BSS_CHANGED_BEACON_ENABLED)
4511                 ath10k_control_beaconing(arvif, info);
4512
4513         if (changed & BSS_CHANGED_ERP_CTS_PROT) {
4514                 arvif->use_cts_prot = info->use_cts_prot;
4515                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
4516                            arvif->vdev_id, info->use_cts_prot);
4517
4518                 ret = ath10k_recalc_rtscts_prot(arvif);
4519                 if (ret)
4520                         ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
4521                                     arvif->vdev_id, ret);
4522
4523                 vdev_param = ar->wmi.vdev_param->protection_mode;
4524                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4525                                                 info->use_cts_prot ? 1 : 0);
4526                 if (ret)
4527                         ath10k_warn(ar, "failed to set protection mode %d on vdev %i: %d\n",
4528                                         info->use_cts_prot, arvif->vdev_id, ret);
4529         }
4530
4531         if (changed & BSS_CHANGED_ERP_SLOT) {
4532                 if (info->use_short_slot)
4533                         slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
4534
4535                 else
4536                         slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
4537
4538                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
4539                            arvif->vdev_id, slottime);
4540
4541                 vdev_param = ar->wmi.vdev_param->slot_time;
4542                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4543                                                 slottime);
4544                 if (ret)
4545                         ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
4546                                     arvif->vdev_id, ret);
4547         }
4548
4549         if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4550                 if (info->use_short_preamble)
4551                         preamble = WMI_VDEV_PREAMBLE_SHORT;
4552                 else
4553                         preamble = WMI_VDEV_PREAMBLE_LONG;
4554
4555                 ath10k_dbg(ar, ATH10K_DBG_MAC,
4556                            "mac vdev %d preamble %dn",
4557                            arvif->vdev_id, preamble);
4558
4559                 vdev_param = ar->wmi.vdev_param->preamble;
4560                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4561                                                 preamble);
4562                 if (ret)
4563                         ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
4564                                     arvif->vdev_id, ret);
4565         }
4566
4567         if (changed & BSS_CHANGED_ASSOC) {
4568                 if (info->assoc) {
4569                         /* Workaround: Make sure monitor vdev is not running
4570                          * when associating to prevent some firmware revisions
4571                          * (e.g. 10.1 and 10.2) from crashing.
4572                          */
4573                         if (ar->monitor_started)
4574                                 ath10k_monitor_stop(ar);
4575                         ath10k_bss_assoc(hw, vif, info);
4576                         ath10k_monitor_recalc(ar);
4577                 } else {
4578                         ath10k_bss_disassoc(hw, vif);
4579                 }
4580         }
4581
4582         if (changed & BSS_CHANGED_TXPOWER) {
4583                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
4584                            arvif->vdev_id, info->txpower);
4585
4586                 arvif->txpower = info->txpower;
4587                 ret = ath10k_mac_txpower_recalc(ar);
4588                 if (ret)
4589                         ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
4590         }
4591
4592         if (changed & BSS_CHANGED_PS) {
4593                 arvif->ps = vif->bss_conf.ps;
4594
4595                 ret = ath10k_config_ps(ar);
4596                 if (ret)
4597                         ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
4598                                     arvif->vdev_id, ret);
4599         }
4600
4601         mutex_unlock(&ar->conf_mutex);
4602 }
4603
4604 static int ath10k_hw_scan(struct ieee80211_hw *hw,
4605                           struct ieee80211_vif *vif,
4606                           struct ieee80211_scan_request *hw_req)
4607 {
4608         struct ath10k *ar = hw->priv;
4609         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4610         struct cfg80211_scan_request *req = &hw_req->req;
4611         struct wmi_start_scan_arg arg;
4612         int ret = 0;
4613         int i;
4614
4615         mutex_lock(&ar->conf_mutex);
4616
4617         spin_lock_bh(&ar->data_lock);
4618         switch (ar->scan.state) {
4619         case ATH10K_SCAN_IDLE:
4620                 reinit_completion(&ar->scan.started);
4621                 reinit_completion(&ar->scan.completed);
4622                 ar->scan.state = ATH10K_SCAN_STARTING;
4623                 ar->scan.is_roc = false;
4624                 ar->scan.vdev_id = arvif->vdev_id;
4625                 ret = 0;
4626                 break;
4627         case ATH10K_SCAN_STARTING:
4628         case ATH10K_SCAN_RUNNING:
4629         case ATH10K_SCAN_ABORTING:
4630                 ret = -EBUSY;
4631                 break;
4632         }
4633         spin_unlock_bh(&ar->data_lock);
4634
4635         if (ret)
4636                 goto exit;
4637
4638         memset(&arg, 0, sizeof(arg));
4639         ath10k_wmi_start_scan_init(ar, &arg);
4640         arg.vdev_id = arvif->vdev_id;
4641         arg.scan_id = ATH10K_SCAN_ID;
4642
4643         if (req->ie_len) {
4644                 arg.ie_len = req->ie_len;
4645                 memcpy(arg.ie, req->ie, arg.ie_len);
4646         }
4647
4648         if (req->n_ssids) {
4649                 arg.n_ssids = req->n_ssids;
4650                 for (i = 0; i < arg.n_ssids; i++) {
4651                         arg.ssids[i].len  = req->ssids[i].ssid_len;
4652                         arg.ssids[i].ssid = req->ssids[i].ssid;
4653                 }
4654         } else {
4655                 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
4656         }
4657
4658         if (req->n_channels) {
4659                 arg.n_channels = req->n_channels;
4660                 for (i = 0; i < arg.n_channels; i++)
4661                         arg.channels[i] = req->channels[i]->center_freq;
4662         }
4663
4664         ret = ath10k_start_scan(ar, &arg);
4665         if (ret) {
4666                 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
4667                 spin_lock_bh(&ar->data_lock);
4668                 ar->scan.state = ATH10K_SCAN_IDLE;
4669                 spin_unlock_bh(&ar->data_lock);
4670         }
4671
4672 exit:
4673         mutex_unlock(&ar->conf_mutex);
4674         return ret;
4675 }
4676
4677 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
4678                                   struct ieee80211_vif *vif)
4679 {
4680         struct ath10k *ar = hw->priv;
4681
4682         mutex_lock(&ar->conf_mutex);
4683         ath10k_scan_abort(ar);
4684         mutex_unlock(&ar->conf_mutex);
4685
4686         cancel_delayed_work_sync(&ar->scan.timeout);
4687 }
4688
4689 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
4690                                         struct ath10k_vif *arvif,
4691                                         enum set_key_cmd cmd,
4692                                         struct ieee80211_key_conf *key)
4693 {
4694         u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
4695         int ret;
4696
4697         /* 10.1 firmware branch requires default key index to be set to group
4698          * key index after installing it. Otherwise FW/HW Txes corrupted
4699          * frames with multi-vif APs. This is not required for main firmware
4700          * branch (e.g. 636).
4701          *
4702          * This is also needed for 636 fw for IBSS-RSN to work more reliably.
4703          *
4704          * FIXME: It remains unknown if this is required for multi-vif STA
4705          * interfaces on 10.1.
4706          */
4707
4708         if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
4709             arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
4710                 return;
4711
4712         if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
4713                 return;
4714
4715         if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
4716                 return;
4717
4718         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4719                 return;
4720
4721         if (cmd != SET_KEY)
4722                 return;
4723
4724         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4725                                         key->keyidx);
4726         if (ret)
4727                 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
4728                             arvif->vdev_id, ret);
4729 }
4730
4731 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
4732                           struct ieee80211_vif *vif, struct ieee80211_sta *sta,
4733                           struct ieee80211_key_conf *key)
4734 {
4735         struct ath10k *ar = hw->priv;
4736         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4737         struct ath10k_peer *peer;
4738         const u8 *peer_addr;
4739         bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
4740                       key->cipher == WLAN_CIPHER_SUITE_WEP104;
4741         int ret = 0;
4742         int ret2;
4743         u32 flags = 0;
4744         u32 flags2;
4745
4746         /* this one needs to be done in software */
4747         if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC)
4748                 return 1;
4749
4750         if (key->keyidx > WMI_MAX_KEY_INDEX)
4751                 return -ENOSPC;
4752
4753         mutex_lock(&ar->conf_mutex);
4754
4755         if (sta)
4756                 peer_addr = sta->addr;
4757         else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
4758                 peer_addr = vif->bss_conf.bssid;
4759         else
4760                 peer_addr = vif->addr;
4761
4762         key->hw_key_idx = key->keyidx;
4763
4764         if (is_wep) {
4765                 if (cmd == SET_KEY)
4766                         arvif->wep_keys[key->keyidx] = key;
4767                 else
4768                         arvif->wep_keys[key->keyidx] = NULL;
4769         }
4770
4771         /* the peer should not disappear in mid-way (unless FW goes awry) since
4772          * we already hold conf_mutex. we just make sure its there now. */
4773         spin_lock_bh(&ar->data_lock);
4774         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
4775         spin_unlock_bh(&ar->data_lock);
4776
4777         if (!peer) {
4778                 if (cmd == SET_KEY) {
4779                         ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
4780                                     peer_addr);
4781                         ret = -EOPNOTSUPP;
4782                         goto exit;
4783                 } else {
4784                         /* if the peer doesn't exist there is no key to disable
4785                          * anymore */
4786                         goto exit;
4787                 }
4788         }
4789
4790         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
4791                 flags |= WMI_KEY_PAIRWISE;
4792         else
4793                 flags |= WMI_KEY_GROUP;
4794
4795         if (is_wep) {
4796                 if (cmd == DISABLE_KEY)
4797                         ath10k_clear_vdev_key(arvif, key);
4798
4799                 /* When WEP keys are uploaded it's possible that there are
4800                  * stations associated already (e.g. when merging) without any
4801                  * keys. Static WEP needs an explicit per-peer key upload.
4802                  */
4803                 if (vif->type == NL80211_IFTYPE_ADHOC &&
4804                     cmd == SET_KEY)
4805                         ath10k_mac_vif_update_wep_key(arvif, key);
4806
4807                 /* 802.1x never sets the def_wep_key_idx so each set_key()
4808                  * call changes default tx key.
4809                  *
4810                  * Static WEP sets def_wep_key_idx via .set_default_unicast_key
4811                  * after first set_key().
4812                  */
4813                 if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
4814                         flags |= WMI_KEY_TX_USAGE;
4815         }
4816
4817         ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
4818         if (ret) {
4819                 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
4820                             arvif->vdev_id, peer_addr, ret);
4821                 goto exit;
4822         }
4823
4824         /* mac80211 sets static WEP keys as groupwise while firmware requires
4825          * them to be installed twice as both pairwise and groupwise.
4826          */
4827         if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
4828                 flags2 = flags;
4829                 flags2 &= ~WMI_KEY_GROUP;
4830                 flags2 |= WMI_KEY_PAIRWISE;
4831
4832                 ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
4833                 if (ret) {
4834                         ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
4835                                     arvif->vdev_id, peer_addr, ret);
4836                         ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
4837                                                   peer_addr, flags);
4838                         if (ret2)
4839                                 ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
4840                                             arvif->vdev_id, peer_addr, ret2);
4841                         goto exit;
4842                 }
4843         }
4844
4845         ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
4846
4847         spin_lock_bh(&ar->data_lock);
4848         peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
4849         if (peer && cmd == SET_KEY)
4850                 peer->keys[key->keyidx] = key;
4851         else if (peer && cmd == DISABLE_KEY)
4852                 peer->keys[key->keyidx] = NULL;
4853         else if (peer == NULL)
4854                 /* impossible unless FW goes crazy */
4855                 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
4856         spin_unlock_bh(&ar->data_lock);
4857
4858 exit:
4859         mutex_unlock(&ar->conf_mutex);
4860         return ret;
4861 }
4862
4863 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
4864                                            struct ieee80211_vif *vif,
4865                                            int keyidx)
4866 {
4867         struct ath10k *ar = hw->priv;
4868         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4869         int ret;
4870
4871         mutex_lock(&arvif->ar->conf_mutex);
4872
4873         if (arvif->ar->state != ATH10K_STATE_ON)
4874                 goto unlock;
4875
4876         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
4877                    arvif->vdev_id, keyidx);
4878
4879         ret = ath10k_wmi_vdev_set_param(arvif->ar,
4880                                         arvif->vdev_id,
4881                                         arvif->ar->wmi.vdev_param->def_keyid,
4882                                         keyidx);
4883
4884         if (ret) {
4885                 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
4886                             arvif->vdev_id,
4887                             ret);
4888                 goto unlock;
4889         }
4890
4891         arvif->def_wep_key_idx = keyidx;
4892
4893 unlock:
4894         mutex_unlock(&arvif->ar->conf_mutex);
4895 }
4896
4897 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
4898 {
4899         struct ath10k *ar;
4900         struct ath10k_vif *arvif;
4901         struct ath10k_sta *arsta;
4902         struct ieee80211_sta *sta;
4903         struct cfg80211_chan_def def;
4904         enum ieee80211_band band;
4905         const u8 *ht_mcs_mask;
4906         const u16 *vht_mcs_mask;
4907         u32 changed, bw, nss, smps;
4908         int err;
4909
4910         arsta = container_of(wk, struct ath10k_sta, update_wk);
4911         sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
4912         arvif = arsta->arvif;
4913         ar = arvif->ar;
4914
4915         if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
4916                 return;
4917
4918         band = def.chan->band;
4919         ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
4920         vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
4921
4922         spin_lock_bh(&ar->data_lock);
4923
4924         changed = arsta->changed;
4925         arsta->changed = 0;
4926
4927         bw = arsta->bw;
4928         nss = arsta->nss;
4929         smps = arsta->smps;
4930
4931         spin_unlock_bh(&ar->data_lock);
4932
4933         mutex_lock(&ar->conf_mutex);
4934
4935         nss = max_t(u32, 1, nss);
4936         nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
4937                            ath10k_mac_max_vht_nss(vht_mcs_mask)));
4938
4939         if (changed & IEEE80211_RC_BW_CHANGED) {
4940                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
4941                            sta->addr, bw);
4942
4943                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
4944                                                 WMI_PEER_CHAN_WIDTH, bw);
4945                 if (err)
4946                         ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
4947                                     sta->addr, bw, err);
4948         }
4949
4950         if (changed & IEEE80211_RC_NSS_CHANGED) {
4951                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
4952                            sta->addr, nss);
4953
4954                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
4955                                                 WMI_PEER_NSS, nss);
4956                 if (err)
4957                         ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
4958                                     sta->addr, nss, err);
4959         }
4960
4961         if (changed & IEEE80211_RC_SMPS_CHANGED) {
4962                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
4963                            sta->addr, smps);
4964
4965                 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
4966                                                 WMI_PEER_SMPS_STATE, smps);
4967                 if (err)
4968                         ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
4969                                     sta->addr, smps, err);
4970         }
4971
4972         if (changed & IEEE80211_RC_SUPP_RATES_CHANGED ||
4973             changed & IEEE80211_RC_NSS_CHANGED) {
4974                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates/nss\n",
4975                            sta->addr);
4976
4977                 err = ath10k_station_assoc(ar, arvif->vif, sta, true);
4978                 if (err)
4979                         ath10k_warn(ar, "failed to reassociate station: %pM\n",
4980                                     sta->addr);
4981         }
4982
4983         mutex_unlock(&ar->conf_mutex);
4984 }
4985
4986 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
4987                                        struct ieee80211_sta *sta)
4988 {
4989         struct ath10k *ar = arvif->ar;
4990
4991         lockdep_assert_held(&ar->conf_mutex);
4992
4993         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
4994                 return 0;
4995
4996         if (ar->num_stations >= ar->max_num_stations)
4997                 return -ENOBUFS;
4998
4999         ar->num_stations++;
5000
5001         return 0;
5002 }
5003
5004 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
5005                                         struct ieee80211_sta *sta)
5006 {
5007         struct ath10k *ar = arvif->ar;
5008
5009         lockdep_assert_held(&ar->conf_mutex);
5010
5011         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
5012                 return;
5013
5014         ar->num_stations--;
5015 }
5016
5017 struct ath10k_mac_tdls_iter_data {
5018         u32 num_tdls_stations;
5019         struct ieee80211_vif *curr_vif;
5020 };
5021
5022 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
5023                                                     struct ieee80211_sta *sta)
5024 {
5025         struct ath10k_mac_tdls_iter_data *iter_data = data;
5026         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5027         struct ieee80211_vif *sta_vif = arsta->arvif->vif;
5028
5029         if (sta->tdls && sta_vif == iter_data->curr_vif)
5030                 iter_data->num_tdls_stations++;
5031 }
5032
5033 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
5034                                               struct ieee80211_vif *vif)
5035 {
5036         struct ath10k_mac_tdls_iter_data data = {};
5037
5038         data.curr_vif = vif;
5039
5040         ieee80211_iterate_stations_atomic(hw,
5041                                           ath10k_mac_tdls_vif_stations_count_iter,
5042                                           &data);
5043         return data.num_tdls_stations;
5044 }
5045
5046 static void ath10k_mac_tdls_vifs_count_iter(void *data, u8 *mac,
5047                                             struct ieee80211_vif *vif)
5048 {
5049         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5050         int *num_tdls_vifs = data;
5051
5052         if (vif->type != NL80211_IFTYPE_STATION)
5053                 return;
5054
5055         if (ath10k_mac_tdls_vif_stations_count(arvif->ar->hw, vif) > 0)
5056                 (*num_tdls_vifs)++;
5057 }
5058
5059 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw *hw)
5060 {
5061         int num_tdls_vifs = 0;
5062
5063         ieee80211_iterate_active_interfaces_atomic(hw,
5064                                                    IEEE80211_IFACE_ITER_NORMAL,
5065                                                    ath10k_mac_tdls_vifs_count_iter,
5066                                                    &num_tdls_vifs);
5067         return num_tdls_vifs;
5068 }
5069
5070 static int ath10k_sta_state(struct ieee80211_hw *hw,
5071                             struct ieee80211_vif *vif,
5072                             struct ieee80211_sta *sta,
5073                             enum ieee80211_sta_state old_state,
5074                             enum ieee80211_sta_state new_state)
5075 {
5076         struct ath10k *ar = hw->priv;
5077         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5078         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5079         int ret = 0;
5080
5081         if (old_state == IEEE80211_STA_NOTEXIST &&
5082             new_state == IEEE80211_STA_NONE) {
5083                 memset(arsta, 0, sizeof(*arsta));
5084                 arsta->arvif = arvif;
5085                 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
5086         }
5087
5088         /* cancel must be done outside the mutex to avoid deadlock */
5089         if ((old_state == IEEE80211_STA_NONE &&
5090              new_state == IEEE80211_STA_NOTEXIST))
5091                 cancel_work_sync(&arsta->update_wk);
5092
5093         mutex_lock(&ar->conf_mutex);
5094
5095         if (old_state == IEEE80211_STA_NOTEXIST &&
5096             new_state == IEEE80211_STA_NONE) {
5097                 /*
5098                  * New station addition.
5099                  */
5100                 enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
5101                 u32 num_tdls_stations;
5102                 u32 num_tdls_vifs;
5103
5104                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5105                            "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
5106                            arvif->vdev_id, sta->addr,
5107                            ar->num_stations + 1, ar->max_num_stations,
5108                            ar->num_peers + 1, ar->max_num_peers);
5109
5110                 ret = ath10k_mac_inc_num_stations(arvif, sta);
5111                 if (ret) {
5112                         ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
5113                                     ar->max_num_stations);
5114                         goto exit;
5115                 }
5116
5117                 if (sta->tdls)
5118                         peer_type = WMI_PEER_TYPE_TDLS;
5119
5120                 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr,
5121                                          peer_type);
5122                 if (ret) {
5123                         ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
5124                                     sta->addr, arvif->vdev_id, ret);
5125                         ath10k_mac_dec_num_stations(arvif, sta);
5126                         goto exit;
5127                 }
5128
5129                 if (!sta->tdls)
5130                         goto exit;
5131
5132                 num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
5133                 num_tdls_vifs = ath10k_mac_tdls_vifs_count(hw);
5134
5135                 if (num_tdls_vifs >= ar->max_num_tdls_vdevs &&
5136                     num_tdls_stations == 0) {
5137                         ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
5138                                     arvif->vdev_id, ar->max_num_tdls_vdevs);
5139                         ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5140                         ath10k_mac_dec_num_stations(arvif, sta);
5141                         ret = -ENOBUFS;
5142                         goto exit;
5143                 }
5144
5145                 if (num_tdls_stations == 0) {
5146                         /* This is the first tdls peer in current vif */
5147                         enum wmi_tdls_state state = WMI_TDLS_ENABLE_ACTIVE;
5148
5149                         ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5150                                                               state);
5151                         if (ret) {
5152                                 ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5153                                             arvif->vdev_id, ret);
5154                                 ath10k_peer_delete(ar, arvif->vdev_id,
5155                                                    sta->addr);
5156                                 ath10k_mac_dec_num_stations(arvif, sta);
5157                                 goto exit;
5158                         }
5159                 }
5160
5161                 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5162                                                   WMI_TDLS_PEER_STATE_PEERING);
5163                 if (ret) {
5164                         ath10k_warn(ar,
5165                                     "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
5166                                     sta->addr, arvif->vdev_id, ret);
5167                         ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5168                         ath10k_mac_dec_num_stations(arvif, sta);
5169
5170                         if (num_tdls_stations != 0)
5171                                 goto exit;
5172                         ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5173                                                         WMI_TDLS_DISABLE);
5174                 }
5175         } else if ((old_state == IEEE80211_STA_NONE &&
5176                     new_state == IEEE80211_STA_NOTEXIST)) {
5177                 /*
5178                  * Existing station deletion.
5179                  */
5180                 ath10k_dbg(ar, ATH10K_DBG_MAC,
5181                            "mac vdev %d peer delete %pM (sta gone)\n",
5182                            arvif->vdev_id, sta->addr);
5183
5184                 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
5185                 if (ret)
5186                         ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
5187                                     sta->addr, arvif->vdev_id, ret);
5188
5189                 ath10k_mac_dec_num_stations(arvif, sta);
5190
5191                 if (!sta->tdls)
5192                         goto exit;
5193
5194                 if (ath10k_mac_tdls_vif_stations_count(hw, vif))
5195                         goto exit;
5196
5197                 /* This was the last tdls peer in current vif */
5198                 ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
5199                                                       WMI_TDLS_DISABLE);
5200                 if (ret) {
5201                         ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
5202                                     arvif->vdev_id, ret);
5203                 }
5204         } else if (old_state == IEEE80211_STA_AUTH &&
5205                    new_state == IEEE80211_STA_ASSOC &&
5206                    (vif->type == NL80211_IFTYPE_AP ||
5207                     vif->type == NL80211_IFTYPE_ADHOC)) {
5208                 /*
5209                  * New association.
5210                  */
5211                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
5212                            sta->addr);
5213
5214                 ret = ath10k_station_assoc(ar, vif, sta, false);
5215                 if (ret)
5216                         ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
5217                                     sta->addr, arvif->vdev_id, ret);
5218         } else if (old_state == IEEE80211_STA_ASSOC &&
5219                    new_state == IEEE80211_STA_AUTHORIZED &&
5220                    sta->tdls) {
5221                 /*
5222                  * Tdls station authorized.
5223                  */
5224                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac tdls sta %pM authorized\n",
5225                            sta->addr);
5226
5227                 ret = ath10k_station_assoc(ar, vif, sta, false);
5228                 if (ret) {
5229                         ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
5230                                     sta->addr, arvif->vdev_id, ret);
5231                         goto exit;
5232                 }
5233
5234                 ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
5235                                                   WMI_TDLS_PEER_STATE_CONNECTED);
5236                 if (ret)
5237                         ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
5238                                     sta->addr, arvif->vdev_id, ret);
5239         } else if (old_state == IEEE80211_STA_ASSOC &&
5240                     new_state == IEEE80211_STA_AUTH &&
5241                     (vif->type == NL80211_IFTYPE_AP ||
5242                      vif->type == NL80211_IFTYPE_ADHOC)) {
5243                 /*
5244                  * Disassociation.
5245                  */
5246                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
5247                            sta->addr);
5248
5249                 ret = ath10k_station_disassoc(ar, vif, sta);
5250                 if (ret)
5251                         ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
5252                                     sta->addr, arvif->vdev_id, ret);
5253         }
5254 exit:
5255         mutex_unlock(&ar->conf_mutex);
5256         return ret;
5257 }
5258
5259 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
5260                                 u16 ac, bool enable)
5261 {
5262         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5263         struct wmi_sta_uapsd_auto_trig_arg arg = {};
5264         u32 prio = 0, acc = 0;
5265         u32 value = 0;
5266         int ret = 0;
5267
5268         lockdep_assert_held(&ar->conf_mutex);
5269
5270         if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
5271                 return 0;
5272
5273         switch (ac) {
5274         case IEEE80211_AC_VO:
5275                 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
5276                         WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
5277                 prio = 7;
5278                 acc = 3;
5279                 break;
5280         case IEEE80211_AC_VI:
5281                 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
5282                         WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
5283                 prio = 5;
5284                 acc = 2;
5285                 break;
5286         case IEEE80211_AC_BE:
5287                 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
5288                         WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
5289                 prio = 2;
5290                 acc = 1;
5291                 break;
5292         case IEEE80211_AC_BK:
5293                 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
5294                         WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
5295                 prio = 0;
5296                 acc = 0;
5297                 break;
5298         }
5299
5300         if (enable)
5301                 arvif->u.sta.uapsd |= value;
5302         else
5303                 arvif->u.sta.uapsd &= ~value;
5304
5305         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5306                                           WMI_STA_PS_PARAM_UAPSD,
5307                                           arvif->u.sta.uapsd);
5308         if (ret) {
5309                 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
5310                 goto exit;
5311         }
5312
5313         if (arvif->u.sta.uapsd)
5314                 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
5315         else
5316                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5317
5318         ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5319                                           WMI_STA_PS_PARAM_RX_WAKE_POLICY,
5320                                           value);
5321         if (ret)
5322                 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
5323
5324         ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
5325         if (ret) {
5326                 ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
5327                             arvif->vdev_id, ret);
5328                 return ret;
5329         }
5330
5331         ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
5332         if (ret) {
5333                 ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
5334                             arvif->vdev_id, ret);
5335                 return ret;
5336         }
5337
5338         if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
5339             test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
5340                 /* Only userspace can make an educated decision when to send
5341                  * trigger frame. The following effectively disables u-UAPSD
5342                  * autotrigger in firmware (which is enabled by default
5343                  * provided the autotrigger service is available).
5344                  */
5345
5346                 arg.wmm_ac = acc;
5347                 arg.user_priority = prio;
5348                 arg.service_interval = 0;
5349                 arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5350                 arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
5351
5352                 ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
5353                                                 arvif->bssid, &arg, 1);
5354                 if (ret) {
5355                         ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
5356                                     ret);
5357                         return ret;
5358                 }
5359         }
5360
5361 exit:
5362         return ret;
5363 }
5364
5365 static int ath10k_conf_tx(struct ieee80211_hw *hw,
5366                           struct ieee80211_vif *vif, u16 ac,
5367                           const struct ieee80211_tx_queue_params *params)
5368 {
5369         struct ath10k *ar = hw->priv;
5370         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5371         struct wmi_wmm_params_arg *p = NULL;
5372         int ret;
5373
5374         mutex_lock(&ar->conf_mutex);
5375
5376         switch (ac) {
5377         case IEEE80211_AC_VO:
5378                 p = &arvif->wmm_params.ac_vo;
5379                 break;
5380         case IEEE80211_AC_VI:
5381                 p = &arvif->wmm_params.ac_vi;
5382                 break;
5383         case IEEE80211_AC_BE:
5384                 p = &arvif->wmm_params.ac_be;
5385                 break;
5386         case IEEE80211_AC_BK:
5387                 p = &arvif->wmm_params.ac_bk;
5388                 break;
5389         }
5390
5391         if (WARN_ON(!p)) {
5392                 ret = -EINVAL;
5393                 goto exit;
5394         }
5395
5396         p->cwmin = params->cw_min;
5397         p->cwmax = params->cw_max;
5398         p->aifs = params->aifs;
5399
5400         /*
5401          * The channel time duration programmed in the HW is in absolute
5402          * microseconds, while mac80211 gives the txop in units of
5403          * 32 microseconds.
5404          */
5405         p->txop = params->txop * 32;
5406
5407         if (ar->wmi.ops->gen_vdev_wmm_conf) {
5408                 ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
5409                                                &arvif->wmm_params);
5410                 if (ret) {
5411                         ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
5412                                     arvif->vdev_id, ret);
5413                         goto exit;
5414                 }
5415         } else {
5416                 /* This won't work well with multi-interface cases but it's
5417                  * better than nothing.
5418                  */
5419                 ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
5420                 if (ret) {
5421                         ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
5422                         goto exit;
5423                 }
5424         }
5425
5426         ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
5427         if (ret)
5428                 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
5429
5430 exit:
5431         mutex_unlock(&ar->conf_mutex);
5432         return ret;
5433 }
5434
5435 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
5436
5437 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
5438                                     struct ieee80211_vif *vif,
5439                                     struct ieee80211_channel *chan,
5440                                     int duration,
5441                                     enum ieee80211_roc_type type)
5442 {
5443         struct ath10k *ar = hw->priv;
5444         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5445         struct wmi_start_scan_arg arg;
5446         int ret = 0;
5447         u32 scan_time_msec;
5448
5449         mutex_lock(&ar->conf_mutex);
5450
5451         spin_lock_bh(&ar->data_lock);
5452         switch (ar->scan.state) {
5453         case ATH10K_SCAN_IDLE:
5454                 reinit_completion(&ar->scan.started);
5455                 reinit_completion(&ar->scan.completed);
5456                 reinit_completion(&ar->scan.on_channel);
5457                 ar->scan.state = ATH10K_SCAN_STARTING;
5458                 ar->scan.is_roc = true;
5459                 ar->scan.vdev_id = arvif->vdev_id;
5460                 ar->scan.roc_freq = chan->center_freq;
5461                 ar->scan.roc_notify = true;
5462                 ret = 0;
5463                 break;
5464         case ATH10K_SCAN_STARTING:
5465         case ATH10K_SCAN_RUNNING:
5466         case ATH10K_SCAN_ABORTING:
5467                 ret = -EBUSY;
5468                 break;
5469         }
5470         spin_unlock_bh(&ar->data_lock);
5471
5472         if (ret)
5473                 goto exit;
5474
5475         scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
5476
5477         memset(&arg, 0, sizeof(arg));
5478         ath10k_wmi_start_scan_init(ar, &arg);
5479         arg.vdev_id = arvif->vdev_id;
5480         arg.scan_id = ATH10K_SCAN_ID;
5481         arg.n_channels = 1;
5482         arg.channels[0] = chan->center_freq;
5483         arg.dwell_time_active = scan_time_msec;
5484         arg.dwell_time_passive = scan_time_msec;
5485         arg.max_scan_time = scan_time_msec;
5486         arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
5487         arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
5488         arg.burst_duration_ms = duration;
5489
5490         ret = ath10k_start_scan(ar, &arg);
5491         if (ret) {
5492                 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
5493                 spin_lock_bh(&ar->data_lock);
5494                 ar->scan.state = ATH10K_SCAN_IDLE;
5495                 spin_unlock_bh(&ar->data_lock);
5496                 goto exit;
5497         }
5498
5499         ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
5500         if (ret == 0) {
5501                 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
5502
5503                 ret = ath10k_scan_stop(ar);
5504                 if (ret)
5505                         ath10k_warn(ar, "failed to stop scan: %d\n", ret);
5506
5507                 ret = -ETIMEDOUT;
5508                 goto exit;
5509         }
5510
5511         ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
5512                                      msecs_to_jiffies(duration));
5513
5514         ret = 0;
5515 exit:
5516         mutex_unlock(&ar->conf_mutex);
5517         return ret;
5518 }
5519
5520 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
5521 {
5522         struct ath10k *ar = hw->priv;
5523
5524         mutex_lock(&ar->conf_mutex);
5525
5526         spin_lock_bh(&ar->data_lock);
5527         ar->scan.roc_notify = false;
5528         spin_unlock_bh(&ar->data_lock);
5529
5530         ath10k_scan_abort(ar);
5531
5532         mutex_unlock(&ar->conf_mutex);
5533
5534         cancel_delayed_work_sync(&ar->scan.timeout);
5535
5536         return 0;
5537 }
5538
5539 /*
5540  * Both RTS and Fragmentation threshold are interface-specific
5541  * in ath10k, but device-specific in mac80211.
5542  */
5543
5544 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
5545 {
5546         struct ath10k *ar = hw->priv;
5547         struct ath10k_vif *arvif;
5548         int ret = 0;
5549
5550         mutex_lock(&ar->conf_mutex);
5551         list_for_each_entry(arvif, &ar->arvifs, list) {
5552                 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
5553                            arvif->vdev_id, value);
5554
5555                 ret = ath10k_mac_set_rts(arvif, value);
5556                 if (ret) {
5557                         ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
5558                                     arvif->vdev_id, ret);
5559                         break;
5560                 }
5561         }
5562         mutex_unlock(&ar->conf_mutex);
5563
5564         return ret;
5565 }
5566
5567 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
5568                          u32 queues, bool drop)
5569 {
5570         struct ath10k *ar = hw->priv;
5571         bool skip;
5572         long time_left;
5573
5574         /* mac80211 doesn't care if we really xmit queued frames or not
5575          * we'll collect those frames either way if we stop/delete vdevs */
5576         if (drop)
5577                 return;
5578
5579         mutex_lock(&ar->conf_mutex);
5580
5581         if (ar->state == ATH10K_STATE_WEDGED)
5582                 goto skip;
5583
5584         time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
5585                         bool empty;
5586
5587                         spin_lock_bh(&ar->htt.tx_lock);
5588                         empty = (ar->htt.num_pending_tx == 0);
5589                         spin_unlock_bh(&ar->htt.tx_lock);
5590
5591                         skip = (ar->state == ATH10K_STATE_WEDGED) ||
5592                                test_bit(ATH10K_FLAG_CRASH_FLUSH,
5593                                         &ar->dev_flags);
5594
5595                         (empty || skip);
5596                 }), ATH10K_FLUSH_TIMEOUT_HZ);
5597
5598         if (time_left == 0 || skip)
5599                 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
5600                             skip, ar->state, time_left);
5601
5602 skip:
5603         mutex_unlock(&ar->conf_mutex);
5604 }
5605
5606 /* TODO: Implement this function properly
5607  * For now it is needed to reply to Probe Requests in IBSS mode.
5608  * Propably we need this information from FW.
5609  */
5610 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
5611 {
5612         return 1;
5613 }
5614
5615 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
5616                                      enum ieee80211_reconfig_type reconfig_type)
5617 {
5618         struct ath10k *ar = hw->priv;
5619
5620         if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
5621                 return;
5622
5623         mutex_lock(&ar->conf_mutex);
5624
5625         /* If device failed to restart it will be in a different state, e.g.
5626          * ATH10K_STATE_WEDGED */
5627         if (ar->state == ATH10K_STATE_RESTARTED) {
5628                 ath10k_info(ar, "device successfully recovered\n");
5629                 ar->state = ATH10K_STATE_ON;
5630                 ieee80211_wake_queues(ar->hw);
5631         }
5632
5633         mutex_unlock(&ar->conf_mutex);
5634 }
5635
5636 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
5637                              struct survey_info *survey)
5638 {
5639         struct ath10k *ar = hw->priv;
5640         struct ieee80211_supported_band *sband;
5641         struct survey_info *ar_survey = &ar->survey[idx];
5642         int ret = 0;
5643
5644         mutex_lock(&ar->conf_mutex);
5645
5646         sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
5647         if (sband && idx >= sband->n_channels) {
5648                 idx -= sband->n_channels;
5649                 sband = NULL;
5650         }
5651
5652         if (!sband)
5653                 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
5654
5655         if (!sband || idx >= sband->n_channels) {
5656                 ret = -ENOENT;
5657                 goto exit;
5658         }
5659
5660         spin_lock_bh(&ar->data_lock);
5661         memcpy(survey, ar_survey, sizeof(*survey));
5662         spin_unlock_bh(&ar->data_lock);
5663
5664         survey->channel = &sband->channels[idx];
5665
5666         if (ar->rx_channel == survey->channel)
5667                 survey->filled |= SURVEY_INFO_IN_USE;
5668
5669 exit:
5670         mutex_unlock(&ar->conf_mutex);
5671         return ret;
5672 }
5673
5674 static bool
5675 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
5676                                         enum ieee80211_band band,
5677                                         const struct cfg80211_bitrate_mask *mask)
5678 {
5679         int num_rates = 0;
5680         int i;
5681
5682         num_rates += hweight32(mask->control[band].legacy);
5683
5684         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
5685                 num_rates += hweight8(mask->control[band].ht_mcs[i]);
5686
5687         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++)
5688                 num_rates += hweight16(mask->control[band].vht_mcs[i]);
5689
5690         return num_rates == 1;
5691 }
5692
5693 static bool
5694 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
5695                                        enum ieee80211_band band,
5696                                        const struct cfg80211_bitrate_mask *mask,
5697                                        int *nss)
5698 {
5699         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
5700         u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
5701         u8 ht_nss_mask = 0;
5702         u8 vht_nss_mask = 0;
5703         int i;
5704
5705         if (mask->control[band].legacy)
5706                 return false;
5707
5708         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
5709                 if (mask->control[band].ht_mcs[i] == 0)
5710                         continue;
5711                 else if (mask->control[band].ht_mcs[i] ==
5712                          sband->ht_cap.mcs.rx_mask[i])
5713                         ht_nss_mask |= BIT(i);
5714                 else
5715                         return false;
5716         }
5717
5718         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
5719                 if (mask->control[band].vht_mcs[i] == 0)
5720                         continue;
5721                 else if (mask->control[band].vht_mcs[i] ==
5722                          ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
5723                         vht_nss_mask |= BIT(i);
5724                 else
5725                         return false;
5726         }
5727
5728         if (ht_nss_mask != vht_nss_mask)
5729                 return false;
5730
5731         if (ht_nss_mask == 0)
5732                 return false;
5733
5734         if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
5735                 return false;
5736
5737         *nss = fls(ht_nss_mask);
5738
5739         return true;
5740 }
5741
5742 static int
5743 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
5744                                         enum ieee80211_band band,
5745                                         const struct cfg80211_bitrate_mask *mask,
5746                                         u8 *rate, u8 *nss)
5747 {
5748         struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
5749         int rate_idx;
5750         int i;
5751         u16 bitrate;
5752         u8 preamble;
5753         u8 hw_rate;
5754
5755         if (hweight32(mask->control[band].legacy) == 1) {
5756                 rate_idx = ffs(mask->control[band].legacy) - 1;
5757
5758                 hw_rate = sband->bitrates[rate_idx].hw_value;
5759                 bitrate = sband->bitrates[rate_idx].bitrate;
5760
5761                 if (ath10k_mac_bitrate_is_cck(bitrate))
5762                         preamble = WMI_RATE_PREAMBLE_CCK;
5763                 else
5764                         preamble = WMI_RATE_PREAMBLE_OFDM;
5765
5766                 *nss = 1;
5767                 *rate = preamble << 6 |
5768                         (*nss - 1) << 4 |
5769                         hw_rate << 0;
5770
5771                 return 0;
5772         }
5773
5774         for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
5775                 if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
5776                         *nss = i + 1;
5777                         *rate = WMI_RATE_PREAMBLE_HT << 6 |
5778                                 (*nss - 1) << 4 |
5779                                 (ffs(mask->control[band].ht_mcs[i]) - 1);
5780
5781                         return 0;
5782                 }
5783         }
5784
5785         for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
5786                 if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
5787                         *nss = i + 1;
5788                         *rate = WMI_RATE_PREAMBLE_VHT << 6 |
5789                                 (*nss - 1) << 4 |
5790                                 (ffs(mask->control[band].vht_mcs[i]) - 1);
5791
5792                         return 0;
5793                 }
5794         }
5795
5796         return -EINVAL;
5797 }
5798
5799 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
5800                                             u8 rate, u8 nss, u8 sgi)
5801 {
5802         struct ath10k *ar = arvif->ar;
5803         u32 vdev_param;
5804         int ret;
5805
5806         lockdep_assert_held(&ar->conf_mutex);
5807
5808         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n",
5809                    arvif->vdev_id, rate, nss, sgi);
5810
5811         vdev_param = ar->wmi.vdev_param->fixed_rate;
5812         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
5813         if (ret) {
5814                 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
5815                             rate, ret);
5816                 return ret;
5817         }
5818
5819         vdev_param = ar->wmi.vdev_param->nss;
5820         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
5821         if (ret) {
5822                 ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
5823                 return ret;
5824         }
5825
5826         vdev_param = ar->wmi.vdev_param->sgi;
5827         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
5828         if (ret) {
5829                 ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
5830                 return ret;
5831         }
5832
5833         return 0;
5834 }
5835
5836 static bool
5837 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
5838                                 enum ieee80211_band band,
5839                                 const struct cfg80211_bitrate_mask *mask)
5840 {
5841         int i;
5842         u16 vht_mcs;
5843
5844         /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
5845          * to express all VHT MCS rate masks. Effectively only the following
5846          * ranges can be used: none, 0-7, 0-8 and 0-9.
5847          */
5848         for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
5849                 vht_mcs = mask->control[band].vht_mcs[i];
5850
5851                 switch (vht_mcs) {
5852                 case 0:
5853                 case BIT(8) - 1:
5854                 case BIT(9) - 1:
5855                 case BIT(10) - 1:
5856                         break;
5857                 default:
5858                         ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
5859                         return false;
5860                 }
5861         }
5862
5863         return true;
5864 }
5865
5866 static void ath10k_mac_set_bitrate_mask_iter(void *data,
5867                                              struct ieee80211_sta *sta)
5868 {
5869         struct ath10k_vif *arvif = data;
5870         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5871         struct ath10k *ar = arvif->ar;
5872
5873         if (arsta->arvif != arvif)
5874                 return;
5875
5876         spin_lock_bh(&ar->data_lock);
5877         arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
5878         spin_unlock_bh(&ar->data_lock);
5879
5880         ieee80211_queue_work(ar->hw, &arsta->update_wk);
5881 }
5882
5883 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
5884                                           struct ieee80211_vif *vif,
5885                                           const struct cfg80211_bitrate_mask *mask)
5886 {
5887         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
5888         struct cfg80211_chan_def def;
5889         struct ath10k *ar = arvif->ar;
5890         enum ieee80211_band band;
5891         const u8 *ht_mcs_mask;
5892         const u16 *vht_mcs_mask;
5893         u8 rate;
5894         u8 nss;
5895         u8 sgi;
5896         int single_nss;
5897         int ret;
5898
5899         if (ath10k_mac_vif_chan(vif, &def))
5900                 return -EPERM;
5901
5902         band = def.chan->band;
5903         ht_mcs_mask = mask->control[band].ht_mcs;
5904         vht_mcs_mask = mask->control[band].vht_mcs;
5905
5906         sgi = mask->control[band].gi;
5907         if (sgi == NL80211_TXRATE_FORCE_LGI)
5908                 return -EINVAL;
5909
5910         if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask)) {
5911                 ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
5912                                                               &rate, &nss);
5913                 if (ret) {
5914                         ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
5915                                     arvif->vdev_id, ret);
5916                         return ret;
5917                 }
5918         } else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
5919                                                           &single_nss)) {
5920                 rate = WMI_FIXED_RATE_NONE;
5921                 nss = single_nss;
5922         } else {
5923                 rate = WMI_FIXED_RATE_NONE;
5924                 nss = min(ar->num_rf_chains,
5925                           max(ath10k_mac_max_ht_nss(ht_mcs_mask),
5926                               ath10k_mac_max_vht_nss(vht_mcs_mask)));
5927
5928                 if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask))
5929                         return -EINVAL;
5930
5931                 mutex_lock(&ar->conf_mutex);
5932
5933                 arvif->bitrate_mask = *mask;
5934                 ieee80211_iterate_stations_atomic(ar->hw,
5935                                                   ath10k_mac_set_bitrate_mask_iter,
5936                                                   arvif);
5937
5938                 mutex_unlock(&ar->conf_mutex);
5939         }
5940
5941         mutex_lock(&ar->conf_mutex);
5942
5943         ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi);
5944         if (ret) {
5945                 ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
5946                             arvif->vdev_id, ret);
5947                 goto exit;
5948         }
5949
5950 exit:
5951         mutex_unlock(&ar->conf_mutex);
5952
5953         return ret;
5954 }
5955
5956 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
5957                                  struct ieee80211_vif *vif,
5958                                  struct ieee80211_sta *sta,
5959                                  u32 changed)
5960 {
5961         struct ath10k *ar = hw->priv;
5962         struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
5963         u32 bw, smps;
5964
5965         spin_lock_bh(&ar->data_lock);
5966
5967         ath10k_dbg(ar, ATH10K_DBG_MAC,
5968                    "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
5969                    sta->addr, changed, sta->bandwidth, sta->rx_nss,
5970                    sta->smps_mode);
5971
5972         if (changed & IEEE80211_RC_BW_CHANGED) {
5973                 bw = WMI_PEER_CHWIDTH_20MHZ;
5974
5975                 switch (sta->bandwidth) {
5976                 case IEEE80211_STA_RX_BW_20:
5977                         bw = WMI_PEER_CHWIDTH_20MHZ;
5978                         break;
5979                 case IEEE80211_STA_RX_BW_40:
5980                         bw = WMI_PEER_CHWIDTH_40MHZ;
5981                         break;
5982                 case IEEE80211_STA_RX_BW_80:
5983                         bw = WMI_PEER_CHWIDTH_80MHZ;
5984                         break;
5985                 case IEEE80211_STA_RX_BW_160:
5986                         ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
5987                                     sta->bandwidth, sta->addr);
5988                         bw = WMI_PEER_CHWIDTH_20MHZ;
5989                         break;
5990                 }
5991
5992                 arsta->bw = bw;
5993         }
5994
5995         if (changed & IEEE80211_RC_NSS_CHANGED)
5996                 arsta->nss = sta->rx_nss;
5997
5998         if (changed & IEEE80211_RC_SMPS_CHANGED) {
5999                 smps = WMI_PEER_SMPS_PS_NONE;
6000
6001                 switch (sta->smps_mode) {
6002                 case IEEE80211_SMPS_AUTOMATIC:
6003                 case IEEE80211_SMPS_OFF:
6004                         smps = WMI_PEER_SMPS_PS_NONE;
6005                         break;
6006                 case IEEE80211_SMPS_STATIC:
6007                         smps = WMI_PEER_SMPS_STATIC;
6008                         break;
6009                 case IEEE80211_SMPS_DYNAMIC:
6010                         smps = WMI_PEER_SMPS_DYNAMIC;
6011                         break;
6012                 case IEEE80211_SMPS_NUM_MODES:
6013                         ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
6014                                     sta->smps_mode, sta->addr);
6015                         smps = WMI_PEER_SMPS_PS_NONE;
6016                         break;
6017                 }
6018
6019                 arsta->smps = smps;
6020         }
6021
6022         arsta->changed |= changed;
6023
6024         spin_unlock_bh(&ar->data_lock);
6025
6026         ieee80211_queue_work(hw, &arsta->update_wk);
6027 }
6028
6029 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
6030 {
6031         /*
6032          * FIXME: Return 0 for time being. Need to figure out whether FW
6033          * has the API to fetch 64-bit local TSF
6034          */
6035
6036         return 0;
6037 }
6038
6039 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
6040                                struct ieee80211_vif *vif,
6041                                enum ieee80211_ampdu_mlme_action action,
6042                                struct ieee80211_sta *sta, u16 tid, u16 *ssn,
6043                                u8 buf_size)
6044 {
6045         struct ath10k *ar = hw->priv;
6046         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6047
6048         ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
6049                    arvif->vdev_id, sta->addr, tid, action);
6050
6051         switch (action) {
6052         case IEEE80211_AMPDU_RX_START:
6053         case IEEE80211_AMPDU_RX_STOP:
6054                 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
6055                  * creation/removal. Do we need to verify this?
6056                  */
6057                 return 0;
6058         case IEEE80211_AMPDU_TX_START:
6059         case IEEE80211_AMPDU_TX_STOP_CONT:
6060         case IEEE80211_AMPDU_TX_STOP_FLUSH:
6061         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
6062         case IEEE80211_AMPDU_TX_OPERATIONAL:
6063                 /* Firmware offloads Tx aggregation entirely so deny mac80211
6064                  * Tx aggregation requests.
6065                  */
6066                 return -EOPNOTSUPP;
6067         }
6068
6069         return -EINVAL;
6070 }
6071
6072 static void
6073 ath10k_mac_update_rx_channel(struct ath10k *ar,
6074                              struct ieee80211_chanctx_conf *ctx,
6075                              struct ieee80211_vif_chanctx_switch *vifs,
6076                              int n_vifs)
6077 {
6078         struct cfg80211_chan_def *def = NULL;
6079
6080         /* Both locks are required because ar->rx_channel is modified. This
6081          * allows readers to hold either lock.
6082          */
6083         lockdep_assert_held(&ar->conf_mutex);
6084         lockdep_assert_held(&ar->data_lock);
6085
6086         WARN_ON(ctx && vifs);
6087         WARN_ON(vifs && n_vifs != 1);
6088
6089         /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
6090          * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
6091          * ppdu on Rx may reduce performance on low-end systems. It should be
6092          * possible to make tables/hashmaps to speed the lookup up (be vary of
6093          * cpu data cache lines though regarding sizes) but to keep the initial
6094          * implementation simple and less intrusive fallback to the slow lookup
6095          * only for multi-channel cases. Single-channel cases will remain to
6096          * use the old channel derival and thus performance should not be
6097          * affected much.
6098          */
6099         rcu_read_lock();
6100         if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
6101                 ieee80211_iter_chan_contexts_atomic(ar->hw,
6102                                         ath10k_mac_get_any_chandef_iter,
6103                                         &def);
6104
6105                 if (vifs)
6106                         def = &vifs[0].new_ctx->def;
6107
6108                 ar->rx_channel = def->chan;
6109         } else if (ctx && ath10k_mac_num_chanctxs(ar) == 0) {
6110                 ar->rx_channel = ctx->def.chan;
6111         } else {
6112                 ar->rx_channel = NULL;
6113         }
6114         rcu_read_unlock();
6115 }
6116
6117 static int
6118 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
6119                           struct ieee80211_chanctx_conf *ctx)
6120 {
6121         struct ath10k *ar = hw->priv;
6122
6123         ath10k_dbg(ar, ATH10K_DBG_MAC,
6124                    "mac chanctx add freq %hu width %d ptr %p\n",
6125                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6126
6127         mutex_lock(&ar->conf_mutex);
6128
6129         spin_lock_bh(&ar->data_lock);
6130         ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
6131         spin_unlock_bh(&ar->data_lock);
6132
6133         ath10k_recalc_radar_detection(ar);
6134         ath10k_monitor_recalc(ar);
6135
6136         mutex_unlock(&ar->conf_mutex);
6137
6138         return 0;
6139 }
6140
6141 static void
6142 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
6143                              struct ieee80211_chanctx_conf *ctx)
6144 {
6145         struct ath10k *ar = hw->priv;
6146
6147         ath10k_dbg(ar, ATH10K_DBG_MAC,
6148                    "mac chanctx remove freq %hu width %d ptr %p\n",
6149                    ctx->def.chan->center_freq, ctx->def.width, ctx);
6150
6151         mutex_lock(&ar->conf_mutex);
6152
6153         spin_lock_bh(&ar->data_lock);
6154         ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
6155         spin_unlock_bh(&ar->data_lock);
6156
6157         ath10k_recalc_radar_detection(ar);
6158         ath10k_monitor_recalc(ar);
6159
6160         mutex_unlock(&ar->conf_mutex);
6161 }
6162
6163 static void
6164 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
6165                              struct ieee80211_chanctx_conf *ctx,
6166                              u32 changed)
6167 {
6168         struct ath10k *ar = hw->priv;
6169
6170         mutex_lock(&ar->conf_mutex);
6171
6172         ath10k_dbg(ar, ATH10K_DBG_MAC,
6173                    "mac chanctx change freq %hu width %d ptr %p changed %x\n",
6174                    ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
6175
6176         /* This shouldn't really happen because channel switching should use
6177          * switch_vif_chanctx().
6178          */
6179         if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
6180                 goto unlock;
6181
6182         ath10k_recalc_radar_detection(ar);
6183
6184         /* FIXME: How to configure Rx chains properly? */
6185
6186         /* No other actions are actually necessary. Firmware maintains channel
6187          * definitions per vdev internally and there's no host-side channel
6188          * context abstraction to configure, e.g. channel width.
6189          */
6190
6191 unlock:
6192         mutex_unlock(&ar->conf_mutex);
6193 }
6194
6195 static int
6196 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
6197                                  struct ieee80211_vif *vif,
6198                                  struct ieee80211_chanctx_conf *ctx)
6199 {
6200         struct ath10k *ar = hw->priv;
6201         struct ath10k_vif *arvif = (void *)vif->drv_priv;
6202         int ret;
6203
6204         mutex_lock(&ar->conf_mutex);
6205
6206         ath10k_dbg(ar, ATH10K_DBG_MAC,
6207                    "mac chanctx assign ptr %p vdev_id %i\n",
6208                    ctx, arvif->vdev_id);
6209
6210         if (WARN_ON(arvif->is_started)) {
6211                 mutex_unlock(&ar->conf_mutex);
6212                 return -EBUSY;
6213         }
6214
6215         ret = ath10k_vdev_start(arvif, &ctx->def);
6216         if (ret) {
6217                 ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
6218                             arvif->vdev_id, vif->addr,
6219                             ctx->def.chan->center_freq, ret);
6220                 goto err;
6221         }
6222
6223         arvif->is_started = true;
6224
6225         if (vif->type == NL80211_IFTYPE_MONITOR) {
6226                 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
6227                 if (ret) {
6228                         ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
6229                                     arvif->vdev_id, ret);
6230                         goto err_stop;
6231                 }
6232
6233                 arvif->is_up = true;
6234         }
6235
6236         mutex_unlock(&ar->conf_mutex);
6237         return 0;
6238
6239 err_stop:
6240         ath10k_vdev_stop(arvif);
6241         arvif->is_started = false;
6242
6243 err:
6244         mutex_unlock(&ar->conf_mutex);
6245         return ret;
6246 }
6247
6248 static void
6249 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
6250                                    struct ieee80211_vif *vif,
6251                                    struct ieee80211_chanctx_conf *ctx)
6252 {
6253         struct ath10k *ar = hw->priv;
6254         struct ath10k_vif *arvif = (void *)vif->drv_priv;
6255         int ret;
6256
6257         mutex_lock(&ar->conf_mutex);
6258
6259         ath10k_dbg(ar, ATH10K_DBG_MAC,
6260                    "mac chanctx unassign ptr %p vdev_id %i\n",
6261                    ctx, arvif->vdev_id);
6262
6263         WARN_ON(!arvif->is_started);
6264
6265         if (vif->type == NL80211_IFTYPE_MONITOR) {
6266                 WARN_ON(!arvif->is_up);
6267
6268                 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6269                 if (ret)
6270                         ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
6271                                     arvif->vdev_id, ret);
6272
6273                 arvif->is_up = false;
6274         }
6275
6276         ret = ath10k_vdev_stop(arvif);
6277         if (ret)
6278                 ath10k_warn(ar, "failed to stop vdev %i: %d\n",
6279                             arvif->vdev_id, ret);
6280
6281         arvif->is_started = false;
6282
6283         mutex_unlock(&ar->conf_mutex);
6284 }
6285
6286 static int
6287 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
6288                                  struct ieee80211_vif_chanctx_switch *vifs,
6289                                  int n_vifs,
6290                                  enum ieee80211_chanctx_switch_mode mode)
6291 {
6292         struct ath10k *ar = hw->priv;
6293         struct ath10k_vif *arvif;
6294         int ret;
6295         int i;
6296
6297         mutex_lock(&ar->conf_mutex);
6298
6299         ath10k_dbg(ar, ATH10K_DBG_MAC,
6300                    "mac chanctx switch n_vifs %d mode %d\n",
6301                    n_vifs, mode);
6302
6303         /* First stop monitor interface. Some FW versions crash if there's a
6304          * lone monitor interface.
6305          */
6306         if (ar->monitor_started)
6307                 ath10k_monitor_stop(ar);
6308
6309         for (i = 0; i < n_vifs; i++) {
6310                 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6311
6312                 ath10k_dbg(ar, ATH10K_DBG_MAC,
6313                            "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n",
6314                            arvif->vdev_id,
6315                            vifs[i].old_ctx->def.chan->center_freq,
6316                            vifs[i].new_ctx->def.chan->center_freq,
6317                            vifs[i].old_ctx->def.width,
6318                            vifs[i].new_ctx->def.width);
6319
6320                 if (WARN_ON(!arvif->is_started))
6321                         continue;
6322
6323                 if (WARN_ON(!arvif->is_up))
6324                         continue;
6325
6326                 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
6327                 if (ret) {
6328                         ath10k_warn(ar, "failed to down vdev %d: %d\n",
6329                                     arvif->vdev_id, ret);
6330                         continue;
6331                 }
6332         }
6333
6334         /* All relevant vdevs are downed and associated channel resources
6335          * should be available for the channel switch now.
6336          */
6337
6338         spin_lock_bh(&ar->data_lock);
6339         ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
6340         spin_unlock_bh(&ar->data_lock);
6341
6342         for (i = 0; i < n_vifs; i++) {
6343                 arvif = ath10k_vif_to_arvif(vifs[i].vif);
6344
6345                 if (WARN_ON(!arvif->is_started))
6346                         continue;
6347
6348                 if (WARN_ON(!arvif->is_up))
6349                         continue;
6350
6351                 ret = ath10k_mac_setup_bcn_tmpl(arvif);
6352                 if (ret)
6353                         ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
6354                                     ret);
6355
6356                 ret = ath10k_mac_setup_prb_tmpl(arvif);
6357                 if (ret)
6358                         ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
6359                                     ret);
6360
6361                 ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
6362                 if (ret) {
6363                         ath10k_warn(ar, "failed to restart vdev %d: %d\n",
6364                                     arvif->vdev_id, ret);
6365                         continue;
6366                 }
6367
6368                 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
6369                                          arvif->bssid);
6370                 if (ret) {
6371                         ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
6372                                     arvif->vdev_id, ret);
6373                         continue;
6374                 }
6375         }
6376
6377         ath10k_monitor_recalc(ar);
6378
6379         mutex_unlock(&ar->conf_mutex);
6380         return 0;
6381 }
6382
6383 static const struct ieee80211_ops ath10k_ops = {
6384         .tx                             = ath10k_tx,
6385         .start                          = ath10k_start,
6386         .stop                           = ath10k_stop,
6387         .config                         = ath10k_config,
6388         .add_interface                  = ath10k_add_interface,
6389         .remove_interface               = ath10k_remove_interface,
6390         .configure_filter               = ath10k_configure_filter,
6391         .bss_info_changed               = ath10k_bss_info_changed,
6392         .hw_scan                        = ath10k_hw_scan,
6393         .cancel_hw_scan                 = ath10k_cancel_hw_scan,
6394         .set_key                        = ath10k_set_key,
6395         .set_default_unicast_key        = ath10k_set_default_unicast_key,
6396         .sta_state                      = ath10k_sta_state,
6397         .conf_tx                        = ath10k_conf_tx,
6398         .remain_on_channel              = ath10k_remain_on_channel,
6399         .cancel_remain_on_channel       = ath10k_cancel_remain_on_channel,
6400         .set_rts_threshold              = ath10k_set_rts_threshold,
6401         .flush                          = ath10k_flush,
6402         .tx_last_beacon                 = ath10k_tx_last_beacon,
6403         .set_antenna                    = ath10k_set_antenna,
6404         .get_antenna                    = ath10k_get_antenna,
6405         .reconfig_complete              = ath10k_reconfig_complete,
6406         .get_survey                     = ath10k_get_survey,
6407         .set_bitrate_mask               = ath10k_mac_op_set_bitrate_mask,
6408         .sta_rc_update                  = ath10k_sta_rc_update,
6409         .get_tsf                        = ath10k_get_tsf,
6410         .ampdu_action                   = ath10k_ampdu_action,
6411         .get_et_sset_count              = ath10k_debug_get_et_sset_count,
6412         .get_et_stats                   = ath10k_debug_get_et_stats,
6413         .get_et_strings                 = ath10k_debug_get_et_strings,
6414         .add_chanctx                    = ath10k_mac_op_add_chanctx,
6415         .remove_chanctx                 = ath10k_mac_op_remove_chanctx,
6416         .change_chanctx                 = ath10k_mac_op_change_chanctx,
6417         .assign_vif_chanctx             = ath10k_mac_op_assign_vif_chanctx,
6418         .unassign_vif_chanctx           = ath10k_mac_op_unassign_vif_chanctx,
6419         .switch_vif_chanctx             = ath10k_mac_op_switch_vif_chanctx,
6420
6421         CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
6422
6423 #ifdef CONFIG_PM
6424         .suspend                        = ath10k_wow_op_suspend,
6425         .resume                         = ath10k_wow_op_resume,
6426 #endif
6427 #ifdef CONFIG_MAC80211_DEBUGFS
6428         .sta_add_debugfs                = ath10k_sta_add_debugfs,
6429 #endif
6430 };
6431
6432 #define CHAN2G(_channel, _freq, _flags) { \
6433         .band                   = IEEE80211_BAND_2GHZ, \
6434         .hw_value               = (_channel), \
6435         .center_freq            = (_freq), \
6436         .flags                  = (_flags), \
6437         .max_antenna_gain       = 0, \
6438         .max_power              = 30, \
6439 }
6440
6441 #define CHAN5G(_channel, _freq, _flags) { \
6442         .band                   = IEEE80211_BAND_5GHZ, \
6443         .hw_value               = (_channel), \
6444         .center_freq            = (_freq), \
6445         .flags                  = (_flags), \
6446         .max_antenna_gain       = 0, \
6447         .max_power              = 30, \
6448 }
6449
6450 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
6451         CHAN2G(1, 2412, 0),
6452         CHAN2G(2, 2417, 0),
6453         CHAN2G(3, 2422, 0),
6454         CHAN2G(4, 2427, 0),
6455         CHAN2G(5, 2432, 0),
6456         CHAN2G(6, 2437, 0),
6457         CHAN2G(7, 2442, 0),
6458         CHAN2G(8, 2447, 0),
6459         CHAN2G(9, 2452, 0),
6460         CHAN2G(10, 2457, 0),
6461         CHAN2G(11, 2462, 0),
6462         CHAN2G(12, 2467, 0),
6463         CHAN2G(13, 2472, 0),
6464         CHAN2G(14, 2484, 0),
6465 };
6466
6467 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
6468         CHAN5G(36, 5180, 0),
6469         CHAN5G(40, 5200, 0),
6470         CHAN5G(44, 5220, 0),
6471         CHAN5G(48, 5240, 0),
6472         CHAN5G(52, 5260, 0),
6473         CHAN5G(56, 5280, 0),
6474         CHAN5G(60, 5300, 0),
6475         CHAN5G(64, 5320, 0),
6476         CHAN5G(100, 5500, 0),
6477         CHAN5G(104, 5520, 0),
6478         CHAN5G(108, 5540, 0),
6479         CHAN5G(112, 5560, 0),
6480         CHAN5G(116, 5580, 0),
6481         CHAN5G(120, 5600, 0),
6482         CHAN5G(124, 5620, 0),
6483         CHAN5G(128, 5640, 0),
6484         CHAN5G(132, 5660, 0),
6485         CHAN5G(136, 5680, 0),
6486         CHAN5G(140, 5700, 0),
6487         CHAN5G(144, 5720, 0),
6488         CHAN5G(149, 5745, 0),
6489         CHAN5G(153, 5765, 0),
6490         CHAN5G(157, 5785, 0),
6491         CHAN5G(161, 5805, 0),
6492         CHAN5G(165, 5825, 0),
6493 };
6494
6495 struct ath10k *ath10k_mac_create(size_t priv_size)
6496 {
6497         struct ieee80211_hw *hw;
6498         struct ath10k *ar;
6499
6500         hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
6501         if (!hw)
6502                 return NULL;
6503
6504         ar = hw->priv;
6505         ar->hw = hw;
6506
6507         return ar;
6508 }
6509
6510 void ath10k_mac_destroy(struct ath10k *ar)
6511 {
6512         ieee80211_free_hw(ar->hw);
6513 }
6514
6515 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
6516         {
6517         .max    = 8,
6518         .types  = BIT(NL80211_IFTYPE_STATION)
6519                 | BIT(NL80211_IFTYPE_P2P_CLIENT)
6520         },
6521         {
6522         .max    = 3,
6523         .types  = BIT(NL80211_IFTYPE_P2P_GO)
6524         },
6525         {
6526         .max    = 1,
6527         .types  = BIT(NL80211_IFTYPE_P2P_DEVICE)
6528         },
6529         {
6530         .max    = 7,
6531         .types  = BIT(NL80211_IFTYPE_AP)
6532         },
6533 };
6534
6535 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
6536         {
6537         .max    = 8,
6538         .types  = BIT(NL80211_IFTYPE_AP)
6539         },
6540 };
6541
6542 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
6543         {
6544                 .limits = ath10k_if_limits,
6545                 .n_limits = ARRAY_SIZE(ath10k_if_limits),
6546                 .max_interfaces = 8,
6547                 .num_different_channels = 1,
6548                 .beacon_int_infra_match = true,
6549         },
6550 };
6551
6552 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
6553         {
6554                 .limits = ath10k_10x_if_limits,
6555                 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
6556                 .max_interfaces = 8,
6557                 .num_different_channels = 1,
6558                 .beacon_int_infra_match = true,
6559 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6560                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6561                                         BIT(NL80211_CHAN_WIDTH_20) |
6562                                         BIT(NL80211_CHAN_WIDTH_40) |
6563                                         BIT(NL80211_CHAN_WIDTH_80),
6564 #endif
6565         },
6566 };
6567
6568 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
6569         {
6570                 .max = 2,
6571                 .types = BIT(NL80211_IFTYPE_STATION) |
6572                          BIT(NL80211_IFTYPE_AP) |
6573                          BIT(NL80211_IFTYPE_P2P_CLIENT) |
6574                          BIT(NL80211_IFTYPE_P2P_GO),
6575         },
6576         {
6577                 .max = 1,
6578                 .types = BIT(NL80211_IFTYPE_P2P_DEVICE),
6579         },
6580 };
6581
6582 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
6583         {
6584                 .max = 1,
6585                 .types = BIT(NL80211_IFTYPE_STATION),
6586         },
6587         {
6588                 .max = 1,
6589                 .types = BIT(NL80211_IFTYPE_ADHOC),
6590         },
6591 };
6592
6593 /* FIXME: This is not thouroughly tested. These combinations may over- or
6594  * underestimate hw/fw capabilities.
6595  */
6596 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
6597         {
6598                 .limits = ath10k_tlv_if_limit,
6599                 .num_different_channels = 1,
6600                 .max_interfaces = 3,
6601                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
6602         },
6603         {
6604                 .limits = ath10k_tlv_if_limit_ibss,
6605                 .num_different_channels = 1,
6606                 .max_interfaces = 2,
6607                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
6608         },
6609 };
6610
6611 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
6612         {
6613                 .limits = ath10k_tlv_if_limit,
6614                 .num_different_channels = 2,
6615                 .max_interfaces = 3,
6616                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
6617         },
6618         {
6619                 .limits = ath10k_tlv_if_limit_ibss,
6620                 .num_different_channels = 1,
6621                 .max_interfaces = 2,
6622                 .n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
6623         },
6624 };
6625
6626 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
6627         {
6628                 .max = 1,
6629                 .types = BIT(NL80211_IFTYPE_STATION),
6630         },
6631         {
6632                 .max    = 16,
6633                 .types  = BIT(NL80211_IFTYPE_AP)
6634         },
6635 };
6636
6637 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
6638         {
6639                 .limits = ath10k_10_4_if_limits,
6640                 .n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
6641                 .max_interfaces = 16,
6642                 .num_different_channels = 1,
6643                 .beacon_int_infra_match = true,
6644 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6645                 .radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
6646                                         BIT(NL80211_CHAN_WIDTH_20) |
6647                                         BIT(NL80211_CHAN_WIDTH_40) |
6648                                         BIT(NL80211_CHAN_WIDTH_80),
6649 #endif
6650         },
6651 };
6652
6653 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
6654 {
6655         struct ieee80211_sta_vht_cap vht_cap = {0};
6656         u16 mcs_map;
6657         u32 val;
6658         int i;
6659
6660         vht_cap.vht_supported = 1;
6661         vht_cap.cap = ar->vht_cap_info;
6662
6663         if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
6664                                 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
6665                 val = ar->num_rf_chains - 1;
6666                 val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
6667                 val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
6668
6669                 vht_cap.cap |= val;
6670         }
6671
6672         if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
6673                                 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
6674                 val = ar->num_rf_chains - 1;
6675                 val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
6676                 val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
6677
6678                 vht_cap.cap |= val;
6679         }
6680
6681         mcs_map = 0;
6682         for (i = 0; i < 8; i++) {
6683                 if (i < ar->num_rf_chains)
6684                         mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
6685                 else
6686                         mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
6687         }
6688
6689         vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
6690         vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
6691
6692         return vht_cap;
6693 }
6694
6695 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
6696 {
6697         int i;
6698         struct ieee80211_sta_ht_cap ht_cap = {0};
6699
6700         if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
6701                 return ht_cap;
6702
6703         ht_cap.ht_supported = 1;
6704         ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
6705         ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
6706         ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
6707         ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
6708         ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
6709
6710         if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
6711                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
6712
6713         if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
6714                 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
6715
6716         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
6717                 u32 smps;
6718
6719                 smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
6720                 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
6721
6722                 ht_cap.cap |= smps;
6723         }
6724
6725         if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
6726                 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
6727
6728         if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
6729                 u32 stbc;
6730
6731                 stbc   = ar->ht_cap_info;
6732                 stbc  &= WMI_HT_CAP_RX_STBC;
6733                 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
6734                 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
6735                 stbc  &= IEEE80211_HT_CAP_RX_STBC;
6736
6737                 ht_cap.cap |= stbc;
6738         }
6739
6740         if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
6741                 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
6742
6743         if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
6744                 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
6745
6746         /* max AMSDU is implicitly taken from vht_cap_info */
6747         if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
6748                 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
6749
6750         for (i = 0; i < ar->num_rf_chains; i++)
6751                 ht_cap.mcs.rx_mask[i] = 0xFF;
6752
6753         ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
6754
6755         return ht_cap;
6756 }
6757
6758 static void ath10k_get_arvif_iter(void *data, u8 *mac,
6759                                   struct ieee80211_vif *vif)
6760 {
6761         struct ath10k_vif_iter *arvif_iter = data;
6762         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
6763
6764         if (arvif->vdev_id == arvif_iter->vdev_id)
6765                 arvif_iter->arvif = arvif;
6766 }
6767
6768 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
6769 {
6770         struct ath10k_vif_iter arvif_iter;
6771         u32 flags;
6772
6773         memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
6774         arvif_iter.vdev_id = vdev_id;
6775
6776         flags = IEEE80211_IFACE_ITER_RESUME_ALL;
6777         ieee80211_iterate_active_interfaces_atomic(ar->hw,
6778                                                    flags,
6779                                                    ath10k_get_arvif_iter,
6780                                                    &arvif_iter);
6781         if (!arvif_iter.arvif) {
6782                 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
6783                 return NULL;
6784         }
6785
6786         return arvif_iter.arvif;
6787 }
6788
6789 int ath10k_mac_register(struct ath10k *ar)
6790 {
6791         static const u32 cipher_suites[] = {
6792                 WLAN_CIPHER_SUITE_WEP40,
6793                 WLAN_CIPHER_SUITE_WEP104,
6794                 WLAN_CIPHER_SUITE_TKIP,
6795                 WLAN_CIPHER_SUITE_CCMP,
6796                 WLAN_CIPHER_SUITE_AES_CMAC,
6797         };
6798         struct ieee80211_supported_band *band;
6799         struct ieee80211_sta_vht_cap vht_cap;
6800         struct ieee80211_sta_ht_cap ht_cap;
6801         void *channels;
6802         int ret;
6803
6804         SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
6805
6806         SET_IEEE80211_DEV(ar->hw, ar->dev);
6807
6808         ht_cap = ath10k_get_ht_cap(ar);
6809         vht_cap = ath10k_create_vht_cap(ar);
6810
6811         BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
6812                       ARRAY_SIZE(ath10k_5ghz_channels)) !=
6813                      ATH10K_NUM_CHANS);
6814
6815         if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
6816                 channels = kmemdup(ath10k_2ghz_channels,
6817                                    sizeof(ath10k_2ghz_channels),
6818                                    GFP_KERNEL);
6819                 if (!channels) {
6820                         ret = -ENOMEM;
6821                         goto err_free;
6822                 }
6823
6824                 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
6825                 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
6826                 band->channels = channels;
6827                 band->n_bitrates = ath10k_g_rates_size;
6828                 band->bitrates = ath10k_g_rates;
6829                 band->ht_cap = ht_cap;
6830
6831                 /* Enable the VHT support at 2.4 GHz */
6832                 band->vht_cap = vht_cap;
6833
6834                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
6835         }
6836
6837         if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
6838                 channels = kmemdup(ath10k_5ghz_channels,
6839                                    sizeof(ath10k_5ghz_channels),
6840                                    GFP_KERNEL);
6841                 if (!channels) {
6842                         ret = -ENOMEM;
6843                         goto err_free;
6844                 }
6845
6846                 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
6847                 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
6848                 band->channels = channels;
6849                 band->n_bitrates = ath10k_a_rates_size;
6850                 band->bitrates = ath10k_a_rates;
6851                 band->ht_cap = ht_cap;
6852                 band->vht_cap = vht_cap;
6853                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
6854         }
6855
6856         ar->hw->wiphy->interface_modes =
6857                 BIT(NL80211_IFTYPE_STATION) |
6858                 BIT(NL80211_IFTYPE_AP);
6859
6860         ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
6861         ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
6862
6863         if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
6864                 ar->hw->wiphy->interface_modes |=
6865                         BIT(NL80211_IFTYPE_P2P_DEVICE) |
6866                         BIT(NL80211_IFTYPE_P2P_CLIENT) |
6867                         BIT(NL80211_IFTYPE_P2P_GO);
6868
6869         ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
6870                         IEEE80211_HW_SUPPORTS_PS |
6871                         IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
6872                         IEEE80211_HW_MFP_CAPABLE |
6873                         IEEE80211_HW_REPORTS_TX_ACK_STATUS |
6874                         IEEE80211_HW_HAS_RATE_CONTROL |
6875                         IEEE80211_HW_AP_LINK_PS |
6876                         IEEE80211_HW_SPECTRUM_MGMT |
6877                         IEEE80211_HW_SW_CRYPTO_CONTROL |
6878                         IEEE80211_HW_SUPPORT_FAST_XMIT |
6879                         IEEE80211_HW_CONNECTION_MONITOR |
6880                         IEEE80211_HW_SUPPORTS_PER_STA_GTK |
6881                         IEEE80211_HW_WANT_MONITOR_VIF |
6882                         IEEE80211_HW_CHANCTX_STA_CSA |
6883                         IEEE80211_HW_QUEUE_CONTROL;
6884
6885         ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
6886         ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
6887
6888         if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
6889                 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
6890
6891         if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
6892                 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
6893                 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
6894         }
6895
6896         ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
6897         ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
6898
6899         ar->hw->vif_data_size = sizeof(struct ath10k_vif);
6900         ar->hw->sta_data_size = sizeof(struct ath10k_sta);
6901
6902         ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
6903
6904         if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
6905                 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
6906
6907                 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
6908                  * that userspace (e.g. wpa_supplicant/hostapd) can generate
6909                  * correct Probe Responses. This is more of a hack advert..
6910                  */
6911                 ar->hw->wiphy->probe_resp_offload |=
6912                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
6913                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
6914                         NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
6915         }
6916
6917         if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map))
6918                 ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
6919
6920         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
6921         ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
6922         ar->hw->wiphy->max_remain_on_channel_duration = 5000;
6923
6924         ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
6925         ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE;
6926
6927         ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
6928
6929         ret = ath10k_wow_init(ar);
6930         if (ret) {
6931                 ath10k_warn(ar, "failed to init wow: %d\n", ret);
6932                 goto err_free;
6933         }
6934
6935         wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
6936
6937         /*
6938          * on LL hardware queues are managed entirely by the FW
6939          * so we only advertise to mac we can do the queues thing
6940          */
6941         ar->hw->queues = IEEE80211_MAX_QUEUES;
6942
6943         /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
6944          * something that vdev_ids can't reach so that we don't stop the queue
6945          * accidentally.
6946          */
6947         ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
6948
6949         switch (ar->wmi.op_version) {
6950         case ATH10K_FW_WMI_OP_VERSION_MAIN:
6951                 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
6952                 ar->hw->wiphy->n_iface_combinations =
6953                         ARRAY_SIZE(ath10k_if_comb);
6954                 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
6955                 break;
6956         case ATH10K_FW_WMI_OP_VERSION_TLV:
6957                 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
6958                         ar->hw->wiphy->iface_combinations =
6959                                 ath10k_tlv_qcs_if_comb;
6960                         ar->hw->wiphy->n_iface_combinations =
6961                                 ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
6962                 } else {
6963                         ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
6964                         ar->hw->wiphy->n_iface_combinations =
6965                                 ARRAY_SIZE(ath10k_tlv_if_comb);
6966                 }
6967                 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
6968                 break;
6969         case ATH10K_FW_WMI_OP_VERSION_10_1:
6970         case ATH10K_FW_WMI_OP_VERSION_10_2:
6971         case ATH10K_FW_WMI_OP_VERSION_10_2_4:
6972                 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
6973                 ar->hw->wiphy->n_iface_combinations =
6974                         ARRAY_SIZE(ath10k_10x_if_comb);
6975                 break;
6976         case ATH10K_FW_WMI_OP_VERSION_10_4:
6977                 ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
6978                 ar->hw->wiphy->n_iface_combinations =
6979                         ARRAY_SIZE(ath10k_10_4_if_comb);
6980                 break;
6981         case ATH10K_FW_WMI_OP_VERSION_UNSET:
6982         case ATH10K_FW_WMI_OP_VERSION_MAX:
6983                 WARN_ON(1);
6984                 ret = -EINVAL;
6985                 goto err_free;
6986         }
6987
6988         ar->hw->netdev_features = NETIF_F_HW_CSUM;
6989
6990         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
6991                 /* Init ath dfs pattern detector */
6992                 ar->ath_common.debug_mask = ATH_DBG_DFS;
6993                 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
6994                                                              NL80211_DFS_UNSET);
6995
6996                 if (!ar->dfs_detector)
6997                         ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
6998         }
6999
7000         ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
7001                             ath10k_reg_notifier);
7002         if (ret) {
7003                 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
7004                 goto err_free;
7005         }
7006
7007         ar->hw->wiphy->cipher_suites = cipher_suites;
7008         ar->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
7009
7010         ret = ieee80211_register_hw(ar->hw);
7011         if (ret) {
7012                 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
7013                 goto err_free;
7014         }
7015
7016         if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
7017                 ret = regulatory_hint(ar->hw->wiphy,
7018                                       ar->ath_common.regulatory.alpha2);
7019                 if (ret)
7020                         goto err_unregister;
7021         }
7022
7023         return 0;
7024
7025 err_unregister:
7026         ieee80211_unregister_hw(ar->hw);
7027 err_free:
7028         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7029         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7030
7031         return ret;
7032 }
7033
7034 void ath10k_mac_unregister(struct ath10k *ar)
7035 {
7036         ieee80211_unregister_hw(ar->hw);
7037
7038         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
7039                 ar->dfs_detector->exit(ar->dfs_detector);
7040
7041         kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
7042         kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
7043
7044         SET_IEEE80211_DEV(ar->hw, NULL);
7045 }