orinoco_usb: use USB API functions rather than constants
[sfrench/cifs-2.6.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
30 /**********/
31 /* Crypto */
32 /**********/
33
34 static int ath10k_send_key(struct ath10k_vif *arvif,
35                            struct ieee80211_key_conf *key,
36                            enum set_key_cmd cmd,
37                            const u8 *macaddr)
38 {
39         struct wmi_vdev_install_key_arg arg = {
40                 .vdev_id = arvif->vdev_id,
41                 .key_idx = key->keyidx,
42                 .key_len = key->keylen,
43                 .key_data = key->key,
44                 .macaddr = macaddr,
45         };
46
47         lockdep_assert_held(&arvif->ar->conf_mutex);
48
49         if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
50                 arg.key_flags = WMI_KEY_PAIRWISE;
51         else
52                 arg.key_flags = WMI_KEY_GROUP;
53
54         switch (key->cipher) {
55         case WLAN_CIPHER_SUITE_CCMP:
56                 arg.key_cipher = WMI_CIPHER_AES_CCM;
57                 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
58                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
59                 else
60                         key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
61                 break;
62         case WLAN_CIPHER_SUITE_TKIP:
63                 arg.key_cipher = WMI_CIPHER_TKIP;
64                 arg.key_txmic_len = 8;
65                 arg.key_rxmic_len = 8;
66                 break;
67         case WLAN_CIPHER_SUITE_WEP40:
68         case WLAN_CIPHER_SUITE_WEP104:
69                 arg.key_cipher = WMI_CIPHER_WEP;
70                 /* AP/IBSS mode requires self-key to be groupwise
71                  * Otherwise pairwise key must be set */
72                 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
73                         arg.key_flags = WMI_KEY_PAIRWISE;
74                 break;
75         default:
76                 ath10k_warn("cipher %d is not supported\n", key->cipher);
77                 return -EOPNOTSUPP;
78         }
79
80         if (cmd == DISABLE_KEY) {
81                 arg.key_cipher = WMI_CIPHER_NONE;
82                 arg.key_data = NULL;
83         }
84
85         return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
86 }
87
88 static int ath10k_install_key(struct ath10k_vif *arvif,
89                               struct ieee80211_key_conf *key,
90                               enum set_key_cmd cmd,
91                               const u8 *macaddr)
92 {
93         struct ath10k *ar = arvif->ar;
94         int ret;
95
96         lockdep_assert_held(&ar->conf_mutex);
97
98         reinit_completion(&ar->install_key_done);
99
100         ret = ath10k_send_key(arvif, key, cmd, macaddr);
101         if (ret)
102                 return ret;
103
104         ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
105         if (ret == 0)
106                 return -ETIMEDOUT;
107
108         return 0;
109 }
110
111 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
112                                         const u8 *addr)
113 {
114         struct ath10k *ar = arvif->ar;
115         struct ath10k_peer *peer;
116         int ret;
117         int i;
118
119         lockdep_assert_held(&ar->conf_mutex);
120
121         spin_lock_bh(&ar->data_lock);
122         peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
123         spin_unlock_bh(&ar->data_lock);
124
125         if (!peer)
126                 return -ENOENT;
127
128         for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
129                 if (arvif->wep_keys[i] == NULL)
130                         continue;
131
132                 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
133                                          addr);
134                 if (ret)
135                         return ret;
136
137                 peer->keys[i] = arvif->wep_keys[i];
138         }
139
140         return 0;
141 }
142
143 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
144                                   const u8 *addr)
145 {
146         struct ath10k *ar = arvif->ar;
147         struct ath10k_peer *peer;
148         int first_errno = 0;
149         int ret;
150         int i;
151
152         lockdep_assert_held(&ar->conf_mutex);
153
154         spin_lock_bh(&ar->data_lock);
155         peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
156         spin_unlock_bh(&ar->data_lock);
157
158         if (!peer)
159                 return -ENOENT;
160
161         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
162                 if (peer->keys[i] == NULL)
163                         continue;
164
165                 ret = ath10k_install_key(arvif, peer->keys[i],
166                                          DISABLE_KEY, addr);
167                 if (ret && first_errno == 0)
168                         first_errno = ret;
169
170                 if (ret)
171                         ath10k_warn("failed to remove peer wep key %d: %d\n",
172                                     i, ret);
173
174                 peer->keys[i] = NULL;
175         }
176
177         return first_errno;
178 }
179
180 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
181                                  struct ieee80211_key_conf *key)
182 {
183         struct ath10k *ar = arvif->ar;
184         struct ath10k_peer *peer;
185         u8 addr[ETH_ALEN];
186         int first_errno = 0;
187         int ret;
188         int i;
189
190         lockdep_assert_held(&ar->conf_mutex);
191
192         for (;;) {
193                 /* since ath10k_install_key we can't hold data_lock all the
194                  * time, so we try to remove the keys incrementally */
195                 spin_lock_bh(&ar->data_lock);
196                 i = 0;
197                 list_for_each_entry(peer, &ar->peers, list) {
198                         for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
199                                 if (peer->keys[i] == key) {
200                                         memcpy(addr, peer->addr, ETH_ALEN);
201                                         peer->keys[i] = NULL;
202                                         break;
203                                 }
204                         }
205
206                         if (i < ARRAY_SIZE(peer->keys))
207                                 break;
208                 }
209                 spin_unlock_bh(&ar->data_lock);
210
211                 if (i == ARRAY_SIZE(peer->keys))
212                         break;
213
214                 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
215                 if (ret && first_errno == 0)
216                         first_errno = ret;
217
218                 if (ret)
219                         ath10k_warn("failed to remove key for %pM: %d\n",
220                                     addr, ret);
221         }
222
223         return first_errno;
224 }
225
226
227 /*********************/
228 /* General utilities */
229 /*********************/
230
231 static inline enum wmi_phy_mode
232 chan_to_phymode(const struct cfg80211_chan_def *chandef)
233 {
234         enum wmi_phy_mode phymode = MODE_UNKNOWN;
235
236         switch (chandef->chan->band) {
237         case IEEE80211_BAND_2GHZ:
238                 switch (chandef->width) {
239                 case NL80211_CHAN_WIDTH_20_NOHT:
240                         phymode = MODE_11G;
241                         break;
242                 case NL80211_CHAN_WIDTH_20:
243                         phymode = MODE_11NG_HT20;
244                         break;
245                 case NL80211_CHAN_WIDTH_40:
246                         phymode = MODE_11NG_HT40;
247                         break;
248                 case NL80211_CHAN_WIDTH_5:
249                 case NL80211_CHAN_WIDTH_10:
250                 case NL80211_CHAN_WIDTH_80:
251                 case NL80211_CHAN_WIDTH_80P80:
252                 case NL80211_CHAN_WIDTH_160:
253                         phymode = MODE_UNKNOWN;
254                         break;
255                 }
256                 break;
257         case IEEE80211_BAND_5GHZ:
258                 switch (chandef->width) {
259                 case NL80211_CHAN_WIDTH_20_NOHT:
260                         phymode = MODE_11A;
261                         break;
262                 case NL80211_CHAN_WIDTH_20:
263                         phymode = MODE_11NA_HT20;
264                         break;
265                 case NL80211_CHAN_WIDTH_40:
266                         phymode = MODE_11NA_HT40;
267                         break;
268                 case NL80211_CHAN_WIDTH_80:
269                         phymode = MODE_11AC_VHT80;
270                         break;
271                 case NL80211_CHAN_WIDTH_5:
272                 case NL80211_CHAN_WIDTH_10:
273                 case NL80211_CHAN_WIDTH_80P80:
274                 case NL80211_CHAN_WIDTH_160:
275                         phymode = MODE_UNKNOWN;
276                         break;
277                 }
278                 break;
279         default:
280                 break;
281         }
282
283         WARN_ON(phymode == MODE_UNKNOWN);
284         return phymode;
285 }
286
287 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
288 {
289 /*
290  * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
291  *   0 for no restriction
292  *   1 for 1/4 us
293  *   2 for 1/2 us
294  *   3 for 1 us
295  *   4 for 2 us
296  *   5 for 4 us
297  *   6 for 8 us
298  *   7 for 16 us
299  */
300         switch (mpdudensity) {
301         case 0:
302                 return 0;
303         case 1:
304         case 2:
305         case 3:
306         /* Our lower layer calculations limit our precision to
307            1 microsecond */
308                 return 1;
309         case 4:
310                 return 2;
311         case 5:
312                 return 4;
313         case 6:
314                 return 8;
315         case 7:
316                 return 16;
317         default:
318                 return 0;
319         }
320 }
321
322 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
323 {
324         int ret;
325
326         lockdep_assert_held(&ar->conf_mutex);
327
328         ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
329         if (ret) {
330                 ath10k_warn("failed to create wmi peer %pM on vdev %i: %i\n",
331                             addr, vdev_id, ret);
332                 return ret;
333         }
334
335         ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
336         if (ret) {
337                 ath10k_warn("failed to wait for created wmi peer %pM on vdev %i: %i\n",
338                             addr, vdev_id, ret);
339                 return ret;
340         }
341         spin_lock_bh(&ar->data_lock);
342         ar->num_peers++;
343         spin_unlock_bh(&ar->data_lock);
344
345         return 0;
346 }
347
348 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
349 {
350         struct ath10k *ar = arvif->ar;
351         u32 param;
352         int ret;
353
354         param = ar->wmi.pdev_param->sta_kickout_th;
355         ret = ath10k_wmi_pdev_set_param(ar, param,
356                                         ATH10K_KICKOUT_THRESHOLD);
357         if (ret) {
358                 ath10k_warn("failed to set kickout threshold on vdev %i: %d\n",
359                             arvif->vdev_id, ret);
360                 return ret;
361         }
362
363         param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
364         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
365                                         ATH10K_KEEPALIVE_MIN_IDLE);
366         if (ret) {
367                 ath10k_warn("failed to set keepalive minimum idle time on vdev %i: %d\n",
368                             arvif->vdev_id, ret);
369                 return ret;
370         }
371
372         param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
373         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
374                                         ATH10K_KEEPALIVE_MAX_IDLE);
375         if (ret) {
376                 ath10k_warn("failed to set keepalive maximum idle time on vdev %i: %d\n",
377                             arvif->vdev_id, ret);
378                 return ret;
379         }
380
381         param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
382         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
383                                         ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
384         if (ret) {
385                 ath10k_warn("failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
386                             arvif->vdev_id, ret);
387                 return ret;
388         }
389
390         return 0;
391 }
392
393 static int  ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
394 {
395         struct ath10k *ar = arvif->ar;
396         u32 vdev_param;
397
398         if (value != 0xFFFFFFFF)
399                 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
400                               ATH10K_RTS_MAX);
401
402         vdev_param = ar->wmi.vdev_param->rts_threshold;
403         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
404 }
405
406 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
407 {
408         struct ath10k *ar = arvif->ar;
409         u32 vdev_param;
410
411         if (value != 0xFFFFFFFF)
412                 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
413                                 ATH10K_FRAGMT_THRESHOLD_MIN,
414                                 ATH10K_FRAGMT_THRESHOLD_MAX);
415
416         vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
417         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
418 }
419
420 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
421 {
422         int ret;
423
424         lockdep_assert_held(&ar->conf_mutex);
425
426         ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
427         if (ret)
428                 return ret;
429
430         ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
431         if (ret)
432                 return ret;
433
434         spin_lock_bh(&ar->data_lock);
435         ar->num_peers--;
436         spin_unlock_bh(&ar->data_lock);
437
438         return 0;
439 }
440
441 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
442 {
443         struct ath10k_peer *peer, *tmp;
444
445         lockdep_assert_held(&ar->conf_mutex);
446
447         spin_lock_bh(&ar->data_lock);
448         list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
449                 if (peer->vdev_id != vdev_id)
450                         continue;
451
452                 ath10k_warn("removing stale peer %pM from vdev_id %d\n",
453                             peer->addr, vdev_id);
454
455                 list_del(&peer->list);
456                 kfree(peer);
457                 ar->num_peers--;
458         }
459         spin_unlock_bh(&ar->data_lock);
460 }
461
462 static void ath10k_peer_cleanup_all(struct ath10k *ar)
463 {
464         struct ath10k_peer *peer, *tmp;
465
466         lockdep_assert_held(&ar->conf_mutex);
467
468         spin_lock_bh(&ar->data_lock);
469         list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
470                 list_del(&peer->list);
471                 kfree(peer);
472         }
473         ar->num_peers = 0;
474         spin_unlock_bh(&ar->data_lock);
475 }
476
477 /************************/
478 /* Interface management */
479 /************************/
480
481 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
482 {
483         int ret;
484
485         lockdep_assert_held(&ar->conf_mutex);
486
487         ret = wait_for_completion_timeout(&ar->vdev_setup_done,
488                                           ATH10K_VDEV_SETUP_TIMEOUT_HZ);
489         if (ret == 0)
490                 return -ETIMEDOUT;
491
492         return 0;
493 }
494
495 static bool ath10k_monitor_is_enabled(struct ath10k *ar)
496 {
497         lockdep_assert_held(&ar->conf_mutex);
498
499         ath10k_dbg(ATH10K_DBG_MAC,
500                    "mac monitor refs: promisc %d monitor %d cac %d\n",
501                    ar->promisc, ar->monitor,
502                    test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags));
503
504         return ar->promisc || ar->monitor ||
505                test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
506 }
507
508 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
509 {
510         struct cfg80211_chan_def *chandef = &ar->chandef;
511         struct ieee80211_channel *channel = chandef->chan;
512         struct wmi_vdev_start_request_arg arg = {};
513         int ret = 0;
514
515         lockdep_assert_held(&ar->conf_mutex);
516
517         arg.vdev_id = vdev_id;
518         arg.channel.freq = channel->center_freq;
519         arg.channel.band_center_freq1 = chandef->center_freq1;
520
521         /* TODO setup this dynamically, what in case we
522            don't have any vifs? */
523         arg.channel.mode = chan_to_phymode(chandef);
524         arg.channel.chan_radar =
525                         !!(channel->flags & IEEE80211_CHAN_RADAR);
526
527         arg.channel.min_power = 0;
528         arg.channel.max_power = channel->max_power * 2;
529         arg.channel.max_reg_power = channel->max_reg_power * 2;
530         arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
531
532         ret = ath10k_wmi_vdev_start(ar, &arg);
533         if (ret) {
534                 ath10k_warn("failed to request monitor vdev %i start: %d\n",
535                             vdev_id, ret);
536                 return ret;
537         }
538
539         ret = ath10k_vdev_setup_sync(ar);
540         if (ret) {
541                 ath10k_warn("failed to synchronize setup for monitor vdev %i: %d\n",
542                             vdev_id, ret);
543                 return ret;
544         }
545
546         ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
547         if (ret) {
548                 ath10k_warn("failed to put up monitor vdev %i: %d\n",
549                             vdev_id, ret);
550                 goto vdev_stop;
551         }
552
553         ar->monitor_vdev_id = vdev_id;
554
555         ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
556                    ar->monitor_vdev_id);
557         return 0;
558
559 vdev_stop:
560         ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
561         if (ret)
562                 ath10k_warn("failed to stop monitor vdev %i after start failure: %d\n",
563                             ar->monitor_vdev_id, ret);
564
565         return ret;
566 }
567
568 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
569 {
570         int ret = 0;
571
572         lockdep_assert_held(&ar->conf_mutex);
573
574         ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
575         if (ret)
576                 ath10k_warn("failed to put down monitor vdev %i: %d\n",
577                             ar->monitor_vdev_id, ret);
578
579         ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
580         if (ret)
581                 ath10k_warn("failed to to request monitor vdev %i stop: %d\n",
582                             ar->monitor_vdev_id, ret);
583
584         ret = ath10k_vdev_setup_sync(ar);
585         if (ret)
586                 ath10k_warn("failed to synchronise monitor vdev %i: %d\n",
587                             ar->monitor_vdev_id, ret);
588
589         ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
590                    ar->monitor_vdev_id);
591         return ret;
592 }
593
594 static int ath10k_monitor_vdev_create(struct ath10k *ar)
595 {
596         int bit, ret = 0;
597
598         lockdep_assert_held(&ar->conf_mutex);
599
600         bit = ffs(ar->free_vdev_map);
601         if (bit == 0) {
602                 ath10k_warn("failed to find free vdev id for monitor vdev\n");
603                 return -ENOMEM;
604         }
605
606         ar->monitor_vdev_id = bit - 1;
607         ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id);
608
609         ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
610                                      WMI_VDEV_TYPE_MONITOR,
611                                      0, ar->mac_addr);
612         if (ret) {
613                 ath10k_warn("failed to request monitor vdev %i creation: %d\n",
614                             ar->monitor_vdev_id, ret);
615                 goto vdev_fail;
616         }
617
618         ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
619                    ar->monitor_vdev_id);
620
621         return 0;
622
623 vdev_fail:
624         /*
625          * Restore the ID to the global map.
626          */
627         ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
628         return ret;
629 }
630
631 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
632 {
633         int ret = 0;
634
635         lockdep_assert_held(&ar->conf_mutex);
636
637         ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
638         if (ret) {
639                 ath10k_warn("failed to request wmi monitor vdev %i removal: %d\n",
640                             ar->monitor_vdev_id, ret);
641                 return ret;
642         }
643
644         ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
645
646         ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
647                    ar->monitor_vdev_id);
648         return ret;
649 }
650
651 static int ath10k_monitor_start(struct ath10k *ar)
652 {
653         int ret;
654
655         lockdep_assert_held(&ar->conf_mutex);
656
657         if (!ath10k_monitor_is_enabled(ar)) {
658                 ath10k_warn("trying to start monitor with no references\n");
659                 return 0;
660         }
661
662         if (ar->monitor_started) {
663                 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor already started\n");
664                 return 0;
665         }
666
667         ret = ath10k_monitor_vdev_create(ar);
668         if (ret) {
669                 ath10k_warn("failed to create monitor vdev: %d\n", ret);
670                 return ret;
671         }
672
673         ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
674         if (ret) {
675                 ath10k_warn("failed to start monitor vdev: %d\n", ret);
676                 ath10k_monitor_vdev_delete(ar);
677                 return ret;
678         }
679
680         ar->monitor_started = true;
681         ath10k_dbg(ATH10K_DBG_MAC, "mac monitor started\n");
682
683         return 0;
684 }
685
686 static void ath10k_monitor_stop(struct ath10k *ar)
687 {
688         int ret;
689
690         lockdep_assert_held(&ar->conf_mutex);
691
692         if (ath10k_monitor_is_enabled(ar)) {
693                 ath10k_dbg(ATH10K_DBG_MAC,
694                            "mac monitor will be stopped later\n");
695                 return;
696         }
697
698         if (!ar->monitor_started) {
699                 ath10k_dbg(ATH10K_DBG_MAC,
700                            "mac monitor probably failed to start earlier\n");
701                 return;
702         }
703
704         ret = ath10k_monitor_vdev_stop(ar);
705         if (ret)
706                 ath10k_warn("failed to stop monitor vdev: %d\n", ret);
707
708         ret = ath10k_monitor_vdev_delete(ar);
709         if (ret)
710                 ath10k_warn("failed to delete monitor vdev: %d\n", ret);
711
712         ar->monitor_started = false;
713         ath10k_dbg(ATH10K_DBG_MAC, "mac monitor stopped\n");
714 }
715
716 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
717 {
718         struct ath10k *ar = arvif->ar;
719         u32 vdev_param, rts_cts = 0;
720
721         lockdep_assert_held(&ar->conf_mutex);
722
723         vdev_param = ar->wmi.vdev_param->enable_rtscts;
724
725         if (arvif->use_cts_prot || arvif->num_legacy_stations > 0)
726                 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
727
728         if (arvif->num_legacy_stations > 0)
729                 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
730                               WMI_RTSCTS_PROFILE);
731
732         return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
733                                          rts_cts);
734 }
735
736 static int ath10k_start_cac(struct ath10k *ar)
737 {
738         int ret;
739
740         lockdep_assert_held(&ar->conf_mutex);
741
742         set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
743
744         ret = ath10k_monitor_start(ar);
745         if (ret) {
746                 ath10k_warn("failed to start monitor (cac): %d\n", ret);
747                 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
748                 return ret;
749         }
750
751         ath10k_dbg(ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
752                    ar->monitor_vdev_id);
753
754         return 0;
755 }
756
757 static int ath10k_stop_cac(struct ath10k *ar)
758 {
759         lockdep_assert_held(&ar->conf_mutex);
760
761         /* CAC is not running - do nothing */
762         if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
763                 return 0;
764
765         clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
766         ath10k_monitor_stop(ar);
767
768         ath10k_dbg(ATH10K_DBG_MAC, "mac cac finished\n");
769
770         return 0;
771 }
772
773 static void ath10k_recalc_radar_detection(struct ath10k *ar)
774 {
775         int ret;
776
777         lockdep_assert_held(&ar->conf_mutex);
778
779         ath10k_stop_cac(ar);
780
781         if (!ar->radar_enabled)
782                 return;
783
784         if (ar->num_started_vdevs > 0)
785                 return;
786
787         ret = ath10k_start_cac(ar);
788         if (ret) {
789                 /*
790                  * Not possible to start CAC on current channel so starting
791                  * radiation is not allowed, make this channel DFS_UNAVAILABLE
792                  * by indicating that radar was detected.
793                  */
794                 ath10k_warn("failed to start CAC: %d\n", ret);
795                 ieee80211_radar_detected(ar->hw);
796         }
797 }
798
799 static int ath10k_vdev_start(struct ath10k_vif *arvif)
800 {
801         struct ath10k *ar = arvif->ar;
802         struct cfg80211_chan_def *chandef = &ar->chandef;
803         struct wmi_vdev_start_request_arg arg = {};
804         int ret = 0;
805
806         lockdep_assert_held(&ar->conf_mutex);
807
808         reinit_completion(&ar->vdev_setup_done);
809
810         arg.vdev_id = arvif->vdev_id;
811         arg.dtim_period = arvif->dtim_period;
812         arg.bcn_intval = arvif->beacon_interval;
813
814         arg.channel.freq = chandef->chan->center_freq;
815         arg.channel.band_center_freq1 = chandef->center_freq1;
816         arg.channel.mode = chan_to_phymode(chandef);
817
818         arg.channel.min_power = 0;
819         arg.channel.max_power = chandef->chan->max_power * 2;
820         arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
821         arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
822
823         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
824                 arg.ssid = arvif->u.ap.ssid;
825                 arg.ssid_len = arvif->u.ap.ssid_len;
826                 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
827
828                 /* For now allow DFS for AP mode */
829                 arg.channel.chan_radar =
830                         !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
831         } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
832                 arg.ssid = arvif->vif->bss_conf.ssid;
833                 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
834         }
835
836         ath10k_dbg(ATH10K_DBG_MAC,
837                    "mac vdev %d start center_freq %d phymode %s\n",
838                    arg.vdev_id, arg.channel.freq,
839                    ath10k_wmi_phymode_str(arg.channel.mode));
840
841         ret = ath10k_wmi_vdev_start(ar, &arg);
842         if (ret) {
843                 ath10k_warn("failed to start WMI vdev %i: %d\n",
844                             arg.vdev_id, ret);
845                 return ret;
846         }
847
848         ret = ath10k_vdev_setup_sync(ar);
849         if (ret) {
850                 ath10k_warn("failed to synchronise setup for vdev %i: %d\n",
851                             arg.vdev_id, ret);
852                 return ret;
853         }
854
855         ar->num_started_vdevs++;
856         ath10k_recalc_radar_detection(ar);
857
858         return ret;
859 }
860
861 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
862 {
863         struct ath10k *ar = arvif->ar;
864         int ret;
865
866         lockdep_assert_held(&ar->conf_mutex);
867
868         reinit_completion(&ar->vdev_setup_done);
869
870         ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
871         if (ret) {
872                 ath10k_warn("failed to stop WMI vdev %i: %d\n",
873                             arvif->vdev_id, ret);
874                 return ret;
875         }
876
877         ret = ath10k_vdev_setup_sync(ar);
878         if (ret) {
879                 ath10k_warn("failed to syncronise setup for vdev %i: %d\n",
880                             arvif->vdev_id, ret);
881                 return ret;
882         }
883
884         WARN_ON(ar->num_started_vdevs == 0);
885
886         if (ar->num_started_vdevs != 0) {
887                 ar->num_started_vdevs--;
888                 ath10k_recalc_radar_detection(ar);
889         }
890
891         return ret;
892 }
893
894 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
895                                 struct ieee80211_bss_conf *info)
896 {
897         int ret = 0;
898
899         lockdep_assert_held(&arvif->ar->conf_mutex);
900
901         if (!info->enable_beacon) {
902                 ath10k_vdev_stop(arvif);
903
904                 arvif->is_started = false;
905                 arvif->is_up = false;
906
907                 spin_lock_bh(&arvif->ar->data_lock);
908                 if (arvif->beacon) {
909                         dma_unmap_single(arvif->ar->dev,
910                                          ATH10K_SKB_CB(arvif->beacon)->paddr,
911                                          arvif->beacon->len, DMA_TO_DEVICE);
912                         dev_kfree_skb_any(arvif->beacon);
913
914                         arvif->beacon = NULL;
915                         arvif->beacon_sent = false;
916                 }
917                 spin_unlock_bh(&arvif->ar->data_lock);
918
919                 return;
920         }
921
922         arvif->tx_seq_no = 0x1000;
923
924         ret = ath10k_vdev_start(arvif);
925         if (ret)
926                 return;
927
928         arvif->aid = 0;
929         memcpy(arvif->bssid, info->bssid, ETH_ALEN);
930
931         ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
932                                  arvif->bssid);
933         if (ret) {
934                 ath10k_warn("failed to bring up vdev %d: %i\n",
935                             arvif->vdev_id, ret);
936                 ath10k_vdev_stop(arvif);
937                 return;
938         }
939
940         arvif->is_started = true;
941         arvif->is_up = true;
942
943         ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
944 }
945
946 static void ath10k_control_ibss(struct ath10k_vif *arvif,
947                                 struct ieee80211_bss_conf *info,
948                                 const u8 self_peer[ETH_ALEN])
949 {
950         u32 vdev_param;
951         int ret = 0;
952
953         lockdep_assert_held(&arvif->ar->conf_mutex);
954
955         if (!info->ibss_joined) {
956                 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
957                 if (ret)
958                         ath10k_warn("failed to delete IBSS self peer %pM for vdev %d: %d\n",
959                                     self_peer, arvif->vdev_id, ret);
960
961                 if (is_zero_ether_addr(arvif->bssid))
962                         return;
963
964                 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
965                                          arvif->bssid);
966                 if (ret) {
967                         ath10k_warn("failed to delete IBSS BSSID peer %pM for vdev %d: %d\n",
968                                     arvif->bssid, arvif->vdev_id, ret);
969                         return;
970                 }
971
972                 memset(arvif->bssid, 0, ETH_ALEN);
973
974                 return;
975         }
976
977         ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
978         if (ret) {
979                 ath10k_warn("failed to create IBSS self peer %pM for vdev %d: %d\n",
980                             self_peer, arvif->vdev_id, ret);
981                 return;
982         }
983
984         vdev_param = arvif->ar->wmi.vdev_param->atim_window;
985         ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
986                                         ATH10K_DEFAULT_ATIM);
987         if (ret)
988                 ath10k_warn("failed to set IBSS ATIM for vdev %d: %d\n",
989                             arvif->vdev_id, ret);
990 }
991
992 /*
993  * Review this when mac80211 gains per-interface powersave support.
994  */
995 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
996 {
997         struct ath10k *ar = arvif->ar;
998         struct ieee80211_conf *conf = &ar->hw->conf;
999         enum wmi_sta_powersave_param param;
1000         enum wmi_sta_ps_mode psmode;
1001         int ret;
1002
1003         lockdep_assert_held(&arvif->ar->conf_mutex);
1004
1005         if (arvif->vif->type != NL80211_IFTYPE_STATION)
1006                 return 0;
1007
1008         if (conf->flags & IEEE80211_CONF_PS) {
1009                 psmode = WMI_STA_PS_MODE_ENABLED;
1010                 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1011
1012                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1013                                                   conf->dynamic_ps_timeout);
1014                 if (ret) {
1015                         ath10k_warn("failed to set inactivity time for vdev %d: %i\n",
1016                                     arvif->vdev_id, ret);
1017                         return ret;
1018                 }
1019         } else {
1020                 psmode = WMI_STA_PS_MODE_DISABLED;
1021         }
1022
1023         ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1024                    arvif->vdev_id, psmode ? "enable" : "disable");
1025
1026         ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1027         if (ret) {
1028                 ath10k_warn("failed to set PS Mode %d for vdev %d: %d\n",
1029                             psmode, arvif->vdev_id, ret);
1030                 return ret;
1031         }
1032
1033         return 0;
1034 }
1035
1036 /**********************/
1037 /* Station management */
1038 /**********************/
1039
1040 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1041                                       struct ath10k_vif *arvif,
1042                                       struct ieee80211_sta *sta,
1043                                       struct ieee80211_bss_conf *bss_conf,
1044                                       struct wmi_peer_assoc_complete_arg *arg)
1045 {
1046         lockdep_assert_held(&ar->conf_mutex);
1047
1048         memcpy(arg->addr, sta->addr, ETH_ALEN);
1049         arg->vdev_id = arvif->vdev_id;
1050         arg->peer_aid = sta->aid;
1051         arg->peer_flags |= WMI_PEER_AUTH;
1052
1053         if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
1054                 /*
1055                  * Seems FW have problems with Power Save in STA
1056                  * mode when we setup this parameter to high (eg. 5).
1057                  * Often we see that FW don't send NULL (with clean P flags)
1058                  * frame even there is info about buffered frames in beacons.
1059                  * Sometimes we have to wait more than 10 seconds before FW
1060                  * will wakeup. Often sending one ping from AP to our device
1061                  * just fail (more than 50%).
1062                  *
1063                  * Seems setting this FW parameter to 1 couse FW
1064                  * will check every beacon and will wakup immediately
1065                  * after detection buffered data.
1066                  */
1067                 arg->peer_listen_intval = 1;
1068         else
1069                 arg->peer_listen_intval = ar->hw->conf.listen_interval;
1070
1071         arg->peer_num_spatial_streams = 1;
1072
1073         /*
1074          * The assoc capabilities are available only in managed mode.
1075          */
1076         if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf)
1077                 arg->peer_caps = bss_conf->assoc_capability;
1078 }
1079
1080 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1081                                        struct ath10k_vif *arvif,
1082                                        struct wmi_peer_assoc_complete_arg *arg)
1083 {
1084         struct ieee80211_vif *vif = arvif->vif;
1085         struct ieee80211_bss_conf *info = &vif->bss_conf;
1086         struct cfg80211_bss *bss;
1087         const u8 *rsnie = NULL;
1088         const u8 *wpaie = NULL;
1089
1090         lockdep_assert_held(&ar->conf_mutex);
1091
1092         bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
1093                                info->bssid, NULL, 0, 0, 0);
1094         if (bss) {
1095                 const struct cfg80211_bss_ies *ies;
1096
1097                 rcu_read_lock();
1098                 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1099
1100                 ies = rcu_dereference(bss->ies);
1101
1102                 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1103                                 WLAN_OUI_TYPE_MICROSOFT_WPA,
1104                                 ies->data,
1105                                 ies->len);
1106                 rcu_read_unlock();
1107                 cfg80211_put_bss(ar->hw->wiphy, bss);
1108         }
1109
1110         /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1111         if (rsnie || wpaie) {
1112                 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
1113                 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1114         }
1115
1116         if (wpaie) {
1117                 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
1118                 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1119         }
1120 }
1121
1122 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
1123                                       struct ieee80211_sta *sta,
1124                                       struct wmi_peer_assoc_complete_arg *arg)
1125 {
1126         struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1127         const struct ieee80211_supported_band *sband;
1128         const struct ieee80211_rate *rates;
1129         u32 ratemask;
1130         int i;
1131
1132         lockdep_assert_held(&ar->conf_mutex);
1133
1134         sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
1135         ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
1136         rates = sband->bitrates;
1137
1138         rateset->num_rates = 0;
1139
1140         for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1141                 if (!(ratemask & 1))
1142                         continue;
1143
1144                 rateset->rates[rateset->num_rates] = rates->hw_value;
1145                 rateset->num_rates++;
1146         }
1147 }
1148
1149 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
1150                                    struct ieee80211_sta *sta,
1151                                    struct wmi_peer_assoc_complete_arg *arg)
1152 {
1153         const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1154         int i, n;
1155
1156         lockdep_assert_held(&ar->conf_mutex);
1157
1158         if (!ht_cap->ht_supported)
1159                 return;
1160
1161         arg->peer_flags |= WMI_PEER_HT;
1162         arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1163                                     ht_cap->ampdu_factor)) - 1;
1164
1165         arg->peer_mpdu_density =
1166                 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1167
1168         arg->peer_ht_caps = ht_cap->cap;
1169         arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1170
1171         if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1172                 arg->peer_flags |= WMI_PEER_LDPC;
1173
1174         if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1175                 arg->peer_flags |= WMI_PEER_40MHZ;
1176                 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1177         }
1178
1179         if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1180                 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1181
1182         if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1183                 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1184
1185         if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1186                 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1187                 arg->peer_flags |= WMI_PEER_STBC;
1188         }
1189
1190         if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1191                 u32 stbc;
1192                 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1193                 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1194                 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1195                 arg->peer_rate_caps |= stbc;
1196                 arg->peer_flags |= WMI_PEER_STBC;
1197         }
1198
1199         if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1200                 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1201         else if (ht_cap->mcs.rx_mask[1])
1202                 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1203
1204         for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1205                 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1206                         arg->peer_ht_rates.rates[n++] = i;
1207
1208         /*
1209          * This is a workaround for HT-enabled STAs which break the spec
1210          * and have no HT capabilities RX mask (no HT RX MCS map).
1211          *
1212          * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1213          * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1214          *
1215          * Firmware asserts if such situation occurs.
1216          */
1217         if (n == 0) {
1218                 arg->peer_ht_rates.num_rates = 8;
1219                 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1220                         arg->peer_ht_rates.rates[i] = i;
1221         } else {
1222                 arg->peer_ht_rates.num_rates = n;
1223                 arg->peer_num_spatial_streams = sta->rx_nss;
1224         }
1225
1226         ath10k_dbg(ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1227                    arg->addr,
1228                    arg->peer_ht_rates.num_rates,
1229                    arg->peer_num_spatial_streams);
1230 }
1231
1232 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
1233                                     struct ath10k_vif *arvif,
1234                                     struct ieee80211_sta *sta)
1235 {
1236         u32 uapsd = 0;
1237         u32 max_sp = 0;
1238         int ret = 0;
1239
1240         lockdep_assert_held(&ar->conf_mutex);
1241
1242         if (sta->wme && sta->uapsd_queues) {
1243                 ath10k_dbg(ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
1244                            sta->uapsd_queues, sta->max_sp);
1245
1246                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1247                         uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1248                                  WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1249                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1250                         uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1251                                  WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1252                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1253                         uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1254                                  WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1255                 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1256                         uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1257                                  WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1258
1259
1260                 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1261                         max_sp = sta->max_sp;
1262
1263                 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1264                                                  sta->addr,
1265                                                  WMI_AP_PS_PEER_PARAM_UAPSD,
1266                                                  uapsd);
1267                 if (ret) {
1268                         ath10k_warn("failed to set ap ps peer param uapsd for vdev %i: %d\n",
1269                                     arvif->vdev_id, ret);
1270                         return ret;
1271                 }
1272
1273                 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1274                                                  sta->addr,
1275                                                  WMI_AP_PS_PEER_PARAM_MAX_SP,
1276                                                  max_sp);
1277                 if (ret) {
1278                         ath10k_warn("failed to set ap ps peer param max sp for vdev %i: %d\n",
1279                                     arvif->vdev_id, ret);
1280                         return ret;
1281                 }
1282
1283                 /* TODO setup this based on STA listen interval and
1284                    beacon interval. Currently we don't know
1285                    sta->listen_interval - mac80211 patch required.
1286                    Currently use 10 seconds */
1287                 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
1288                                         WMI_AP_PS_PEER_PARAM_AGEOUT_TIME, 10);
1289                 if (ret) {
1290                         ath10k_warn("failed to set ap ps peer param ageout time for vdev %i: %d\n",
1291                                     arvif->vdev_id, ret);
1292                         return ret;
1293                 }
1294         }
1295
1296         return 0;
1297 }
1298
1299 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1300                                     struct ieee80211_sta *sta,
1301                                     struct wmi_peer_assoc_complete_arg *arg)
1302 {
1303         const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1304         u8 ampdu_factor;
1305
1306         if (!vht_cap->vht_supported)
1307                 return;
1308
1309         arg->peer_flags |= WMI_PEER_VHT;
1310         arg->peer_vht_caps = vht_cap->cap;
1311
1312
1313         ampdu_factor = (vht_cap->cap &
1314                         IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1315                        IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1316
1317         /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1318          * zero in VHT IE. Using it would result in degraded throughput.
1319          * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1320          * it if VHT max_mpdu is smaller. */
1321         arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1322                                  (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1323                                         ampdu_factor)) - 1);
1324
1325         if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1326                 arg->peer_flags |= WMI_PEER_80MHZ;
1327
1328         arg->peer_vht_rates.rx_max_rate =
1329                 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1330         arg->peer_vht_rates.rx_mcs_set =
1331                 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1332         arg->peer_vht_rates.tx_max_rate =
1333                 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1334         arg->peer_vht_rates.tx_mcs_set =
1335                 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1336
1337         ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1338                    sta->addr, arg->peer_max_mpdu, arg->peer_flags);
1339 }
1340
1341 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1342                                     struct ath10k_vif *arvif,
1343                                     struct ieee80211_sta *sta,
1344                                     struct ieee80211_bss_conf *bss_conf,
1345                                     struct wmi_peer_assoc_complete_arg *arg)
1346 {
1347         switch (arvif->vdev_type) {
1348         case WMI_VDEV_TYPE_AP:
1349                 if (sta->wme)
1350                         arg->peer_flags |= WMI_PEER_QOS;
1351
1352                 if (sta->wme && sta->uapsd_queues) {
1353                         arg->peer_flags |= WMI_PEER_APSD;
1354                         arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
1355                 }
1356                 break;
1357         case WMI_VDEV_TYPE_STA:
1358                 if (bss_conf->qos)
1359                         arg->peer_flags |= WMI_PEER_QOS;
1360                 break;
1361         default:
1362                 break;
1363         }
1364 }
1365
1366 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1367                                         struct ath10k_vif *arvif,
1368                                         struct ieee80211_sta *sta,
1369                                         struct wmi_peer_assoc_complete_arg *arg)
1370 {
1371         enum wmi_phy_mode phymode = MODE_UNKNOWN;
1372
1373         switch (ar->hw->conf.chandef.chan->band) {
1374         case IEEE80211_BAND_2GHZ:
1375                 if (sta->ht_cap.ht_supported) {
1376                         if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1377                                 phymode = MODE_11NG_HT40;
1378                         else
1379                                 phymode = MODE_11NG_HT20;
1380                 } else {
1381                         phymode = MODE_11G;
1382                 }
1383
1384                 break;
1385         case IEEE80211_BAND_5GHZ:
1386                 /*
1387                  * Check VHT first.
1388                  */
1389                 if (sta->vht_cap.vht_supported) {
1390                         if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1391                                 phymode = MODE_11AC_VHT80;
1392                         else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1393                                 phymode = MODE_11AC_VHT40;
1394                         else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1395                                 phymode = MODE_11AC_VHT20;
1396                 } else if (sta->ht_cap.ht_supported) {
1397                         if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1398                                 phymode = MODE_11NA_HT40;
1399                         else
1400                                 phymode = MODE_11NA_HT20;
1401                 } else {
1402                         phymode = MODE_11A;
1403                 }
1404
1405                 break;
1406         default:
1407                 break;
1408         }
1409
1410         ath10k_dbg(ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1411                    sta->addr, ath10k_wmi_phymode_str(phymode));
1412
1413         arg->peer_phymode = phymode;
1414         WARN_ON(phymode == MODE_UNKNOWN);
1415 }
1416
1417 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
1418                                      struct ath10k_vif *arvif,
1419                                      struct ieee80211_sta *sta,
1420                                      struct ieee80211_bss_conf *bss_conf,
1421                                      struct wmi_peer_assoc_complete_arg *arg)
1422 {
1423         lockdep_assert_held(&ar->conf_mutex);
1424
1425         memset(arg, 0, sizeof(*arg));
1426
1427         ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, arg);
1428         ath10k_peer_assoc_h_crypto(ar, arvif, arg);
1429         ath10k_peer_assoc_h_rates(ar, sta, arg);
1430         ath10k_peer_assoc_h_ht(ar, sta, arg);
1431         ath10k_peer_assoc_h_vht(ar, sta, arg);
1432         ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, arg);
1433         ath10k_peer_assoc_h_phymode(ar, arvif, sta, arg);
1434
1435         return 0;
1436 }
1437
1438 static const u32 ath10k_smps_map[] = {
1439         [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
1440         [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
1441         [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
1442         [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
1443 };
1444
1445 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
1446                                   const u8 *addr,
1447                                   const struct ieee80211_sta_ht_cap *ht_cap)
1448 {
1449         int smps;
1450
1451         if (!ht_cap->ht_supported)
1452                 return 0;
1453
1454         smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1455         smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1456
1457         if (smps >= ARRAY_SIZE(ath10k_smps_map))
1458                 return -EINVAL;
1459
1460         return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
1461                                          WMI_PEER_SMPS_STATE,
1462                                          ath10k_smps_map[smps]);
1463 }
1464
1465 /* can be called only in mac80211 callbacks due to `key_count` usage */
1466 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1467                              struct ieee80211_vif *vif,
1468                              struct ieee80211_bss_conf *bss_conf)
1469 {
1470         struct ath10k *ar = hw->priv;
1471         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1472         struct ieee80211_sta_ht_cap ht_cap;
1473         struct wmi_peer_assoc_complete_arg peer_arg;
1474         struct ieee80211_sta *ap_sta;
1475         int ret;
1476
1477         lockdep_assert_held(&ar->conf_mutex);
1478
1479         rcu_read_lock();
1480
1481         ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1482         if (!ap_sta) {
1483                 ath10k_warn("failed to find station entry for bss %pM vdev %i\n",
1484                             bss_conf->bssid, arvif->vdev_id);
1485                 rcu_read_unlock();
1486                 return;
1487         }
1488
1489         /* ap_sta must be accessed only within rcu section which must be left
1490          * before calling ath10k_setup_peer_smps() which might sleep. */
1491         ht_cap = ap_sta->ht_cap;
1492
1493         ret = ath10k_peer_assoc_prepare(ar, arvif, ap_sta,
1494                                         bss_conf, &peer_arg);
1495         if (ret) {
1496                 ath10k_warn("failed to prepare peer assoc for %pM vdev %i: %d\n",
1497                             bss_conf->bssid, arvif->vdev_id, ret);
1498                 rcu_read_unlock();
1499                 return;
1500         }
1501
1502         rcu_read_unlock();
1503
1504         ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1505         if (ret) {
1506                 ath10k_warn("failed to run peer assoc for %pM vdev %i: %d\n",
1507                             bss_conf->bssid, arvif->vdev_id, ret);
1508                 return;
1509         }
1510
1511         ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
1512         if (ret) {
1513                 ath10k_warn("failed to setup peer SMPS for vdev %i: %d\n",
1514                             arvif->vdev_id, ret);
1515                 return;
1516         }
1517
1518         ath10k_dbg(ATH10K_DBG_MAC,
1519                    "mac vdev %d up (associated) bssid %pM aid %d\n",
1520                    arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1521
1522         arvif->aid = bss_conf->aid;
1523         memcpy(arvif->bssid, bss_conf->bssid, ETH_ALEN);
1524
1525         ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
1526         if (ret) {
1527                 ath10k_warn("failed to set vdev %d up: %d\n",
1528                             arvif->vdev_id, ret);
1529                 return;
1530         }
1531
1532         arvif->is_up = true;
1533 }
1534
1535 /*
1536  * FIXME: flush TIDs
1537  */
1538 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1539                                 struct ieee80211_vif *vif)
1540 {
1541         struct ath10k *ar = hw->priv;
1542         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1543         int ret;
1544
1545         lockdep_assert_held(&ar->conf_mutex);
1546
1547         /*
1548          * For some reason, calling VDEV-DOWN before VDEV-STOP
1549          * makes the FW to send frames via HTT after disassociation.
1550          * No idea why this happens, even though VDEV-DOWN is supposed
1551          * to be analogous to link down, so just stop the VDEV.
1552          */
1553         ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d stop (disassociated\n",
1554                    arvif->vdev_id);
1555
1556         /* FIXME: check return value */
1557         ret = ath10k_vdev_stop(arvif);
1558
1559         /*
1560          * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1561          * report beacons from previously associated network through HTT.
1562          * This in turn would spam mac80211 WARN_ON if we bring down all
1563          * interfaces as it expects there is no rx when no interface is
1564          * running.
1565          */
1566         ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d down\n", arvif->vdev_id);
1567
1568         /* FIXME: why don't we print error if wmi call fails? */
1569         ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1570
1571         arvif->def_wep_key_idx = 0;
1572
1573         arvif->is_started = false;
1574         arvif->is_up = false;
1575 }
1576
1577 static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1578                                 struct ieee80211_sta *sta, bool reassoc)
1579 {
1580         struct wmi_peer_assoc_complete_arg peer_arg;
1581         int ret = 0;
1582
1583         lockdep_assert_held(&ar->conf_mutex);
1584
1585         ret = ath10k_peer_assoc_prepare(ar, arvif, sta, NULL, &peer_arg);
1586         if (ret) {
1587                 ath10k_warn("failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
1588                             sta->addr, arvif->vdev_id, ret);
1589                 return ret;
1590         }
1591
1592         peer_arg.peer_reassoc = reassoc;
1593         ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1594         if (ret) {
1595                 ath10k_warn("failed to run peer assoc for STA %pM vdev %i: %d\n",
1596                             sta->addr, arvif->vdev_id, ret);
1597                 return ret;
1598         }
1599
1600         ret = ath10k_setup_peer_smps(ar, arvif, sta->addr, &sta->ht_cap);
1601         if (ret) {
1602                 ath10k_warn("failed to setup peer SMPS for vdev %d: %d\n",
1603                             arvif->vdev_id, ret);
1604                 return ret;
1605         }
1606
1607         if (!sta->wme) {
1608                 arvif->num_legacy_stations++;
1609                 ret  = ath10k_recalc_rtscts_prot(arvif);
1610                 if (ret) {
1611                         ath10k_warn("failed to recalculate rts/cts prot for vdev %d: %d\n",
1612                                     arvif->vdev_id, ret);
1613                         return ret;
1614                 }
1615         }
1616
1617         ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1618         if (ret) {
1619                 ath10k_warn("failed to install peer wep keys for vdev %i: %d\n",
1620                             arvif->vdev_id, ret);
1621                 return ret;
1622         }
1623
1624         ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
1625         if (ret) {
1626                 ath10k_warn("failed to set qos params for STA %pM for vdev %i: %d\n",
1627                             sta->addr, arvif->vdev_id, ret);
1628                 return ret;
1629         }
1630
1631         return ret;
1632 }
1633
1634 static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1635                                    struct ieee80211_sta *sta)
1636 {
1637         int ret = 0;
1638
1639         lockdep_assert_held(&ar->conf_mutex);
1640
1641         if (!sta->wme) {
1642                 arvif->num_legacy_stations--;
1643                 ret = ath10k_recalc_rtscts_prot(arvif);
1644                 if (ret) {
1645                         ath10k_warn("failed to recalculate rts/cts prot for vdev %d: %d\n",
1646                                     arvif->vdev_id, ret);
1647                         return ret;
1648                 }
1649         }
1650
1651         ret = ath10k_clear_peer_keys(arvif, sta->addr);
1652         if (ret) {
1653                 ath10k_warn("failed to clear all peer wep keys for vdev %i: %d\n",
1654                             arvif->vdev_id, ret);
1655                 return ret;
1656         }
1657
1658         return ret;
1659 }
1660
1661 /**************/
1662 /* Regulatory */
1663 /**************/
1664
1665 static int ath10k_update_channel_list(struct ath10k *ar)
1666 {
1667         struct ieee80211_hw *hw = ar->hw;
1668         struct ieee80211_supported_band **bands;
1669         enum ieee80211_band band;
1670         struct ieee80211_channel *channel;
1671         struct wmi_scan_chan_list_arg arg = {0};
1672         struct wmi_channel_arg *ch;
1673         bool passive;
1674         int len;
1675         int ret;
1676         int i;
1677
1678         lockdep_assert_held(&ar->conf_mutex);
1679
1680         bands = hw->wiphy->bands;
1681         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1682                 if (!bands[band])
1683                         continue;
1684
1685                 for (i = 0; i < bands[band]->n_channels; i++) {
1686                         if (bands[band]->channels[i].flags &
1687                             IEEE80211_CHAN_DISABLED)
1688                                 continue;
1689
1690                         arg.n_channels++;
1691                 }
1692         }
1693
1694         len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1695         arg.channels = kzalloc(len, GFP_KERNEL);
1696         if (!arg.channels)
1697                 return -ENOMEM;
1698
1699         ch = arg.channels;
1700         for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1701                 if (!bands[band])
1702                         continue;
1703
1704                 for (i = 0; i < bands[band]->n_channels; i++) {
1705                         channel = &bands[band]->channels[i];
1706
1707                         if (channel->flags & IEEE80211_CHAN_DISABLED)
1708                                 continue;
1709
1710                         ch->allow_ht   = true;
1711
1712                         /* FIXME: when should we really allow VHT? */
1713                         ch->allow_vht = true;
1714
1715                         ch->allow_ibss =
1716                                 !(channel->flags & IEEE80211_CHAN_NO_IR);
1717
1718                         ch->ht40plus =
1719                                 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1720
1721                         ch->chan_radar =
1722                                 !!(channel->flags & IEEE80211_CHAN_RADAR);
1723
1724                         passive = channel->flags & IEEE80211_CHAN_NO_IR;
1725                         ch->passive = passive;
1726
1727                         ch->freq = channel->center_freq;
1728                         ch->min_power = 0;
1729                         ch->max_power = channel->max_power * 2;
1730                         ch->max_reg_power = channel->max_reg_power * 2;
1731                         ch->max_antenna_gain = channel->max_antenna_gain * 2;
1732                         ch->reg_class_id = 0; /* FIXME */
1733
1734                         /* FIXME: why use only legacy modes, why not any
1735                          * HT/VHT modes? Would that even make any
1736                          * difference? */
1737                         if (channel->band == IEEE80211_BAND_2GHZ)
1738                                 ch->mode = MODE_11G;
1739                         else
1740                                 ch->mode = MODE_11A;
1741
1742                         if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1743                                 continue;
1744
1745                         ath10k_dbg(ATH10K_DBG_WMI,
1746                                    "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1747                                     ch - arg.channels, arg.n_channels,
1748                                    ch->freq, ch->max_power, ch->max_reg_power,
1749                                    ch->max_antenna_gain, ch->mode);
1750
1751                         ch++;
1752                 }
1753         }
1754
1755         ret = ath10k_wmi_scan_chan_list(ar, &arg);
1756         kfree(arg.channels);
1757
1758         return ret;
1759 }
1760
1761 static enum wmi_dfs_region
1762 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
1763 {
1764         switch (dfs_region) {
1765         case NL80211_DFS_UNSET:
1766                 return WMI_UNINIT_DFS_DOMAIN;
1767         case NL80211_DFS_FCC:
1768                 return WMI_FCC_DFS_DOMAIN;
1769         case NL80211_DFS_ETSI:
1770                 return WMI_ETSI_DFS_DOMAIN;
1771         case NL80211_DFS_JP:
1772                 return WMI_MKK4_DFS_DOMAIN;
1773         }
1774         return WMI_UNINIT_DFS_DOMAIN;
1775 }
1776
1777 static void ath10k_regd_update(struct ath10k *ar)
1778 {
1779         struct reg_dmn_pair_mapping *regpair;
1780         int ret;
1781         enum wmi_dfs_region wmi_dfs_reg;
1782         enum nl80211_dfs_regions nl_dfs_reg;
1783
1784         lockdep_assert_held(&ar->conf_mutex);
1785
1786         ret = ath10k_update_channel_list(ar);
1787         if (ret)
1788                 ath10k_warn("failed to update channel list: %d\n", ret);
1789
1790         regpair = ar->ath_common.regulatory.regpair;
1791
1792         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1793                 nl_dfs_reg = ar->dfs_detector->region;
1794                 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
1795         } else {
1796                 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
1797         }
1798
1799         /* Target allows setting up per-band regdomain but ath_common provides
1800          * a combined one only */
1801         ret = ath10k_wmi_pdev_set_regdomain(ar,
1802                                             regpair->reg_domain,
1803                                             regpair->reg_domain, /* 2ghz */
1804                                             regpair->reg_domain, /* 5ghz */
1805                                             regpair->reg_2ghz_ctl,
1806                                             regpair->reg_5ghz_ctl,
1807                                             wmi_dfs_reg);
1808         if (ret)
1809                 ath10k_warn("failed to set pdev regdomain: %d\n", ret);
1810 }
1811
1812 static void ath10k_reg_notifier(struct wiphy *wiphy,
1813                                 struct regulatory_request *request)
1814 {
1815         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1816         struct ath10k *ar = hw->priv;
1817         bool result;
1818
1819         ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1820
1821         if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1822                 ath10k_dbg(ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
1823                            request->dfs_region);
1824                 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
1825                                                           request->dfs_region);
1826                 if (!result)
1827                         ath10k_warn("DFS region 0x%X not supported, will trigger radar for every pulse\n",
1828                                     request->dfs_region);
1829         }
1830
1831         mutex_lock(&ar->conf_mutex);
1832         if (ar->state == ATH10K_STATE_ON)
1833                 ath10k_regd_update(ar);
1834         mutex_unlock(&ar->conf_mutex);
1835 }
1836
1837 /***************/
1838 /* TX handlers */
1839 /***************/
1840
1841 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
1842 {
1843         if (ieee80211_is_mgmt(hdr->frame_control))
1844                 return HTT_DATA_TX_EXT_TID_MGMT;
1845
1846         if (!ieee80211_is_data_qos(hdr->frame_control))
1847                 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1848
1849         if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
1850                 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1851
1852         return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
1853 }
1854
1855 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar,
1856                                   struct ieee80211_tx_info *info)
1857 {
1858         if (info->control.vif)
1859                 return ath10k_vif_to_arvif(info->control.vif)->vdev_id;
1860
1861         if (ar->monitor_started)
1862                 return ar->monitor_vdev_id;
1863
1864         ath10k_warn("failed to resolve vdev id\n");
1865         return 0;
1866 }
1867
1868 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
1869  * Control in the header.
1870  */
1871 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
1872 {
1873         struct ieee80211_hdr *hdr = (void *)skb->data;
1874         struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
1875         u8 *qos_ctl;
1876
1877         if (!ieee80211_is_data_qos(hdr->frame_control))
1878                 return;
1879
1880         qos_ctl = ieee80211_get_qos_ctl(hdr);
1881         memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1882                 skb->data, (void *)qos_ctl - (void *)skb->data);
1883         skb_pull(skb, IEEE80211_QOS_CTL_LEN);
1884
1885         /* Fw/Hw generates a corrupted QoS Control Field for QoS NullFunc
1886          * frames. Powersave is handled by the fw/hw so QoS NyllFunc frames are
1887          * used only for CQM purposes (e.g. hostapd station keepalive ping) so
1888          * it is safe to downgrade to NullFunc.
1889          */
1890         if (ieee80211_is_qos_nullfunc(hdr->frame_control)) {
1891                 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
1892                 cb->htt.tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1893         }
1894 }
1895
1896 static void ath10k_tx_wep_key_work(struct work_struct *work)
1897 {
1898         struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1899                                                 wep_key_work);
1900         int ret, keyidx = arvif->def_wep_key_newidx;
1901
1902         mutex_lock(&arvif->ar->conf_mutex);
1903
1904         if (arvif->ar->state != ATH10K_STATE_ON)
1905                 goto unlock;
1906
1907         if (arvif->def_wep_key_idx == keyidx)
1908                 goto unlock;
1909
1910         ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
1911                    arvif->vdev_id, keyidx);
1912
1913         ret = ath10k_wmi_vdev_set_param(arvif->ar,
1914                                         arvif->vdev_id,
1915                                         arvif->ar->wmi.vdev_param->def_keyid,
1916                                         keyidx);
1917         if (ret) {
1918                 ath10k_warn("failed to update wep key index for vdev %d: %d\n",
1919                             arvif->vdev_id,
1920                             ret);
1921                 goto unlock;
1922         }
1923
1924         arvif->def_wep_key_idx = keyidx;
1925
1926 unlock:
1927         mutex_unlock(&arvif->ar->conf_mutex);
1928 }
1929
1930 static void ath10k_tx_h_update_wep_key(struct ieee80211_vif *vif,
1931                                        struct ieee80211_key_conf *key,
1932                                        struct sk_buff *skb)
1933 {
1934         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1935         struct ath10k *ar = arvif->ar;
1936         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1937
1938         if (!ieee80211_has_protected(hdr->frame_control))
1939                 return;
1940
1941         if (!key)
1942                 return;
1943
1944         if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1945             key->cipher != WLAN_CIPHER_SUITE_WEP104)
1946                 return;
1947
1948         if (key->keyidx == arvif->def_wep_key_idx)
1949                 return;
1950
1951         /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1952          * queueing frames until key index is updated is not an option because
1953          * sk_buff may need more processing to be done, e.g. offchannel */
1954         arvif->def_wep_key_newidx = key->keyidx;
1955         ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
1956 }
1957
1958 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
1959                                        struct ieee80211_vif *vif,
1960                                        struct sk_buff *skb)
1961 {
1962         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1963         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1964
1965         /* This is case only for P2P_GO */
1966         if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1967             arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1968                 return;
1969
1970         if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1971                 spin_lock_bh(&ar->data_lock);
1972                 if (arvif->u.ap.noa_data)
1973                         if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1974                                               GFP_ATOMIC))
1975                                 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1976                                        arvif->u.ap.noa_data,
1977                                        arvif->u.ap.noa_len);
1978                 spin_unlock_bh(&ar->data_lock);
1979         }
1980 }
1981
1982 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1983 {
1984         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1985         int ret = 0;
1986
1987         if (ar->htt.target_version_major >= 3) {
1988                 /* Since HTT 3.0 there is no separate mgmt tx command */
1989                 ret = ath10k_htt_tx(&ar->htt, skb);
1990                 goto exit;
1991         }
1992
1993         if (ieee80211_is_mgmt(hdr->frame_control)) {
1994                 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
1995                              ar->fw_features)) {
1996                         if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
1997                             ATH10K_MAX_NUM_MGMT_PENDING) {
1998                                 ath10k_warn("reached WMI management tranmist queue limit\n");
1999                                 ret = -EBUSY;
2000                                 goto exit;
2001                         }
2002
2003                         skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
2004                         ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
2005                 } else {
2006                         ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2007                 }
2008         } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2009                              ar->fw_features) &&
2010                    ieee80211_is_nullfunc(hdr->frame_control)) {
2011                 /* FW does not report tx status properly for NullFunc frames
2012                  * unless they are sent through mgmt tx path. mac80211 sends
2013                  * those frames when it detects link/beacon loss and depends
2014                  * on the tx status to be correct. */
2015                 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2016         } else {
2017                 ret = ath10k_htt_tx(&ar->htt, skb);
2018         }
2019
2020 exit:
2021         if (ret) {
2022                 ath10k_warn("failed to transmit packet, dropping: %d\n", ret);
2023                 ieee80211_free_txskb(ar->hw, skb);
2024         }
2025 }
2026
2027 void ath10k_offchan_tx_purge(struct ath10k *ar)
2028 {
2029         struct sk_buff *skb;
2030
2031         for (;;) {
2032                 skb = skb_dequeue(&ar->offchan_tx_queue);
2033                 if (!skb)
2034                         break;
2035
2036                 ieee80211_free_txskb(ar->hw, skb);
2037         }
2038 }
2039
2040 void ath10k_offchan_tx_work(struct work_struct *work)
2041 {
2042         struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
2043         struct ath10k_peer *peer;
2044         struct ieee80211_hdr *hdr;
2045         struct sk_buff *skb;
2046         const u8 *peer_addr;
2047         int vdev_id;
2048         int ret;
2049
2050         /* FW requirement: We must create a peer before FW will send out
2051          * an offchannel frame. Otherwise the frame will be stuck and
2052          * never transmitted. We delete the peer upon tx completion.
2053          * It is unlikely that a peer for offchannel tx will already be
2054          * present. However it may be in some rare cases so account for that.
2055          * Otherwise we might remove a legitimate peer and break stuff. */
2056
2057         for (;;) {
2058                 skb = skb_dequeue(&ar->offchan_tx_queue);
2059                 if (!skb)
2060                         break;
2061
2062                 mutex_lock(&ar->conf_mutex);
2063
2064                 ath10k_dbg(ATH10K_DBG_MAC, "mac offchannel skb %p\n",
2065                            skb);
2066
2067                 hdr = (struct ieee80211_hdr *)skb->data;
2068                 peer_addr = ieee80211_get_DA(hdr);
2069                 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
2070
2071                 spin_lock_bh(&ar->data_lock);
2072                 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
2073                 spin_unlock_bh(&ar->data_lock);
2074
2075                 if (peer)
2076                         /* FIXME: should this use ath10k_warn()? */
2077                         ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
2078                                    peer_addr, vdev_id);
2079
2080                 if (!peer) {
2081                         ret = ath10k_peer_create(ar, vdev_id, peer_addr);
2082                         if (ret)
2083                                 ath10k_warn("failed to create peer %pM on vdev %d: %d\n",
2084                                             peer_addr, vdev_id, ret);
2085                 }
2086
2087                 spin_lock_bh(&ar->data_lock);
2088                 reinit_completion(&ar->offchan_tx_completed);
2089                 ar->offchan_tx_skb = skb;
2090                 spin_unlock_bh(&ar->data_lock);
2091
2092                 ath10k_tx_htt(ar, skb);
2093
2094                 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
2095                                                   3 * HZ);
2096                 if (ret <= 0)
2097                         ath10k_warn("timed out waiting for offchannel skb %p\n",
2098                                     skb);
2099
2100                 if (!peer) {
2101                         ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
2102                         if (ret)
2103                                 ath10k_warn("failed to delete peer %pM on vdev %d: %d\n",
2104                                             peer_addr, vdev_id, ret);
2105                 }
2106
2107                 mutex_unlock(&ar->conf_mutex);
2108         }
2109 }
2110
2111 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
2112 {
2113         struct sk_buff *skb;
2114
2115         for (;;) {
2116                 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2117                 if (!skb)
2118                         break;
2119
2120                 ieee80211_free_txskb(ar->hw, skb);
2121         }
2122 }
2123
2124 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
2125 {
2126         struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
2127         struct sk_buff *skb;
2128         int ret;
2129
2130         for (;;) {
2131                 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2132                 if (!skb)
2133                         break;
2134
2135                 ret = ath10k_wmi_mgmt_tx(ar, skb);
2136                 if (ret) {
2137                         ath10k_warn("failed to transmit management frame via WMI: %d\n",
2138                                     ret);
2139                         ieee80211_free_txskb(ar->hw, skb);
2140                 }
2141         }
2142 }
2143
2144 /************/
2145 /* Scanning */
2146 /************/
2147
2148 /*
2149  * This gets called if we dont get a heart-beat during scan.
2150  * This may indicate the FW has hung and we need to abort the
2151  * scan manually to prevent cancel_hw_scan() from deadlocking
2152  */
2153 void ath10k_reset_scan(unsigned long ptr)
2154 {
2155         struct ath10k *ar = (struct ath10k *)ptr;
2156
2157         spin_lock_bh(&ar->data_lock);
2158         if (!ar->scan.in_progress) {
2159                 spin_unlock_bh(&ar->data_lock);
2160                 return;
2161         }
2162
2163         ath10k_warn("scan timed out, firmware problem?\n");
2164
2165         if (ar->scan.is_roc)
2166                 ieee80211_remain_on_channel_expired(ar->hw);
2167         else
2168                 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
2169
2170         ar->scan.in_progress = false;
2171         complete_all(&ar->scan.completed);
2172         spin_unlock_bh(&ar->data_lock);
2173 }
2174
2175 static int ath10k_abort_scan(struct ath10k *ar)
2176 {
2177         struct wmi_stop_scan_arg arg = {
2178                 .req_id = 1, /* FIXME */
2179                 .req_type = WMI_SCAN_STOP_ONE,
2180                 .u.scan_id = ATH10K_SCAN_ID,
2181         };
2182         int ret;
2183
2184         lockdep_assert_held(&ar->conf_mutex);
2185
2186         del_timer_sync(&ar->scan.timeout);
2187
2188         spin_lock_bh(&ar->data_lock);
2189         if (!ar->scan.in_progress) {
2190                 spin_unlock_bh(&ar->data_lock);
2191                 return 0;
2192         }
2193
2194         ar->scan.aborting = true;
2195         spin_unlock_bh(&ar->data_lock);
2196
2197         ret = ath10k_wmi_stop_scan(ar, &arg);
2198         if (ret) {
2199                 ath10k_warn("failed to stop wmi scan: %d\n", ret);
2200                 spin_lock_bh(&ar->data_lock);
2201                 ar->scan.in_progress = false;
2202                 ath10k_offchan_tx_purge(ar);
2203                 spin_unlock_bh(&ar->data_lock);
2204                 return -EIO;
2205         }
2206
2207         ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
2208         if (ret == 0)
2209                 ath10k_warn("timed out while waiting for scan to stop\n");
2210
2211         /* scan completion may be done right after we timeout here, so let's
2212          * check the in_progress and tell mac80211 scan is completed. if we
2213          * don't do that and FW fails to send us scan completion indication
2214          * then userspace won't be able to scan anymore */
2215         ret = 0;
2216
2217         spin_lock_bh(&ar->data_lock);
2218         if (ar->scan.in_progress) {
2219                 ath10k_warn("failed to stop scan, it's still in progress\n");
2220                 ar->scan.in_progress = false;
2221                 ath10k_offchan_tx_purge(ar);
2222                 ret = -ETIMEDOUT;
2223         }
2224         spin_unlock_bh(&ar->data_lock);
2225
2226         return ret;
2227 }
2228
2229 static int ath10k_start_scan(struct ath10k *ar,
2230                              const struct wmi_start_scan_arg *arg)
2231 {
2232         int ret;
2233
2234         lockdep_assert_held(&ar->conf_mutex);
2235
2236         ret = ath10k_wmi_start_scan(ar, arg);
2237         if (ret)
2238                 return ret;
2239
2240         ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
2241         if (ret == 0) {
2242                 ath10k_abort_scan(ar);
2243                 return ret;
2244         }
2245
2246         /* the scan can complete earlier, before we even
2247          * start the timer. in that case the timer handler
2248          * checks ar->scan.in_progress and bails out if its
2249          * false. Add a 200ms margin to account event/command
2250          * processing. */
2251         mod_timer(&ar->scan.timeout, jiffies +
2252                   msecs_to_jiffies(arg->max_scan_time+200));
2253         return 0;
2254 }
2255
2256 /**********************/
2257 /* mac80211 callbacks */
2258 /**********************/
2259
2260 static void ath10k_tx(struct ieee80211_hw *hw,
2261                       struct ieee80211_tx_control *control,
2262                       struct sk_buff *skb)
2263 {
2264         struct ath10k *ar = hw->priv;
2265         struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2266         struct ieee80211_vif *vif = info->control.vif;
2267         struct ieee80211_key_conf *key = info->control.hw_key;
2268         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2269
2270         /* We should disable CCK RATE due to P2P */
2271         if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
2272                 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2273
2274         ATH10K_SKB_CB(skb)->htt.is_offchan = false;
2275         ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr);
2276         ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, info);
2277
2278         /* it makes no sense to process injected frames like that */
2279         if (vif && vif->type != NL80211_IFTYPE_MONITOR) {
2280                 ath10k_tx_h_nwifi(hw, skb);
2281                 ath10k_tx_h_update_wep_key(vif, key, skb);
2282                 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
2283                 ath10k_tx_h_seq_no(vif, skb);
2284         }
2285
2286         if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2287                 spin_lock_bh(&ar->data_lock);
2288                 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
2289                 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
2290                 spin_unlock_bh(&ar->data_lock);
2291
2292                 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
2293
2294                 skb_queue_tail(&ar->offchan_tx_queue, skb);
2295                 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2296                 return;
2297         }
2298
2299         ath10k_tx_htt(ar, skb);
2300 }
2301
2302 /* Must not be called with conf_mutex held as workers can use that also. */
2303 static void ath10k_drain_tx(struct ath10k *ar)
2304 {
2305         /* make sure rcu-protected mac80211 tx path itself is drained */
2306         synchronize_net();
2307
2308         ath10k_offchan_tx_purge(ar);
2309         ath10k_mgmt_over_wmi_tx_purge(ar);
2310
2311         cancel_work_sync(&ar->offchan_tx_work);
2312         cancel_work_sync(&ar->wmi_mgmt_tx_work);
2313 }
2314
2315 void ath10k_halt(struct ath10k *ar)
2316 {
2317         struct ath10k_vif *arvif;
2318
2319         lockdep_assert_held(&ar->conf_mutex);
2320
2321         if (ath10k_monitor_is_enabled(ar)) {
2322                 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
2323                 ar->promisc = false;
2324                 ar->monitor = false;
2325                 ath10k_monitor_stop(ar);
2326         }
2327
2328         del_timer_sync(&ar->scan.timeout);
2329         ath10k_reset_scan((unsigned long)ar);
2330         ath10k_peer_cleanup_all(ar);
2331         ath10k_core_stop(ar);
2332         ath10k_hif_power_down(ar);
2333
2334         spin_lock_bh(&ar->data_lock);
2335         list_for_each_entry(arvif, &ar->arvifs, list) {
2336                 if (!arvif->beacon)
2337                         continue;
2338
2339                 dma_unmap_single(arvif->ar->dev,
2340                                  ATH10K_SKB_CB(arvif->beacon)->paddr,
2341                                  arvif->beacon->len, DMA_TO_DEVICE);
2342                 dev_kfree_skb_any(arvif->beacon);
2343                 arvif->beacon = NULL;
2344         }
2345         spin_unlock_bh(&ar->data_lock);
2346 }
2347
2348 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2349 {
2350         struct ath10k *ar = hw->priv;
2351
2352         mutex_lock(&ar->conf_mutex);
2353
2354         if (ar->cfg_tx_chainmask) {
2355                 *tx_ant = ar->cfg_tx_chainmask;
2356                 *rx_ant = ar->cfg_rx_chainmask;
2357         } else {
2358                 *tx_ant = ar->supp_tx_chainmask;
2359                 *rx_ant = ar->supp_rx_chainmask;
2360         }
2361
2362         mutex_unlock(&ar->conf_mutex);
2363
2364         return 0;
2365 }
2366
2367 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
2368 {
2369         int ret;
2370
2371         lockdep_assert_held(&ar->conf_mutex);
2372
2373         ar->cfg_tx_chainmask = tx_ant;
2374         ar->cfg_rx_chainmask = rx_ant;
2375
2376         if ((ar->state != ATH10K_STATE_ON) &&
2377             (ar->state != ATH10K_STATE_RESTARTED))
2378                 return 0;
2379
2380         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
2381                                         tx_ant);
2382         if (ret) {
2383                 ath10k_warn("failed to set tx-chainmask: %d, req 0x%x\n",
2384                             ret, tx_ant);
2385                 return ret;
2386         }
2387
2388         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
2389                                         rx_ant);
2390         if (ret) {
2391                 ath10k_warn("failed to set rx-chainmask: %d, req 0x%x\n",
2392                             ret, rx_ant);
2393                 return ret;
2394         }
2395
2396         return 0;
2397 }
2398
2399 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2400 {
2401         struct ath10k *ar = hw->priv;
2402         int ret;
2403
2404         mutex_lock(&ar->conf_mutex);
2405         ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
2406         mutex_unlock(&ar->conf_mutex);
2407         return ret;
2408 }
2409
2410 static int ath10k_start(struct ieee80211_hw *hw)
2411 {
2412         struct ath10k *ar = hw->priv;
2413         int ret = 0;
2414
2415         /*
2416          * This makes sense only when restarting hw. It is harmless to call
2417          * uncoditionally. This is necessary to make sure no HTT/WMI tx
2418          * commands will be submitted while restarting.
2419          */
2420         ath10k_drain_tx(ar);
2421
2422         mutex_lock(&ar->conf_mutex);
2423
2424         switch (ar->state) {
2425         case ATH10K_STATE_OFF:
2426                 ar->state = ATH10K_STATE_ON;
2427                 break;
2428         case ATH10K_STATE_RESTARTING:
2429                 ath10k_halt(ar);
2430                 ar->state = ATH10K_STATE_RESTARTED;
2431                 break;
2432         case ATH10K_STATE_ON:
2433         case ATH10K_STATE_RESTARTED:
2434         case ATH10K_STATE_WEDGED:
2435                 WARN_ON(1);
2436                 ret = -EINVAL;
2437                 goto err;
2438         }
2439
2440         ret = ath10k_hif_power_up(ar);
2441         if (ret) {
2442                 ath10k_err("Could not init hif: %d\n", ret);
2443                 goto err_off;
2444         }
2445
2446         ret = ath10k_core_start(ar);
2447         if (ret) {
2448                 ath10k_err("Could not init core: %d\n", ret);
2449                 goto err_power_down;
2450         }
2451
2452         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
2453         if (ret) {
2454                 ath10k_warn("failed to enable PMF QOS: %d\n", ret);
2455                 goto err_core_stop;
2456         }
2457
2458         ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
2459         if (ret) {
2460                 ath10k_warn("failed to enable dynamic BW: %d\n", ret);
2461                 goto err_core_stop;
2462         }
2463
2464         if (ar->cfg_tx_chainmask)
2465                 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
2466                                      ar->cfg_rx_chainmask);
2467
2468         /*
2469          * By default FW set ARP frames ac to voice (6). In that case ARP
2470          * exchange is not working properly for UAPSD enabled AP. ARP requests
2471          * which arrives with access category 0 are processed by network stack
2472          * and send back with access category 0, but FW changes access category
2473          * to 6. Set ARP frames access category to best effort (0) solves
2474          * this problem.
2475          */
2476
2477         ret = ath10k_wmi_pdev_set_param(ar,
2478                                         ar->wmi.pdev_param->arp_ac_override, 0);
2479         if (ret) {
2480                 ath10k_warn("failed to set arp ac override parameter: %d\n",
2481                             ret);
2482                 goto err_core_stop;
2483         }
2484
2485         ar->num_started_vdevs = 0;
2486         ath10k_regd_update(ar);
2487
2488         mutex_unlock(&ar->conf_mutex);
2489         return 0;
2490
2491 err_core_stop:
2492         ath10k_core_stop(ar);
2493
2494 err_power_down:
2495         ath10k_hif_power_down(ar);
2496
2497 err_off:
2498         ar->state = ATH10K_STATE_OFF;
2499
2500 err:
2501         mutex_unlock(&ar->conf_mutex);
2502         return ret;
2503 }
2504
2505 static void ath10k_stop(struct ieee80211_hw *hw)
2506 {
2507         struct ath10k *ar = hw->priv;
2508
2509         ath10k_drain_tx(ar);
2510
2511         mutex_lock(&ar->conf_mutex);
2512         if (ar->state != ATH10K_STATE_OFF) {
2513                 ath10k_halt(ar);
2514                 ar->state = ATH10K_STATE_OFF;
2515         }
2516         mutex_unlock(&ar->conf_mutex);
2517
2518         cancel_work_sync(&ar->restart_work);
2519 }
2520
2521 static int ath10k_config_ps(struct ath10k *ar)
2522 {
2523         struct ath10k_vif *arvif;
2524         int ret = 0;
2525
2526         lockdep_assert_held(&ar->conf_mutex);
2527
2528         list_for_each_entry(arvif, &ar->arvifs, list) {
2529                 ret = ath10k_mac_vif_setup_ps(arvif);
2530                 if (ret) {
2531                         ath10k_warn("failed to setup powersave: %d\n", ret);
2532                         break;
2533                 }
2534         }
2535
2536         return ret;
2537 }
2538
2539 static const char *chandef_get_width(enum nl80211_chan_width width)
2540 {
2541         switch (width) {
2542         case NL80211_CHAN_WIDTH_20_NOHT:
2543                 return "20 (noht)";
2544         case NL80211_CHAN_WIDTH_20:
2545                 return "20";
2546         case NL80211_CHAN_WIDTH_40:
2547                 return "40";
2548         case NL80211_CHAN_WIDTH_80:
2549                 return "80";
2550         case NL80211_CHAN_WIDTH_80P80:
2551                 return "80+80";
2552         case NL80211_CHAN_WIDTH_160:
2553                 return "160";
2554         case NL80211_CHAN_WIDTH_5:
2555                 return "5";
2556         case NL80211_CHAN_WIDTH_10:
2557                 return "10";
2558         }
2559         return "?";
2560 }
2561
2562 static void ath10k_config_chan(struct ath10k *ar)
2563 {
2564         struct ath10k_vif *arvif;
2565         int ret;
2566
2567         lockdep_assert_held(&ar->conf_mutex);
2568
2569         ath10k_dbg(ATH10K_DBG_MAC,
2570                    "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2571                    ar->chandef.chan->center_freq,
2572                    ar->chandef.center_freq1,
2573                    ar->chandef.center_freq2,
2574                    chandef_get_width(ar->chandef.width));
2575
2576         /* First stop monitor interface. Some FW versions crash if there's a
2577          * lone monitor interface. */
2578         if (ar->monitor_started)
2579                 ath10k_monitor_vdev_stop(ar);
2580
2581         list_for_each_entry(arvif, &ar->arvifs, list) {
2582                 if (!arvif->is_started)
2583                         continue;
2584
2585                 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2586                         continue;
2587
2588                 ret = ath10k_vdev_stop(arvif);
2589                 if (ret) {
2590                         ath10k_warn("failed to stop vdev %d: %d\n",
2591                                     arvif->vdev_id, ret);
2592                         continue;
2593                 }
2594         }
2595
2596         /* all vdevs are now stopped - now attempt to restart them */
2597
2598         list_for_each_entry(arvif, &ar->arvifs, list) {
2599                 if (!arvif->is_started)
2600                         continue;
2601
2602                 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2603                         continue;
2604
2605                 ret = ath10k_vdev_start(arvif);
2606                 if (ret) {
2607                         ath10k_warn("failed to start vdev %d: %d\n",
2608                                     arvif->vdev_id, ret);
2609                         continue;
2610                 }
2611
2612                 if (!arvif->is_up)
2613                         continue;
2614
2615                 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
2616                                          arvif->bssid);
2617                 if (ret) {
2618                         ath10k_warn("failed to bring vdev up %d: %d\n",
2619                                     arvif->vdev_id, ret);
2620                         continue;
2621                 }
2622         }
2623
2624         if (ath10k_monitor_is_enabled(ar))
2625                 ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
2626 }
2627
2628 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2629 {
2630         struct ath10k *ar = hw->priv;
2631         struct ieee80211_conf *conf = &hw->conf;
2632         int ret = 0;
2633         u32 param;
2634
2635         mutex_lock(&ar->conf_mutex);
2636
2637         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2638                 ath10k_dbg(ATH10K_DBG_MAC,
2639                            "mac config channel %dMHz flags 0x%x radar %d\n",
2640                            conf->chandef.chan->center_freq,
2641                            conf->chandef.chan->flags,
2642                            conf->radar_enabled);
2643
2644                 spin_lock_bh(&ar->data_lock);
2645                 ar->rx_channel = conf->chandef.chan;
2646                 spin_unlock_bh(&ar->data_lock);
2647
2648                 ar->radar_enabled = conf->radar_enabled;
2649                 ath10k_recalc_radar_detection(ar);
2650
2651                 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) {
2652                         ar->chandef = conf->chandef;
2653                         ath10k_config_chan(ar);
2654                 }
2655         }
2656
2657         if (changed & IEEE80211_CONF_CHANGE_POWER) {
2658                 ath10k_dbg(ATH10K_DBG_MAC, "mac config power %d\n",
2659                            hw->conf.power_level);
2660
2661                 param = ar->wmi.pdev_param->txpower_limit2g;
2662                 ret = ath10k_wmi_pdev_set_param(ar, param,
2663                                                 hw->conf.power_level * 2);
2664                 if (ret)
2665                         ath10k_warn("failed to set 2g txpower %d: %d\n",
2666                                     hw->conf.power_level, ret);
2667
2668                 param = ar->wmi.pdev_param->txpower_limit5g;
2669                 ret = ath10k_wmi_pdev_set_param(ar, param,
2670                                                 hw->conf.power_level * 2);
2671                 if (ret)
2672                         ath10k_warn("failed to set 5g txpower %d: %d\n",
2673                                     hw->conf.power_level, ret);
2674         }
2675
2676         if (changed & IEEE80211_CONF_CHANGE_PS)
2677                 ath10k_config_ps(ar);
2678
2679         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
2680                 if (conf->flags & IEEE80211_CONF_MONITOR && !ar->monitor) {
2681                         ar->monitor = true;
2682                         ret = ath10k_monitor_start(ar);
2683                         if (ret) {
2684                                 ath10k_warn("failed to start monitor (config): %d\n",
2685                                             ret);
2686                                 ar->monitor = false;
2687                         }
2688                 } else if (!(conf->flags & IEEE80211_CONF_MONITOR) &&
2689                            ar->monitor) {
2690                         ar->monitor = false;
2691                         ath10k_monitor_stop(ar);
2692                 }
2693         }
2694
2695         mutex_unlock(&ar->conf_mutex);
2696         return ret;
2697 }
2698
2699 /*
2700  * TODO:
2701  * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2702  * because we will send mgmt frames without CCK. This requirement
2703  * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2704  * in the TX packet.
2705  */
2706 static int ath10k_add_interface(struct ieee80211_hw *hw,
2707                                 struct ieee80211_vif *vif)
2708 {
2709         struct ath10k *ar = hw->priv;
2710         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2711         enum wmi_sta_powersave_param param;
2712         int ret = 0;
2713         u32 value;
2714         int bit;
2715         u32 vdev_param;
2716
2717         mutex_lock(&ar->conf_mutex);
2718
2719         memset(arvif, 0, sizeof(*arvif));
2720
2721         arvif->ar = ar;
2722         arvif->vif = vif;
2723
2724         INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
2725         INIT_LIST_HEAD(&arvif->list);
2726
2727         bit = ffs(ar->free_vdev_map);
2728         if (bit == 0) {
2729                 ret = -EBUSY;
2730                 goto err;
2731         }
2732
2733         arvif->vdev_id = bit - 1;
2734         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
2735
2736         if (ar->p2p)
2737                 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2738
2739         switch (vif->type) {
2740         case NL80211_IFTYPE_UNSPECIFIED:
2741         case NL80211_IFTYPE_STATION:
2742                 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2743                 if (vif->p2p)
2744                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2745                 break;
2746         case NL80211_IFTYPE_ADHOC:
2747                 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2748                 break;
2749         case NL80211_IFTYPE_AP:
2750                 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2751
2752                 if (vif->p2p)
2753                         arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2754                 break;
2755         case NL80211_IFTYPE_MONITOR:
2756                 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2757                 break;
2758         default:
2759                 WARN_ON(1);
2760                 break;
2761         }
2762
2763         ath10k_dbg(ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n",
2764                    arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
2765
2766         ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
2767                                      arvif->vdev_subtype, vif->addr);
2768         if (ret) {
2769                 ath10k_warn("failed to create WMI vdev %i: %d\n",
2770                             arvif->vdev_id, ret);
2771                 goto err;
2772         }
2773
2774         ar->free_vdev_map &= ~BIT(arvif->vdev_id);
2775         list_add(&arvif->list, &ar->arvifs);
2776
2777         vdev_param = ar->wmi.vdev_param->def_keyid;
2778         ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
2779                                         arvif->def_wep_key_idx);
2780         if (ret) {
2781                 ath10k_warn("failed to set vdev %i default key id: %d\n",
2782                             arvif->vdev_id, ret);
2783                 goto err_vdev_delete;
2784         }
2785
2786         vdev_param = ar->wmi.vdev_param->tx_encap_type;
2787         ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2788                                         ATH10K_HW_TXRX_NATIVE_WIFI);
2789         /* 10.X firmware does not support this VDEV parameter. Do not warn */
2790         if (ret && ret != -EOPNOTSUPP) {
2791                 ath10k_warn("failed to set vdev %i TX encapsulation: %d\n",
2792                             arvif->vdev_id, ret);
2793                 goto err_vdev_delete;
2794         }
2795
2796         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2797                 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2798                 if (ret) {
2799                         ath10k_warn("failed to create vdev %i peer for AP: %d\n",
2800                                     arvif->vdev_id, ret);
2801                         goto err_vdev_delete;
2802                 }
2803
2804                 ret = ath10k_mac_set_kickout(arvif);
2805                 if (ret) {
2806                         ath10k_warn("failed to set vdev %i kickout parameters: %d\n",
2807                                     arvif->vdev_id, ret);
2808                         goto err_peer_delete;
2809                 }
2810         }
2811
2812         if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2813                 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2814                 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2815                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2816                                                   param, value);
2817                 if (ret) {
2818                         ath10k_warn("failed to set vdev %i RX wake policy: %d\n",
2819                                     arvif->vdev_id, ret);
2820                         goto err_peer_delete;
2821                 }
2822
2823                 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2824                 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2825                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2826                                                   param, value);
2827                 if (ret) {
2828                         ath10k_warn("failed to set vdev %i TX wake thresh: %d\n",
2829                                     arvif->vdev_id, ret);
2830                         goto err_peer_delete;
2831                 }
2832
2833                 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2834                 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2835                 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2836                                                   param, value);
2837                 if (ret) {
2838                         ath10k_warn("failed to set vdev %i PSPOLL count: %d\n",
2839                                     arvif->vdev_id, ret);
2840                         goto err_peer_delete;
2841                 }
2842         }
2843
2844         ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
2845         if (ret) {
2846                 ath10k_warn("failed to set rts threshold for vdev %d: %d\n",
2847                             arvif->vdev_id, ret);
2848                 goto err_peer_delete;
2849         }
2850
2851         ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
2852         if (ret) {
2853                 ath10k_warn("failed to set frag threshold for vdev %d: %d\n",
2854                             arvif->vdev_id, ret);
2855                 goto err_peer_delete;
2856         }
2857
2858         mutex_unlock(&ar->conf_mutex);
2859         return 0;
2860
2861 err_peer_delete:
2862         if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
2863                 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
2864
2865 err_vdev_delete:
2866         ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2867         ar->free_vdev_map &= ~BIT(arvif->vdev_id);
2868         list_del(&arvif->list);
2869
2870 err:
2871         mutex_unlock(&ar->conf_mutex);
2872
2873         return ret;
2874 }
2875
2876 static void ath10k_remove_interface(struct ieee80211_hw *hw,
2877                                     struct ieee80211_vif *vif)
2878 {
2879         struct ath10k *ar = hw->priv;
2880         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2881         int ret;
2882
2883         mutex_lock(&ar->conf_mutex);
2884
2885         cancel_work_sync(&arvif->wep_key_work);
2886
2887         spin_lock_bh(&ar->data_lock);
2888         if (arvif->beacon) {
2889                 dma_unmap_single(arvif->ar->dev,
2890                                  ATH10K_SKB_CB(arvif->beacon)->paddr,
2891                                  arvif->beacon->len, DMA_TO_DEVICE);
2892                 dev_kfree_skb_any(arvif->beacon);
2893                 arvif->beacon = NULL;
2894         }
2895         spin_unlock_bh(&ar->data_lock);
2896
2897         ar->free_vdev_map |= 1 << (arvif->vdev_id);
2898         list_del(&arvif->list);
2899
2900         if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2901                 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2902                 if (ret)
2903                         ath10k_warn("failed to remove peer for AP vdev %i: %d\n",
2904                                     arvif->vdev_id, ret);
2905
2906                 kfree(arvif->u.ap.noa_data);
2907         }
2908
2909         ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
2910                    arvif->vdev_id);
2911
2912         ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2913         if (ret)
2914                 ath10k_warn("failed to delete WMI vdev %i: %d\n",
2915                             arvif->vdev_id, ret);
2916
2917         ath10k_peer_cleanup(ar, arvif->vdev_id);
2918
2919         mutex_unlock(&ar->conf_mutex);
2920 }
2921
2922 /*
2923  * FIXME: Has to be verified.
2924  */
2925 #define SUPPORTED_FILTERS                       \
2926         (FIF_PROMISC_IN_BSS |                   \
2927         FIF_ALLMULTI |                          \
2928         FIF_CONTROL |                           \
2929         FIF_PSPOLL |                            \
2930         FIF_OTHER_BSS |                         \
2931         FIF_BCN_PRBRESP_PROMISC |               \
2932         FIF_PROBE_REQ |                         \
2933         FIF_FCSFAIL)
2934
2935 static void ath10k_configure_filter(struct ieee80211_hw *hw,
2936                                     unsigned int changed_flags,
2937                                     unsigned int *total_flags,
2938                                     u64 multicast)
2939 {
2940         struct ath10k *ar = hw->priv;
2941         int ret;
2942
2943         mutex_lock(&ar->conf_mutex);
2944
2945         changed_flags &= SUPPORTED_FILTERS;
2946         *total_flags &= SUPPORTED_FILTERS;
2947         ar->filter_flags = *total_flags;
2948
2949         if (ar->filter_flags & FIF_PROMISC_IN_BSS && !ar->promisc) {
2950                 ar->promisc = true;
2951                 ret = ath10k_monitor_start(ar);
2952                 if (ret) {
2953                         ath10k_warn("failed to start monitor (promisc): %d\n",
2954                                     ret);
2955                         ar->promisc = false;
2956                 }
2957         } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) && ar->promisc) {
2958                 ar->promisc = false;
2959                 ath10k_monitor_stop(ar);
2960         }
2961
2962         mutex_unlock(&ar->conf_mutex);
2963 }
2964
2965 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
2966                                     struct ieee80211_vif *vif,
2967                                     struct ieee80211_bss_conf *info,
2968                                     u32 changed)
2969 {
2970         struct ath10k *ar = hw->priv;
2971         struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2972         int ret = 0;
2973         u32 vdev_param, pdev_param;
2974
2975         mutex_lock(&ar->conf_mutex);
2976
2977         if (changed & BSS_CHANGED_IBSS)
2978                 ath10k_control_ibss(arvif, info, vif->addr);
2979
2980         if (changed & BSS_CHANGED_BEACON_INT) {
2981                 arvif->beacon_interval = info->beacon_int;
2982                 vdev_param = ar->wmi.vdev_param->beacon_interval;
2983                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2984                                                 arvif->beacon_interval);
2985                 ath10k_dbg(ATH10K_DBG_MAC,
2986                            "mac vdev %d beacon_interval %d\n",
2987                            arvif->vdev_id, arvif->beacon_interval);
2988
2989                 if (ret)
2990                         ath10k_warn("failed to set beacon interval for vdev %d: %i\n",
2991                                     arvif->vdev_id, ret);
2992         }
2993
2994         if (changed & BSS_CHANGED_BEACON) {
2995                 ath10k_dbg(ATH10K_DBG_MAC,
2996                            "vdev %d set beacon tx mode to staggered\n",
2997                            arvif->vdev_id);
2998
2999                 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
3000                 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
3001                                                 WMI_BEACON_STAGGERED_MODE);
3002                 if (ret)
3003                         ath10k_warn("failed to set beacon mode for vdev %d: %i\n",
3004                                     arvif->vdev_id, ret);
3005         }
3006
3007         if (changed & BSS_CHANGED_BEACON_INFO) {
3008                 arvif->dtim_period = info->dtim_period;
3009
3010                 ath10k_dbg(ATH10K_DBG_MAC,
3011                            "mac vdev %d dtim_period %d\n",
3012                            arvif->vdev_id, arvif->dtim_period);
3013
3014                 vdev_param = ar->wmi.vdev_param->dtim_period;
3015                 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3016                                                 arvif->dtim_period);
3017                 if (ret)
3018                         ath10k_warn("failed to set dtim period for vdev %d: %i\n",
3019                                     arvif->vdev_id, ret);
3020         }
3021
3022         if (changed & BSS_CHANGED_SSID &&
3023             vif->type == NL80211_IFTYPE_AP) {
3024                 arvif->u.ap.ssid_len = info->ssid_len;
3025                 if (info->ssid_len)
3026                         memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
3027                 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3028         }
3029
3030         /*
3031          * Firmware manages AP self-peer internally so make sure to not create
3032          * it in driver. Otherwise AP self-peer deletion may timeout later.
3033          */
3034         if (changed & BSS_CHANGED_BSSID &&
3035             vif->type != NL80211_IFTYPE_AP) {
3036                 if (!is_zero_ether_addr(info->bssid)) {
3037                         ath10k_dbg(ATH10K_DBG_MAC,
3038                                    "mac vdev %d create peer %pM\n",
3039                                    arvif->vdev_id, info->bssid);
3040
3041                         ret = ath10k_peer_create(ar, arvif->vdev_id,
3042                                                  info->bssid);
3043                         if (ret)
3044                                 ath10k_warn("failed to add peer %pM for vdev %d when changing bssid: %i\n",
3045                                             info->bssid, arvif->vdev_id, ret);
3046
3047                         if (vif->type == NL80211_IFTYPE_STATION) {
3048                                 /*
3049                                  * this is never erased as we it for crypto key
3050                                  * clearing; this is FW requirement
3051                                  */
3052                                 memcpy(arvif->bssid, info->bssid, ETH_ALEN);
3053 <